Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mjpeg.c @ 688cbabe

History | View | Annotate | Download (62 KB)

1
/*
2
 * MJPEG encoder and decoder
3
 * Copyright (c) 2000, 2001 Fabrice Bellard.
4
 *
5
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9
 *
10
 * This library is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 *
19
 * Support for external huffman table, various fixes (AVID workaround),
20
 * aspecting, new decode_frame mechanism and apple mjpeg-b support
21
 *                                  by Alex Beregszaszi <alex@naxine.org>
22
 */
23

    
24
/**
25
 * @file mjpeg.c
26
 * MJPEG encoder and decoder.
27
 */
28
 
29
//#define DEBUG
30
#include <assert.h>
31

    
32
#include "avcodec.h"
33
#include "dsputil.h"
34
#include "mpegvideo.h"
35

    
36
/* use two quantizer tables (one for luminance and one for chrominance) */
37
/* not yet working */
38
#undef TWOMATRIXES
39

    
40
typedef struct MJpegContext {
41
    uint8_t huff_size_dc_luminance[12]; //FIXME use array [3] instead of lumi / chrom, for easier addressing 
42
    uint16_t huff_code_dc_luminance[12];
43
    uint8_t huff_size_dc_chrominance[12];
44
    uint16_t huff_code_dc_chrominance[12];
45

    
46
    uint8_t huff_size_ac_luminance[256];
47
    uint16_t huff_code_ac_luminance[256];
48
    uint8_t huff_size_ac_chrominance[256];
49
    uint16_t huff_code_ac_chrominance[256];
50
} MJpegContext;
51

    
52
/* JPEG marker codes */
53
typedef enum {
54
    /* start of frame */
55
    SOF0  = 0xc0,        /* baseline */
56
    SOF1  = 0xc1,        /* extended sequential, huffman */
57
    SOF2  = 0xc2,        /* progressive, huffman */
58
    SOF3  = 0xc3,        /* lossless, huffman */
59

    
60
    SOF5  = 0xc5,        /* differential sequential, huffman */
61
    SOF6  = 0xc6,        /* differential progressive, huffman */
62
    SOF7  = 0xc7,        /* differential lossless, huffman */
63
    JPG   = 0xc8,        /* reserved for JPEG extension */
64
    SOF9  = 0xc9,        /* extended sequential, arithmetic */
65
    SOF10 = 0xca,        /* progressive, arithmetic */
66
    SOF11 = 0xcb,        /* lossless, arithmetic */
67

    
68
    SOF13 = 0xcd,        /* differential sequential, arithmetic */
69
    SOF14 = 0xce,        /* differential progressive, arithmetic */
70
    SOF15 = 0xcf,        /* differential lossless, arithmetic */
71

    
72
    DHT   = 0xc4,        /* define huffman tables */
73

    
74
    DAC   = 0xcc,        /* define arithmetic-coding conditioning */
75

    
76
    /* restart with modulo 8 count "m" */
77
    RST0  = 0xd0,
78
    RST1  = 0xd1,
79
    RST2  = 0xd2,
80
    RST3  = 0xd3,
81
    RST4  = 0xd4,
82
    RST5  = 0xd5,
83
    RST6  = 0xd6,
84
    RST7  = 0xd7,
85

    
86
    SOI   = 0xd8,        /* start of image */
87
    EOI   = 0xd9,        /* end of image */
88
    SOS   = 0xda,        /* start of scan */
89
    DQT   = 0xdb,        /* define quantization tables */
90
    DNL   = 0xdc,        /* define number of lines */
91
    DRI   = 0xdd,        /* define restart interval */
92
    DHP   = 0xde,        /* define hierarchical progression */
93
    EXP   = 0xdf,        /* expand reference components */
94

    
95
    APP0  = 0xe0,
96
    APP1  = 0xe1,
97
    APP2  = 0xe2,
98
    APP3  = 0xe3,
99
    APP4  = 0xe4,
100
    APP5  = 0xe5,
101
    APP6  = 0xe6,
102
    APP7  = 0xe7,
103
    APP8  = 0xe8,
104
    APP9  = 0xe9,
105
    APP10 = 0xea,
106
    APP11 = 0xeb,
107
    APP12 = 0xec,
108
    APP13 = 0xed,
109
    APP14 = 0xee,
110
    APP15 = 0xef,
111

    
112
    JPG0  = 0xf0,
113
    JPG1  = 0xf1,
114
    JPG2  = 0xf2,
115
    JPG3  = 0xf3,
116
    JPG4  = 0xf4,
117
    JPG5  = 0xf5,
118
    JPG6  = 0xf6,
119
    JPG7  = 0xf7,
120
    JPG8  = 0xf8,
121
    JPG9  = 0xf9,
122
    JPG10 = 0xfa,
123
    JPG11 = 0xfb,
124
    JPG12 = 0xfc,
125
    JPG13 = 0xfd,
126

    
127
    COM   = 0xfe,        /* comment */
128

    
129
    TEM   = 0x01,        /* temporary private use for arithmetic coding */
130

    
131
    /* 0x02 -> 0xbf reserved */
132
} JPEG_MARKER;
133

    
134
#if 0
135
/* These are the sample quantization tables given in JPEG spec section K.1.
136
 * The spec says that the values given produce "good" quality, and
137
 * when divided by 2, "very good" quality.
138
 */
139
static const unsigned char std_luminance_quant_tbl[64] = {
140
    16,  11,  10,  16,  24,  40,  51,  61,
141
    12,  12,  14,  19,  26,  58,  60,  55,
142
    14,  13,  16,  24,  40,  57,  69,  56,
143
    14,  17,  22,  29,  51,  87,  80,  62,
144
    18,  22,  37,  56,  68, 109, 103,  77,
145
    24,  35,  55,  64,  81, 104, 113,  92,
146
    49,  64,  78,  87, 103, 121, 120, 101,
147
    72,  92,  95,  98, 112, 100, 103,  99
148
};
149
static const unsigned char std_chrominance_quant_tbl[64] = {
150
    17,  18,  24,  47,  99,  99,  99,  99,
151
    18,  21,  26,  66,  99,  99,  99,  99,
152
    24,  26,  56,  99,  99,  99,  99,  99,
153
    47,  66,  99,  99,  99,  99,  99,  99,
154
    99,  99,  99,  99,  99,  99,  99,  99,
155
    99,  99,  99,  99,  99,  99,  99,  99,
156
    99,  99,  99,  99,  99,  99,  99,  99,
157
    99,  99,  99,  99,  99,  99,  99,  99
158
};
159
#endif
160

    
161
/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
162
/* IMPORTANT: these are only valid for 8-bit data precision! */
163
static const uint8_t bits_dc_luminance[17] =
164
{ /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
165
static const uint8_t val_dc_luminance[] =
166
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
167

    
168
static const uint8_t bits_dc_chrominance[17] =
169
{ /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
170
static const uint8_t val_dc_chrominance[] =
171
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
172

    
173
static const uint8_t bits_ac_luminance[17] =
174
{ /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
175
static const uint8_t val_ac_luminance[] =
176
{ 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
177
  0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
178
  0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
179
  0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
180
  0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
181
  0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
182
  0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
183
  0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
184
  0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
185
  0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
186
  0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
187
  0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
188
  0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
189
  0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
190
  0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
191
  0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
192
  0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
193
  0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
194
  0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
195
  0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
196
  0xf9, 0xfa 
197
};
198

    
199
static const uint8_t bits_ac_chrominance[17] =
200
{ /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
201

    
202
static const uint8_t val_ac_chrominance[] =
203
{ 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
204
  0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
205
  0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
206
  0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
207
  0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
208
  0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
209
  0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
210
  0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
211
  0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
212
  0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
213
  0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
214
  0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
215
  0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
216
  0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
217
  0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
218
  0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
219
  0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
220
  0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
221
  0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
222
  0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
223
  0xf9, 0xfa 
224
};
225

    
226
/* isn't this function nicer than the one in the libjpeg ? */
227
static void build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code,
228
                                const uint8_t *bits_table, const uint8_t *val_table)
229
{
230
    int i, j, k,nb, code, sym;
231

    
232
    code = 0;
233
    k = 0;
234
    for(i=1;i<=16;i++) {
235
        nb = bits_table[i];
236
        for(j=0;j<nb;j++) {
237
            sym = val_table[k++];
238
            huff_size[sym] = i;
239
            huff_code[sym] = code;
240
            code++;
241
        }
242
        code <<= 1;
243
    }
244
}
245

    
246
int mjpeg_init(MpegEncContext *s)
247
{
248
    MJpegContext *m;
249
    
250
    m = av_malloc(sizeof(MJpegContext));
251
    if (!m)
252
        return -1;
253
    
254
    s->min_qcoeff=-1023;
255
    s->max_qcoeff= 1023;
256

    
257
    /* build all the huffman tables */
258
    build_huffman_codes(m->huff_size_dc_luminance,
259
                        m->huff_code_dc_luminance,
260
                        bits_dc_luminance,
261
                        val_dc_luminance);
262
    build_huffman_codes(m->huff_size_dc_chrominance,
263
                        m->huff_code_dc_chrominance,
264
                        bits_dc_chrominance,
265
                        val_dc_chrominance);
266
    build_huffman_codes(m->huff_size_ac_luminance,
267
                        m->huff_code_ac_luminance,
268
                        bits_ac_luminance,
269
                        val_ac_luminance);
270
    build_huffman_codes(m->huff_size_ac_chrominance,
271
                        m->huff_code_ac_chrominance,
272
                        bits_ac_chrominance,
273
                        val_ac_chrominance);
274
    
275
    s->mjpeg_ctx = m;
276
    return 0;
277
}
278

    
279
void mjpeg_close(MpegEncContext *s)
280
{
281
    av_free(s->mjpeg_ctx);
282
}
283

    
284
#define PREDICT(ret, topleft, top, left, predictor)\
285
    switch(predictor){\
286
        case 1: ret= left; break;\
287
        case 2: ret= top; break;\
288
        case 3: ret= topleft; break;\
289
        case 4: ret= left   +   top - topleft; break;\
290
        case 5: ret= left   + ((top - topleft)>>1); break;\
291
        case 6: ret= top + ((left   - topleft)>>1); break;\
292
        default:\
293
        case 7: ret= (left + top)>>1; break;\
294
    }
295

    
296
#ifdef CONFIG_ENCODERS
297
static inline void put_marker(PutBitContext *p, int code)
298
{
299
    put_bits(p, 8, 0xff);
300
    put_bits(p, 8, code);
301
}
302

    
303
/* table_class: 0 = DC coef, 1 = AC coefs */
304
static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
305
                             const uint8_t *bits_table, const uint8_t *value_table)
306
{
307
    PutBitContext *p = &s->pb;
308
    int n, i;
309

    
310
    put_bits(p, 4, table_class);
311
    put_bits(p, 4, table_id);
312

    
313
    n = 0;
314
    for(i=1;i<=16;i++) {
315
        n += bits_table[i];
316
        put_bits(p, 8, bits_table[i]);
317
    }
318

    
319
    for(i=0;i<n;i++)
320
        put_bits(p, 8, value_table[i]);
321

    
322
    return n + 17;
323
}
324

    
325
static void jpeg_table_header(MpegEncContext *s)
326
{
327
    PutBitContext *p = &s->pb;
328
    int i, j, size;
329
    uint8_t *ptr;
330

    
331
    /* quant matrixes */
332
    put_marker(p, DQT);
333
#ifdef TWOMATRIXES
334
    put_bits(p, 16, 2 + 2 * (1 + 64));
335
#else
336
    put_bits(p, 16, 2 + 1 * (1 + 64));
337
#endif
338
    put_bits(p, 4, 0); /* 8 bit precision */
339
    put_bits(p, 4, 0); /* table 0 */
340
    for(i=0;i<64;i++) {
341
        j = s->intra_scantable.permutated[i];
342
        put_bits(p, 8, s->intra_matrix[j]);
343
    }
344
#ifdef TWOMATRIXES
345
    put_bits(p, 4, 0); /* 8 bit precision */
346
    put_bits(p, 4, 1); /* table 1 */
347
    for(i=0;i<64;i++) {
348
        j = s->intra_scantable.permutated[i];
349
        put_bits(p, 8, s->chroma_intra_matrix[j]);
350
    }
351
#endif
352

    
353
    /* huffman table */
354
    put_marker(p, DHT);
355
    flush_put_bits(p);
356
    ptr = pbBufPtr(p);
357
    put_bits(p, 16, 0); /* patched later */
358
    size = 2;
359
    size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
360
    size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
361
    
362
    size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
363
    size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
364
    ptr[0] = size >> 8;
365
    ptr[1] = size;
366
}
367

    
368
static void jpeg_put_comments(MpegEncContext *s)
369
{
370
    PutBitContext *p = &s->pb;
371
    int size;
372
    uint8_t *ptr;
373

    
374
    if (s->aspect_ratio_info /* && !lossless */)
375
    {
376
    /* JFIF header */
377
    put_marker(p, APP0);
378
    put_bits(p, 16, 16);
379
    put_string(p, "JFIF"); /* this puts the trailing zero-byte too */
380
    put_bits(p, 16, 0x0201); /* v 1.02 */
381
    put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
382
    switch(s->aspect_ratio_info)
383
    {
384
        case FF_ASPECT_4_3_625:
385
        case FF_ASPECT_4_3_525:
386
            put_bits(p, 16, 4); 
387
            put_bits(p, 16, 3);
388
            break;
389
        case FF_ASPECT_16_9_625:
390
        case FF_ASPECT_16_9_525:
391
            put_bits(p, 16, 16); 
392
            put_bits(p, 16, 9);
393
            break;
394
        case FF_ASPECT_EXTENDED:
395
            put_bits(p, 16, s->aspected_width);
396
            put_bits(p, 16, s->aspected_height);
397
            break;
398
        case FF_ASPECT_SQUARE:
399
        default:
400
            put_bits(p, 16, 1); /* aspect: 1:1 */
401
            put_bits(p, 16, 1);
402
            break;
403
    }
404
    put_bits(p, 8, 0); /* thumbnail width */
405
    put_bits(p, 8, 0); /* thumbnail height */
406
    }
407

    
408
    /* comment */
409
    if(!(s->flags & CODEC_FLAG_BITEXACT)){
410
        put_marker(p, COM);
411
        flush_put_bits(p);
412
        ptr = pbBufPtr(p);
413
        put_bits(p, 16, 0); /* patched later */
414
        put_string(p, LIBAVCODEC_IDENT);
415
        size = strlen(LIBAVCODEC_IDENT)+3;
416
        ptr[0] = size >> 8;
417
        ptr[1] = size;
418
    }
419
}
420

    
421
void mjpeg_picture_header(MpegEncContext *s)
422
{
423
    const int lossless= s->avctx->codec_id == CODEC_ID_LJPEG;
424

    
425
    put_marker(&s->pb, SOI);
426

    
427
    if (!s->mjpeg_data_only_frames)
428
    {
429
    jpeg_put_comments(s);    
430

    
431
    if (s->mjpeg_write_tables) jpeg_table_header(s);
432

    
433
    put_marker(&s->pb, lossless ? SOF3 : SOF0);
434

    
435
    put_bits(&s->pb, 16, 17);
436
    if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32)
437
        put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
438
    else
439
        put_bits(&s->pb, 8, 8); /* 8 bits/component */
440
    put_bits(&s->pb, 16, s->height);
441
    put_bits(&s->pb, 16, s->width);
442
    put_bits(&s->pb, 8, 3); /* 3 components */
443
    
444
    /* Y component */
445
    put_bits(&s->pb, 8, 1); /* component number */
446
    put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
447
    put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
448
    put_bits(&s->pb, 8, 0); /* select matrix */
449
    
450
    /* Cb component */
451
    put_bits(&s->pb, 8, 2); /* component number */
452
    put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
453
    put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
454
#ifdef TWOMATRIXES
455
    put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
456
#else
457
    put_bits(&s->pb, 8, 0); /* select matrix */
458
#endif
459

    
460
    /* Cr component */
461
    put_bits(&s->pb, 8, 3); /* component number */
462
    put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
463
    put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
464
#ifdef TWOMATRIXES
465
    put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
466
#else
467
    put_bits(&s->pb, 8, 0); /* select matrix */
468
#endif
469
    }
470

    
471
    /* scan header */
472
    put_marker(&s->pb, SOS);
473
    put_bits(&s->pb, 16, 12); /* length */
474
    put_bits(&s->pb, 8, 3); /* 3 components */
475
    
476
    /* Y component */
477
    put_bits(&s->pb, 8, 1); /* index */
478
    put_bits(&s->pb, 4, 0); /* DC huffman table index */
479
    put_bits(&s->pb, 4, 0); /* AC huffman table index */
480
    
481
    /* Cb component */
482
    put_bits(&s->pb, 8, 2); /* index */
483
    put_bits(&s->pb, 4, 1); /* DC huffman table index */
484
    put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
485
    
486
    /* Cr component */
487
    put_bits(&s->pb, 8, 3); /* index */
488
    put_bits(&s->pb, 4, 1); /* DC huffman table index */
489
    put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
490

    
491
    put_bits(&s->pb, 8, lossless ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
492
    put_bits(&s->pb, 8, lossless ? 0 : 63); /* Se (not used) */
493
    put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
494
}
495

    
496
static void escape_FF(MpegEncContext *s, int start)
497
{
498
    int size= get_bit_count(&s->pb) - start*8;
499
    int i, ff_count;
500
    uint8_t *buf= s->pb.buf + start;
501
    int align= (-(size_t)(buf))&3;
502
    
503
    assert((size&7) == 0);
504
    size >>= 3;
505
    
506
    ff_count=0;
507
    for(i=0; i<size && i<align; i++){
508
        if(buf[i]==0xFF) ff_count++;
509
    }
510
    for(; i<size-15; i+=16){
511
        int acc, v;
512

    
513
        v= *(uint32_t*)(&buf[i]);
514
        acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
515
        v= *(uint32_t*)(&buf[i+4]);
516
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
517
        v= *(uint32_t*)(&buf[i+8]);
518
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
519
        v= *(uint32_t*)(&buf[i+12]);
520
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
521

    
522
        acc>>=4;
523
        acc+= (acc>>16);
524
        acc+= (acc>>8);
525
        ff_count+= acc&0xFF;
526
    }
527
    for(; i<size; i++){
528
        if(buf[i]==0xFF) ff_count++;
529
    }
530

    
531
    if(ff_count==0) return;
532
    
533
    /* skip put bits */
534
    for(i=0; i<ff_count-3; i+=4)
535
        put_bits(&s->pb, 32, 0);
536
    put_bits(&s->pb, (ff_count-i)*8, 0);
537
    flush_put_bits(&s->pb); 
538

    
539
    for(i=size-1; ff_count; i--){
540
        int v= buf[i];
541

    
542
        if(v==0xFF){
543
//printf("%d %d\n", i, ff_count);
544
            buf[i+ff_count]= 0;
545
            ff_count--;
546
        }
547

    
548
        buf[i+ff_count]= v;
549
    }
550
}
551

    
552
void mjpeg_picture_trailer(MpegEncContext *s)
553
{
554
    int pad= (-get_bit_count(&s->pb))&7;
555
    
556
    put_bits(&s->pb, pad,0xFF>>(8-pad));
557
    flush_put_bits(&s->pb);
558

    
559
    assert((s->header_bits&7)==0);
560
    
561
    escape_FF(s, s->header_bits>>3);
562

    
563
    put_marker(&s->pb, EOI);
564
}
565

    
566
static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
567
                                   uint8_t *huff_size, uint16_t *huff_code)
568
{
569
    int mant, nbits;
570

    
571
    if (val == 0) {
572
        put_bits(&s->pb, huff_size[0], huff_code[0]);
573
    } else {
574
        mant = val;
575
        if (val < 0) {
576
            val = -val;
577
            mant--;
578
        }
579
        
580
        nbits= av_log2_16bit(val) + 1;
581
            
582
        put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
583
        
584
        put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
585
    }
586
}
587

    
588
static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
589
{
590
    int mant, nbits, code, i, j;
591
    int component, dc, run, last_index, val;
592
    MJpegContext *m = s->mjpeg_ctx;
593
    uint8_t *huff_size_ac;
594
    uint16_t *huff_code_ac;
595
    
596
    /* DC coef */
597
    component = (n <= 3 ? 0 : n - 4 + 1);
598
    dc = block[0]; /* overflow is impossible */
599
    val = dc - s->last_dc[component];
600
    if (n < 4) {
601
        mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
602
        huff_size_ac = m->huff_size_ac_luminance;
603
        huff_code_ac = m->huff_code_ac_luminance;
604
    } else {
605
        mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
606
        huff_size_ac = m->huff_size_ac_chrominance;
607
        huff_code_ac = m->huff_code_ac_chrominance;
608
    }
609
    s->last_dc[component] = dc;
610
    
611
    /* AC coefs */
612
    
613
    run = 0;
614
    last_index = s->block_last_index[n];
615
    for(i=1;i<=last_index;i++) {
616
        j = s->intra_scantable.permutated[i];
617
        val = block[j];
618
        if (val == 0) {
619
            run++;
620
        } else {
621
            while (run >= 16) {
622
                put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
623
                run -= 16;
624
            }
625
            mant = val;
626
            if (val < 0) {
627
                val = -val;
628
                mant--;
629
            }
630
            
631
            nbits= av_log2(val) + 1;
632
            code = (run << 4) | nbits;
633

    
634
            put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
635
        
636
            put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
637
            run = 0;
638
        }
639
    }
640

    
641
    /* output EOB only if not already 64 values */
642
    if (last_index < 63 || run != 0)
643
        put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
644
}
645

    
646
void mjpeg_encode_mb(MpegEncContext *s, 
647
                     DCTELEM block[6][64])
648
{
649
    int i;
650
    for(i=0;i<6;i++) {
651
        encode_block(s, block[i], i);
652
    }
653
}
654

    
655
static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
656
    MpegEncContext * const s = avctx->priv_data;
657
    MJpegContext * const m = s->mjpeg_ctx;
658
    AVFrame *pict = data;
659
    const int width= s->width;
660
    const int height= s->height;
661
    AVFrame * const p= (AVFrame*)&s->current_picture;
662
    const int predictor= avctx->prediction_method+1;
663

    
664
    init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
665

    
666
    *p = *pict;
667
    p->pict_type= FF_I_TYPE;
668
    p->key_frame= 1;
669
    
670
    mjpeg_picture_header(s);
671

    
672
    s->header_bits= get_bit_count(&s->pb);
673

    
674
    if(avctx->pix_fmt == PIX_FMT_RGBA32){
675
        int x, y, i;
676
        const int linesize= p->linesize[0];
677
        uint16_t buffer[2048][4];
678
        int left[3], top[3], topleft[3];
679

    
680
        for(i=0; i<3; i++){
681
            buffer[0][i]= 1 << (9 - 1);
682
        }
683

    
684
        for(y = 0; y < height; y++) {
685
            const int modified_predictor= y ? predictor : 1;
686
            uint8_t *ptr = p->data[0] + (linesize * y);
687

    
688
            for(i=0; i<3; i++){
689
                top[i]= left[i]= topleft[i]= buffer[0][i];
690
            }
691
            for(x = 0; x < width; x++) {
692
                buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
693
                buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
694
                buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
695

    
696
                for(i=0;i<3;i++) {
697
                    int pred, diff;
698

    
699
                    PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
700
                        
701
                    topleft[i]= top[i];
702
                    top[i]= buffer[x+1][i];
703
                    
704
                    left[i]= buffer[x][i];
705

    
706
                    diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
707
                    
708
                    if(i==0)
709
                        mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
710
                    else
711
                        mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
712
                }
713
            }
714
        }
715
    }else{
716
        int mb_x, mb_y, i;
717
        const int mb_width  = (width  + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
718
        const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
719
        
720
        for(mb_y = 0; mb_y < mb_height; mb_y++) {
721
            for(mb_x = 0; mb_x < mb_width; mb_x++) {
722
                if(mb_x==0 || mb_y==0){
723
                    for(i=0;i<3;i++) {
724
                        uint8_t *ptr;
725
                        int x, y, h, v, linesize;
726
                        h = s->mjpeg_hsample[i];
727
                        v = s->mjpeg_vsample[i];
728
                        linesize= p->linesize[i];
729

    
730
                        for(y=0; y<v; y++){
731
                            for(x=0; x<h; x++){
732
                                int pred;
733

    
734
                                ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
735
                                if(y==0 && mb_y==0){
736
                                    if(x==0 && mb_x==0){
737
                                        pred= 128;
738
                                    }else{
739
                                        pred= ptr[-1];
740
                                    }
741
                                }else{
742
                                    if(x==0 && mb_x==0){
743
                                        pred= ptr[-linesize];
744
                                    }else{
745
                                        PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
746
                                    }
747
                                }
748
                                
749
                                if(i==0)
750
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
751
                                else
752
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
753
                            }
754
                        }
755
                    }
756
                }else{
757
                    for(i=0;i<3;i++) {
758
                        uint8_t *ptr;
759
                        int x, y, h, v, linesize;
760
                        h = s->mjpeg_hsample[i];
761
                        v = s->mjpeg_vsample[i];
762
                        linesize= p->linesize[i];
763
                             
764
                        for(y=0; y<v; y++){
765
                            for(x=0; x<h; x++){
766
                                int pred;
767

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

    
772
                                if(i==0)
773
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
774
                                else
775
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
776
                            }
777
                        }
778
                    }
779
                }
780
            }
781
        }
782
    }
783

    
784
    emms_c();
785
    
786
    mjpeg_picture_trailer(s);
787
    s->picture_number++;
788

    
789
    flush_put_bits(&s->pb);
790
    return pbBufPtr(&s->pb) - s->pb.buf;
791
//    return (get_bit_count(&f->pb)+7)/8;
792
}
793

    
794
#endif //CONFIG_ENCODERS
795

    
796
/******************************************/
797
/* decoding */
798

    
799
#define MAX_COMPONENTS 4
800

    
801
typedef struct MJpegDecodeContext {
802
    AVCodecContext *avctx;
803
    GetBitContext gb;
804
    int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
805

    
806
    int start_code; /* current start code */
807
    int buffer_size;
808
    uint8_t *buffer;
809

    
810
    int16_t quant_matrixes[4][64];
811
    VLC vlcs[2][4];
812
    int qscale[4];      ///< quantizer scale calculated from quant_matrixes
813

    
814
    int org_width, org_height;  /* size given at codec init */
815
    int first_picture;    /* true if decoding first picture */
816
    int interlaced;     /* true if interlaced */
817
    int bottom_field;   /* true if bottom field */
818
    int lossless;
819
    int rgb;
820
    int rct;            /* standard rct */  
821
    int pegasus_rct;    /* pegasus reversible colorspace transform */  
822
    int bits;           /* bits per component */
823

    
824
    int width, height;
825
    int mb_width, mb_height;
826
    int nb_components;
827
    int component_id[MAX_COMPONENTS];
828
    int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
829
    int v_count[MAX_COMPONENTS];
830
    int comp_index[MAX_COMPONENTS];
831
    int dc_index[MAX_COMPONENTS];
832
    int ac_index[MAX_COMPONENTS];
833
    int nb_blocks[MAX_COMPONENTS];
834
    int h_scount[MAX_COMPONENTS];
835
    int v_scount[MAX_COMPONENTS];
836
    int h_max, v_max; /* maximum h and v counts */
837
    int quant_index[4];   /* quant table index for each component */
838
    int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
839
    AVFrame picture; /* picture structure */
840
    int linesize[MAX_COMPONENTS];                   ///< linesize << interlaced
841
    uint8_t *qscale_table;
842
    DCTELEM block[64] __align8;
843
    ScanTable scantable;
844
    void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
845

    
846
    int restart_interval;
847
    int restart_count;
848

    
849
    int buggy_avid;
850
    int interlace_polarity;
851
} MJpegDecodeContext;
852

    
853
static int mjpeg_decode_dht(MJpegDecodeContext *s);
854

    
855
static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table, 
856
                      int nb_codes)
857
{
858
    uint8_t huff_size[256];
859
    uint16_t huff_code[256];
860

    
861
    memset(huff_size, 0, sizeof(huff_size));
862
    build_huffman_codes(huff_size, huff_code, bits_table, val_table);
863
    
864
    return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
865
}
866

    
867
static int mjpeg_decode_init(AVCodecContext *avctx)
868
{
869
    MJpegDecodeContext *s = avctx->priv_data;
870
    MpegEncContext s2;
871

    
872
    s->avctx = avctx;
873

    
874
    /* ugly way to get the idct & scantable FIXME */
875
    memset(&s2, 0, sizeof(MpegEncContext));
876
    s2.flags= avctx->flags;
877
    s2.avctx= avctx;
878
//    s2->out_format = FMT_MJPEG;
879
    s2.width = 8;
880
    s2.height = 8;
881
    if (MPV_common_init(&s2) < 0)
882
       return -1;
883
    s->scantable= s2.intra_scantable;
884
    s->idct_put= s2.dsp.idct_put;
885
    MPV_common_end(&s2);
886

    
887
    s->mpeg_enc_ctx_allocated = 0;
888
    s->buffer_size = 102400; /* smaller buffer should be enough,
889
                                but photojpg files could ahive bigger sizes */
890
    s->buffer = av_malloc(s->buffer_size);
891
    if (!s->buffer)
892
        return -1;
893
    s->start_code = -1;
894
    s->first_picture = 1;
895
    s->org_width = avctx->width;
896
    s->org_height = avctx->height;
897
    
898
    build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
899
    build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
900
    build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
901
    build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
902

    
903
    if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
904
    {
905
        printf("mjpeg: using external huffman table\n");
906
        init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
907
        mjpeg_decode_dht(s);
908
        /* should check for error - but dunno */
909
    }
910

    
911
    return 0;
912
}
913

    
914
/* quantize tables */
915
static int mjpeg_decode_dqt(MJpegDecodeContext *s)
916
{
917
    int len, index, i, j;
918
    
919
    len = get_bits(&s->gb, 16) - 2;
920

    
921
    while (len >= 65) {
922
        /* only 8 bit precision handled */
923
        if (get_bits(&s->gb, 4) != 0)
924
        {
925
            dprintf("dqt: 16bit precision\n");
926
            return -1;
927
        }
928
        index = get_bits(&s->gb, 4);
929
        if (index >= 4)
930
            return -1;
931
        dprintf("index=%d\n", index);
932
        /* read quant table */
933
        for(i=0;i<64;i++) {
934
            j = s->scantable.permutated[i];
935
            s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
936
        }
937

    
938
        //XXX FIXME finetune, and perhaps add dc too
939
        s->qscale[index]= FFMAX(
940
            s->quant_matrixes[index][s->scantable.permutated[1]],
941
            s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
942
        len -= 65;
943
    }
944
    
945
    return 0;
946
}
947

    
948
/* decode huffman tables and build VLC decoders */
949
static int mjpeg_decode_dht(MJpegDecodeContext *s)
950
{
951
    int len, index, i, class, n, v, code_max;
952
    uint8_t bits_table[17];
953
    uint8_t val_table[256];
954
    
955
    len = get_bits(&s->gb, 16) - 2;
956

    
957
    while (len > 0) {
958
        if (len < 17)
959
            return -1;
960
        class = get_bits(&s->gb, 4);
961
        if (class >= 2)
962
            return -1;
963
        index = get_bits(&s->gb, 4);
964
        if (index >= 4)
965
            return -1;
966
        n = 0;
967
        for(i=1;i<=16;i++) {
968
            bits_table[i] = get_bits(&s->gb, 8);
969
            n += bits_table[i];
970
        }
971
        len -= 17;
972
        if (len < n || n > 256)
973
            return -1;
974

    
975
        code_max = 0;
976
        for(i=0;i<n;i++) {
977
            v = get_bits(&s->gb, 8);
978
            if (v > code_max)
979
                code_max = v;
980
            val_table[i] = v;
981
        }
982
        len -= n;
983

    
984
        /* build VLC and flush previous vlc if present */
985
        free_vlc(&s->vlcs[class][index]);
986
        dprintf("class=%d index=%d nb_codes=%d\n",
987
               class, index, code_max + 1);
988
        if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1) < 0){
989
            return -1;
990
        }
991
    }
992
    return 0;
993
}
994

    
995
static int mjpeg_decode_sof(MJpegDecodeContext *s)
996
{
997
    int len, nb_components, i, width, height;
998

    
999
    /* XXX: verify len field validity */
1000
    len = get_bits(&s->gb, 16);
1001
    s->bits= get_bits(&s->gb, 8);
1002
    
1003
    if(s->pegasus_rct) s->bits=9;  
1004
    if(s->bits==9 && !s->pegasus_rct) s->rct=1;    //FIXME ugly
1005

    
1006
    if (s->bits != 8 && !s->lossless){
1007
        printf("only 8 bits/component accepted\n");
1008
        return -1;
1009
    }
1010
    height = get_bits(&s->gb, 16);
1011
    width = get_bits(&s->gb, 16);
1012
    dprintf("sof0: picture: %dx%d\n", width, height);
1013

    
1014
    nb_components = get_bits(&s->gb, 8);
1015
    if (nb_components <= 0 ||
1016
        nb_components > MAX_COMPONENTS)
1017
        return -1;
1018
    s->nb_components = nb_components;
1019
    s->h_max = 1;
1020
    s->v_max = 1;
1021
    for(i=0;i<nb_components;i++) {
1022
        /* component id */
1023
        s->component_id[i] = get_bits(&s->gb, 8) - 1;
1024
        s->h_count[i] = get_bits(&s->gb, 4);
1025
        s->v_count[i] = get_bits(&s->gb, 4);
1026
        /* compute hmax and vmax (only used in interleaved case) */
1027
        if (s->h_count[i] > s->h_max)
1028
            s->h_max = s->h_count[i];
1029
        if (s->v_count[i] > s->v_max)
1030
            s->v_max = s->v_count[i];
1031
        s->quant_index[i] = get_bits(&s->gb, 8);
1032
        if (s->quant_index[i] >= 4)
1033
            return -1;
1034
        dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1035
            s->v_count[i], s->component_id[i], s->quant_index[i]);
1036
    }
1037
    
1038
    if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1039

    
1040
    /* if different size, realloc/alloc picture */
1041
    /* XXX: also check h_count and v_count */
1042
    if (width != s->width || height != s->height) {
1043
        av_freep(&s->qscale_table);
1044
            
1045
        s->width = width;
1046
        s->height = height;
1047
        /* test interlaced mode */
1048
        if (s->first_picture &&
1049
            s->org_height != 0 &&
1050
            s->height < ((s->org_height * 3) / 4)) {
1051
            s->interlaced = 1;
1052
//            s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1053
            s->bottom_field = 0;
1054
        }
1055

    
1056
        s->qscale_table= av_mallocz((s->width+15)/16);
1057

    
1058
        s->first_picture = 0;
1059
    }
1060
    
1061
    if(s->interlaced && s->bottom_field)
1062
        return 0;
1063
 
1064
    /* XXX: not complete test ! */
1065
    switch((s->h_count[0] << 4) | s->v_count[0]) {
1066
    case 0x11:
1067
        if(s->rgb){
1068
            s->avctx->pix_fmt = PIX_FMT_RGBA32;
1069
        }else
1070
            s->avctx->pix_fmt = PIX_FMT_YUV444P;
1071
        break;
1072
    case 0x21:
1073
        s->avctx->pix_fmt = PIX_FMT_YUV422P;
1074
        break;
1075
    default:
1076
    case 0x22:
1077
        s->avctx->pix_fmt = PIX_FMT_YUV420P;
1078
        break;
1079
    }
1080

    
1081
    if(s->picture.data[0])
1082
        s->avctx->release_buffer(s->avctx, &s->picture);
1083

    
1084
    s->picture.reference= 0;
1085
    if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1086
        fprintf(stderr, "get_buffer() failed\n");
1087
        return -1;
1088
    }
1089
    s->picture.pict_type= I_TYPE;
1090
    s->picture.key_frame= 1;
1091
    
1092
    for(i=0; i<3; i++){
1093
        s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1094
    }
1095

    
1096
//    printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1097
    
1098
    if (len != (8+(3*nb_components)))
1099
    {
1100
        dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1101
    }
1102
    
1103
    return 0;
1104
}
1105

    
1106
static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1107
{
1108
    int code;
1109
    code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1110
    if (code < 0)
1111
    {
1112
        dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1113
                &s->vlcs[0][dc_index]);
1114
        return 0xffff;
1115
    }
1116

    
1117
    if(code)
1118
        return get_xbits(&s->gb, code);
1119
    else
1120
        return 0;
1121
}
1122

    
1123
/* decode block and dequantize */
1124
static int decode_block(MJpegDecodeContext *s, DCTELEM *block, 
1125
                        int component, int dc_index, int ac_index, int quant_index)
1126
{
1127
    int code, i, j, level, val;
1128
    VLC *ac_vlc;
1129
    int16_t *quant_matrix;
1130

    
1131
    /* DC coef */
1132
    val = mjpeg_decode_dc(s, dc_index);
1133
    if (val == 0xffff) {
1134
        dprintf("error dc\n");
1135
        return -1;
1136
    }
1137
    quant_matrix = s->quant_matrixes[quant_index];
1138
    val = val * quant_matrix[0] + s->last_dc[component];
1139
    s->last_dc[component] = val;
1140
    block[0] = val;
1141
    /* AC coefs */
1142
    ac_vlc = &s->vlcs[1][ac_index];
1143
    i = 1;
1144
    for(;;) {
1145
        code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
1146

    
1147
        if (code < 0) {
1148
            dprintf("error ac\n");
1149
            return -1;
1150
        }
1151
        /* EOB */
1152
        if (code == 0)
1153
            break;
1154
        if (code == 0xf0) {
1155
            i += 16;
1156
        } else {
1157
            level = get_xbits(&s->gb, code & 0xf);
1158
            i += code >> 4;
1159
            if (i >= 64) {
1160
                dprintf("error count: %d\n", i);
1161
                return -1;
1162
            }
1163
            j = s->scantable.permutated[i];
1164
            block[j] = level * quant_matrix[j];
1165
            i++;
1166
            if (i >= 64)
1167
                break;
1168
        }
1169
    }
1170
    return 0;
1171
}
1172

    
1173
static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1174
    int i, mb_x, mb_y;
1175
    uint16_t buffer[2048][4];
1176
    int left[3], top[3], topleft[3];
1177
    const int linesize= s->linesize[0];
1178
    const int mask= (1<<s->bits)-1;
1179
    
1180
    for(i=0; i<3; i++){
1181
        buffer[0][i]= 1 << (s->bits + point_transform - 1);
1182
    }
1183
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1184
        const int modified_predictor= mb_y ? predictor : 1;
1185
        uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1186

    
1187
        if (s->interlaced && s->bottom_field)
1188
            ptr += linesize >> 1;
1189

    
1190
        for(i=0; i<3; i++){
1191
            top[i]= left[i]= topleft[i]= buffer[0][i];
1192
        }
1193
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1194
            if (s->restart_interval && !s->restart_count)
1195
                s->restart_count = s->restart_interval;
1196

    
1197
            for(i=0;i<3;i++) {
1198
                int pred;
1199

    
1200
                topleft[i]= top[i];
1201
                top[i]= buffer[mb_x][i];
1202

    
1203
                PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1204
                
1205
                left[i]= 
1206
                buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1207
            }
1208

    
1209
            if (s->restart_interval && !--s->restart_count) {
1210
                align_get_bits(&s->gb);
1211
                skip_bits(&s->gb, 16); /* skip RSTn */
1212
            }
1213
        }
1214

    
1215
        if(s->rct){
1216
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1217
                ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1218
                ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1219
                ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1220
            }
1221
        }else if(s->pegasus_rct){
1222
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1223
                ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1224
                ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1225
                ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1226
            }
1227
        }else{
1228
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1229
                ptr[4*mb_x+0] = buffer[mb_x][0];
1230
                ptr[4*mb_x+1] = buffer[mb_x][1];
1231
                ptr[4*mb_x+2] = buffer[mb_x][2];
1232
            }
1233
        }
1234
    }
1235
    return 0;
1236
}
1237

    
1238
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1239
    int i, mb_x, mb_y;
1240
    const int nb_components=3;
1241

    
1242
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1243
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1244
            if (s->restart_interval && !s->restart_count)
1245
                s->restart_count = s->restart_interval;
1246

    
1247
            if(mb_x==0 || mb_y==0 || s->interlaced){
1248
                for(i=0;i<nb_components;i++) {
1249
                    uint8_t *ptr;
1250
                    int n, h, v, x, y, c, j, linesize;
1251
                    n = s->nb_blocks[i];
1252
                    c = s->comp_index[i];
1253
                    h = s->h_scount[i];
1254
                    v = s->v_scount[i];
1255
                    x = 0;
1256
                    y = 0;
1257
                    linesize= s->linesize[c];
1258
                    
1259
                    for(j=0; j<n; j++) {
1260
                        int pred;
1261

    
1262
                        ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1263
                        if(y==0 && mb_y==0){
1264
                            if(x==0 && mb_x==0){
1265
                                pred= 128 << point_transform;
1266
                            }else{
1267
                                pred= ptr[-1];
1268
                            }
1269
                        }else{
1270
                            if(x==0 && mb_x==0){
1271
                                pred= ptr[-linesize];
1272
                            }else{
1273
                                PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1274
                            }
1275
                        }
1276
                        
1277
                        if (s->interlaced && s->bottom_field)
1278
                            ptr += linesize >> 1;
1279
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1280

    
1281
                        if (++x == h) {
1282
                            x = 0;
1283
                            y++;
1284
                        }
1285
                    }
1286
                }
1287
            }else{
1288
                for(i=0;i<nb_components;i++) {
1289
                    uint8_t *ptr;
1290
                    int n, h, v, x, y, c, j, linesize;
1291
                    n = s->nb_blocks[i];
1292
                    c = s->comp_index[i];
1293
                    h = s->h_scount[i];
1294
                    v = s->v_scount[i];
1295
                    x = 0;
1296
                    y = 0;
1297
                    linesize= s->linesize[c];
1298
                    
1299
                    for(j=0; j<n; j++) {
1300
                        int pred;
1301

    
1302
                        ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1303
                        PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1304
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1305
                        if (++x == h) {
1306
                            x = 0;
1307
                            y++;
1308
                        }
1309
                    }
1310
                }
1311
            }
1312
            if (s->restart_interval && !--s->restart_count) {
1313
                align_get_bits(&s->gb);
1314
                skip_bits(&s->gb, 16); /* skip RSTn */
1315
            }
1316
        }
1317
    }
1318
    return 0;
1319
}
1320

    
1321
static int mjpeg_decode_scan(MJpegDecodeContext *s){
1322
    int i, mb_x, mb_y;
1323
    const int nb_components=3;
1324

    
1325
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1326
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1327
            if (s->restart_interval && !s->restart_count)
1328
                s->restart_count = s->restart_interval;
1329

    
1330
            for(i=0;i<nb_components;i++) {
1331
                uint8_t *ptr;
1332
                int n, h, v, x, y, c, j;
1333
                n = s->nb_blocks[i];
1334
                c = s->comp_index[i];
1335
                h = s->h_scount[i];
1336
                v = s->v_scount[i];
1337
                x = 0;
1338
                y = 0;
1339
                for(j=0;j<n;j++) {
1340
                    memset(s->block, 0, sizeof(s->block));
1341
                    if (decode_block(s, s->block, i, 
1342
                                     s->dc_index[i], s->ac_index[i], 
1343
                                     s->quant_index[c]) < 0) {
1344
                        dprintf("error y=%d x=%d\n", mb_y, mb_x);
1345
                        return -1;
1346
                    }
1347
//                    dprintf("mb: %d %d processed\n", mb_y, mb_x);
1348
                    ptr = s->picture.data[c] + 
1349
                        (s->linesize[c] * (v * mb_y + y) * 8) + 
1350
                        (h * mb_x + x) * 8;
1351
                    if (s->interlaced && s->bottom_field)
1352
                        ptr += s->linesize[c] >> 1;
1353
//printf("%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);
1354
                    s->idct_put(ptr, s->linesize[c], s->block);
1355
                    if (++x == h) {
1356
                        x = 0;
1357
                        y++;
1358
                    }
1359
                }
1360
            }
1361
            /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1362
            if (s->restart_interval && (s->restart_interval < 1350) &&
1363
                !--s->restart_count) {
1364
                align_get_bits(&s->gb);
1365
                skip_bits(&s->gb, 16); /* skip RSTn */
1366
                for (i=0; i<nb_components; i++) /* reset dc */
1367
                    s->last_dc[i] = 1024;
1368
            }
1369
        }
1370
    }
1371
    return 0;
1372
}
1373

    
1374
static int mjpeg_decode_sos(MJpegDecodeContext *s)
1375
{
1376
    int len, nb_components, i, h, v, predictor, point_transform;
1377
    int vmax, hmax, index, id;
1378
    const int block_size= s->lossless ? 1 : 8;
1379

    
1380
    /* XXX: verify len field validity */
1381
    len = get_bits(&s->gb, 16);
1382
    nb_components = get_bits(&s->gb, 8);
1383
    if (len != 6+2*nb_components)
1384
    {
1385
        dprintf("decode_sos: invalid len (%d)\n", len);
1386
        return -1;
1387
    }
1388
    /* XXX: only interleaved scan accepted */
1389
    if (nb_components != 3)
1390
    {
1391
        dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1392
        return -1;
1393
    }
1394
    vmax = 0;
1395
    hmax = 0;
1396
    for(i=0;i<nb_components;i++) {
1397
        id = get_bits(&s->gb, 8) - 1;
1398
        dprintf("component: %d\n", id);
1399
        /* find component index */
1400
        for(index=0;index<s->nb_components;index++)
1401
            if (id == s->component_id[index])
1402
                break;
1403
        if (index == s->nb_components)
1404
        {
1405
            dprintf("decode_sos: index(%d) out of components\n", index);
1406
            return -1;
1407
        }
1408

    
1409
        s->comp_index[i] = index;
1410

    
1411
        s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1412
        s->h_scount[i] = s->h_count[index];
1413
        s->v_scount[i] = s->v_count[index];
1414

    
1415
        s->dc_index[i] = get_bits(&s->gb, 4);
1416
        s->ac_index[i] = get_bits(&s->gb, 4);
1417

    
1418
        if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1419
            s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1420
            goto out_of_range;
1421
#if 0 //buggy
1422
        switch(s->start_code)
1423
        {
1424
            case SOF0:
1425
                if (dc_index[i] > 1 || ac_index[i] > 1)
1426
                    goto out_of_range;
1427
                break;
1428
            case SOF1:
1429
            case SOF2:
1430
                if (dc_index[i] > 3 || ac_index[i] > 3)
1431
                    goto out_of_range;
1432
                break;
1433
            case SOF3:
1434
                if (dc_index[i] > 3 || ac_index[i] != 0)
1435
                    goto out_of_range;
1436
                break;        
1437
        }
1438
#endif
1439
    }
1440

    
1441
    predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */
1442
    skip_bits(&s->gb, 8); /* Se */
1443
    skip_bits(&s->gb, 4); /* Ah */
1444
    point_transform= get_bits(&s->gb, 4); /* Al */
1445

    
1446
    for(i=0;i<nb_components;i++) 
1447
        s->last_dc[i] = 1024;
1448

    
1449
    if (nb_components > 1) {
1450
        /* interleaved stream */
1451
        s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1452
        s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1453
    } else {
1454
        h = s->h_max / s->h_scount[s->comp_index[0]];
1455
        v = s->v_max / s->v_scount[s->comp_index[0]];
1456
        s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1457
        s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1458
        s->nb_blocks[0] = 1;
1459
        s->h_scount[0] = 1;
1460
        s->v_scount[0] = 1;
1461
    }
1462

    
1463
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1464
        printf("%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform);
1465
    
1466
    if(s->lossless){
1467
            if(s->rgb){
1468
                if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1469
                    return -1;
1470
            }else{
1471
                if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1472
                    return -1;
1473
            }
1474
    }else{
1475
        if(mjpeg_decode_scan(s) < 0)
1476
            return -1;
1477
    }
1478
    emms_c();
1479
    return 0;
1480
 out_of_range:
1481
    dprintf("decode_sos: ac/dc index out of range\n");
1482
    return -1;
1483
}
1484

    
1485
static int mjpeg_decode_dri(MJpegDecodeContext *s)
1486
{
1487
    if (get_bits(&s->gb, 16) != 4)
1488
        return -1;
1489
    s->restart_interval = get_bits(&s->gb, 16);
1490
    dprintf("restart interval: %d\n", s->restart_interval);
1491

    
1492
    return 0;
1493
}
1494

    
1495
static int mjpeg_decode_app(MJpegDecodeContext *s)
1496
{
1497
    int len, id;
1498

    
1499
    /* XXX: verify len field validity */
1500
    len = get_bits(&s->gb, 16);
1501
    if (len < 5)
1502
        return -1;
1503

    
1504
    id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1505
    id = be2me_32(id);
1506
    len -= 6;
1507

    
1508
    if(s->avctx->debug & FF_DEBUG_STARTCODE){
1509
        printf("APPx %8X\n", id); 
1510
    }
1511
    
1512
    /* buggy AVID, it puts EOI only at every 10th frame */
1513
    /* also this fourcc is used by non-avid files too, it holds some
1514
       informations, but it's always present in AVID creates files */
1515
    if (id == ff_get_fourcc("AVI1"))
1516
    {
1517
        /* structure:
1518
            4bytes        AVI1
1519
            1bytes        polarity
1520
            1bytes        always zero
1521
            4bytes        field_size
1522
            4bytes        field_size_less_padding
1523
        */
1524
            s->buggy_avid = 1;
1525
//        if (s->first_picture)
1526
//            printf("mjpeg: workarounding buggy AVID\n");
1527
        s->interlace_polarity = get_bits(&s->gb, 8);
1528
#if 0
1529
        skip_bits(&s->gb, 8);
1530
        skip_bits(&s->gb, 32);
1531
        skip_bits(&s->gb, 32);
1532
        len -= 10;
1533
#endif
1534
//        if (s->interlace_polarity)
1535
//            printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1536
        goto out;
1537
    }
1538
    
1539
//    len -= 2;
1540
    
1541
    if (id == ff_get_fourcc("JFIF"))
1542
    {
1543
        int t_w, t_h;
1544
        skip_bits(&s->gb, 8); /* the trailing zero-byte */
1545
        printf("mjpeg: JFIF header found (version: %x.%x)\n",
1546
            get_bits(&s->gb, 8), get_bits(&s->gb, 8));
1547
        if (get_bits(&s->gb, 8) == 0)
1548
        {
1549
            int x_density, y_density; 
1550
            x_density = get_bits(&s->gb, 16);
1551
            y_density = get_bits(&s->gb, 16);
1552

    
1553
            dprintf("x/y density: %d (%f), %d (%f)\n", x_density,
1554
                (float)x_density, y_density, (float)y_density);
1555
#if 0
1556
            //MN: needs to be checked
1557
            if(x_density)
1558
//                s->avctx->aspect_ratio= s->width*y_density/((float)s->height*x_density);
1559
                s->avctx->aspect_ratio = (float)x_density/y_density;
1560
                /* it's better, but every JFIF I have seen stores 1:1 */
1561
            else
1562
                s->avctx->aspect_ratio= 0.0;
1563
#endif
1564
        }
1565
        else
1566
        {
1567
            skip_bits(&s->gb, 16);
1568
            skip_bits(&s->gb, 16);
1569
        }
1570

    
1571
        t_w = get_bits(&s->gb, 8);
1572
        t_h = get_bits(&s->gb, 8);
1573
        if (t_w && t_h)
1574
        {
1575
            /* skip thumbnail */
1576
            if (len-10-(t_w*t_h*3) > 0)
1577
                len -= t_w*t_h*3;
1578
        }
1579
        len -= 10;
1580
        goto out;
1581
    }
1582
    
1583
    if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1584
    {
1585
        printf("mjpeg: Adobe header found\n");
1586
        skip_bits(&s->gb, 16); /* version */
1587
        skip_bits(&s->gb, 16); /* flags0 */
1588
        skip_bits(&s->gb, 16); /* flags1 */
1589
        skip_bits(&s->gb, 8); /* transform */
1590
        len -= 7;
1591
        goto out;
1592
    }
1593

    
1594
    if (id == ff_get_fourcc("LJIF")){
1595
        printf("Pegasus lossless jpeg header found\n");
1596
        skip_bits(&s->gb, 16); /* version ? */
1597
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1598
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1599
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1600
        switch( get_bits(&s->gb, 8)){
1601
        case 1:
1602
            s->rgb= 1;
1603
            s->pegasus_rct=0;
1604
            break;
1605
        case 2:
1606
            s->rgb= 1;
1607
            s->pegasus_rct=1;
1608
            break;
1609
        default:
1610
            printf("unknown colorspace\n");
1611
        }
1612
        len -= 9;
1613
        goto out;
1614
    }
1615
    
1616
    /* Apple MJPEG-A */
1617
    if ((s->start_code == APP1) && (len > (0x28 - 8)))
1618
    {
1619
        id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1620
        id = be2me_32(id);
1621
        len -= 4;
1622
        if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1623
        {
1624
#if 0
1625
            skip_bits(&s->gb, 32); /* field size */
1626
            skip_bits(&s->gb, 32); /* pad field size */
1627
            skip_bits(&s->gb, 32); /* next off */
1628
            skip_bits(&s->gb, 32); /* quant off */
1629
            skip_bits(&s->gb, 32); /* huff off */
1630
            skip_bits(&s->gb, 32); /* image off */
1631
            skip_bits(&s->gb, 32); /* scan off */
1632
            skip_bits(&s->gb, 32); /* data off */
1633
#endif
1634
            if (s->first_picture)
1635
                printf("mjpeg: Apple MJPEG-A header found\n");
1636
        }
1637
    }
1638

    
1639
out:
1640
    /* slow but needed for extreme adobe jpegs */
1641
    if (len < 0)
1642
        printf("mjpeg: error, decode_app parser read over the end\n");
1643
    while(--len > 0)
1644
        skip_bits(&s->gb, 8);
1645

    
1646
    return 0;
1647
}
1648

    
1649
static int mjpeg_decode_com(MJpegDecodeContext *s)
1650
{
1651
    /* XXX: verify len field validity */
1652
    int len = get_bits(&s->gb, 16);
1653
    if (len >= 2 && len < 32768) {
1654
        /* XXX: any better upper bound */
1655
        uint8_t *cbuf = av_malloc(len - 1);
1656
        if (cbuf) {
1657
            int i;
1658
            for (i = 0; i < len - 2; i++)
1659
                cbuf[i] = get_bits(&s->gb, 8);
1660
            if (i > 0 && cbuf[i-1] == '\n')
1661
                cbuf[i-1] = 0;
1662
            else
1663
                cbuf[i] = 0;
1664

    
1665
            printf("mjpeg comment: '%s'\n", cbuf);
1666

    
1667
            /* buggy avid, it puts EOI only at every 10th frame */
1668
            if (!strcmp(cbuf, "AVID"))
1669
            {
1670
                s->buggy_avid = 1;
1671
                //        if (s->first_picture)
1672
                //            printf("mjpeg: workarounding buggy AVID\n");
1673
            }
1674

    
1675
            av_free(cbuf);
1676
        }
1677
    }
1678

    
1679
    return 0;
1680
}
1681

    
1682
#if 0
1683
static int valid_marker_list[] =
1684
{
1685
        /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1686
/* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1687
/* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1688
/* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1689
/* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1690
/* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1691
/* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1692
/* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1693
/* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1694
/* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1695
/* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1696
/* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1697
/* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1698
/* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1699
/* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1700
/* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1701
/* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1702
}
1703
#endif
1704

    
1705
/* return the 8 bit start code value and update the search
1706
   state. Return -1 if no start code found */
1707
static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1708
{
1709
    uint8_t *buf_ptr;
1710
    unsigned int v, v2;
1711
    int val;
1712
#ifdef DEBUG
1713
    int skipped=0;
1714
#endif
1715

    
1716
    buf_ptr = *pbuf_ptr;
1717
    while (buf_ptr < buf_end) {
1718
        v = *buf_ptr++;
1719
        v2 = *buf_ptr;
1720
        if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe)) {
1721
            val = *buf_ptr++;
1722
            goto found;
1723
        }
1724
#ifdef DEBUG
1725
        skipped++;
1726
#endif
1727
    }
1728
    val = -1;
1729
found:
1730
#ifdef DEBUG
1731
    dprintf("find_marker skipped %d bytes\n", skipped);
1732
#endif
1733
    *pbuf_ptr = buf_ptr;
1734
    return val;
1735
}
1736

    
1737
static int mjpeg_decode_frame(AVCodecContext *avctx, 
1738
                              void *data, int *data_size,
1739
                              uint8_t *buf, int buf_size)
1740
{
1741
    MJpegDecodeContext *s = avctx->priv_data;
1742
    uint8_t *buf_end, *buf_ptr;
1743
    int i, start_code;
1744
    AVFrame *picture = data;
1745

    
1746
    *data_size = 0;
1747

    
1748
    /* no supplementary picture */
1749
    if (buf_size == 0)
1750
        return 0;
1751

    
1752
    buf_ptr = buf;
1753
    buf_end = buf + buf_size;
1754
    while (buf_ptr < buf_end) {
1755
        /* find start next marker */
1756
        start_code = find_marker(&buf_ptr, buf_end);
1757
        {
1758
            /* EOF */
1759
            if (start_code < 0) {
1760
                goto the_end;
1761
            } else {
1762
                dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1763
                
1764
                if ((buf_end - buf_ptr) > s->buffer_size)
1765
                {
1766
                    av_free(s->buffer);
1767
                    s->buffer_size = buf_end-buf_ptr;
1768
                    s->buffer = av_malloc(s->buffer_size);
1769
                    dprintf("buffer too small, expanding to %d bytes\n",
1770
                        s->buffer_size);
1771
                }
1772
                
1773
                /* unescape buffer of SOS */
1774
                if (start_code == SOS)
1775
                {
1776
                    uint8_t *src = buf_ptr;
1777
                    uint8_t *dst = s->buffer;
1778

    
1779
                    while (src<buf_end)
1780
                    {
1781
                        uint8_t x = *(src++);
1782

    
1783
                        *(dst++) = x;
1784
                        if (x == 0xff)
1785
                        {
1786
                            while(*src == 0xff) src++;
1787

    
1788
                            x = *(src++);
1789
                            if (x >= 0xd0 && x <= 0xd7)
1790
                                *(dst++) = x;
1791
                            else if (x)
1792
                                break;
1793
                        }
1794
                    }
1795
                    init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1796
                    
1797
                    dprintf("escaping removed %d bytes\n",
1798
                        (buf_end - buf_ptr) - (dst - s->buffer));
1799
                }
1800
                else
1801
                    init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1802
                
1803
                s->start_code = start_code;
1804
                if(s->avctx->debug & FF_DEBUG_STARTCODE){
1805
                    printf("startcode: %X\n", start_code);
1806
                }
1807

    
1808
                /* process markers */
1809
                if (start_code >= 0xd0 && start_code <= 0xd7) {
1810
                    dprintf("restart marker: %d\n", start_code&0x0f);
1811
                } else if (s->first_picture) {
1812
                    /* APP fields */
1813
                    if (start_code >= 0xe0 && start_code <= 0xef)
1814
                        mjpeg_decode_app(s);
1815
                    /* Comment */
1816
                    else if (start_code == COM)
1817
                        mjpeg_decode_com(s);
1818
                }
1819

    
1820
                switch(start_code) {
1821
                case SOI:
1822
                    s->restart_interval = 0;
1823
                    /* nothing to do on SOI */
1824
                    break;
1825
                case DQT:
1826
                    mjpeg_decode_dqt(s);
1827
                    break;
1828
                case DHT:
1829
                    if(mjpeg_decode_dht(s) < 0){
1830
                        fprintf(stderr, "huffman table decode error\n");
1831
                        return -1;
1832
                    }
1833
                    break;
1834
                case SOF0:
1835
                    s->lossless=0;
1836
                    if (mjpeg_decode_sof(s) < 0) 
1837
                        return -1;
1838
                    break;
1839
                case SOF3:
1840
                    s->lossless=1;
1841
                    if (mjpeg_decode_sof(s) < 0) 
1842
                        return -1;
1843
                    break;
1844
                case EOI:
1845
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval) 
1846
                        break;
1847
eoi_parser:
1848
                    {
1849
                        if (s->interlaced) {
1850
                            s->bottom_field ^= 1;
1851
                            /* if not bottom field, do not output image yet */
1852
                            if (s->bottom_field)
1853
                                goto not_the_end;
1854
                        }
1855
                        *picture = s->picture;
1856
                        *data_size = sizeof(AVFrame);
1857
                        avctx->height = s->height;
1858
                        if (s->interlaced)
1859
                            avctx->height *= 2;
1860
                        avctx->width = s->width;
1861

    
1862
                        if(!s->lossless){
1863
                            picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 
1864
                            picture->qstride= 0;
1865
                            picture->qscale_table= s->qscale_table;
1866
                            memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1867
                            if(avctx->debug & FF_DEBUG_QP)
1868
                                printf("QP: %d\n", picture->quality);
1869
                            picture->quality*= FF_QP2LAMBDA;
1870
                        }
1871
                        
1872
                        goto the_end;
1873
                    }
1874
                    break;
1875
                case SOS:
1876
                    mjpeg_decode_sos(s);
1877
                    /* buggy avid puts EOI every 10-20th frame */
1878
                    /* if restart period is over process EOI */
1879
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1880
                        goto eoi_parser;
1881
                    break;
1882
                case DRI:
1883
                    mjpeg_decode_dri(s);
1884
                    break;
1885
                case SOF1:
1886
                case SOF2:
1887
                case SOF5:
1888
                case SOF6:
1889
                case SOF7:
1890
                case SOF9:
1891
                case SOF10:
1892
                case SOF11:
1893
                case SOF13:
1894
                case SOF14:
1895
                case SOF15:
1896
                case JPG:
1897
                    printf("mjpeg: unsupported coding type (%x)\n", start_code);
1898
                    break;
1899
//                default:
1900
//                    printf("mjpeg: unsupported marker (%x)\n", start_code);
1901
//                    break;
1902
                }
1903

    
1904
not_the_end:
1905
                /* eof process start code */
1906
                buf_ptr += (get_bits_count(&s->gb)+7)/8;
1907
                dprintf("marker parser used %d bytes (%d bits)\n",
1908
                    (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1909
            }
1910
        }
1911
    }
1912
the_end:
1913
    dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1914
//    return buf_end - buf_ptr;
1915
    return buf_ptr - buf;
1916
}
1917

    
1918
static int mjpegb_decode_frame(AVCodecContext *avctx, 
1919
                              void *data, int *data_size,
1920
                              uint8_t *buf, int buf_size)
1921
{
1922
    MJpegDecodeContext *s = avctx->priv_data;
1923
    uint8_t *buf_end, *buf_ptr;
1924
    int i;
1925
    AVFrame *picture = data;
1926
    GetBitContext hgb; /* for the header */
1927
    uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
1928
    uint32_t field_size;
1929

    
1930
    *data_size = 0;
1931

    
1932
    /* no supplementary picture */
1933
    if (buf_size == 0)
1934
        return 0;
1935

    
1936
    buf_ptr = buf;
1937
    buf_end = buf + buf_size;
1938
    
1939
read_header:
1940
    /* reset on every SOI */
1941
    s->restart_interval = 0;
1942

    
1943
    init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
1944

    
1945
    skip_bits(&hgb, 32); /* reserved zeros */
1946
    
1947
    if (get_bits(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
1948
    {
1949
        dprintf("not mjpeg-b (bad fourcc)\n");
1950
        return 0;
1951
    }
1952

    
1953
    field_size = get_bits(&hgb, 32); /* field size */
1954
    dprintf("field size: 0x%x\n", field_size);
1955
    skip_bits(&hgb, 32); /* padded field size */
1956
    second_field_offs = get_bits(&hgb, 32);
1957
    dprintf("second field offs: 0x%x\n", second_field_offs);
1958
    if (second_field_offs)
1959
        s->interlaced = 1;
1960

    
1961
    dqt_offs = get_bits(&hgb, 32);
1962
    dprintf("dqt offs: 0x%x\n", dqt_offs);
1963
    if (dqt_offs)
1964
    {
1965
        init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
1966
        s->start_code = DQT;
1967
        mjpeg_decode_dqt(s);
1968
    }
1969
    
1970
    dht_offs = get_bits(&hgb, 32);
1971
    dprintf("dht offs: 0x%x\n", dht_offs);
1972
    if (dht_offs)
1973
    {
1974
        init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
1975
        s->start_code = DHT;
1976
        mjpeg_decode_dht(s);
1977
    }
1978

    
1979
    sof_offs = get_bits(&hgb, 32);
1980
    dprintf("sof offs: 0x%x\n", sof_offs);
1981
    if (sof_offs)
1982
    {
1983
        init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
1984
        s->start_code = SOF0;
1985
        if (mjpeg_decode_sof(s) < 0)
1986
            return -1;
1987
    }
1988

    
1989
    sos_offs = get_bits(&hgb, 32);
1990
    dprintf("sos offs: 0x%x\n", sos_offs);
1991
    if (sos_offs)
1992
    {
1993
//        init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
1994
        init_get_bits(&s->gb, buf+sos_offs, field_size*8);
1995
        s->start_code = SOS;
1996
        mjpeg_decode_sos(s);
1997
    }
1998

    
1999
    skip_bits(&hgb, 32); /* start of data offset */
2000

    
2001
    if (s->interlaced) {
2002
        s->bottom_field ^= 1;
2003
        /* if not bottom field, do not output image yet */
2004
        if (s->bottom_field && second_field_offs)
2005
        {
2006
            buf_ptr = buf + second_field_offs;
2007
            second_field_offs = 0;
2008
            goto read_header;
2009
            }
2010
    }
2011

    
2012
    //XXX FIXME factorize, this looks very similar to the EOI code
2013

    
2014
    *picture= s->picture;
2015
    *data_size = sizeof(AVFrame);
2016
    avctx->height = s->height;
2017
    if (s->interlaced)
2018
        avctx->height *= 2;
2019
    avctx->width = s->width;
2020
    
2021
    if(!s->lossless){
2022
        picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 
2023
        picture->qstride= 0;
2024
        picture->qscale_table= s->qscale_table;
2025
        memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2026
        if(avctx->debug & FF_DEBUG_QP)
2027
            printf("QP: %d\n", picture->quality);
2028
        picture->quality*= FF_QP2LAMBDA;
2029
    }
2030

    
2031
    return buf_ptr - buf;
2032
}
2033

    
2034

    
2035
static int mjpeg_decode_end(AVCodecContext *avctx)
2036
{
2037
    MJpegDecodeContext *s = avctx->priv_data;
2038
    int i, j;
2039

    
2040
    av_free(s->buffer);
2041
    av_free(s->qscale_table);
2042
    avcodec_default_free_buffers(avctx);
2043
    
2044
    for(i=0;i<2;i++) {
2045
        for(j=0;j<4;j++)
2046
            free_vlc(&s->vlcs[i][j]);
2047
    }
2048
    return 0;
2049
}
2050

    
2051
AVCodec mjpeg_decoder = {
2052
    "mjpeg",
2053
    CODEC_TYPE_VIDEO,
2054
    CODEC_ID_MJPEG,
2055
    sizeof(MJpegDecodeContext),
2056
    mjpeg_decode_init,
2057
    NULL,
2058
    mjpeg_decode_end,
2059
    mjpeg_decode_frame,
2060
    CODEC_CAP_DR1,
2061
    NULL
2062
};
2063

    
2064
AVCodec mjpegb_decoder = {
2065
    "mjpegb",
2066
    CODEC_TYPE_VIDEO,
2067
    CODEC_ID_MJPEGB,
2068
    sizeof(MJpegDecodeContext),
2069
    mjpeg_decode_init,
2070
    NULL,
2071
    mjpeg_decode_end,
2072
    mjpegb_decode_frame,
2073
    CODEC_CAP_DR1,
2074
    NULL
2075
};
2076

    
2077
#ifdef CONFIG_ENCODERS
2078
AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2079
    "ljpeg",
2080
    CODEC_TYPE_VIDEO,
2081
    CODEC_ID_LJPEG,
2082
    sizeof(MpegEncContext),
2083
    MPV_encode_init,
2084
    encode_picture_lossless,
2085
    MPV_encode_end,
2086
};
2087
#endif