Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mjpeg.c @ 55429b55

History | View | Annotate | Download (68.2 KB)

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

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

    
34
#include "avcodec.h"
35
#include "dsputil.h"
36
#include "mpegvideo.h"
37

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

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

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

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

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

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

    
74
    DHT   = 0xc4,        /* define huffman tables */
75

    
76
    DAC   = 0xcc,        /* define arithmetic-coding conditioning */
77

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

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

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

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

    
129
    COM   = 0xfe,        /* comment */
130

    
131
    TEM   = 0x01,        /* temporary private use for arithmetic coding */
132

    
133
    /* 0x02 -> 0xbf reserved */
134
} JPEG_MARKER;
135

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

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

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

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

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

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

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

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

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

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

    
282
void mjpeg_close(MpegEncContext *s)
283
{
284
    av_free(s->mjpeg_ctx);
285
}
286
#endif //CONFIG_ENCODERS
287

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

    
300
#ifdef CONFIG_ENCODERS
301
static inline void put_marker(PutBitContext *p, int code)
302
{
303
    put_bits(p, 8, 0xff);
304
    put_bits(p, 8, code);
305
}
306

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

    
314
    put_bits(p, 4, table_class);
315
    put_bits(p, 4, table_id);
316

    
317
    n = 0;
318
    for(i=1;i<=16;i++) {
319
        n += bits_table[i];
320
        put_bits(p, 8, bits_table[i]);
321
    }
322

    
323
    for(i=0;i<n;i++)
324
        put_bits(p, 8, value_table[i]);
325

    
326
    return n + 17;
327
}
328

    
329
static void jpeg_table_header(MpegEncContext *s)
330
{
331
    PutBitContext *p = &s->pb;
332
    int i, j, size;
333
    uint8_t *ptr;
334

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

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

    
372
static void jpeg_put_comments(MpegEncContext *s)
373
{
374
    PutBitContext *p = &s->pb;
375
    int size;
376
    uint8_t *ptr;
377

    
378
    if (s->aspect_ratio_info /* && !lossless */)
379
    {
380
    /* JFIF header */
381
    put_marker(p, APP0);
382
    put_bits(p, 16, 16);
383
    put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */
384
    put_bits(p, 16, 0x0201); /* v 1.02 */
385
    put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
386
    put_bits(p, 16, s->avctx->sample_aspect_ratio.num);
387
    put_bits(p, 16, s->avctx->sample_aspect_ratio.den);
388
    put_bits(p, 8, 0); /* thumbnail width */
389
    put_bits(p, 8, 0); /* thumbnail height */
390
    }
391

    
392
    /* comment */
393
    if(!(s->flags & CODEC_FLAG_BITEXACT)){
394
        put_marker(p, COM);
395
        flush_put_bits(p);
396
        ptr = pbBufPtr(p);
397
        put_bits(p, 16, 0); /* patched later */
398
        put_string(p, LIBAVCODEC_IDENT, 1);
399
        size = strlen(LIBAVCODEC_IDENT)+3;
400
        ptr[0] = size >> 8;
401
        ptr[1] = size;
402
    }
403
}
404

    
405
void mjpeg_picture_header(MpegEncContext *s)
406
{
407
    const int lossless= s->avctx->codec_id == CODEC_ID_LJPEG;
408

    
409
    put_marker(&s->pb, SOI);
410

    
411
    if (!s->mjpeg_data_only_frames)
412
    {
413
    jpeg_put_comments(s);    
414

    
415
    if (s->mjpeg_write_tables) jpeg_table_header(s);
416

    
417
    put_marker(&s->pb, lossless ? SOF3 : SOF0);
418

    
419
    put_bits(&s->pb, 16, 17);
420
    if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32)
421
        put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
422
    else
423
        put_bits(&s->pb, 8, 8); /* 8 bits/component */
424
    put_bits(&s->pb, 16, s->height);
425
    put_bits(&s->pb, 16, s->width);
426
    put_bits(&s->pb, 8, 3); /* 3 components */
427
    
428
    /* Y component */
429
    put_bits(&s->pb, 8, 1); /* component number */
430
    put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
431
    put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
432
    put_bits(&s->pb, 8, 0); /* select matrix */
433
    
434
    /* Cb component */
435
    put_bits(&s->pb, 8, 2); /* component number */
436
    put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
437
    put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
438
#ifdef TWOMATRIXES
439
    put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
440
#else
441
    put_bits(&s->pb, 8, 0); /* select matrix */
442
#endif
443

    
444
    /* Cr component */
445
    put_bits(&s->pb, 8, 3); /* component number */
446
    put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
447
    put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
448
#ifdef TWOMATRIXES
449
    put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
450
#else
451
    put_bits(&s->pb, 8, 0); /* select matrix */
452
#endif
453
    }
454

    
455
    /* scan header */
456
    put_marker(&s->pb, SOS);
457
    put_bits(&s->pb, 16, 12); /* length */
458
    put_bits(&s->pb, 8, 3); /* 3 components */
459
    
460
    /* Y component */
461
    put_bits(&s->pb, 8, 1); /* index */
462
    put_bits(&s->pb, 4, 0); /* DC huffman table index */
463
    put_bits(&s->pb, 4, 0); /* AC huffman table index */
464
    
465
    /* Cb component */
466
    put_bits(&s->pb, 8, 2); /* index */
467
    put_bits(&s->pb, 4, 1); /* DC huffman table index */
468
    put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
469
    
470
    /* Cr component */
471
    put_bits(&s->pb, 8, 3); /* index */
472
    put_bits(&s->pb, 4, 1); /* DC huffman table index */
473
    put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
474

    
475
    put_bits(&s->pb, 8, lossless ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
476
    put_bits(&s->pb, 8, lossless ? 0 : 63); /* Se (not used) */
477
    put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
478
}
479

    
480
static void escape_FF(MpegEncContext *s, int start)
481
{
482
    int size= put_bits_count(&s->pb) - start*8;
483
    int i, ff_count;
484
    uint8_t *buf= s->pb.buf + start;
485
    int align= (-(size_t)(buf))&3;
486
    
487
    assert((size&7) == 0);
488
    size >>= 3;
489
    
490
    ff_count=0;
491
    for(i=0; i<size && i<align; i++){
492
        if(buf[i]==0xFF) ff_count++;
493
    }
494
    for(; i<size-15; i+=16){
495
        int acc, v;
496

    
497
        v= *(uint32_t*)(&buf[i]);
498
        acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
499
        v= *(uint32_t*)(&buf[i+4]);
500
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
501
        v= *(uint32_t*)(&buf[i+8]);
502
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
503
        v= *(uint32_t*)(&buf[i+12]);
504
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
505

    
506
        acc>>=4;
507
        acc+= (acc>>16);
508
        acc+= (acc>>8);
509
        ff_count+= acc&0xFF;
510
    }
511
    for(; i<size; i++){
512
        if(buf[i]==0xFF) ff_count++;
513
    }
514

    
515
    if(ff_count==0) return;
516
    
517
    /* skip put bits */
518
    for(i=0; i<ff_count-3; i+=4)
519
        put_bits(&s->pb, 32, 0);
520
    put_bits(&s->pb, (ff_count-i)*8, 0);
521
    flush_put_bits(&s->pb); 
522

    
523
    for(i=size-1; ff_count; i--){
524
        int v= buf[i];
525

    
526
        if(v==0xFF){
527
//printf("%d %d\n", i, ff_count);
528
            buf[i+ff_count]= 0;
529
            ff_count--;
530
        }
531

    
532
        buf[i+ff_count]= v;
533
    }
534
}
535

    
536
void ff_mjpeg_stuffing(PutBitContext * pbc)
537
{
538
    int length;
539
    length= (-put_bits_count(pbc))&7;
540
    if(length) put_bits(pbc, length, (1<<length)-1);
541
}
542

    
543
void mjpeg_picture_trailer(MpegEncContext *s)
544
{
545
    ff_mjpeg_stuffing(&s->pb);
546
    flush_put_bits(&s->pb);
547

    
548
    assert((s->header_bits&7)==0);
549
    
550
    escape_FF(s, s->header_bits>>3);
551

    
552
    put_marker(&s->pb, EOI);
553
}
554

    
555
static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
556
                                   uint8_t *huff_size, uint16_t *huff_code)
557
{
558
    int mant, nbits;
559

    
560
    if (val == 0) {
561
        put_bits(&s->pb, huff_size[0], huff_code[0]);
562
    } else {
563
        mant = val;
564
        if (val < 0) {
565
            val = -val;
566
            mant--;
567
        }
568
        
569
        nbits= av_log2_16bit(val) + 1;
570
            
571
        put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
572
        
573
        put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
574
    }
575
}
576

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

    
623
            put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
624
        
625
            put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
626
            run = 0;
627
        }
628
    }
629

    
630
    /* output EOB only if not already 64 values */
631
    if (last_index < 63 || run != 0)
632
        put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
633
}
634

    
635
void mjpeg_encode_mb(MpegEncContext *s, 
636
                     DCTELEM block[6][64])
637
{
638
    int i;
639
    for(i=0;i<6;i++) {
640
        encode_block(s, block[i], i);
641
    }
642
}
643

    
644
static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
645
    MpegEncContext * const s = avctx->priv_data;
646
    MJpegContext * const m = s->mjpeg_ctx;
647
    AVFrame *pict = data;
648
    const int width= s->width;
649
    const int height= s->height;
650
    AVFrame * const p= (AVFrame*)&s->current_picture;
651
    const int predictor= avctx->prediction_method+1;
652

    
653
    init_put_bits(&s->pb, buf, buf_size);
654

    
655
    *p = *pict;
656
    p->pict_type= FF_I_TYPE;
657
    p->key_frame= 1;
658
    
659
    mjpeg_picture_header(s);
660

    
661
    s->header_bits= put_bits_count(&s->pb);
662

    
663
    if(avctx->pix_fmt == PIX_FMT_RGBA32){
664
        int x, y, i;
665
        const int linesize= p->linesize[0];
666
        uint16_t buffer[2048][4];
667
        int left[3], top[3], topleft[3];
668

    
669
        for(i=0; i<3; i++){
670
            buffer[0][i]= 1 << (9 - 1);
671
        }
672

    
673
        for(y = 0; y < height; y++) {
674
            const int modified_predictor= y ? predictor : 1;
675
            uint8_t *ptr = p->data[0] + (linesize * y);
676

    
677
            for(i=0; i<3; i++){
678
                top[i]= left[i]= topleft[i]= buffer[0][i];
679
            }
680
            for(x = 0; x < width; x++) {
681
                buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
682
                buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
683
                buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
684

    
685
                for(i=0;i<3;i++) {
686
                    int pred, diff;
687

    
688
                    PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
689
                        
690
                    topleft[i]= top[i];
691
                    top[i]= buffer[x+1][i];
692
                    
693
                    left[i]= buffer[x][i];
694

    
695
                    diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
696
                    
697
                    if(i==0)
698
                        mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
699
                    else
700
                        mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
701
                }
702
            }
703
        }
704
    }else{
705
        int mb_x, mb_y, i;
706
        const int mb_width  = (width  + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
707
        const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
708
        
709
        for(mb_y = 0; mb_y < mb_height; mb_y++) {
710
            for(mb_x = 0; mb_x < mb_width; mb_x++) {
711
                if(mb_x==0 || mb_y==0){
712
                    for(i=0;i<3;i++) {
713
                        uint8_t *ptr;
714
                        int x, y, h, v, linesize;
715
                        h = s->mjpeg_hsample[i];
716
                        v = s->mjpeg_vsample[i];
717
                        linesize= p->linesize[i];
718

    
719
                        for(y=0; y<v; y++){
720
                            for(x=0; x<h; x++){
721
                                int pred;
722

    
723
                                ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
724
                                if(y==0 && mb_y==0){
725
                                    if(x==0 && mb_x==0){
726
                                        pred= 128;
727
                                    }else{
728
                                        pred= ptr[-1];
729
                                    }
730
                                }else{
731
                                    if(x==0 && mb_x==0){
732
                                        pred= ptr[-linesize];
733
                                    }else{
734
                                        PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
735
                                    }
736
                                }
737
                                
738
                                if(i==0)
739
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
740
                                else
741
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
742
                            }
743
                        }
744
                    }
745
                }else{
746
                    for(i=0;i<3;i++) {
747
                        uint8_t *ptr;
748
                        int x, y, h, v, linesize;
749
                        h = s->mjpeg_hsample[i];
750
                        v = s->mjpeg_vsample[i];
751
                        linesize= p->linesize[i];
752
                             
753
                        for(y=0; y<v; y++){
754
                            for(x=0; x<h; x++){
755
                                int pred;
756

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

    
761
                                if(i==0)
762
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
763
                                else
764
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
765
                            }
766
                        }
767
                    }
768
                }
769
            }
770
        }
771
    }
772

    
773
    emms_c();
774
    
775
    mjpeg_picture_trailer(s);
776
    s->picture_number++;
777

    
778
    flush_put_bits(&s->pb);
779
    return pbBufPtr(&s->pb) - s->pb.buf;
780
//    return (put_bits_count(&f->pb)+7)/8;
781
}
782

    
783
#endif //CONFIG_ENCODERS
784

    
785
/******************************************/
786
/* decoding */
787

    
788
#define MAX_COMPONENTS 4
789

    
790
typedef struct MJpegDecodeContext {
791
    AVCodecContext *avctx;
792
    GetBitContext gb;
793
    int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
794

    
795
    int start_code; /* current start code */
796
    int buffer_size;
797
    uint8_t *buffer;
798

    
799
    int16_t quant_matrixes[4][64];
800
    VLC vlcs[2][4];
801
    int qscale[4];      ///< quantizer scale calculated from quant_matrixes
802

    
803
    int org_height;  /* size given at codec init */
804
    int first_picture;    /* true if decoding first picture */
805
    int interlaced;     /* true if interlaced */
806
    int bottom_field;   /* true if bottom field */
807
    int lossless;
808
    int rgb;
809
    int rct;            /* standard rct */  
810
    int pegasus_rct;    /* pegasus reversible colorspace transform */  
811
    int bits;           /* bits per component */
812

    
813
    int width, height;
814
    int mb_width, mb_height;
815
    int nb_components;
816
    int component_id[MAX_COMPONENTS];
817
    int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
818
    int v_count[MAX_COMPONENTS];
819
    int comp_index[MAX_COMPONENTS];
820
    int dc_index[MAX_COMPONENTS];
821
    int ac_index[MAX_COMPONENTS];
822
    int nb_blocks[MAX_COMPONENTS];
823
    int h_scount[MAX_COMPONENTS];
824
    int v_scount[MAX_COMPONENTS];
825
    int h_max, v_max; /* maximum h and v counts */
826
    int quant_index[4];   /* quant table index for each component */
827
    int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
828
    AVFrame picture; /* picture structure */
829
    int linesize[MAX_COMPONENTS];                   ///< linesize << interlaced
830
    uint8_t *qscale_table;
831
    DCTELEM block[64] __align8;
832
    ScanTable scantable;
833
    void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
834

    
835
    int restart_interval;
836
    int restart_count;
837

    
838
    int buggy_avid;
839
    int interlace_polarity;
840

    
841
    int mjpb_skiptosod;
842
} MJpegDecodeContext;
843

    
844
static int mjpeg_decode_dht(MJpegDecodeContext *s);
845

    
846
static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table, 
847
                      int nb_codes)
848
{
849
    uint8_t huff_size[256];
850
    uint16_t huff_code[256];
851

    
852
    memset(huff_size, 0, sizeof(huff_size));
853
    build_huffman_codes(huff_size, huff_code, bits_table, val_table);
854
    
855
    return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
856
}
857

    
858
static int mjpeg_decode_init(AVCodecContext *avctx)
859
{
860
    MJpegDecodeContext *s = avctx->priv_data;
861
    MpegEncContext s2;
862

    
863
    s->avctx = avctx;
864

    
865
    /* ugly way to get the idct & scantable FIXME */
866
    memset(&s2, 0, sizeof(MpegEncContext));
867
    s2.avctx= avctx;
868
//    s2->out_format = FMT_MJPEG;
869
    dsputil_init(&s2.dsp, avctx);
870
    DCT_common_init(&s2);
871

    
872
    s->scantable= s2.intra_scantable;
873
    s->idct_put= s2.dsp.idct_put;
874

    
875
    s->mpeg_enc_ctx_allocated = 0;
876
    s->buffer_size = 102400; /* smaller buffer should be enough,
877
                                but photojpg files could ahive bigger sizes */
878
    s->buffer = av_malloc(s->buffer_size);
879
    if (!s->buffer)
880
        return -1;
881
    s->start_code = -1;
882
    s->first_picture = 1;
883
    s->org_height = avctx->coded_height;
884
    
885
    build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
886
    build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
887
    build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
888
    build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
889

    
890
    if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
891
    {
892
        av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
893
        init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
894
        mjpeg_decode_dht(s);
895
        /* should check for error - but dunno */
896
    }
897

    
898
    return 0;
899
}
900

    
901

    
902
/**
903
 * finds the end of the current frame in the bitstream.
904
 * @return the position of the first byte of the next frame, or -1
905
 */
906
static int find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size){
907
    int vop_found, i;
908
    uint16_t state;
909
    
910
    vop_found= pc->frame_start_found;
911
    state= pc->state;
912
    
913
    i=0;
914
    if(!vop_found){
915
        for(i=0; i<buf_size; i++){
916
            state= (state<<8) | buf[i];
917
            if(state == 0xFFD8){
918
                i++;
919
                vop_found=1;
920
                break;
921
            }
922
        }
923
    }
924

    
925
    if(vop_found){
926
        /* EOF considered as end of frame */
927
        if (buf_size == 0)
928
            return 0;
929
        for(; i<buf_size; i++){
930
            state= (state<<8) | buf[i];
931
            if(state == 0xFFD8){
932
                pc->frame_start_found=0;
933
                pc->state=0; 
934
                return i-1;
935
            }
936
        }
937
    }
938
    pc->frame_start_found= vop_found;
939
    pc->state= state;
940
    return END_NOT_FOUND;
941
}
942

    
943
static int jpeg_parse(AVCodecParserContext *s,
944
                           AVCodecContext *avctx,
945
                           uint8_t **poutbuf, int *poutbuf_size, 
946
                           const uint8_t *buf, int buf_size)
947
{
948
    ParseContext *pc = s->priv_data;
949
    int next;
950
    
951
    next= find_frame_end(pc, buf, buf_size);
952

    
953
    if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
954
        *poutbuf = NULL;
955
        *poutbuf_size = 0;
956
        return buf_size;
957
    }
958

    
959
    *poutbuf = (uint8_t *)buf;
960
    *poutbuf_size = buf_size;
961
    return next;
962
}
963

    
964
/* quantize tables */
965
static int mjpeg_decode_dqt(MJpegDecodeContext *s)
966
{
967
    int len, index, i, j;
968
    
969
    len = get_bits(&s->gb, 16) - 2;
970

    
971
    while (len >= 65) {
972
        /* only 8 bit precision handled */
973
        if (get_bits(&s->gb, 4) != 0)
974
        {
975
            dprintf("dqt: 16bit precision\n");
976
            return -1;
977
        }
978
        index = get_bits(&s->gb, 4);
979
        if (index >= 4)
980
            return -1;
981
        dprintf("index=%d\n", index);
982
        /* read quant table */
983
        for(i=0;i<64;i++) {
984
            j = s->scantable.permutated[i];
985
            s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
986
        }
987

    
988
        //XXX FIXME finetune, and perhaps add dc too
989
        s->qscale[index]= FFMAX(
990
            s->quant_matrixes[index][s->scantable.permutated[1]],
991
            s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
992
        dprintf("qscale[%d]: %d\n", index, s->qscale[index]);
993
        len -= 65;
994
    }
995
    
996
    return 0;
997
}
998

    
999
/* decode huffman tables and build VLC decoders */
1000
static int mjpeg_decode_dht(MJpegDecodeContext *s)
1001
{
1002
    int len, index, i, class, n, v, code_max;
1003
    uint8_t bits_table[17];
1004
    uint8_t val_table[256];
1005
    
1006
    len = get_bits(&s->gb, 16) - 2;
1007

    
1008
    while (len > 0) {
1009
        if (len < 17)
1010
            return -1;
1011
        class = get_bits(&s->gb, 4);
1012
        if (class >= 2)
1013
            return -1;
1014
        index = get_bits(&s->gb, 4);
1015
        if (index >= 4)
1016
            return -1;
1017
        n = 0;
1018
        for(i=1;i<=16;i++) {
1019
            bits_table[i] = get_bits(&s->gb, 8);
1020
            n += bits_table[i];
1021
        }
1022
        len -= 17;
1023
        if (len < n || n > 256)
1024
            return -1;
1025

    
1026
        code_max = 0;
1027
        for(i=0;i<n;i++) {
1028
            v = get_bits(&s->gb, 8);
1029
            if (v > code_max)
1030
                code_max = v;
1031
            val_table[i] = v;
1032
        }
1033
        len -= n;
1034

    
1035
        /* build VLC and flush previous vlc if present */
1036
        free_vlc(&s->vlcs[class][index]);
1037
        dprintf("class=%d index=%d nb_codes=%d\n",
1038
               class, index, code_max + 1);
1039
        if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1) < 0){
1040
            return -1;
1041
        }
1042
    }
1043
    return 0;
1044
}
1045

    
1046
static int mjpeg_decode_sof(MJpegDecodeContext *s)
1047
{
1048
    int len, nb_components, i, width, height;
1049

    
1050
    /* XXX: verify len field validity */
1051
    len = get_bits(&s->gb, 16);
1052
    s->bits= get_bits(&s->gb, 8);
1053
    
1054
    if(s->pegasus_rct) s->bits=9;  
1055
    if(s->bits==9 && !s->pegasus_rct) s->rct=1;    //FIXME ugly
1056

    
1057
    if (s->bits != 8 && !s->lossless){
1058
        av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
1059
        return -1;
1060
    }
1061
    height = get_bits(&s->gb, 16);
1062
    width = get_bits(&s->gb, 16);
1063
    dprintf("sof0: picture: %dx%d\n", width, height);
1064

    
1065
    nb_components = get_bits(&s->gb, 8);
1066
    if (nb_components <= 0 ||
1067
        nb_components > MAX_COMPONENTS)
1068
        return -1;
1069
    s->nb_components = nb_components;
1070
    s->h_max = 1;
1071
    s->v_max = 1;
1072
    for(i=0;i<nb_components;i++) {
1073
        /* component id */
1074
        s->component_id[i] = get_bits(&s->gb, 8) - 1;
1075
        s->h_count[i] = get_bits(&s->gb, 4);
1076
        s->v_count[i] = get_bits(&s->gb, 4);
1077
        /* compute hmax and vmax (only used in interleaved case) */
1078
        if (s->h_count[i] > s->h_max)
1079
            s->h_max = s->h_count[i];
1080
        if (s->v_count[i] > s->v_max)
1081
            s->v_max = s->v_count[i];
1082
        s->quant_index[i] = get_bits(&s->gb, 8);
1083
        if (s->quant_index[i] >= 4)
1084
            return -1;
1085
        dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1086
            s->v_count[i], s->component_id[i], s->quant_index[i]);
1087
    }
1088
    
1089
    if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1090

    
1091
    /* if different size, realloc/alloc picture */
1092
    /* XXX: also check h_count and v_count */
1093
    if (width != s->width || height != s->height) {
1094
        av_freep(&s->qscale_table);
1095
            
1096
        s->width = width;
1097
        s->height = height;
1098
        avcodec_set_dimensions(s->avctx, width, height);
1099

    
1100
        /* test interlaced mode */
1101
        if (s->first_picture &&
1102
            s->org_height != 0 &&
1103
            s->height < ((s->org_height * 3) / 4)) {
1104
            s->interlaced = 1;
1105
//            s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1106
            s->bottom_field = 0;
1107
            s->avctx->height *= 2;
1108
        }
1109

    
1110
        s->qscale_table= av_mallocz((s->width+15)/16);
1111

    
1112
        s->first_picture = 0;
1113
    }
1114
    
1115
    if(s->interlaced && s->bottom_field)
1116
        return 0;
1117
 
1118
    /* XXX: not complete test ! */
1119
    switch((s->h_count[0] << 4) | s->v_count[0]) {
1120
    case 0x11:
1121
        if(s->rgb){
1122
            s->avctx->pix_fmt = PIX_FMT_RGBA32;
1123
        }else if(s->nb_components==3)
1124
            s->avctx->pix_fmt = PIX_FMT_YUV444P;
1125
        else
1126
            s->avctx->pix_fmt = PIX_FMT_GRAY8;
1127
        break;
1128
    case 0x21:
1129
        s->avctx->pix_fmt = PIX_FMT_YUV422P;
1130
        break;
1131
    default:
1132
    case 0x22:
1133
        s->avctx->pix_fmt = PIX_FMT_YUV420P;
1134
        break;
1135
    }
1136

    
1137
    if(s->picture.data[0])
1138
        s->avctx->release_buffer(s->avctx, &s->picture);
1139

    
1140
    s->picture.reference= 0;
1141
    if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1142
        av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1143
        return -1;
1144
    }
1145
    s->picture.pict_type= I_TYPE;
1146
    s->picture.key_frame= 1;
1147
    
1148
    for(i=0; i<3; i++){
1149
        s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1150
    }
1151

    
1152
//    printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1153
    
1154
    if (len != (8+(3*nb_components)))
1155
    {
1156
        dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1157
    }
1158
    
1159
    return 0;
1160
}
1161

    
1162
static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1163
{
1164
    int code;
1165
    code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1166
    if (code < 0)
1167
    {
1168
        dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1169
                &s->vlcs[0][dc_index]);
1170
        return 0xffff;
1171
    }
1172

    
1173
    if(code)
1174
        return get_xbits(&s->gb, code);
1175
    else
1176
        return 0;
1177
}
1178

    
1179
/* decode block and dequantize */
1180
static int decode_block(MJpegDecodeContext *s, DCTELEM *block, 
1181
                        int component, int dc_index, int ac_index, int quant_index)
1182
{
1183
    int code, i, j, level, val;
1184
    VLC *ac_vlc;
1185
    int16_t *quant_matrix;
1186

    
1187
    /* DC coef */
1188
    val = mjpeg_decode_dc(s, dc_index);
1189
    if (val == 0xffff) {
1190
        dprintf("error dc\n");
1191
        return -1;
1192
    }
1193
    quant_matrix = s->quant_matrixes[quant_index];
1194
    val = val * quant_matrix[0] + s->last_dc[component];
1195
    s->last_dc[component] = val;
1196
    block[0] = val;
1197
    /* AC coefs */
1198
    ac_vlc = &s->vlcs[1][ac_index];
1199
    i = 1;
1200
    for(;;) {
1201
        code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
1202

    
1203
        if (code < 0) {
1204
            dprintf("error ac\n");
1205
            return -1;
1206
        }
1207
        /* EOB */
1208
        if (code == 0)
1209
            break;
1210
        if (code == 0xf0) {
1211
            i += 16;
1212
        } else {
1213
            level = get_xbits(&s->gb, code & 0xf);
1214
            i += code >> 4;
1215
            if (i >= 64) {
1216
                dprintf("error count: %d\n", i);
1217
                return -1;
1218
            }
1219
            j = s->scantable.permutated[i];
1220
            block[j] = level * quant_matrix[j];
1221
            i++;
1222
            if (i >= 64)
1223
                break;
1224
        }
1225
    }
1226
    return 0;
1227
}
1228

    
1229
static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1230
    int i, mb_x, mb_y;
1231
    uint16_t buffer[2048][4];
1232
    int left[3], top[3], topleft[3];
1233
    const int linesize= s->linesize[0];
1234
    const int mask= (1<<s->bits)-1;
1235
    
1236
    for(i=0; i<3; i++){
1237
        buffer[0][i]= 1 << (s->bits + point_transform - 1);
1238
    }
1239
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1240
        const int modified_predictor= mb_y ? predictor : 1;
1241
        uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1242

    
1243
        if (s->interlaced && s->bottom_field)
1244
            ptr += linesize >> 1;
1245

    
1246
        for(i=0; i<3; i++){
1247
            top[i]= left[i]= topleft[i]= buffer[0][i];
1248
        }
1249
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1250
            if (s->restart_interval && !s->restart_count)
1251
                s->restart_count = s->restart_interval;
1252

    
1253
            for(i=0;i<3;i++) {
1254
                int pred;
1255

    
1256
                topleft[i]= top[i];
1257
                top[i]= buffer[mb_x][i];
1258

    
1259
                PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1260
                
1261
                left[i]= 
1262
                buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1263
            }
1264

    
1265
            if (s->restart_interval && !--s->restart_count) {
1266
                align_get_bits(&s->gb);
1267
                skip_bits(&s->gb, 16); /* skip RSTn */
1268
            }
1269
        }
1270

    
1271
        if(s->rct){
1272
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1273
                ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1274
                ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1275
                ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1276
            }
1277
        }else if(s->pegasus_rct){
1278
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1279
                ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1280
                ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1281
                ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1282
            }
1283
        }else{
1284
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1285
                ptr[4*mb_x+0] = buffer[mb_x][0];
1286
                ptr[4*mb_x+1] = buffer[mb_x][1];
1287
                ptr[4*mb_x+2] = buffer[mb_x][2];
1288
            }
1289
        }
1290
    }
1291
    return 0;
1292
}
1293

    
1294
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1295
    int i, mb_x, mb_y;
1296
    const int nb_components=3;
1297

    
1298
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1299
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1300
            if (s->restart_interval && !s->restart_count)
1301
                s->restart_count = s->restart_interval;
1302

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

    
1318
                        ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1319
                        if(y==0 && mb_y==0){
1320
                            if(x==0 && mb_x==0){
1321
                                pred= 128 << point_transform;
1322
                            }else{
1323
                                pred= ptr[-1];
1324
                            }
1325
                        }else{
1326
                            if(x==0 && mb_x==0){
1327
                                pred= ptr[-linesize];
1328
                            }else{
1329
                                PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1330
                            }
1331
                        }
1332
                        
1333
                        if (s->interlaced && s->bottom_field)
1334
                            ptr += linesize >> 1;
1335
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1336

    
1337
                        if (++x == h) {
1338
                            x = 0;
1339
                            y++;
1340
                        }
1341
                    }
1342
                }
1343
            }else{
1344
                for(i=0;i<nb_components;i++) {
1345
                    uint8_t *ptr;
1346
                    int n, h, v, x, y, c, j, linesize;
1347
                    n = s->nb_blocks[i];
1348
                    c = s->comp_index[i];
1349
                    h = s->h_scount[i];
1350
                    v = s->v_scount[i];
1351
                    x = 0;
1352
                    y = 0;
1353
                    linesize= s->linesize[c];
1354
                    
1355
                    for(j=0; j<n; j++) {
1356
                        int pred;
1357

    
1358
                        ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1359
                        PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1360
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1361
                        if (++x == h) {
1362
                            x = 0;
1363
                            y++;
1364
                        }
1365
                    }
1366
                }
1367
            }
1368
            if (s->restart_interval && !--s->restart_count) {
1369
                align_get_bits(&s->gb);
1370
                skip_bits(&s->gb, 16); /* skip RSTn */
1371
            }
1372
        }
1373
    }
1374
    return 0;
1375
}
1376

    
1377
static int mjpeg_decode_scan(MJpegDecodeContext *s){
1378
    int i, mb_x, mb_y;
1379
    const int nb_components=3;
1380

    
1381
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1382
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1383
            if (s->restart_interval && !s->restart_count)
1384
                s->restart_count = s->restart_interval;
1385

    
1386
            for(i=0;i<nb_components;i++) {
1387
                uint8_t *ptr;
1388
                int n, h, v, x, y, c, j;
1389
                n = s->nb_blocks[i];
1390
                c = s->comp_index[i];
1391
                h = s->h_scount[i];
1392
                v = s->v_scount[i];
1393
                x = 0;
1394
                y = 0;
1395
                for(j=0;j<n;j++) {
1396
                    memset(s->block, 0, sizeof(s->block));
1397
                    if (decode_block(s, s->block, i, 
1398
                                     s->dc_index[i], s->ac_index[i], 
1399
                                     s->quant_index[c]) < 0) {
1400
                        dprintf("error y=%d x=%d\n", mb_y, mb_x);
1401
                        return -1;
1402
                    }
1403
//                    dprintf("mb: %d %d processed\n", mb_y, mb_x);
1404
                    ptr = s->picture.data[c] + 
1405
                        (((s->linesize[c] * (v * mb_y + y) * 8) + 
1406
                        (h * mb_x + x) * 8) >> s->avctx->lowres);
1407
                    if (s->interlaced && s->bottom_field)
1408
                        ptr += s->linesize[c] >> 1;
1409
//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);
1410
                    s->idct_put(ptr, s->linesize[c], s->block);
1411
                    if (++x == h) {
1412
                        x = 0;
1413
                        y++;
1414
                    }
1415
                }
1416
            }
1417
            /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1418
            if (s->restart_interval && (s->restart_interval < 1350) &&
1419
                !--s->restart_count) {
1420
                align_get_bits(&s->gb);
1421
                skip_bits(&s->gb, 16); /* skip RSTn */
1422
                for (i=0; i<nb_components; i++) /* reset dc */
1423
                    s->last_dc[i] = 1024;
1424
            }
1425
        }
1426
    }
1427
    return 0;
1428
}
1429

    
1430
static int mjpeg_decode_sos(MJpegDecodeContext *s)
1431
{
1432
    int len, nb_components, i, h, v, predictor, point_transform;
1433
    int vmax, hmax, index, id;
1434
    const int block_size= s->lossless ? 1 : 8;
1435

    
1436
    /* XXX: verify len field validity */
1437
    len = get_bits(&s->gb, 16);
1438
    nb_components = get_bits(&s->gb, 8);
1439
    if (len != 6+2*nb_components)
1440
    {
1441
        dprintf("decode_sos: invalid len (%d)\n", len);
1442
        return -1;
1443
    }
1444
    /* XXX: only interleaved scan accepted */
1445
    if (nb_components != s->nb_components)
1446
    {
1447
        dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1448
        return -1;
1449
    }
1450
    vmax = 0;
1451
    hmax = 0;
1452
    for(i=0;i<nb_components;i++) {
1453
        id = get_bits(&s->gb, 8) - 1;
1454
        dprintf("component: %d\n", id);
1455
        /* find component index */
1456
        for(index=0;index<s->nb_components;index++)
1457
            if (id == s->component_id[index])
1458
                break;
1459
        if (index == s->nb_components)
1460
        {
1461
            dprintf("decode_sos: index(%d) out of components\n", index);
1462
            return -1;
1463
        }
1464

    
1465
        s->comp_index[i] = index;
1466

    
1467
        s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1468
        s->h_scount[i] = s->h_count[index];
1469
        s->v_scount[i] = s->v_count[index];
1470

    
1471
        s->dc_index[i] = get_bits(&s->gb, 4);
1472
        s->ac_index[i] = get_bits(&s->gb, 4);
1473

    
1474
        if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1475
            s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1476
            goto out_of_range;
1477
#if 0 //buggy
1478
        switch(s->start_code)
1479
        {
1480
            case SOF0:
1481
                if (dc_index[i] > 1 || ac_index[i] > 1)
1482
                    goto out_of_range;
1483
                break;
1484
            case SOF1:
1485
            case SOF2:
1486
                if (dc_index[i] > 3 || ac_index[i] > 3)
1487
                    goto out_of_range;
1488
                break;
1489
            case SOF3:
1490
                if (dc_index[i] > 3 || ac_index[i] != 0)
1491
                    goto out_of_range;
1492
                break;        
1493
        }
1494
#endif
1495
    }
1496

    
1497
    predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */
1498
    skip_bits(&s->gb, 8); /* Se */
1499
    skip_bits(&s->gb, 4); /* Ah */
1500
    point_transform= get_bits(&s->gb, 4); /* Al */
1501

    
1502
    for(i=0;i<nb_components;i++) 
1503
        s->last_dc[i] = 1024;
1504

    
1505
    if (nb_components > 1) {
1506
        /* interleaved stream */
1507
        s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1508
        s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1509
    } else {
1510
        h = s->h_max / s->h_scount[s->comp_index[0]];
1511
        v = s->v_max / s->v_scount[s->comp_index[0]];
1512
        s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1513
        s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1514
        s->nb_blocks[0] = 1;
1515
        s->h_scount[0] = 1;
1516
        s->v_scount[0] = 1;
1517
    }
1518

    
1519
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1520
        av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform);
1521
    
1522
    /* mjpeg-b can have padding bytes between sos and image data, skip them */
1523
    for (i = s->mjpb_skiptosod; i > 0; i--)
1524
        skip_bits(&s->gb, 8);
1525

    
1526
    if(s->lossless){
1527
            if(s->rgb){
1528
                if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1529
                    return -1;
1530
            }else{
1531
                if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1532
                    return -1;
1533
            }
1534
    }else{
1535
        if(mjpeg_decode_scan(s) < 0)
1536
            return -1;
1537
    }
1538
    emms_c();
1539
    return 0;
1540
 out_of_range:
1541
    dprintf("decode_sos: ac/dc index out of range\n");
1542
    return -1;
1543
}
1544

    
1545
static int mjpeg_decode_dri(MJpegDecodeContext *s)
1546
{
1547
    if (get_bits(&s->gb, 16) != 4)
1548
        return -1;
1549
    s->restart_interval = get_bits(&s->gb, 16);
1550
    dprintf("restart interval: %d\n", s->restart_interval);
1551

    
1552
    return 0;
1553
}
1554

    
1555
static int mjpeg_decode_app(MJpegDecodeContext *s)
1556
{
1557
    int len, id;
1558

    
1559
    /* XXX: verify len field validity */
1560
    len = get_bits(&s->gb, 16);
1561
    if (len < 5)
1562
        return -1;
1563

    
1564
    id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1565
    id = be2me_32(id);
1566
    len -= 6;
1567

    
1568
    if(s->avctx->debug & FF_DEBUG_STARTCODE){
1569
        av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id); 
1570
    }
1571
    
1572
    /* buggy AVID, it puts EOI only at every 10th frame */
1573
    /* also this fourcc is used by non-avid files too, it holds some
1574
       informations, but it's always present in AVID creates files */
1575
    if (id == ff_get_fourcc("AVI1"))
1576
    {
1577
        /* structure:
1578
            4bytes        AVI1
1579
            1bytes        polarity
1580
            1bytes        always zero
1581
            4bytes        field_size
1582
            4bytes        field_size_less_padding
1583
        */
1584
            s->buggy_avid = 1;
1585
//        if (s->first_picture)
1586
//            printf("mjpeg: workarounding buggy AVID\n");
1587
        s->interlace_polarity = get_bits(&s->gb, 8);
1588
#if 0
1589
        skip_bits(&s->gb, 8);
1590
        skip_bits(&s->gb, 32);
1591
        skip_bits(&s->gb, 32);
1592
        len -= 10;
1593
#endif
1594
//        if (s->interlace_polarity)
1595
//            printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1596
        goto out;
1597
    }
1598
    
1599
//    len -= 2;
1600
    
1601
    if (id == ff_get_fourcc("JFIF"))
1602
    {
1603
        int t_w, t_h, v1, v2;
1604
        skip_bits(&s->gb, 8); /* the trailing zero-byte */
1605
        v1= get_bits(&s->gb, 8);
1606
        v2= get_bits(&s->gb, 8);
1607
        skip_bits(&s->gb, 8);
1608

    
1609
        s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1610
        s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1611

    
1612
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1613
            av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1614
                v1, v2,
1615
                s->avctx->sample_aspect_ratio.num,
1616
                s->avctx->sample_aspect_ratio.den
1617
            );
1618

    
1619
        t_w = get_bits(&s->gb, 8);
1620
        t_h = get_bits(&s->gb, 8);
1621
        if (t_w && t_h)
1622
        {
1623
            /* skip thumbnail */
1624
            if (len-10-(t_w*t_h*3) > 0)
1625
                len -= t_w*t_h*3;
1626
        }
1627
        len -= 10;
1628
        goto out;
1629
    }
1630
    
1631
    if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1632
    {
1633
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1634
            av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1635
        skip_bits(&s->gb, 16); /* version */
1636
        skip_bits(&s->gb, 16); /* flags0 */
1637
        skip_bits(&s->gb, 16); /* flags1 */
1638
        skip_bits(&s->gb, 8); /* transform */
1639
        len -= 7;
1640
        goto out;
1641
    }
1642

    
1643
    if (id == ff_get_fourcc("LJIF")){
1644
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1645
            av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1646
        skip_bits(&s->gb, 16); /* version ? */
1647
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1648
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1649
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1650
        switch( get_bits(&s->gb, 8)){
1651
        case 1:
1652
            s->rgb= 1;
1653
            s->pegasus_rct=0;
1654
            break;
1655
        case 2:
1656
            s->rgb= 1;
1657
            s->pegasus_rct=1;
1658
            break;
1659
        default:
1660
            av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1661
        }
1662
        len -= 9;
1663
        goto out;
1664
    }
1665
    
1666
    /* Apple MJPEG-A */
1667
    if ((s->start_code == APP1) && (len > (0x28 - 8)))
1668
    {
1669
        id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1670
        id = be2me_32(id);
1671
        len -= 4;
1672
        if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1673
        {
1674
#if 0
1675
            skip_bits(&s->gb, 32); /* field size */
1676
            skip_bits(&s->gb, 32); /* pad field size */
1677
            skip_bits(&s->gb, 32); /* next off */
1678
            skip_bits(&s->gb, 32); /* quant off */
1679
            skip_bits(&s->gb, 32); /* huff off */
1680
            skip_bits(&s->gb, 32); /* image off */
1681
            skip_bits(&s->gb, 32); /* scan off */
1682
            skip_bits(&s->gb, 32); /* data off */
1683
#endif
1684
            if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1685
                av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1686
        }
1687
    }
1688

    
1689
out:
1690
    /* slow but needed for extreme adobe jpegs */
1691
    if (len < 0)
1692
        av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1693
    while(--len > 0)
1694
        skip_bits(&s->gb, 8);
1695

    
1696
    return 0;
1697
}
1698

    
1699
static int mjpeg_decode_com(MJpegDecodeContext *s)
1700
{
1701
    /* XXX: verify len field validity */
1702
    int len = get_bits(&s->gb, 16);
1703
    if (len >= 2 && len < 32768) {
1704
        /* XXX: any better upper bound */
1705
        uint8_t *cbuf = av_malloc(len - 1);
1706
        if (cbuf) {
1707
            int i;
1708
            for (i = 0; i < len - 2; i++)
1709
                cbuf[i] = get_bits(&s->gb, 8);
1710
            if (i > 0 && cbuf[i-1] == '\n')
1711
                cbuf[i-1] = 0;
1712
            else
1713
                cbuf[i] = 0;
1714

    
1715
            if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1716
                av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1717

    
1718
            /* buggy avid, it puts EOI only at every 10th frame */
1719
            if (!strcmp(cbuf, "AVID"))
1720
            {
1721
                s->buggy_avid = 1;
1722
                //        if (s->first_picture)
1723
                //            printf("mjpeg: workarounding buggy AVID\n");
1724
            }
1725

    
1726
            av_free(cbuf);
1727
        }
1728
    }
1729

    
1730
    return 0;
1731
}
1732

    
1733
#if 0
1734
static int valid_marker_list[] =
1735
{
1736
        /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1737
/* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1738
/* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1739
/* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1740
/* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1741
/* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1742
/* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1743
/* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1744
/* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1745
/* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1746
/* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1747
/* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1748
/* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1749
/* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1750
/* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1751
/* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1752
/* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1753
}
1754
#endif
1755

    
1756
/* return the 8 bit start code value and update the search
1757
   state. Return -1 if no start code found */
1758
static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1759
{
1760
    uint8_t *buf_ptr;
1761
    unsigned int v, v2;
1762
    int val;
1763
#ifdef DEBUG
1764
    int skipped=0;
1765
#endif
1766

    
1767
    buf_ptr = *pbuf_ptr;
1768
    while (buf_ptr < buf_end) {
1769
        v = *buf_ptr++;
1770
        v2 = *buf_ptr;
1771
        if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1772
            val = *buf_ptr++;
1773
            goto found;
1774
        }
1775
#ifdef DEBUG
1776
        skipped++;
1777
#endif
1778
    }
1779
    val = -1;
1780
found:
1781
#ifdef DEBUG
1782
    dprintf("find_marker skipped %d bytes\n", skipped);
1783
#endif
1784
    *pbuf_ptr = buf_ptr;
1785
    return val;
1786
}
1787

    
1788
static int mjpeg_decode_frame(AVCodecContext *avctx, 
1789
                              void *data, int *data_size,
1790
                              uint8_t *buf, int buf_size)
1791
{
1792
    MJpegDecodeContext *s = avctx->priv_data;
1793
    uint8_t *buf_end, *buf_ptr;
1794
    int start_code;
1795
    AVFrame *picture = data;
1796

    
1797
    /* no supplementary picture */
1798
    if (buf_size == 0)
1799
        return 0;
1800

    
1801
    buf_ptr = buf;
1802
    buf_end = buf + buf_size;
1803
    while (buf_ptr < buf_end) {
1804
        /* find start next marker */
1805
        start_code = find_marker(&buf_ptr, buf_end);
1806
        {
1807
            /* EOF */
1808
            if (start_code < 0) {
1809
                goto the_end;
1810
            } else {
1811
                dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1812
                
1813
                if ((buf_end - buf_ptr) > s->buffer_size)
1814
                {
1815
                    av_free(s->buffer);
1816
                    s->buffer_size = buf_end-buf_ptr;
1817
                    s->buffer = av_malloc(s->buffer_size);
1818
                    dprintf("buffer too small, expanding to %d bytes\n",
1819
                        s->buffer_size);
1820
                }
1821
                
1822
                /* unescape buffer of SOS */
1823
                if (start_code == SOS)
1824
                {
1825
                    uint8_t *src = buf_ptr;
1826
                    uint8_t *dst = s->buffer;
1827

    
1828
                    while (src<buf_end)
1829
                    {
1830
                        uint8_t x = *(src++);
1831

    
1832
                        *(dst++) = x;
1833
                        if (x == 0xff)
1834
                        {
1835
                            while(src<buf_end && x == 0xff)
1836
                                x = *(src++);
1837

    
1838
                            if (x >= 0xd0 && x <= 0xd7)
1839
                                *(dst++) = x;
1840
                            else if (x)
1841
                                break;
1842
                        }
1843
                    }
1844
                    init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1845
                    
1846
                    dprintf("escaping removed %d bytes\n",
1847
                        (buf_end - buf_ptr) - (dst - s->buffer));
1848
                }
1849
                else
1850
                    init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1851
                
1852
                s->start_code = start_code;
1853
                if(s->avctx->debug & FF_DEBUG_STARTCODE){
1854
                    av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
1855
                }
1856

    
1857
                /* process markers */
1858
                if (start_code >= 0xd0 && start_code <= 0xd7) {
1859
                    dprintf("restart marker: %d\n", start_code&0x0f);
1860
                    /* APP fields */
1861
                } else if (start_code >= APP0 && start_code <= APP15) {
1862
                    mjpeg_decode_app(s);
1863
                    /* Comment */
1864
                } else if (start_code == COM){
1865
                    mjpeg_decode_com(s);
1866
                }
1867

    
1868
                switch(start_code) {
1869
                case SOI:
1870
                    s->restart_interval = 0;
1871
                    /* nothing to do on SOI */
1872
                    break;
1873
                case DQT:
1874
                    mjpeg_decode_dqt(s);
1875
                    break;
1876
                case DHT:
1877
                    if(mjpeg_decode_dht(s) < 0){
1878
                        av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n");
1879
                        return -1;
1880
                    }
1881
                    break;
1882
                case SOF0:
1883
                    s->lossless=0;
1884
                    if (mjpeg_decode_sof(s) < 0) 
1885
                        return -1;
1886
                    break;
1887
                case SOF3:
1888
                    s->lossless=1;
1889
                    if (mjpeg_decode_sof(s) < 0) 
1890
                        return -1;
1891
                    break;
1892
                case EOI:
1893
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval) 
1894
                        break;
1895
eoi_parser:
1896
                    {
1897
                        if (s->interlaced) {
1898
                            s->bottom_field ^= 1;
1899
                            /* if not bottom field, do not output image yet */
1900
                            if (s->bottom_field)
1901
                                goto not_the_end;
1902
                        }
1903
                        *picture = s->picture;
1904
                        *data_size = sizeof(AVFrame);
1905

    
1906
                        if(!s->lossless){
1907
                            picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 
1908
                            picture->qstride= 0;
1909
                            picture->qscale_table= s->qscale_table;
1910
                            memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1911
                            if(avctx->debug & FF_DEBUG_QP)
1912
                                av_log(s->avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
1913
                            picture->quality*= FF_QP2LAMBDA;
1914
                        }
1915
                        
1916
                        goto the_end;
1917
                    }
1918
                    break;
1919
                case SOS:
1920
                    mjpeg_decode_sos(s);
1921
                    /* buggy avid puts EOI every 10-20th frame */
1922
                    /* if restart period is over process EOI */
1923
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1924
                        goto eoi_parser;
1925
                    break;
1926
                case DRI:
1927
                    mjpeg_decode_dri(s);
1928
                    break;
1929
                case SOF1:
1930
                case SOF2:
1931
                case SOF5:
1932
                case SOF6:
1933
                case SOF7:
1934
                case SOF9:
1935
                case SOF10:
1936
                case SOF11:
1937
                case SOF13:
1938
                case SOF14:
1939
                case SOF15:
1940
                case JPG:
1941
                    av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
1942
                    break;
1943
//                default:
1944
//                    printf("mjpeg: unsupported marker (%x)\n", start_code);
1945
//                    break;
1946
                }
1947

    
1948
not_the_end:
1949
                /* eof process start code */
1950
                buf_ptr += (get_bits_count(&s->gb)+7)/8;
1951
                dprintf("marker parser used %d bytes (%d bits)\n",
1952
                    (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1953
            }
1954
        }
1955
    }
1956
the_end:
1957
    dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1958
//    return buf_end - buf_ptr;
1959
    return buf_ptr - buf;
1960
}
1961

    
1962
static int mjpegb_decode_frame(AVCodecContext *avctx, 
1963
                              void *data, int *data_size,
1964
                              uint8_t *buf, int buf_size)
1965
{
1966
    MJpegDecodeContext *s = avctx->priv_data;
1967
    uint8_t *buf_end, *buf_ptr;
1968
    AVFrame *picture = data;
1969
    GetBitContext hgb; /* for the header */
1970
    uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
1971
    uint32_t field_size, sod_offs;
1972

    
1973
    /* no supplementary picture */
1974
    if (buf_size == 0)
1975
        return 0;
1976

    
1977
    buf_ptr = buf;
1978
    buf_end = buf + buf_size;
1979
    
1980
read_header:
1981
    /* reset on every SOI */
1982
    s->restart_interval = 0;
1983
    s->mjpb_skiptosod = 0;
1984

    
1985
    init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
1986

    
1987
    skip_bits(&hgb, 32); /* reserved zeros */
1988
    
1989
    if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
1990
    {
1991
        dprintf("not mjpeg-b (bad fourcc)\n");
1992
        return 0;
1993
    }
1994

    
1995
    field_size = get_bits_long(&hgb, 32); /* field size */
1996
    dprintf("field size: 0x%x\n", field_size);
1997
    skip_bits(&hgb, 32); /* padded field size */
1998
    second_field_offs = get_bits_long(&hgb, 32);
1999
    dprintf("second field offs: 0x%x\n", second_field_offs);
2000
    if (second_field_offs)
2001
        s->interlaced = 1;
2002

    
2003
    dqt_offs = get_bits_long(&hgb, 32);
2004
    dprintf("dqt offs: 0x%x\n", dqt_offs);
2005
    if (dqt_offs)
2006
    {
2007
        init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
2008
        s->start_code = DQT;
2009
        mjpeg_decode_dqt(s);
2010
    }
2011
    
2012
    dht_offs = get_bits_long(&hgb, 32);
2013
    dprintf("dht offs: 0x%x\n", dht_offs);
2014
    if (dht_offs)
2015
    {
2016
        init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
2017
        s->start_code = DHT;
2018
        mjpeg_decode_dht(s);
2019
    }
2020

    
2021
    sof_offs = get_bits_long(&hgb, 32);
2022
    dprintf("sof offs: 0x%x\n", sof_offs);
2023
    if (sof_offs)
2024
    {
2025
        init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
2026
        s->start_code = SOF0;
2027
        if (mjpeg_decode_sof(s) < 0)
2028
            return -1;
2029
    }
2030

    
2031
    sos_offs = get_bits_long(&hgb, 32);
2032
    dprintf("sos offs: 0x%x\n", sos_offs);
2033
    sod_offs = get_bits_long(&hgb, 32);
2034
    dprintf("sod offs: 0x%x\n", sod_offs);
2035
    if (sos_offs)
2036
    {
2037
//        init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2038
        init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2039
        s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
2040
        s->start_code = SOS;
2041
        mjpeg_decode_sos(s);
2042
    }
2043

    
2044
    if (s->interlaced) {
2045
        s->bottom_field ^= 1;
2046
        /* if not bottom field, do not output image yet */
2047
        if (s->bottom_field && second_field_offs)
2048
        {
2049
            buf_ptr = buf + second_field_offs;
2050
            second_field_offs = 0;
2051
            goto read_header;
2052
            }
2053
    }
2054

    
2055
    //XXX FIXME factorize, this looks very similar to the EOI code
2056

    
2057
    *picture= s->picture;
2058
    *data_size = sizeof(AVFrame);
2059
    
2060
    if(!s->lossless){
2061
        picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 
2062
        picture->qstride= 0;
2063
        picture->qscale_table= s->qscale_table;
2064
        memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2065
        if(avctx->debug & FF_DEBUG_QP)
2066
            av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2067
        picture->quality*= FF_QP2LAMBDA;
2068
    }
2069

    
2070
    return buf_ptr - buf;
2071
}
2072

    
2073
#include "sp5x.h"
2074

    
2075
static int sp5x_decode_frame(AVCodecContext *avctx, 
2076
                              void *data, int *data_size,
2077
                              uint8_t *buf, int buf_size)
2078
{
2079
#if 0
2080
    MJpegDecodeContext *s = avctx->priv_data;
2081
#endif
2082
    const int qscale = 5;
2083
    uint8_t *buf_ptr, *buf_end, *recoded;
2084
    int i = 0, j = 0;
2085

    
2086
    /* no supplementary picture */
2087
    if (buf_size == 0)
2088
        return 0;
2089

    
2090
    if (!avctx->width || !avctx->height)
2091
        return -1;
2092

    
2093
    buf_ptr = buf;
2094
    buf_end = buf + buf_size;
2095

    
2096
#if 1
2097
    recoded = av_mallocz(buf_size + 1024);
2098
    if (!recoded)
2099
        return -1;
2100

    
2101
    /* SOI */
2102
    recoded[j++] = 0xFF;
2103
    recoded[j++] = 0xD8;
2104

    
2105
    memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2106
    memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2107
    memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2108
    j += sizeof(sp5x_data_dqt);
2109

    
2110
    memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2111
    j += sizeof(sp5x_data_dht);
2112

    
2113
    memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2114
    recoded[j+5] = (avctx->coded_height >> 8) & 0xFF;
2115
    recoded[j+6] = avctx->coded_height & 0xFF;
2116
    recoded[j+7] = (avctx->coded_width >> 8) & 0xFF;
2117
    recoded[j+8] = avctx->coded_width & 0xFF;
2118
    j += sizeof(sp5x_data_sof);
2119

    
2120
    memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2121
    j += sizeof(sp5x_data_sos);
2122

    
2123
    for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2124
    {
2125
        recoded[j++] = buf[i];
2126
        if (buf[i] == 0xff)
2127
            recoded[j++] = 0;
2128
    }
2129

    
2130
    /* EOI */
2131
    recoded[j++] = 0xFF;
2132
    recoded[j++] = 0xD9;
2133

    
2134
    i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2135

    
2136
    av_free(recoded);
2137

    
2138
#else
2139
    /* SOF */
2140
    s->bits = 8;
2141
    s->width  = avctx->coded_width;
2142
    s->height = avctx->coded_height;
2143
    s->nb_components = 3;
2144
    s->component_id[0] = 0;
2145
    s->h_count[0] = 2;
2146
    s->v_count[0] = 2;
2147
    s->quant_index[0] = 0;
2148
    s->component_id[1] = 1;
2149
    s->h_count[1] = 1;
2150
    s->v_count[1] = 1;
2151
    s->quant_index[1] = 1;
2152
    s->component_id[2] = 2;
2153
    s->h_count[2] = 1;
2154
    s->v_count[2] = 1;
2155
    s->quant_index[2] = 1;
2156
    s->h_max = 2;
2157
    s->v_max = 2;
2158
    
2159
    s->qscale_table = av_mallocz((s->width+15)/16);
2160
    avctx->pix_fmt = PIX_FMT_YUV420P;
2161
    s->interlaced = 0;
2162
    
2163
    s->picture.reference = 0;
2164
    if (avctx->get_buffer(avctx, &s->picture) < 0)
2165
    {
2166
        fprintf(stderr, "get_buffer() failed\n");
2167
        return -1;
2168
    }
2169

    
2170
    s->picture.pict_type = I_TYPE;
2171
    s->picture.key_frame = 1;
2172

    
2173
    for (i = 0; i < 3; i++)
2174
        s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2175

    
2176
    /* DQT */
2177
    for (i = 0; i < 64; i++)
2178
    {
2179
        j = s->scantable.permutated[i];
2180
        s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2181
    }
2182
    s->qscale[0] = FFMAX(
2183
        s->quant_matrixes[0][s->scantable.permutated[1]],
2184
        s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2185

    
2186
    for (i = 0; i < 64; i++)
2187
    {
2188
        j = s->scantable.permutated[i];
2189
        s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2190
    }
2191
    s->qscale[1] = FFMAX(
2192
        s->quant_matrixes[1][s->scantable.permutated[1]],
2193
        s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2194

    
2195
    /* DHT */
2196

    
2197
    /* SOS */
2198
    s->comp_index[0] = 0;
2199
    s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2200
    s->h_scount[0] = s->h_count[0];
2201
    s->v_scount[0] = s->v_count[0];
2202
    s->dc_index[0] = 0;
2203
    s->ac_index[0] = 0;
2204

    
2205
    s->comp_index[1] = 1;
2206
    s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2207
    s->h_scount[1] = s->h_count[1];
2208
    s->v_scount[1] = s->v_count[1];
2209
    s->dc_index[1] = 1;
2210
    s->ac_index[1] = 1;
2211

    
2212
    s->comp_index[2] = 2;
2213
    s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2214
    s->h_scount[2] = s->h_count[2];
2215
    s->v_scount[2] = s->v_count[2];
2216
    s->dc_index[2] = 1;
2217
    s->ac_index[2] = 1;
2218
    
2219
    for (i = 0; i < 3; i++)
2220
        s->last_dc[i] = 1024;
2221

    
2222
    s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2223
    s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2224

    
2225
    init_get_bits(&s->gb, buf+14, (buf_size-14)*8);
2226
    
2227
    return mjpeg_decode_scan(s);
2228
#endif
2229

    
2230
    return i;
2231
}
2232

    
2233
static int mjpeg_decode_end(AVCodecContext *avctx)
2234
{
2235
    MJpegDecodeContext *s = avctx->priv_data;
2236
    int i, j;
2237

    
2238
    av_free(s->buffer);
2239
    av_free(s->qscale_table);
2240
    
2241
    for(i=0;i<2;i++) {
2242
        for(j=0;j<4;j++)
2243
            free_vlc(&s->vlcs[i][j]);
2244
    }
2245
    return 0;
2246
}
2247

    
2248
AVCodec mjpeg_decoder = {
2249
    "mjpeg",
2250
    CODEC_TYPE_VIDEO,
2251
    CODEC_ID_MJPEG,
2252
    sizeof(MJpegDecodeContext),
2253
    mjpeg_decode_init,
2254
    NULL,
2255
    mjpeg_decode_end,
2256
    mjpeg_decode_frame,
2257
    CODEC_CAP_DR1,
2258
    NULL
2259
};
2260

    
2261
AVCodec mjpegb_decoder = {
2262
    "mjpegb",
2263
    CODEC_TYPE_VIDEO,
2264
    CODEC_ID_MJPEGB,
2265
    sizeof(MJpegDecodeContext),
2266
    mjpeg_decode_init,
2267
    NULL,
2268
    mjpeg_decode_end,
2269
    mjpegb_decode_frame,
2270
    CODEC_CAP_DR1,
2271
    NULL
2272
};
2273

    
2274
AVCodec sp5x_decoder = {
2275
    "sp5x",
2276
    CODEC_TYPE_VIDEO,
2277
    CODEC_ID_SP5X,
2278
    sizeof(MJpegDecodeContext),
2279
    mjpeg_decode_init,
2280
    NULL,
2281
    mjpeg_decode_end,
2282
    sp5x_decode_frame,
2283
    CODEC_CAP_DR1,
2284
    NULL
2285
};
2286

    
2287
#ifdef CONFIG_ENCODERS
2288
AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2289
    "ljpeg",
2290
    CODEC_TYPE_VIDEO,
2291
    CODEC_ID_LJPEG,
2292
    sizeof(MpegEncContext),
2293
    MPV_encode_init,
2294
    encode_picture_lossless,
2295
    MPV_encode_end,
2296
};
2297
#endif
2298

    
2299
AVCodecParser mjpeg_parser = {
2300
    { CODEC_ID_MJPEG },
2301
    sizeof(ParseContext),
2302
    NULL,
2303
    jpeg_parse,
2304
    ff_parse_close,
2305
};
2306