Revision 4922a5b0 libavcodec/mjpeg.c

View differences:

libavcodec/mjpeg.c
30 30
 * MJPEG encoder and decoder.
31 31
 */
32 32

  
33
//#define DEBUG
34
#include <assert.h>
35

  
36
#include "avcodec.h"
37
#include "dsputil.h"
38
#include "mpegvideo.h"
39
#include "bytestream.h"
40 33
#include "mjpeg.h"
41
#include "jpeglsdec.h"
42

  
43
/* use two quantizer tables (one for luminance and one for chrominance) */
44
/* not yet working */
45
#undef TWOMATRIXES
46 34

  
47
typedef struct MJpegContext {
48
    uint8_t huff_size_dc_luminance[12]; //FIXME use array [3] instead of lumi / chrom, for easier addressing
49
    uint16_t huff_code_dc_luminance[12];
50
    uint8_t huff_size_dc_chrominance[12];
51
    uint16_t huff_code_dc_chrominance[12];
52

  
53
    uint8_t huff_size_ac_luminance[256];
54
    uint16_t huff_code_ac_luminance[256];
55
    uint8_t huff_size_ac_chrominance[256];
56
    uint16_t huff_code_ac_chrominance[256];
57
} MJpegContext;
58 35

  
59 36
#if 0
60 37
/* These are the sample quantization tables given in JPEG spec section K.1.
61 38
 * The spec says that the values given produce "good" quality, and
62 39
 * when divided by 2, "very good" quality.
63 40
 */
64
static const unsigned char std_luminance_quant_tbl[64] = {
41
const unsigned char std_luminance_quant_tbl[64] = {
65 42
    16,  11,  10,  16,  24,  40,  51,  61,
66 43
    12,  12,  14,  19,  26,  58,  60,  55,
67 44
    14,  13,  16,  24,  40,  57,  69,  56,
......
71 48
    49,  64,  78,  87, 103, 121, 120, 101,
72 49
    72,  92,  95,  98, 112, 100, 103,  99
73 50
};
74
static const unsigned char std_chrominance_quant_tbl[64] = {
51
const unsigned char std_chrominance_quant_tbl[64] = {
75 52
    17,  18,  24,  47,  99,  99,  99,  99,
76 53
    18,  21,  26,  66,  99,  99,  99,  99,
77 54
    24,  26,  56,  99,  99,  99,  99,  99,
......
85 62

  
86 63
/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
87 64
/* IMPORTANT: these are only valid for 8-bit data precision! */
88
static const uint8_t bits_dc_luminance[17] =
65
const uint8_t bits_dc_luminance[17] =
89 66
{ /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
90
static const uint8_t val_dc_luminance[] =
67
const uint8_t val_dc_luminance[] =
91 68
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
92 69

  
93
static const uint8_t bits_dc_chrominance[17] =
70
const uint8_t bits_dc_chrominance[17] =
94 71
{ /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
95
static const uint8_t val_dc_chrominance[] =
72
const uint8_t val_dc_chrominance[] =
96 73
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
97 74

  
98
static const uint8_t bits_ac_luminance[17] =
75
const uint8_t bits_ac_luminance[17] =
99 76
{ /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
100
static const uint8_t val_ac_luminance[] =
77
const uint8_t val_ac_luminance[] =
101 78
{ 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
102 79
  0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
103 80
  0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
......
121 98
  0xf9, 0xfa
122 99
};
123 100

  
124
static const uint8_t bits_ac_chrominance[17] =
101
const uint8_t bits_ac_chrominance[17] =
125 102
{ /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
126 103

  
127
static const uint8_t val_ac_chrominance[] =
104
const uint8_t val_ac_chrominance[] =
128 105
{ 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
129 106
  0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
130 107
  0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
......
149 126
};
150 127

  
151 128
/* isn't this function nicer than the one in the libjpeg ? */
152
static void build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code,
129
void build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code,
153 130
                                const uint8_t *bits_table, const uint8_t *val_table)
154 131
{
155 132
    int i, j, k,nb, code, sym;
......
167 144
        code <<= 1;
168 145
    }
169 146
}
170

  
171
#ifdef CONFIG_ENCODERS
172
int mjpeg_init(MpegEncContext *s)
173
{
174
    MJpegContext *m;
175

  
176
    m = av_malloc(sizeof(MJpegContext));
177
    if (!m)
178
        return -1;
179

  
180
    s->min_qcoeff=-1023;
181
    s->max_qcoeff= 1023;
182

  
183
    /* build all the huffman tables */
184
    build_huffman_codes(m->huff_size_dc_luminance,
185
                        m->huff_code_dc_luminance,
186
                        bits_dc_luminance,
187
                        val_dc_luminance);
188
    build_huffman_codes(m->huff_size_dc_chrominance,
189
                        m->huff_code_dc_chrominance,
190
                        bits_dc_chrominance,
191
                        val_dc_chrominance);
192
    build_huffman_codes(m->huff_size_ac_luminance,
193
                        m->huff_code_ac_luminance,
194
                        bits_ac_luminance,
195
                        val_ac_luminance);
196
    build_huffman_codes(m->huff_size_ac_chrominance,
197
                        m->huff_code_ac_chrominance,
198
                        bits_ac_chrominance,
199
                        val_ac_chrominance);
200

  
201
    s->mjpeg_ctx = m;
202
    return 0;
203
}
204

  
205
void mjpeg_close(MpegEncContext *s)
206
{
207
    av_free(s->mjpeg_ctx);
208
}
209
#endif //CONFIG_ENCODERS
210

  
211
#define PREDICT(ret, topleft, top, left, predictor)\
212
    switch(predictor){\
213
        case 1: ret= left; break;\
214
        case 2: ret= top; break;\
215
        case 3: ret= topleft; break;\
216
        case 4: ret= left   +   top - topleft; break;\
217
        case 5: ret= left   + ((top - topleft)>>1); break;\
218
        case 6: ret= top + ((left   - topleft)>>1); break;\
219
        default:\
220
        case 7: ret= (left + top)>>1; break;\
221
    }
222

  
223
#ifdef CONFIG_ENCODERS
224
/* table_class: 0 = DC coef, 1 = AC coefs */
225
static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
226
                             const uint8_t *bits_table, const uint8_t *value_table)
227
{
228
    PutBitContext *p = &s->pb;
229
    int n, i;
230

  
231
    put_bits(p, 4, table_class);
232
    put_bits(p, 4, table_id);
233

  
234
    n = 0;
235
    for(i=1;i<=16;i++) {
236
        n += bits_table[i];
237
        put_bits(p, 8, bits_table[i]);
238
    }
239

  
240
    for(i=0;i<n;i++)
241
        put_bits(p, 8, value_table[i]);
242

  
243
    return n + 17;
244
}
245

  
246
static void jpeg_table_header(MpegEncContext *s)
247
{
248
    PutBitContext *p = &s->pb;
249
    int i, j, size;
250
    uint8_t *ptr;
251

  
252
    /* quant matrixes */
253
    put_marker(p, DQT);
254
#ifdef TWOMATRIXES
255
    put_bits(p, 16, 2 + 2 * (1 + 64));
256
#else
257
    put_bits(p, 16, 2 + 1 * (1 + 64));
258
#endif
259
    put_bits(p, 4, 0); /* 8 bit precision */
260
    put_bits(p, 4, 0); /* table 0 */
261
    for(i=0;i<64;i++) {
262
        j = s->intra_scantable.permutated[i];
263
        put_bits(p, 8, s->intra_matrix[j]);
264
    }
265
#ifdef TWOMATRIXES
266
    put_bits(p, 4, 0); /* 8 bit precision */
267
    put_bits(p, 4, 1); /* table 1 */
268
    for(i=0;i<64;i++) {
269
        j = s->intra_scantable.permutated[i];
270
        put_bits(p, 8, s->chroma_intra_matrix[j]);
271
    }
272
#endif
273

  
274
    /* huffman table */
275
    put_marker(p, DHT);
276
    flush_put_bits(p);
277
    ptr = pbBufPtr(p);
278
    put_bits(p, 16, 0); /* patched later */
279
    size = 2;
280
    size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
281
    size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
282

  
283
    size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
284
    size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
285
    ptr[0] = size >> 8;
286
    ptr[1] = size;
287
}
288

  
289
static void jpeg_put_comments(MpegEncContext *s)
290
{
291
    PutBitContext *p = &s->pb;
292
    int size;
293
    uint8_t *ptr;
294

  
295
    if (s->aspect_ratio_info /* && !lossless */)
296
    {
297
    /* JFIF header */
298
    put_marker(p, APP0);
299
    put_bits(p, 16, 16);
300
    ff_put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */
301
    put_bits(p, 16, 0x0201); /* v 1.02 */
302
    put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
303
    put_bits(p, 16, s->avctx->sample_aspect_ratio.num);
304
    put_bits(p, 16, s->avctx->sample_aspect_ratio.den);
305
    put_bits(p, 8, 0); /* thumbnail width */
306
    put_bits(p, 8, 0); /* thumbnail height */
307
    }
308

  
309
    /* comment */
310
    if(!(s->flags & CODEC_FLAG_BITEXACT)){
311
        put_marker(p, COM);
312
        flush_put_bits(p);
313
        ptr = pbBufPtr(p);
314
        put_bits(p, 16, 0); /* patched later */
315
        ff_put_string(p, LIBAVCODEC_IDENT, 1);
316
        size = strlen(LIBAVCODEC_IDENT)+3;
317
        ptr[0] = size >> 8;
318
        ptr[1] = size;
319
    }
320

  
321
    if(  s->avctx->pix_fmt == PIX_FMT_YUV420P
322
       ||s->avctx->pix_fmt == PIX_FMT_YUV422P
323
       ||s->avctx->pix_fmt == PIX_FMT_YUV444P){
324
        put_marker(p, COM);
325
        flush_put_bits(p);
326
        ptr = pbBufPtr(p);
327
        put_bits(p, 16, 0); /* patched later */
328
        ff_put_string(p, "CS=ITU601", 1);
329
        size = strlen("CS=ITU601")+3;
330
        ptr[0] = size >> 8;
331
        ptr[1] = size;
332
    }
333
}
334

  
335
void mjpeg_picture_header(MpegEncContext *s)
336
{
337
    const int lossless= s->avctx->codec_id != CODEC_ID_MJPEG;
338

  
339
    put_marker(&s->pb, SOI);
340

  
341
    jpeg_put_comments(s);
342

  
343
    jpeg_table_header(s);
344

  
345
    switch(s->avctx->codec_id){
346
    case CODEC_ID_MJPEG:  put_marker(&s->pb, SOF0 ); break;
347
    case CODEC_ID_LJPEG:  put_marker(&s->pb, SOF3 ); break;
348
    default: assert(0);
349
    }
350

  
351
    put_bits(&s->pb, 16, 17);
352
    if(lossless && s->avctx->pix_fmt == PIX_FMT_RGB32)
353
        put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
354
    else
355
        put_bits(&s->pb, 8, 8); /* 8 bits/component */
356
    put_bits(&s->pb, 16, s->height);
357
    put_bits(&s->pb, 16, s->width);
358
    put_bits(&s->pb, 8, 3); /* 3 components */
359

  
360
    /* Y component */
361
    put_bits(&s->pb, 8, 1); /* component number */
362
    put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
363
    put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
364
    put_bits(&s->pb, 8, 0); /* select matrix */
365

  
366
    /* Cb component */
367
    put_bits(&s->pb, 8, 2); /* component number */
368
    put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
369
    put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
370
#ifdef TWOMATRIXES
371
    put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
372
#else
373
    put_bits(&s->pb, 8, 0); /* select matrix */
374
#endif
375

  
376
    /* Cr component */
377
    put_bits(&s->pb, 8, 3); /* component number */
378
    put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
379
    put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
380
#ifdef TWOMATRIXES
381
    put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
382
#else
383
    put_bits(&s->pb, 8, 0); /* select matrix */
384
#endif
385

  
386
    /* scan header */
387
    put_marker(&s->pb, SOS);
388
    put_bits(&s->pb, 16, 12); /* length */
389
    put_bits(&s->pb, 8, 3); /* 3 components */
390

  
391
    /* Y component */
392
    put_bits(&s->pb, 8, 1); /* index */
393
    put_bits(&s->pb, 4, 0); /* DC huffman table index */
394
    put_bits(&s->pb, 4, 0); /* AC huffman table index */
395

  
396
    /* Cb component */
397
    put_bits(&s->pb, 8, 2); /* index */
398
    put_bits(&s->pb, 4, 1); /* DC huffman table index */
399
    put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
400

  
401
    /* Cr component */
402
    put_bits(&s->pb, 8, 3); /* index */
403
    put_bits(&s->pb, 4, 1); /* DC huffman table index */
404
    put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
405

  
406
    put_bits(&s->pb, 8, lossless ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
407

  
408
    switch(s->avctx->codec_id){
409
    case CODEC_ID_MJPEG:  put_bits(&s->pb, 8, 63); break; /* Se (not used) */
410
    case CODEC_ID_LJPEG:  put_bits(&s->pb, 8,  0); break; /* not used */
411
    default: assert(0);
412
    }
413

  
414
    put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
415
}
416

  
417
static void escape_FF(MpegEncContext *s, int start)
418
{
419
    int size= put_bits_count(&s->pb) - start*8;
420
    int i, ff_count;
421
    uint8_t *buf= s->pb.buf + start;
422
    int align= (-(size_t)(buf))&3;
423

  
424
    assert((size&7) == 0);
425
    size >>= 3;
426

  
427
    ff_count=0;
428
    for(i=0; i<size && i<align; i++){
429
        if(buf[i]==0xFF) ff_count++;
430
    }
431
    for(; i<size-15; i+=16){
432
        int acc, v;
433

  
434
        v= *(uint32_t*)(&buf[i]);
435
        acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
436
        v= *(uint32_t*)(&buf[i+4]);
437
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
438
        v= *(uint32_t*)(&buf[i+8]);
439
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
440
        v= *(uint32_t*)(&buf[i+12]);
441
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
442

  
443
        acc>>=4;
444
        acc+= (acc>>16);
445
        acc+= (acc>>8);
446
        ff_count+= acc&0xFF;
447
    }
448
    for(; i<size; i++){
449
        if(buf[i]==0xFF) ff_count++;
450
    }
451

  
452
    if(ff_count==0) return;
453

  
454
    /* skip put bits */
455
    for(i=0; i<ff_count-3; i+=4)
456
        put_bits(&s->pb, 32, 0);
457
    put_bits(&s->pb, (ff_count-i)*8, 0);
458
    flush_put_bits(&s->pb);
459

  
460
    for(i=size-1; ff_count; i--){
461
        int v= buf[i];
462

  
463
        if(v==0xFF){
464
//printf("%d %d\n", i, ff_count);
465
            buf[i+ff_count]= 0;
466
            ff_count--;
467
        }
468

  
469
        buf[i+ff_count]= v;
470
    }
471
}
472

  
473
void ff_mjpeg_stuffing(PutBitContext * pbc)
474
{
475
    int length;
476
    length= (-put_bits_count(pbc))&7;
477
    if(length) put_bits(pbc, length, (1<<length)-1);
478
}
479

  
480
void mjpeg_picture_trailer(MpegEncContext *s)
481
{
482
    ff_mjpeg_stuffing(&s->pb);
483
    flush_put_bits(&s->pb);
484

  
485
    assert((s->header_bits&7)==0);
486

  
487
    escape_FF(s, s->header_bits>>3);
488

  
489
    put_marker(&s->pb, EOI);
490
}
491

  
492
static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
493
                                   uint8_t *huff_size, uint16_t *huff_code)
494
{
495
    int mant, nbits;
496

  
497
    if (val == 0) {
498
        put_bits(&s->pb, huff_size[0], huff_code[0]);
499
    } else {
500
        mant = val;
501
        if (val < 0) {
502
            val = -val;
503
            mant--;
504
        }
505

  
506
        nbits= av_log2_16bit(val) + 1;
507

  
508
        put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
509

  
510
        put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
511
    }
512
}
513

  
514
static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
515
{
516
    int mant, nbits, code, i, j;
517
    int component, dc, run, last_index, val;
518
    MJpegContext *m = s->mjpeg_ctx;
519
    uint8_t *huff_size_ac;
520
    uint16_t *huff_code_ac;
521

  
522
    /* DC coef */
523
    component = (n <= 3 ? 0 : (n&1) + 1);
524
    dc = block[0]; /* overflow is impossible */
525
    val = dc - s->last_dc[component];
526
    if (n < 4) {
527
        mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
528
        huff_size_ac = m->huff_size_ac_luminance;
529
        huff_code_ac = m->huff_code_ac_luminance;
530
    } else {
531
        mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
532
        huff_size_ac = m->huff_size_ac_chrominance;
533
        huff_code_ac = m->huff_code_ac_chrominance;
534
    }
535
    s->last_dc[component] = dc;
536

  
537
    /* AC coefs */
538

  
539
    run = 0;
540
    last_index = s->block_last_index[n];
541
    for(i=1;i<=last_index;i++) {
542
        j = s->intra_scantable.permutated[i];
543
        val = block[j];
544
        if (val == 0) {
545
            run++;
546
        } else {
547
            while (run >= 16) {
548
                put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
549
                run -= 16;
550
            }
551
            mant = val;
552
            if (val < 0) {
553
                val = -val;
554
                mant--;
555
            }
556

  
557
            nbits= av_log2(val) + 1;
558
            code = (run << 4) | nbits;
559

  
560
            put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
561

  
562
            put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
563
            run = 0;
564
        }
565
    }
566

  
567
    /* output EOB only if not already 64 values */
568
    if (last_index < 63 || run != 0)
569
        put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
570
}
571

  
572
void mjpeg_encode_mb(MpegEncContext *s,
573
                     DCTELEM block[6][64])
574
{
575
    int i;
576
    for(i=0;i<5;i++) {
577
        encode_block(s, block[i], i);
578
    }
579
    if (s->chroma_format == CHROMA_420) {
580
        encode_block(s, block[5], 5);
581
    } else {
582
        encode_block(s, block[6], 6);
583
        encode_block(s, block[5], 5);
584
        encode_block(s, block[7], 7);
585
    }
586
}
587

  
588
static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
589
    MpegEncContext * const s = avctx->priv_data;
590
    MJpegContext * const m = s->mjpeg_ctx;
591
    AVFrame *pict = data;
592
    const int width= s->width;
593
    const int height= s->height;
594
    AVFrame * const p= (AVFrame*)&s->current_picture;
595
    const int predictor= avctx->prediction_method+1;
596

  
597
    init_put_bits(&s->pb, buf, buf_size);
598

  
599
    *p = *pict;
600
    p->pict_type= FF_I_TYPE;
601
    p->key_frame= 1;
602

  
603
    mjpeg_picture_header(s);
604

  
605
    s->header_bits= put_bits_count(&s->pb);
606

  
607
    if(avctx->pix_fmt == PIX_FMT_RGB32){
608
        int x, y, i;
609
        const int linesize= p->linesize[0];
610
        uint16_t (*buffer)[4]= (void *) s->rd_scratchpad;
611
        int left[3], top[3], topleft[3];
612

  
613
        for(i=0; i<3; i++){
614
            buffer[0][i]= 1 << (9 - 1);
615
        }
616

  
617
        for(y = 0; y < height; y++) {
618
            const int modified_predictor= y ? predictor : 1;
619
            uint8_t *ptr = p->data[0] + (linesize * y);
620

  
621
            if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < width*3*4){
622
                av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
623
                return -1;
624
            }
625

  
626
            for(i=0; i<3; i++){
627
                top[i]= left[i]= topleft[i]= buffer[0][i];
628
            }
629
            for(x = 0; x < width; x++) {
630
                buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
631
                buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
632
                buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
633

  
634
                for(i=0;i<3;i++) {
635
                    int pred, diff;
636

  
637
                    PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
638

  
639
                    topleft[i]= top[i];
640
                    top[i]= buffer[x+1][i];
641

  
642
                    left[i]= buffer[x][i];
643

  
644
                    diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
645

  
646
                    if(i==0)
647
                        mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
648
                    else
649
                        mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
650
                }
651
            }
652
        }
653
    }else{
654
        int mb_x, mb_y, i;
655
        const int mb_width  = (width  + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
656
        const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
657

  
658
        for(mb_y = 0; mb_y < mb_height; mb_y++) {
659
            if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < mb_width * 4 * 3 * s->mjpeg_hsample[0] * s->mjpeg_vsample[0]){
660
                av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
661
                return -1;
662
            }
663
            for(mb_x = 0; mb_x < mb_width; mb_x++) {
664
                if(mb_x==0 || mb_y==0){
665
                    for(i=0;i<3;i++) {
666
                        uint8_t *ptr;
667
                        int x, y, h, v, linesize;
668
                        h = s->mjpeg_hsample[i];
669
                        v = s->mjpeg_vsample[i];
670
                        linesize= p->linesize[i];
671

  
672
                        for(y=0; y<v; y++){
673
                            for(x=0; x<h; x++){
674
                                int pred;
675

  
676
                                ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
677
                                if(y==0 && mb_y==0){
678
                                    if(x==0 && mb_x==0){
679
                                        pred= 128;
680
                                    }else{
681
                                        pred= ptr[-1];
682
                                    }
683
                                }else{
684
                                    if(x==0 && mb_x==0){
685
                                        pred= ptr[-linesize];
686
                                    }else{
687
                                        PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
688
                                    }
689
                                }
690

  
691
                                if(i==0)
692
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
693
                                else
694
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
695
                            }
696
                        }
697
                    }
698
                }else{
699
                    for(i=0;i<3;i++) {
700
                        uint8_t *ptr;
701
                        int x, y, h, v, linesize;
702
                        h = s->mjpeg_hsample[i];
703
                        v = s->mjpeg_vsample[i];
704
                        linesize= p->linesize[i];
705

  
706
                        for(y=0; y<v; y++){
707
                            for(x=0; x<h; x++){
708
                                int pred;
709

  
710
                                ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
711
//printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr);
712
                                PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
713

  
714
                                if(i==0)
715
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
716
                                else
717
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
718
                            }
719
                        }
720
                    }
721
                }
722
            }
723
        }
724
    }
725

  
726
    emms_c();
727

  
728
    mjpeg_picture_trailer(s);
729
    s->picture_number++;
730

  
731
    flush_put_bits(&s->pb);
732
    return pbBufPtr(&s->pb) - s->pb.buf;
733
//    return (put_bits_count(&f->pb)+7)/8;
734
}
735

  
736
#endif //CONFIG_ENCODERS
737

  
738
/******************************************/
739
/* decoding */
740

  
741
static int mjpeg_decode_dht(MJpegDecodeContext *s);
742

  
743
static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,
744
                      int nb_codes, int use_static, int is_ac)
745
{
746
    uint8_t huff_size[256+16];
747
    uint16_t huff_code[256+16];
748

  
749
    assert(nb_codes <= 256);
750

  
751
    memset(huff_size, 0, sizeof(huff_size));
752
    build_huffman_codes(huff_size, huff_code, bits_table, val_table);
753

  
754
    if(is_ac){
755
        memmove(huff_size+16, huff_size, sizeof(uint8_t)*nb_codes);
756
        memmove(huff_code+16, huff_code, sizeof(uint16_t)*nb_codes);
757
        memset(huff_size, 0, sizeof(uint8_t)*16);
758
        memset(huff_code, 0, sizeof(uint16_t)*16);
759
        nb_codes += 16;
760
    }
761

  
762
    return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2, use_static);
763
}
764

  
765
static int mjpeg_decode_init(AVCodecContext *avctx)
766
{
767
    MJpegDecodeContext *s = avctx->priv_data;
768

  
769
    s->avctx = avctx;
770
    dsputil_init(&s->dsp, avctx);
771
    ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct);
772
    s->buffer_size = 0;
773
    s->buffer = NULL;
774
    s->start_code = -1;
775
    s->first_picture = 1;
776
    s->org_height = avctx->coded_height;
777

  
778
    build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12, 0, 0);
779
    build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12, 0, 0);
780
    build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251, 0, 1);
781
    build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251, 0, 1);
782

  
783
    if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
784
    {
785
        av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
786
        init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
787
        mjpeg_decode_dht(s);
788
        /* should check for error - but dunno */
789
    }
790
    if (avctx->extradata_size > 9 &&
791
        AV_RL32(avctx->extradata + 4) == MKTAG('f','i','e','l')) {
792
        if (avctx->extradata[9] == 6) { /* quicktime icefloe 019 */
793
            s->interlace_polarity = 1; /* bottom field first */
794
            av_log(avctx, AV_LOG_DEBUG, "mjpeg bottom field first\n");
795
        }
796
    }
797

  
798
    return 0;
799
}
800

  
801

  
802
/* quantize tables */
803
static int mjpeg_decode_dqt(MJpegDecodeContext *s)
804
{
805
    int len, index, i, j;
806

  
807
    len = get_bits(&s->gb, 16) - 2;
808

  
809
    while (len >= 65) {
810
        /* only 8 bit precision handled */
811
        if (get_bits(&s->gb, 4) != 0)
812
        {
813
            av_log(s->avctx, AV_LOG_ERROR, "dqt: 16bit precision\n");
814
            return -1;
815
        }
816
        index = get_bits(&s->gb, 4);
817
        if (index >= 4)
818
            return -1;
819
        av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index);
820
        /* read quant table */
821
        for(i=0;i<64;i++) {
822
            j = s->scantable.permutated[i];
823
            s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
824
        }
825

  
826
        //XXX FIXME finetune, and perhaps add dc too
827
        s->qscale[index]= FFMAX(
828
            s->quant_matrixes[index][s->scantable.permutated[1]],
829
            s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
830
        av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n", index, s->qscale[index]);
831
        len -= 65;
832
    }
833

  
834
    return 0;
835
}
836

  
837
/* decode huffman tables and build VLC decoders */
838
static int mjpeg_decode_dht(MJpegDecodeContext *s)
839
{
840
    int len, index, i, class, n, v, code_max;
841
    uint8_t bits_table[17];
842
    uint8_t val_table[256];
843

  
844
    len = get_bits(&s->gb, 16) - 2;
845

  
846
    while (len > 0) {
847
        if (len < 17)
848
            return -1;
849
        class = get_bits(&s->gb, 4);
850
        if (class >= 2)
851
            return -1;
852
        index = get_bits(&s->gb, 4);
853
        if (index >= 4)
854
            return -1;
855
        n = 0;
856
        for(i=1;i<=16;i++) {
857
            bits_table[i] = get_bits(&s->gb, 8);
858
            n += bits_table[i];
859
        }
860
        len -= 17;
861
        if (len < n || n > 256)
862
            return -1;
863

  
864
        code_max = 0;
865
        for(i=0;i<n;i++) {
866
            v = get_bits(&s->gb, 8);
867
            if (v > code_max)
868
                code_max = v;
869
            val_table[i] = v;
870
        }
871
        len -= n;
872

  
873
        /* build VLC and flush previous vlc if present */
874
        free_vlc(&s->vlcs[class][index]);
875
        av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
876
               class, index, code_max + 1);
877
        if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0, class > 0) < 0){
878
            return -1;
879
        }
880
    }
881
    return 0;
882
}
883

  
884
static int mjpeg_decode_sof(MJpegDecodeContext *s)
885
{
886
    int len, nb_components, i, width, height, pix_fmt_id;
887

  
888
    /* XXX: verify len field validity */
889
    len = get_bits(&s->gb, 16);
890
    s->bits= get_bits(&s->gb, 8);
891

  
892
    if(s->pegasus_rct) s->bits=9;
893
    if(s->bits==9 && !s->pegasus_rct) s->rct=1;    //FIXME ugly
894

  
895
    if (s->bits != 8 && !s->lossless){
896
        av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
897
        return -1;
898
    }
899

  
900
    height = get_bits(&s->gb, 16);
901
    width = get_bits(&s->gb, 16);
902

  
903
    //HACK for odd_height.mov
904
    if(s->interlaced && s->width == width && s->height == height + 1)
905
        height= s->height;
906

  
907
    av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
908
    if(avcodec_check_dimensions(s->avctx, width, height))
909
        return -1;
910

  
911
    nb_components = get_bits(&s->gb, 8);
912
    if (nb_components <= 0 ||
913
        nb_components > MAX_COMPONENTS)
914
        return -1;
915
    if (s->ls && !(s->bits <= 8 || nb_components == 1)){
916
        av_log(s->avctx, AV_LOG_ERROR, "only <= 8 bits/component or 16-bit gray accepted for JPEG-LS\n");
917
        return -1;
918
    }
919
    s->nb_components = nb_components;
920
    s->h_max = 1;
921
    s->v_max = 1;
922
    for(i=0;i<nb_components;i++) {
923
        /* component id */
924
        s->component_id[i] = get_bits(&s->gb, 8) - 1;
925
        s->h_count[i] = get_bits(&s->gb, 4);
926
        s->v_count[i] = get_bits(&s->gb, 4);
927
        /* compute hmax and vmax (only used in interleaved case) */
928
        if (s->h_count[i] > s->h_max)
929
            s->h_max = s->h_count[i];
930
        if (s->v_count[i] > s->v_max)
931
            s->v_max = s->v_count[i];
932
        s->quant_index[i] = get_bits(&s->gb, 8);
933
        if (s->quant_index[i] >= 4)
934
            return -1;
935
        av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
936
               s->v_count[i], s->component_id[i], s->quant_index[i]);
937
    }
938

  
939
    if(s->ls && (s->h_max > 1 || s->v_max > 1)) {
940
        av_log(s->avctx, AV_LOG_ERROR, "Subsampling in JPEG-LS is not supported.\n");
941
        return -1;
942
    }
943

  
944
    if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
945

  
946
    /* if different size, realloc/alloc picture */
947
    /* XXX: also check h_count and v_count */
948
    if (width != s->width || height != s->height) {
949
        av_freep(&s->qscale_table);
950

  
951
        s->width = width;
952
        s->height = height;
953
        s->interlaced = 0;
954

  
955
        /* test interlaced mode */
956
        if (s->first_picture &&
957
            s->org_height != 0 &&
958
            s->height < ((s->org_height * 3) / 4)) {
959
            s->interlaced = 1;
960
            s->bottom_field = s->interlace_polarity;
961
            s->picture.interlaced_frame = 1;
962
            s->picture.top_field_first = !s->interlace_polarity;
963
            height *= 2;
964
        }
965

  
966
        avcodec_set_dimensions(s->avctx, width, height);
967

  
968
        s->qscale_table= av_mallocz((s->width+15)/16);
969

  
970
        s->first_picture = 0;
971
    }
972

  
973
    if(s->interlaced && (s->bottom_field == !s->interlace_polarity))
974
        return 0;
975

  
976
    /* XXX: not complete test ! */
977
    pix_fmt_id = (s->h_count[0] << 20) | (s->v_count[0] << 16) |
978
                 (s->h_count[1] << 12) | (s->v_count[1] <<  8) |
979
                 (s->h_count[2] <<  4) |  s->v_count[2];
980
    av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);
981
    switch(pix_fmt_id){
982
    case 0x222222:
983
    case 0x111111:
984
        if(s->rgb){
985
            s->avctx->pix_fmt = PIX_FMT_RGB32;
986
        }else if(s->nb_components==3)
987
            s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;
988
        else
989
            s->avctx->pix_fmt = PIX_FMT_GRAY8;
990
        break;
991
    case 0x211111:
992
    case 0x221212:
993
        s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P;
994
        break;
995
    default:
996
    case 0x221111:
997
        s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P;
998
        break;
999
    }
1000
    if(s->ls){
1001
        if(s->nb_components > 1)
1002
            s->avctx->pix_fmt = PIX_FMT_RGB24;
1003
        else if(s->bits <= 8)
1004
            s->avctx->pix_fmt = PIX_FMT_GRAY8;
1005
        else
1006
            s->avctx->pix_fmt = PIX_FMT_GRAY16;
1007
    }
1008

  
1009
    if(s->picture.data[0])
1010
        s->avctx->release_buffer(s->avctx, &s->picture);
1011

  
1012
    s->picture.reference= 0;
1013
    if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1014
        av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1015
        return -1;
1016
    }
1017
    s->picture.pict_type= I_TYPE;
1018
    s->picture.key_frame= 1;
1019

  
1020
    for(i=0; i<3; i++){
1021
        s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1022
    }
1023

  
1024
//    printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1025

  
1026
    if (len != (8+(3*nb_components)))
1027
    {
1028
        av_log(s->avctx, AV_LOG_DEBUG, "decode_sof0: error, len(%d) mismatch\n", len);
1029
    }
1030

  
1031
    /* totally blank picture as progressive JPEG will only add details to it */
1032
    if(s->progressive){
1033
        memset(s->picture.data[0], 0, s->picture.linesize[0] * s->height);
1034
        memset(s->picture.data[1], 0, s->picture.linesize[1] * s->height >> (s->v_max - s->v_count[1]));
1035
        memset(s->picture.data[2], 0, s->picture.linesize[2] * s->height >> (s->v_max - s->v_count[2]));
1036
    }
1037
    return 0;
1038
}
1039

  
1040
static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1041
{
1042
    int code;
1043
    code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1044
    if (code < 0)
1045
    {
1046
        av_log(s->avctx, AV_LOG_WARNING, "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1047
               &s->vlcs[0][dc_index]);
1048
        return 0xffff;
1049
    }
1050

  
1051
    if(code)
1052
        return get_xbits(&s->gb, code);
1053
    else
1054
        return 0;
1055
}
1056

  
1057
/* decode block and dequantize */
1058
static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1059
                        int component, int dc_index, int ac_index, int16_t *quant_matrix)
1060
{
1061
    int code, i, j, level, val;
1062

  
1063
    /* DC coef */
1064
    val = mjpeg_decode_dc(s, dc_index);
1065
    if (val == 0xffff) {
1066
        av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
1067
        return -1;
1068
    }
1069
    val = val * quant_matrix[0] + s->last_dc[component];
1070
    s->last_dc[component] = val;
1071
    block[0] = val;
1072
    /* AC coefs */
1073
    i = 0;
1074
    {OPEN_READER(re, &s->gb)
1075
    for(;;) {
1076
        UPDATE_CACHE(re, &s->gb);
1077
        GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)
1078

  
1079
        /* EOB */
1080
        if (code == 0x10)
1081
            break;
1082
        i += ((unsigned)code) >> 4;
1083
        if(code != 0x100){
1084
            code &= 0xf;
1085
            if(code > MIN_CACHE_BITS - 16){
1086
                UPDATE_CACHE(re, &s->gb)
1087
            }
1088
            {
1089
                int cache=GET_CACHE(re,&s->gb);
1090
                int sign=(~cache)>>31;
1091
                level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
1092
            }
1093

  
1094
            LAST_SKIP_BITS(re, &s->gb, code)
1095

  
1096
            if (i >= 63) {
1097
                if(i == 63){
1098
                    j = s->scantable.permutated[63];
1099
                    block[j] = level * quant_matrix[j];
1100
                    break;
1101
                }
1102
                av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
1103
                return -1;
1104
            }
1105
            j = s->scantable.permutated[i];
1106
            block[j] = level * quant_matrix[j];
1107
        }
1108
    }
1109
    CLOSE_READER(re, &s->gb)}
1110

  
1111
    return 0;
1112
}
1113

  
1114
/* decode block and dequantize - progressive JPEG version */
1115
static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block,
1116
                        int component, int dc_index, int ac_index, int16_t *quant_matrix,
1117
                        int ss, int se, int Ah, int Al, int *EOBRUN)
1118
{
1119
    int code, i, j, level, val, run;
1120

  
1121
    /* DC coef */
1122
    if(!ss){
1123
        val = mjpeg_decode_dc(s, dc_index);
1124
        if (val == 0xffff) {
1125
            av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
1126
            return -1;
1127
        }
1128
        val = (val * quant_matrix[0] << Al) + s->last_dc[component];
1129
    }else
1130
        val = 0;
1131
    s->last_dc[component] = val;
1132
    block[0] = val;
1133
    if(!se) return 0;
1134
    /* AC coefs */
1135
    if(*EOBRUN){
1136
        (*EOBRUN)--;
1137
        return 0;
1138
    }
1139
    {OPEN_READER(re, &s->gb)
1140
    for(i=ss;;i++) {
1141
        UPDATE_CACHE(re, &s->gb);
1142
        GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)
1143
        /* Progressive JPEG use AC coeffs from zero and this decoder sets offset 16 by default */
1144
        code -= 16;
1145
        if(code & 0xF) {
1146
            i += ((unsigned) code) >> 4;
1147
            code &= 0xf;
1148
            if(code > MIN_CACHE_BITS - 16){
1149
                UPDATE_CACHE(re, &s->gb)
1150
            }
1151
            {
1152
                int cache=GET_CACHE(re,&s->gb);
1153
                int sign=(~cache)>>31;
1154
                level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
1155
            }
1156

  
1157
            LAST_SKIP_BITS(re, &s->gb, code)
1158

  
1159
            if (i >= se) {
1160
                if(i == se){
1161
                    j = s->scantable.permutated[se];
1162
                    block[j] = level * quant_matrix[j] << Al;
1163
                    break;
1164
                }
1165
                av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
1166
                return -1;
1167
            }
1168
            j = s->scantable.permutated[i];
1169
            block[j] = level * quant_matrix[j] << Al;
1170
        }else{
1171
            run = ((unsigned) code) >> 4;
1172
            if(run == 0xF){// ZRL - skip 15 coefficients
1173
                i += 15;
1174
            }else{
1175
                val = run;
1176
                run = (1 << run);
1177
                UPDATE_CACHE(re, &s->gb);
1178
                run += (GET_CACHE(re, &s->gb) >> (32 - val)) & (run - 1);
1179
                if(val)
1180
                    LAST_SKIP_BITS(re, &s->gb, val);
1181
                *EOBRUN = run - 1;
1182
                break;
1183
            }
1184
        }
1185
    }
1186
    CLOSE_READER(re, &s->gb)}
1187

  
1188
    return 0;
1189
}
1190

  
1191
static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1192
    int i, mb_x, mb_y;
1193
    uint16_t buffer[32768][4];
1194
    int left[3], top[3], topleft[3];
1195
    const int linesize= s->linesize[0];
1196
    const int mask= (1<<s->bits)-1;
1197

  
1198
    if((unsigned)s->mb_width > 32768) //dynamic alloc
1199
        return -1;
1200

  
1201
    for(i=0; i<3; i++){
1202
        buffer[0][i]= 1 << (s->bits + point_transform - 1);
1203
    }
1204
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1205
        const int modified_predictor= mb_y ? predictor : 1;
1206
        uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1207

  
1208
        if (s->interlaced && s->bottom_field)
1209
            ptr += linesize >> 1;
1210

  
1211
        for(i=0; i<3; i++){
1212
            top[i]= left[i]= topleft[i]= buffer[0][i];
1213
        }
1214
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1215
            if (s->restart_interval && !s->restart_count)
1216
                s->restart_count = s->restart_interval;
1217

  
1218
            for(i=0;i<3;i++) {
1219
                int pred;
1220

  
1221
                topleft[i]= top[i];
1222
                top[i]= buffer[mb_x][i];
1223

  
1224
                PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1225

  
1226
                left[i]=
1227
                buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1228
            }
1229

  
1230
            if (s->restart_interval && !--s->restart_count) {
1231
                align_get_bits(&s->gb);
1232
                skip_bits(&s->gb, 16); /* skip RSTn */
1233
            }
1234
        }
1235

  
1236
        if(s->rct){
1237
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1238
                ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1239
                ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1240
                ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1241
            }
1242
        }else if(s->pegasus_rct){
1243
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1244
                ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1245
                ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1246
                ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1247
            }
1248
        }else{
1249
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1250
                ptr[4*mb_x+0] = buffer[mb_x][0];
1251
                ptr[4*mb_x+1] = buffer[mb_x][1];
1252
                ptr[4*mb_x+2] = buffer[mb_x][2];
1253
            }
1254
        }
1255
    }
1256
    return 0;
1257
}
1258

  
1259
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1260
    int i, mb_x, mb_y;
1261
    const int nb_components=3;
1262

  
1263
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1264
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1265
            if (s->restart_interval && !s->restart_count)
1266
                s->restart_count = s->restart_interval;
1267

  
1268
            if(mb_x==0 || mb_y==0 || s->interlaced){
1269
                for(i=0;i<nb_components;i++) {
1270
                    uint8_t *ptr;
1271
                    int n, h, v, x, y, c, j, linesize;
1272
                    n = s->nb_blocks[i];
1273
                    c = s->comp_index[i];
1274
                    h = s->h_scount[i];
1275
                    v = s->v_scount[i];
1276
                    x = 0;
1277
                    y = 0;
1278
                    linesize= s->linesize[c];
1279

  
1280
                    for(j=0; j<n; j++) {
1281
                        int pred;
1282

  
1283
                        ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1284
                        if(y==0 && mb_y==0){
1285
                            if(x==0 && mb_x==0){
1286
                                pred= 128 << point_transform;
1287
                            }else{
1288
                                pred= ptr[-1];
1289
                            }
1290
                        }else{
1291
                            if(x==0 && mb_x==0){
1292
                                pred= ptr[-linesize];
1293
                            }else{
1294
                                PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1295
                            }
1296
                        }
1297

  
1298
                        if (s->interlaced && s->bottom_field)
1299
                            ptr += linesize >> 1;
1300
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1301

  
1302
                        if (++x == h) {
1303
                            x = 0;
1304
                            y++;
1305
                        }
1306
                    }
1307
                }
1308
            }else{
1309
                for(i=0;i<nb_components;i++) {
1310
                    uint8_t *ptr;
1311
                    int n, h, v, x, y, c, j, linesize;
1312
                    n = s->nb_blocks[i];
1313
                    c = s->comp_index[i];
1314
                    h = s->h_scount[i];
1315
                    v = s->v_scount[i];
1316
                    x = 0;
1317
                    y = 0;
1318
                    linesize= s->linesize[c];
1319

  
1320
                    for(j=0; j<n; j++) {
1321
                        int pred;
1322

  
1323
                        ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1324
                        PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1325
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1326
                        if (++x == h) {
1327
                            x = 0;
1328
                            y++;
1329
                        }
1330
                    }
1331
                }
1332
            }
1333
            if (s->restart_interval && !--s->restart_count) {
1334
                align_get_bits(&s->gb);
1335
                skip_bits(&s->gb, 16); /* skip RSTn */
1336
            }
1337
        }
1338
    }
1339
    return 0;
1340
}
1341

  
1342
static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int ss, int se, int Ah, int Al){
1343
    int i, mb_x, mb_y;
1344
    int EOBRUN = 0;
1345

  
1346
    if(Ah) return 0; /* TODO decode refinement planes too */
1347
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1348
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1349
            if (s->restart_interval && !s->restart_count)
1350
                s->restart_count = s->restart_interval;
1351

  
1352
            for(i=0;i<nb_components;i++) {
1353
                uint8_t *ptr;
1354
                int n, h, v, x, y, c, j;
1355
                n = s->nb_blocks[i];
1356
                c = s->comp_index[i];
1357
                h = s->h_scount[i];
1358
                v = s->v_scount[i];
1359
                x = 0;
1360
                y = 0;
1361
                for(j=0;j<n;j++) {
1362
                    memset(s->block, 0, sizeof(s->block));
1363
                    if (!s->progressive && decode_block(s, s->block, i,
1364
                                     s->dc_index[i], s->ac_index[i],
1365
                                     s->quant_matrixes[ s->quant_index[c] ]) < 0) {
1366
                        av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
1367
                        return -1;
1368
                    }
1369
                    if (s->progressive && decode_block_progressive(s, s->block, i,
1370
                                     s->dc_index[i], s->ac_index[i],
1371
                                     s->quant_matrixes[ s->quant_index[c] ], ss, se, Ah, Al, &EOBRUN) < 0) {
1372
                        av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
1373
                        return -1;
1374
                    }
1375
//                    av_log(s->avctx, AV_LOG_DEBUG, "mb: %d %d processed\n", mb_y, mb_x);
1376
                    ptr = s->picture.data[c] +
1377
                        (((s->linesize[c] * (v * mb_y + y) * 8) +
1378
                        (h * mb_x + x) * 8) >> s->avctx->lowres);
1379
                    if (s->interlaced && s->bottom_field)
1380
                        ptr += s->linesize[c] >> 1;
1381
//av_log(NULL, AV_LOG_DEBUG, "%d %d %d %d %d %d %d %d \n", mb_x, mb_y, x, y, c, s->bottom_field, (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1382
                    if(!s->progressive)
1383
                        s->dsp.idct_put(ptr, s->linesize[c], s->block);
1384
                    else
1385
                        s->dsp.idct_add(ptr, s->linesize[c], s->block);
1386
                    if (++x == h) {
1387
                        x = 0;
1388
                        y++;
1389
                    }
1390
                }
1391
            }
1392
            /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1393
            if (s->restart_interval && (s->restart_interval < 1350) &&
1394
                !--s->restart_count) {
1395
                align_get_bits(&s->gb);
1396
                skip_bits(&s->gb, 16); /* skip RSTn */
1397
                for (i=0; i<nb_components; i++) /* reset dc */
1398
                    s->last_dc[i] = 1024;
1399
            }
1400
        }
1401
    }
1402
    return 0;
1403
}
1404

  
1405
static int mjpeg_decode_sos(MJpegDecodeContext *s)
1406
{
1407
    int len, nb_components, i, h, v, predictor, point_transform;
1408
    int vmax, hmax, index, id;
1409
    const int block_size= s->lossless ? 1 : 8;
1410
    int ilv, prev_shift;
1411

  
1412
    /* XXX: verify len field validity */
1413
    len = get_bits(&s->gb, 16);
1414
    nb_components = get_bits(&s->gb, 8);
1415
    if (len != 6+2*nb_components)
1416
    {
1417
        av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1418
        return -1;
1419
    }
1420
    vmax = 0;
1421
    hmax = 0;
1422
    for(i=0;i<nb_components;i++) {
1423
        id = get_bits(&s->gb, 8) - 1;
1424
        av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1425
        /* find component index */
1426
        for(index=0;index<s->nb_components;index++)
1427
            if (id == s->component_id[index])
1428
                break;
1429
        if (index == s->nb_components)
1430
        {
1431
            av_log(s->avctx, AV_LOG_ERROR, "decode_sos: index(%d) out of components\n", index);
1432
            return -1;
1433
        }
1434

  
1435
        s->comp_index[i] = index;
1436

  
1437
        s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1438
        s->h_scount[i] = s->h_count[index];
1439
        s->v_scount[i] = s->v_count[index];
1440

  
1441
        s->dc_index[i] = get_bits(&s->gb, 4);
1442
        s->ac_index[i] = get_bits(&s->gb, 4);
1443

  
1444
        if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1445
            s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1446
            goto out_of_range;
1447
#if 0 //buggy
1448
        switch(s->start_code)
1449
        {
1450
            case SOF0:
1451
                if (dc_index[i] > 1 || ac_index[i] > 1)
1452
                    goto out_of_range;
1453
                break;
1454
            case SOF1:
1455
            case SOF2:
1456
                if (dc_index[i] > 3 || ac_index[i] > 3)
1457
                    goto out_of_range;
1458
                break;
1459
            case SOF3:
1460
                if (dc_index[i] > 3 || ac_index[i] != 0)
1461
                    goto out_of_range;
1462
                break;
1463
        }
1464
#endif
1465
    }
1466

  
1467
    predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1468
    ilv= get_bits(&s->gb, 8);    /* JPEG Se / JPEG-LS ILV */
1469
    prev_shift = get_bits(&s->gb, 4); /* Ah */
1470
    point_transform= get_bits(&s->gb, 4); /* Al */
1471

  
1472
    for(i=0;i<nb_components;i++)
1473
        s->last_dc[i] = 1024;
1474

  
1475
    if (nb_components > 1) {
1476
        /* interleaved stream */
1477
        s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1478
        s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1479
    } else if(!s->ls) { /* skip this for JPEG-LS */
1480
        h = s->h_max / s->h_scount[0];
1481
        v = s->v_max / s->v_scount[0];
1482
        s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1483
        s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1484
        s->nb_blocks[0] = 1;
1485
        s->h_scount[0] = 1;
1486
        s->v_scount[0] = 1;
1487
    }
1488

  
1489
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1490
        av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d %s\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "",
1491
               predictor, point_transform, ilv, s->bits,
1492
               s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));
1493

  
1494

  
1495
    /* mjpeg-b can have padding bytes between sos and image data, skip them */
1496
    for (i = s->mjpb_skiptosod; i > 0; i--)
1497
        skip_bits(&s->gb, 8);
1498

  
1499
    if(s->lossless){
1500
        if(s->ls){
1501
//            for(){
1502
//            reset_ls_coding_parameters(s, 0);
1503

  
1504
            ff_jpegls_decode_picture(s, predictor, point_transform, ilv);
1505
        }else{
1506
            if(s->rgb){
1507
                if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1508
                    return -1;
1509
            }else{
1510
                if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1511
                    return -1;
1512
            }
1513
        }
1514
    }else{
1515
        if(mjpeg_decode_scan(s, nb_components, predictor, ilv, prev_shift, point_transform) < 0)
1516
            return -1;
1517
    }
1518
    emms_c();
1519
    return 0;
1520
 out_of_range:
1521
    av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1522
    return -1;
1523
}
1524

  
1525
static int mjpeg_decode_dri(MJpegDecodeContext *s)
1526
{
1527
    if (get_bits(&s->gb, 16) != 4)
1528
        return -1;
1529
    s->restart_interval = get_bits(&s->gb, 16);
1530
    s->restart_count = 0;
1531
    av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n", s->restart_interval);
1532

  
1533
    return 0;
1534
}
1535

  
1536
static int mjpeg_decode_app(MJpegDecodeContext *s)
1537
{
1538
    int len, id, i;
1539

  
1540
    len = get_bits(&s->gb, 16);
1541
    if (len < 5)
1542
        return -1;
1543
    if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits)
1544
        return -1;
1545

  
1546
    id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1547
    id = be2me_32(id);
1548
    len -= 6;
1549

  
1550
    if(s->avctx->debug & FF_DEBUG_STARTCODE){
1551
        av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
1552
    }
1553

  
1554
    /* buggy AVID, it puts EOI only at every 10th frame */
1555
    /* also this fourcc is used by non-avid files too, it holds some
1556
       informations, but it's always present in AVID creates files */
1557
    if (id == ff_get_fourcc("AVI1"))
... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff