Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mjpeg.c @ 4eecd5bc

History | View | Annotate | Download (69.3 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
    if(  s->avctx->pix_fmt == PIX_FMT_YUV420P 
405
       ||s->avctx->pix_fmt == PIX_FMT_YUV422P
406
       ||s->avctx->pix_fmt == PIX_FMT_YUV444P){
407
        put_marker(p, COM);
408
        flush_put_bits(p);
409
        ptr = pbBufPtr(p);
410
        put_bits(p, 16, 0); /* patched later */
411
        put_string(p, "CS=ITU601", 1);
412
        size = strlen("CS=ITU601")+3;
413
        ptr[0] = size >> 8;
414
        ptr[1] = size;
415
    }
416
}
417

    
418
void mjpeg_picture_header(MpegEncContext *s)
419
{
420
    const int lossless= s->avctx->codec_id == CODEC_ID_LJPEG;
421

    
422
    put_marker(&s->pb, SOI);
423

    
424
    if (!s->mjpeg_data_only_frames)
425
    {
426
    jpeg_put_comments(s);    
427

    
428
    if (s->mjpeg_write_tables) jpeg_table_header(s);
429

    
430
    put_marker(&s->pb, lossless ? SOF3 : SOF0);
431

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

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

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

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

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

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

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

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

    
536
    for(i=size-1; ff_count; i--){
537
        int v= buf[i];
538

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

    
545
        buf[i+ff_count]= v;
546
    }
547
}
548

    
549
void ff_mjpeg_stuffing(PutBitContext * pbc)
550
{
551
    int length;
552
    length= (-put_bits_count(pbc))&7;
553
    if(length) put_bits(pbc, length, (1<<length)-1);
554
}
555

    
556
void mjpeg_picture_trailer(MpegEncContext *s)
557
{
558
    ff_mjpeg_stuffing(&s->pb);
559
    flush_put_bits(&s->pb);
560

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

    
565
    put_marker(&s->pb, EOI);
566
}
567

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

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

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

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

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

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

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

    
666
    init_put_bits(&s->pb, buf, buf_size);
667

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

    
674
    s->header_bits= put_bits_count(&s->pb);
675
    
676
    if(avctx->pix_fmt == PIX_FMT_RGBA32){
677
        int x, y, i;
678
        const int linesize= p->linesize[0];
679
        uint16_t (*buffer)[4]= (void *) s->rd_scratchpad;
680
        int left[3], top[3], topleft[3];
681

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

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

    
690
            if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < width*3*4){
691
                av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
692
                return -1;
693
            }
694
            
695
            for(i=0; i<3; i++){
696
                top[i]= left[i]= topleft[i]= buffer[0][i];
697
            }
698
            for(x = 0; x < width; x++) {
699
                buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
700
                buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
701
                buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
702

    
703
                for(i=0;i<3;i++) {
704
                    int pred, diff;
705

    
706
                    PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
707
                        
708
                    topleft[i]= top[i];
709
                    top[i]= buffer[x+1][i];
710
                    
711
                    left[i]= buffer[x][i];
712

    
713
                    diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
714
                    
715
                    if(i==0)
716
                        mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
717
                    else
718
                        mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
719
                }
720
            }
721
        }
722
    }else{
723
        int mb_x, mb_y, i;
724
        const int mb_width  = (width  + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
725
        const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
726
        
727
        for(mb_y = 0; mb_y < mb_height; mb_y++) {
728
            if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < mb_width * 4 * 3 * s->mjpeg_hsample[0] * s->mjpeg_vsample[0]){
729
                av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
730
                return -1;
731
            }
732
            for(mb_x = 0; mb_x < mb_width; mb_x++) {
733
                if(mb_x==0 || mb_y==0){
734
                    for(i=0;i<3;i++) {
735
                        uint8_t *ptr;
736
                        int x, y, h, v, linesize;
737
                        h = s->mjpeg_hsample[i];
738
                        v = s->mjpeg_vsample[i];
739
                        linesize= p->linesize[i];
740

    
741
                        for(y=0; y<v; y++){
742
                            for(x=0; x<h; x++){
743
                                int pred;
744

    
745
                                ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
746
                                if(y==0 && mb_y==0){
747
                                    if(x==0 && mb_x==0){
748
                                        pred= 128;
749
                                    }else{
750
                                        pred= ptr[-1];
751
                                    }
752
                                }else{
753
                                    if(x==0 && mb_x==0){
754
                                        pred= ptr[-linesize];
755
                                    }else{
756
                                        PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
757
                                    }
758
                                }
759
                                
760
                                if(i==0)
761
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
762
                                else
763
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
764
                            }
765
                        }
766
                    }
767
                }else{
768
                    for(i=0;i<3;i++) {
769
                        uint8_t *ptr;
770
                        int x, y, h, v, linesize;
771
                        h = s->mjpeg_hsample[i];
772
                        v = s->mjpeg_vsample[i];
773
                        linesize= p->linesize[i];
774
                             
775
                        for(y=0; y<v; y++){
776
                            for(x=0; x<h; x++){
777
                                int pred;
778

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

    
783
                                if(i==0)
784
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
785
                                else
786
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
787
                            }
788
                        }
789
                    }
790
                }
791
            }
792
        }
793
    }
794

    
795
    emms_c();
796
    
797
    mjpeg_picture_trailer(s);
798
    s->picture_number++;
799

    
800
    flush_put_bits(&s->pb);
801
    return pbBufPtr(&s->pb) - s->pb.buf;
802
//    return (put_bits_count(&f->pb)+7)/8;
803
}
804

    
805
#endif //CONFIG_ENCODERS
806

    
807
/******************************************/
808
/* decoding */
809

    
810
#define MAX_COMPONENTS 4
811

    
812
typedef struct MJpegDecodeContext {
813
    AVCodecContext *avctx;
814
    GetBitContext gb;
815
    int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
816

    
817
    int start_code; /* current start code */
818
    int buffer_size;
819
    uint8_t *buffer;
820

    
821
    int16_t quant_matrixes[4][64];
822
    VLC vlcs[2][4];
823
    int qscale[4];      ///< quantizer scale calculated from quant_matrixes
824

    
825
    int org_height;  /* size given at codec init */
826
    int first_picture;    /* true if decoding first picture */
827
    int interlaced;     /* true if interlaced */
828
    int bottom_field;   /* true if bottom field */
829
    int lossless;
830
    int rgb;
831
    int rct;            /* standard rct */  
832
    int pegasus_rct;    /* pegasus reversible colorspace transform */  
833
    int bits;           /* bits per component */
834

    
835
    int width, height;
836
    int mb_width, mb_height;
837
    int nb_components;
838
    int component_id[MAX_COMPONENTS];
839
    int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
840
    int v_count[MAX_COMPONENTS];
841
    int comp_index[MAX_COMPONENTS];
842
    int dc_index[MAX_COMPONENTS];
843
    int ac_index[MAX_COMPONENTS];
844
    int nb_blocks[MAX_COMPONENTS];
845
    int h_scount[MAX_COMPONENTS];
846
    int v_scount[MAX_COMPONENTS];
847
    int h_max, v_max; /* maximum h and v counts */
848
    int quant_index[4];   /* quant table index for each component */
849
    int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
850
    AVFrame picture; /* picture structure */
851
    int linesize[MAX_COMPONENTS];                   ///< linesize << interlaced
852
    int8_t *qscale_table;
853
    DCTELEM block[64] __align8;
854
    ScanTable scantable;
855
    void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
856

    
857
    int restart_interval;
858
    int restart_count;
859

    
860
    int buggy_avid;
861
    int cs_itu601;
862
    int interlace_polarity;
863

    
864
    int mjpb_skiptosod;
865
} MJpegDecodeContext;
866

    
867
static int mjpeg_decode_dht(MJpegDecodeContext *s);
868

    
869
static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table, 
870
                      int nb_codes, int use_static)
871
{
872
    uint8_t huff_size[256];
873
    uint16_t huff_code[256];
874

    
875
    memset(huff_size, 0, sizeof(huff_size));
876
    build_huffman_codes(huff_size, huff_code, bits_table, val_table);
877
    
878
    return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2, use_static);
879
}
880

    
881
static int mjpeg_decode_init(AVCodecContext *avctx)
882
{
883
    MJpegDecodeContext *s = avctx->priv_data;
884
    MpegEncContext s2;
885
    memset(s, 0, sizeof(MJpegDecodeContext));
886

    
887
    s->avctx = avctx;
888

    
889
    /* ugly way to get the idct & scantable FIXME */
890
    memset(&s2, 0, sizeof(MpegEncContext));
891
    s2.avctx= avctx;
892
//    s2->out_format = FMT_MJPEG;
893
    dsputil_init(&s2.dsp, avctx);
894
    DCT_common_init(&s2);
895

    
896
    s->scantable= s2.intra_scantable;
897
    s->idct_put= s2.dsp.idct_put;
898

    
899
    s->mpeg_enc_ctx_allocated = 0;
900
    s->buffer_size = 0;
901
    s->buffer = NULL;
902
    s->start_code = -1;
903
    s->first_picture = 1;
904
    s->org_height = avctx->coded_height;
905
    
906
    build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12, 0);
907
    build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12, 0);
908
    build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251, 0);
909
    build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251, 0);
910

    
911
    if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
912
    {
913
        av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
914
        init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
915
        mjpeg_decode_dht(s);
916
        /* should check for error - but dunno */
917
    }
918

    
919
    return 0;
920
}
921

    
922

    
923
/**
924
 * finds the end of the current frame in the bitstream.
925
 * @return the position of the first byte of the next frame, or -1
926
 */
927
static int find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size){
928
    int vop_found, i;
929
    uint16_t state;
930
    
931
    vop_found= pc->frame_start_found;
932
    state= pc->state;
933
    
934
    i=0;
935
    if(!vop_found){
936
        for(i=0; i<buf_size; i++){
937
            state= (state<<8) | buf[i];
938
            if(state == 0xFFD8){
939
                i++;
940
                vop_found=1;
941
                break;
942
            }
943
        }
944
    }
945

    
946
    if(vop_found){
947
        /* EOF considered as end of frame */
948
        if (buf_size == 0)
949
            return 0;
950
        for(; i<buf_size; i++){
951
            state= (state<<8) | buf[i];
952
            if(state == 0xFFD8){
953
                pc->frame_start_found=0;
954
                pc->state=0; 
955
                return i-1;
956
            }
957
        }
958
    }
959
    pc->frame_start_found= vop_found;
960
    pc->state= state;
961
    return END_NOT_FOUND;
962
}
963

    
964
static int jpeg_parse(AVCodecParserContext *s,
965
                           AVCodecContext *avctx,
966
                           uint8_t **poutbuf, int *poutbuf_size, 
967
                           const uint8_t *buf, int buf_size)
968
{
969
    ParseContext *pc = s->priv_data;
970
    int next;
971
    
972
    next= find_frame_end(pc, buf, buf_size);
973

    
974
    if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
975
        *poutbuf = NULL;
976
        *poutbuf_size = 0;
977
        return buf_size;
978
    }
979

    
980
    *poutbuf = (uint8_t *)buf;
981
    *poutbuf_size = buf_size;
982
    return next;
983
}
984

    
985
/* quantize tables */
986
static int mjpeg_decode_dqt(MJpegDecodeContext *s)
987
{
988
    int len, index, i, j;
989
    
990
    len = get_bits(&s->gb, 16) - 2;
991

    
992
    while (len >= 65) {
993
        /* only 8 bit precision handled */
994
        if (get_bits(&s->gb, 4) != 0)
995
        {
996
            dprintf("dqt: 16bit precision\n");
997
            return -1;
998
        }
999
        index = get_bits(&s->gb, 4);
1000
        if (index >= 4)
1001
            return -1;
1002
        dprintf("index=%d\n", index);
1003
        /* read quant table */
1004
        for(i=0;i<64;i++) {
1005
            j = s->scantable.permutated[i];
1006
            s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
1007
        }
1008

    
1009
        //XXX FIXME finetune, and perhaps add dc too
1010
        s->qscale[index]= FFMAX(
1011
            s->quant_matrixes[index][s->scantable.permutated[1]],
1012
            s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
1013
        dprintf("qscale[%d]: %d\n", index, s->qscale[index]);
1014
        len -= 65;
1015
    }
1016
    
1017
    return 0;
1018
}
1019

    
1020
/* decode huffman tables and build VLC decoders */
1021
static int mjpeg_decode_dht(MJpegDecodeContext *s)
1022
{
1023
    int len, index, i, class, n, v, code_max;
1024
    uint8_t bits_table[17];
1025
    uint8_t val_table[256];
1026
    
1027
    len = get_bits(&s->gb, 16) - 2;
1028

    
1029
    while (len > 0) {
1030
        if (len < 17)
1031
            return -1;
1032
        class = get_bits(&s->gb, 4);
1033
        if (class >= 2)
1034
            return -1;
1035
        index = get_bits(&s->gb, 4);
1036
        if (index >= 4)
1037
            return -1;
1038
        n = 0;
1039
        for(i=1;i<=16;i++) {
1040
            bits_table[i] = get_bits(&s->gb, 8);
1041
            n += bits_table[i];
1042
        }
1043
        len -= 17;
1044
        if (len < n || n > 256)
1045
            return -1;
1046

    
1047
        code_max = 0;
1048
        for(i=0;i<n;i++) {
1049
            v = get_bits(&s->gb, 8);
1050
            if (v > code_max)
1051
                code_max = v;
1052
            val_table[i] = v;
1053
        }
1054
        len -= n;
1055

    
1056
        /* build VLC and flush previous vlc if present */
1057
        free_vlc(&s->vlcs[class][index]);
1058
        dprintf("class=%d index=%d nb_codes=%d\n",
1059
               class, index, code_max + 1);
1060
        if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0) < 0){
1061
            return -1;
1062
        }
1063
    }
1064
    return 0;
1065
}
1066

    
1067
static int mjpeg_decode_sof(MJpegDecodeContext *s)
1068
{
1069
    int len, nb_components, i, width, height;
1070

    
1071
    /* XXX: verify len field validity */
1072
    len = get_bits(&s->gb, 16);
1073
    s->bits= get_bits(&s->gb, 8);
1074
    
1075
    if(s->pegasus_rct) s->bits=9;  
1076
    if(s->bits==9 && !s->pegasus_rct) s->rct=1;    //FIXME ugly
1077

    
1078
    if (s->bits != 8 && !s->lossless){
1079
        av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
1080
        return -1;
1081
    }
1082
    height = get_bits(&s->gb, 16);
1083
    width = get_bits(&s->gb, 16);
1084
    
1085
    dprintf("sof0: picture: %dx%d\n", width, height);
1086
    if(avcodec_check_dimensions(s->avctx, width, height))
1087
        return -1;
1088

    
1089
    nb_components = get_bits(&s->gb, 8);
1090
    if (nb_components <= 0 ||
1091
        nb_components > MAX_COMPONENTS)
1092
        return -1;
1093
    s->nb_components = nb_components;
1094
    s->h_max = 1;
1095
    s->v_max = 1;
1096
    for(i=0;i<nb_components;i++) {
1097
        /* component id */
1098
        s->component_id[i] = get_bits(&s->gb, 8) - 1;
1099
        s->h_count[i] = get_bits(&s->gb, 4);
1100
        s->v_count[i] = get_bits(&s->gb, 4);
1101
        /* compute hmax and vmax (only used in interleaved case) */
1102
        if (s->h_count[i] > s->h_max)
1103
            s->h_max = s->h_count[i];
1104
        if (s->v_count[i] > s->v_max)
1105
            s->v_max = s->v_count[i];
1106
        s->quant_index[i] = get_bits(&s->gb, 8);
1107
        if (s->quant_index[i] >= 4)
1108
            return -1;
1109
        dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1110
            s->v_count[i], s->component_id[i], s->quant_index[i]);
1111
    }
1112
    
1113
    if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1114

    
1115
    /* if different size, realloc/alloc picture */
1116
    /* XXX: also check h_count and v_count */
1117
    if (width != s->width || height != s->height) {
1118
        av_freep(&s->qscale_table);
1119
            
1120
        s->width = width;
1121
        s->height = height;
1122
        avcodec_set_dimensions(s->avctx, width, height);
1123

    
1124
        /* test interlaced mode */
1125
        if (s->first_picture &&
1126
            s->org_height != 0 &&
1127
            s->height < ((s->org_height * 3) / 4)) {
1128
            s->interlaced = 1;
1129
//            s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1130
            s->bottom_field = 0;
1131
            s->avctx->height *= 2;
1132
        }
1133

    
1134
        s->qscale_table= av_mallocz((s->width+15)/16);
1135

    
1136
        s->first_picture = 0;
1137
    }
1138
    
1139
    if(s->interlaced && s->bottom_field)
1140
        return 0;
1141
 
1142
    /* XXX: not complete test ! */
1143
    switch((s->h_count[0] << 4) | s->v_count[0]) {
1144
    case 0x11:
1145
        if(s->rgb){
1146
            s->avctx->pix_fmt = PIX_FMT_RGBA32;
1147
        }else if(s->nb_components==3)
1148
            s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;
1149
        else
1150
            s->avctx->pix_fmt = PIX_FMT_GRAY8;
1151
        break;
1152
    case 0x21:
1153
        s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P;
1154
        break;
1155
    default:
1156
    case 0x22:
1157
        s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P;
1158
        break;
1159
    }
1160

    
1161
    if(s->picture.data[0])
1162
        s->avctx->release_buffer(s->avctx, &s->picture);
1163

    
1164
    s->picture.reference= 0;
1165
    if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1166
        av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1167
        return -1;
1168
    }
1169
    s->picture.pict_type= I_TYPE;
1170
    s->picture.key_frame= 1;
1171
    
1172
    for(i=0; i<3; i++){
1173
        s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1174
    }
1175

    
1176
//    printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1177
    
1178
    if (len != (8+(3*nb_components)))
1179
    {
1180
        dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1181
    }
1182
    
1183
    return 0;
1184
}
1185

    
1186
static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1187
{
1188
    int code;
1189
    code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1190
    if (code < 0)
1191
    {
1192
        dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1193
                &s->vlcs[0][dc_index]);
1194
        return 0xffff;
1195
    }
1196

    
1197
    if(code)
1198
        return get_xbits(&s->gb, code);
1199
    else
1200
        return 0;
1201
}
1202

    
1203
/* decode block and dequantize */
1204
static int decode_block(MJpegDecodeContext *s, DCTELEM *block, 
1205
                        int component, int dc_index, int ac_index, int quant_index)
1206
{
1207
    int code, i, j, level, val;
1208
    VLC *ac_vlc;
1209
    int16_t *quant_matrix;
1210

    
1211
    /* DC coef */
1212
    val = mjpeg_decode_dc(s, dc_index);
1213
    if (val == 0xffff) {
1214
        dprintf("error dc\n");
1215
        return -1;
1216
    }
1217
    quant_matrix = s->quant_matrixes[quant_index];
1218
    val = val * quant_matrix[0] + s->last_dc[component];
1219
    s->last_dc[component] = val;
1220
    block[0] = val;
1221
    /* AC coefs */
1222
    ac_vlc = &s->vlcs[1][ac_index];
1223
    i = 1;
1224
    for(;;) {
1225
        code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
1226

    
1227
        if (code < 0) {
1228
            dprintf("error ac\n");
1229
            return -1;
1230
        }
1231
        /* EOB */
1232
        if (code == 0)
1233
            break;
1234
        if (code == 0xf0) {
1235
            i += 16;
1236
        } else {
1237
            level = get_xbits(&s->gb, code & 0xf);
1238
            i += code >> 4;
1239
            if (i >= 64) {
1240
                dprintf("error count: %d\n", i);
1241
                return -1;
1242
            }
1243
            j = s->scantable.permutated[i];
1244
            block[j] = level * quant_matrix[j];
1245
            i++;
1246
            if (i >= 64)
1247
                break;
1248
        }
1249
    }
1250
    return 0;
1251
}
1252

    
1253
static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1254
    int i, mb_x, mb_y;
1255
    uint16_t buffer[32768][4];
1256
    int left[3], top[3], topleft[3];
1257
    const int linesize= s->linesize[0];
1258
    const int mask= (1<<s->bits)-1;
1259
    
1260
    if((unsigned)s->mb_width > 32768) //dynamic alloc
1261
        return -1;
1262
    
1263
    for(i=0; i<3; i++){
1264
        buffer[0][i]= 1 << (s->bits + point_transform - 1);
1265
    }
1266
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1267
        const int modified_predictor= mb_y ? predictor : 1;
1268
        uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1269

    
1270
        if (s->interlaced && s->bottom_field)
1271
            ptr += linesize >> 1;
1272

    
1273
        for(i=0; i<3; i++){
1274
            top[i]= left[i]= topleft[i]= buffer[0][i];
1275
        }
1276
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1277
            if (s->restart_interval && !s->restart_count)
1278
                s->restart_count = s->restart_interval;
1279

    
1280
            for(i=0;i<3;i++) {
1281
                int pred;
1282

    
1283
                topleft[i]= top[i];
1284
                top[i]= buffer[mb_x][i];
1285

    
1286
                PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1287
                
1288
                left[i]= 
1289
                buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1290
            }
1291

    
1292
            if (s->restart_interval && !--s->restart_count) {
1293
                align_get_bits(&s->gb);
1294
                skip_bits(&s->gb, 16); /* skip RSTn */
1295
            }
1296
        }
1297

    
1298
        if(s->rct){
1299
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1300
                ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1301
                ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1302
                ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1303
            }
1304
        }else if(s->pegasus_rct){
1305
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1306
                ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1307
                ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1308
                ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1309
            }
1310
        }else{
1311
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1312
                ptr[4*mb_x+0] = buffer[mb_x][0];
1313
                ptr[4*mb_x+1] = buffer[mb_x][1];
1314
                ptr[4*mb_x+2] = buffer[mb_x][2];
1315
            }
1316
        }
1317
    }
1318
    return 0;
1319
}
1320

    
1321
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
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
            if(mb_x==0 || mb_y==0 || s->interlaced){
1331
                for(i=0;i<nb_components;i++) {
1332
                    uint8_t *ptr;
1333
                    int n, h, v, x, y, c, j, linesize;
1334
                    n = s->nb_blocks[i];
1335
                    c = s->comp_index[i];
1336
                    h = s->h_scount[i];
1337
                    v = s->v_scount[i];
1338
                    x = 0;
1339
                    y = 0;
1340
                    linesize= s->linesize[c];
1341
                    
1342
                    for(j=0; j<n; j++) {
1343
                        int pred;
1344

    
1345
                        ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1346
                        if(y==0 && mb_y==0){
1347
                            if(x==0 && mb_x==0){
1348
                                pred= 128 << point_transform;
1349
                            }else{
1350
                                pred= ptr[-1];
1351
                            }
1352
                        }else{
1353
                            if(x==0 && mb_x==0){
1354
                                pred= ptr[-linesize];
1355
                            }else{
1356
                                PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1357
                            }
1358
                        }
1359
                        
1360
                        if (s->interlaced && s->bottom_field)
1361
                            ptr += linesize >> 1;
1362
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1363

    
1364
                        if (++x == h) {
1365
                            x = 0;
1366
                            y++;
1367
                        }
1368
                    }
1369
                }
1370
            }else{
1371
                for(i=0;i<nb_components;i++) {
1372
                    uint8_t *ptr;
1373
                    int n, h, v, x, y, c, j, linesize;
1374
                    n = s->nb_blocks[i];
1375
                    c = s->comp_index[i];
1376
                    h = s->h_scount[i];
1377
                    v = s->v_scount[i];
1378
                    x = 0;
1379
                    y = 0;
1380
                    linesize= s->linesize[c];
1381
                    
1382
                    for(j=0; j<n; j++) {
1383
                        int pred;
1384

    
1385
                        ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1386
                        PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1387
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1388
                        if (++x == h) {
1389
                            x = 0;
1390
                            y++;
1391
                        }
1392
                    }
1393
                }
1394
            }
1395
            if (s->restart_interval && !--s->restart_count) {
1396
                align_get_bits(&s->gb);
1397
                skip_bits(&s->gb, 16); /* skip RSTn */
1398
            }
1399
        }
1400
    }
1401
    return 0;
1402
}
1403

    
1404
static int mjpeg_decode_scan(MJpegDecodeContext *s){
1405
    int i, mb_x, mb_y;
1406
    const int nb_components=3;
1407

    
1408
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1409
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1410
            if (s->restart_interval && !s->restart_count)
1411
                s->restart_count = s->restart_interval;
1412

    
1413
            for(i=0;i<nb_components;i++) {
1414
                uint8_t *ptr;
1415
                int n, h, v, x, y, c, j;
1416
                n = s->nb_blocks[i];
1417
                c = s->comp_index[i];
1418
                h = s->h_scount[i];
1419
                v = s->v_scount[i];
1420
                x = 0;
1421
                y = 0;
1422
                for(j=0;j<n;j++) {
1423
                    memset(s->block, 0, sizeof(s->block));
1424
                    if (decode_block(s, s->block, i, 
1425
                                     s->dc_index[i], s->ac_index[i], 
1426
                                     s->quant_index[c]) < 0) {
1427
                        dprintf("error y=%d x=%d\n", mb_y, mb_x);
1428
                        return -1;
1429
                    }
1430
//                    dprintf("mb: %d %d processed\n", mb_y, mb_x);
1431
                    ptr = s->picture.data[c] + 
1432
                        (((s->linesize[c] * (v * mb_y + y) * 8) + 
1433
                        (h * mb_x + x) * 8) >> s->avctx->lowres);
1434
                    if (s->interlaced && s->bottom_field)
1435
                        ptr += s->linesize[c] >> 1;
1436
//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);
1437
                    s->idct_put(ptr, s->linesize[c], s->block);
1438
                    if (++x == h) {
1439
                        x = 0;
1440
                        y++;
1441
                    }
1442
                }
1443
            }
1444
            /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1445
            if (s->restart_interval && (s->restart_interval < 1350) &&
1446
                !--s->restart_count) {
1447
                align_get_bits(&s->gb);
1448
                skip_bits(&s->gb, 16); /* skip RSTn */
1449
                for (i=0; i<nb_components; i++) /* reset dc */
1450
                    s->last_dc[i] = 1024;
1451
            }
1452
        }
1453
    }
1454
    return 0;
1455
}
1456

    
1457
static int mjpeg_decode_sos(MJpegDecodeContext *s)
1458
{
1459
    int len, nb_components, i, h, v, predictor, point_transform;
1460
    int vmax, hmax, index, id;
1461
    const int block_size= s->lossless ? 1 : 8;
1462

    
1463
    /* XXX: verify len field validity */
1464
    len = get_bits(&s->gb, 16);
1465
    nb_components = get_bits(&s->gb, 8);
1466
    if (len != 6+2*nb_components)
1467
    {
1468
        dprintf("decode_sos: invalid len (%d)\n", len);
1469
        return -1;
1470
    }
1471
    /* XXX: only interleaved scan accepted */
1472
    if (nb_components != s->nb_components)
1473
    {
1474
        dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1475
        return -1;
1476
    }
1477
    vmax = 0;
1478
    hmax = 0;
1479
    for(i=0;i<nb_components;i++) {
1480
        id = get_bits(&s->gb, 8) - 1;
1481
        dprintf("component: %d\n", id);
1482
        /* find component index */
1483
        for(index=0;index<s->nb_components;index++)
1484
            if (id == s->component_id[index])
1485
                break;
1486
        if (index == s->nb_components)
1487
        {
1488
            dprintf("decode_sos: index(%d) out of components\n", index);
1489
            return -1;
1490
        }
1491

    
1492
        s->comp_index[i] = index;
1493

    
1494
        s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1495
        s->h_scount[i] = s->h_count[index];
1496
        s->v_scount[i] = s->v_count[index];
1497

    
1498
        s->dc_index[i] = get_bits(&s->gb, 4);
1499
        s->ac_index[i] = get_bits(&s->gb, 4);
1500

    
1501
        if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1502
            s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1503
            goto out_of_range;
1504
#if 0 //buggy
1505
        switch(s->start_code)
1506
        {
1507
            case SOF0:
1508
                if (dc_index[i] > 1 || ac_index[i] > 1)
1509
                    goto out_of_range;
1510
                break;
1511
            case SOF1:
1512
            case SOF2:
1513
                if (dc_index[i] > 3 || ac_index[i] > 3)
1514
                    goto out_of_range;
1515
                break;
1516
            case SOF3:
1517
                if (dc_index[i] > 3 || ac_index[i] != 0)
1518
                    goto out_of_range;
1519
                break;        
1520
        }
1521
#endif
1522
    }
1523

    
1524
    predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */
1525
    skip_bits(&s->gb, 8); /* Se */
1526
    skip_bits(&s->gb, 4); /* Ah */
1527
    point_transform= get_bits(&s->gb, 4); /* Al */
1528

    
1529
    for(i=0;i<nb_components;i++) 
1530
        s->last_dc[i] = 1024;
1531

    
1532
    if (nb_components > 1) {
1533
        /* interleaved stream */
1534
        s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1535
        s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1536
    } else {
1537
        h = s->h_max / s->h_scount[s->comp_index[0]];
1538
        v = s->v_max / s->v_scount[s->comp_index[0]];
1539
        s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1540
        s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1541
        s->nb_blocks[0] = 1;
1542
        s->h_scount[0] = 1;
1543
        s->v_scount[0] = 1;
1544
    }
1545

    
1546
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1547
        av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform);
1548
    
1549
    /* mjpeg-b can have padding bytes between sos and image data, skip them */
1550
    for (i = s->mjpb_skiptosod; i > 0; i--)
1551
        skip_bits(&s->gb, 8);
1552

    
1553
    if(s->lossless){
1554
            if(s->rgb){
1555
                if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1556
                    return -1;
1557
            }else{
1558
                if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1559
                    return -1;
1560
            }
1561
    }else{
1562
        if(mjpeg_decode_scan(s) < 0)
1563
            return -1;
1564
    }
1565
    emms_c();
1566
    return 0;
1567
 out_of_range:
1568
    dprintf("decode_sos: ac/dc index out of range\n");
1569
    return -1;
1570
}
1571

    
1572
static int mjpeg_decode_dri(MJpegDecodeContext *s)
1573
{
1574
    if (get_bits(&s->gb, 16) != 4)
1575
        return -1;
1576
    s->restart_interval = get_bits(&s->gb, 16);
1577
    s->restart_count = 0;
1578
    dprintf("restart interval: %d\n", s->restart_interval);
1579

    
1580
    return 0;
1581
}
1582

    
1583
static int mjpeg_decode_app(MJpegDecodeContext *s)
1584
{
1585
    int len, id;
1586

    
1587
    len = get_bits(&s->gb, 16);
1588
    if (len < 5)
1589
        return -1;
1590
    if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits)
1591
        return -1;
1592

    
1593
    id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1594
    id = be2me_32(id);
1595
    len -= 6;
1596

    
1597
    if(s->avctx->debug & FF_DEBUG_STARTCODE){
1598
        av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id); 
1599
    }
1600
    
1601
    /* buggy AVID, it puts EOI only at every 10th frame */
1602
    /* also this fourcc is used by non-avid files too, it holds some
1603
       informations, but it's always present in AVID creates files */
1604
    if (id == ff_get_fourcc("AVI1"))
1605
    {
1606
        /* structure:
1607
            4bytes        AVI1
1608
            1bytes        polarity
1609
            1bytes        always zero
1610
            4bytes        field_size
1611
            4bytes        field_size_less_padding
1612
        */
1613
            s->buggy_avid = 1;
1614
//        if (s->first_picture)
1615
//            printf("mjpeg: workarounding buggy AVID\n");
1616
        s->interlace_polarity = get_bits(&s->gb, 8);
1617
#if 0
1618
        skip_bits(&s->gb, 8);
1619
        skip_bits(&s->gb, 32);
1620
        skip_bits(&s->gb, 32);
1621
        len -= 10;
1622
#endif
1623
//        if (s->interlace_polarity)
1624
//            printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1625
        goto out;
1626
    }
1627
    
1628
//    len -= 2;
1629
    
1630
    if (id == ff_get_fourcc("JFIF"))
1631
    {
1632
        int t_w, t_h, v1, v2;
1633
        skip_bits(&s->gb, 8); /* the trailing zero-byte */
1634
        v1= get_bits(&s->gb, 8);
1635
        v2= get_bits(&s->gb, 8);
1636
        skip_bits(&s->gb, 8);
1637

    
1638
        s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1639
        s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1640

    
1641
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1642
            av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1643
                v1, v2,
1644
                s->avctx->sample_aspect_ratio.num,
1645
                s->avctx->sample_aspect_ratio.den
1646
            );
1647

    
1648
        t_w = get_bits(&s->gb, 8);
1649
        t_h = get_bits(&s->gb, 8);
1650
        if (t_w && t_h)
1651
        {
1652
            /* skip thumbnail */
1653
            if (len-10-(t_w*t_h*3) > 0)
1654
                len -= t_w*t_h*3;
1655
        }
1656
        len -= 10;
1657
        goto out;
1658
    }
1659
    
1660
    if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1661
    {
1662
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1663
            av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1664
        skip_bits(&s->gb, 16); /* version */
1665
        skip_bits(&s->gb, 16); /* flags0 */
1666
        skip_bits(&s->gb, 16); /* flags1 */
1667
        skip_bits(&s->gb, 8); /* transform */
1668
        len -= 7;
1669
        goto out;
1670
    }
1671

    
1672
    if (id == ff_get_fourcc("LJIF")){
1673
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1674
            av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1675
        skip_bits(&s->gb, 16); /* version ? */
1676
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1677
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1678
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1679
        switch( get_bits(&s->gb, 8)){
1680
        case 1:
1681
            s->rgb= 1;
1682
            s->pegasus_rct=0;
1683
            break;
1684
        case 2:
1685
            s->rgb= 1;
1686
            s->pegasus_rct=1;
1687
            break;
1688
        default:
1689
            av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1690
        }
1691
        len -= 9;
1692
        goto out;
1693
    }
1694
    
1695
    /* Apple MJPEG-A */
1696
    if ((s->start_code == APP1) && (len > (0x28 - 8)))
1697
    {
1698
        id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1699
        id = be2me_32(id);
1700
        len -= 4;
1701
        if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1702
        {
1703
#if 0
1704
            skip_bits(&s->gb, 32); /* field size */
1705
            skip_bits(&s->gb, 32); /* pad field size */
1706
            skip_bits(&s->gb, 32); /* next off */
1707
            skip_bits(&s->gb, 32); /* quant off */
1708
            skip_bits(&s->gb, 32); /* huff off */
1709
            skip_bits(&s->gb, 32); /* image off */
1710
            skip_bits(&s->gb, 32); /* scan off */
1711
            skip_bits(&s->gb, 32); /* data off */
1712
#endif
1713
            if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1714
                av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1715
        }
1716
    }
1717

    
1718
out:
1719
    /* slow but needed for extreme adobe jpegs */
1720
    if (len < 0)
1721
        av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1722
    while(--len > 0)
1723
        skip_bits(&s->gb, 8);
1724

    
1725
    return 0;
1726
}
1727

    
1728
static int mjpeg_decode_com(MJpegDecodeContext *s)
1729
{
1730
    int len = get_bits(&s->gb, 16);
1731
    if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) {
1732
        uint8_t *cbuf = av_malloc(len - 1);
1733
        if (cbuf) {
1734
            int i;
1735
            for (i = 0; i < len - 2; i++)
1736
                cbuf[i] = get_bits(&s->gb, 8);
1737
            if (i > 0 && cbuf[i-1] == '\n')
1738
                cbuf[i-1] = 0;
1739
            else
1740
                cbuf[i] = 0;
1741

    
1742
            if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1743
                av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1744

    
1745
            /* buggy avid, it puts EOI only at every 10th frame */
1746
            if (!strcmp(cbuf, "AVID"))
1747
            {
1748
                s->buggy_avid = 1;
1749
                //        if (s->first_picture)
1750
                //            printf("mjpeg: workarounding buggy AVID\n");
1751
            }
1752
            else if(!strcmp(cbuf, "CS=ITU601")){
1753
                s->cs_itu601= 1;
1754
            }
1755

    
1756
            av_free(cbuf);
1757
        }
1758
    }
1759

    
1760
    return 0;
1761
}
1762

    
1763
#if 0
1764
static int valid_marker_list[] =
1765
{
1766
        /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1767
/* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1768
/* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1769
/* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1770
/* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1771
/* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1772
/* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1773
/* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1774
/* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1775
/* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1776
/* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1777
/* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1778
/* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1779
/* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1780
/* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1781
/* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1782
/* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1783
}
1784
#endif
1785

    
1786
/* return the 8 bit start code value and update the search
1787
   state. Return -1 if no start code found */
1788
static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1789
{
1790
    uint8_t *buf_ptr;
1791
    unsigned int v, v2;
1792
    int val;
1793
#ifdef DEBUG
1794
    int skipped=0;
1795
#endif
1796

    
1797
    buf_ptr = *pbuf_ptr;
1798
    while (buf_ptr < buf_end) {
1799
        v = *buf_ptr++;
1800
        v2 = *buf_ptr;
1801
        if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1802
            val = *buf_ptr++;
1803
            goto found;
1804
        }
1805
#ifdef DEBUG
1806
        skipped++;
1807
#endif
1808
    }
1809
    val = -1;
1810
found:
1811
#ifdef DEBUG
1812
    dprintf("find_marker skipped %d bytes\n", skipped);
1813
#endif
1814
    *pbuf_ptr = buf_ptr;
1815
    return val;
1816
}
1817

    
1818
static int mjpeg_decode_frame(AVCodecContext *avctx, 
1819
                              void *data, int *data_size,
1820
                              uint8_t *buf, int buf_size)
1821
{
1822
    MJpegDecodeContext *s = avctx->priv_data;
1823
    uint8_t *buf_end, *buf_ptr;
1824
    int start_code;
1825
    AVFrame *picture = data;
1826

    
1827
    buf_ptr = buf;
1828
    buf_end = buf + buf_size;
1829
    while (buf_ptr < buf_end) {
1830
        /* find start next marker */
1831
        start_code = find_marker(&buf_ptr, buf_end);
1832
        {
1833
            /* EOF */
1834
            if (start_code < 0) {
1835
                goto the_end;
1836
            } else {
1837
                dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1838
                
1839
                if ((buf_end - buf_ptr) > s->buffer_size)
1840
                {
1841
                    av_free(s->buffer);
1842
                    s->buffer_size = buf_end-buf_ptr;
1843
                    s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
1844
                    dprintf("buffer too small, expanding to %d bytes\n",
1845
                        s->buffer_size);
1846
                }
1847
                
1848
                /* unescape buffer of SOS */
1849
                if (start_code == SOS)
1850
                {
1851
                    uint8_t *src = buf_ptr;
1852
                    uint8_t *dst = s->buffer;
1853

    
1854
                    while (src<buf_end)
1855
                    {
1856
                        uint8_t x = *(src++);
1857

    
1858
                        *(dst++) = x;
1859
                        if (x == 0xff)
1860
                        {
1861
                            while(src<buf_end && x == 0xff)
1862
                                x = *(src++);
1863

    
1864
                            if (x >= 0xd0 && x <= 0xd7)
1865
                                *(dst++) = x;
1866
                            else if (x)
1867
                                break;
1868
                        }
1869
                    }
1870
                    init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1871
                    
1872
                    dprintf("escaping removed %d bytes\n",
1873
                        (buf_end - buf_ptr) - (dst - s->buffer));
1874
                }
1875
                else
1876
                    init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1877
                
1878
                s->start_code = start_code;
1879
                if(s->avctx->debug & FF_DEBUG_STARTCODE){
1880
                    av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
1881
                }
1882

    
1883
                /* process markers */
1884
                if (start_code >= 0xd0 && start_code <= 0xd7) {
1885
                    dprintf("restart marker: %d\n", start_code&0x0f);
1886
                    /* APP fields */
1887
                } else if (start_code >= APP0 && start_code <= APP15) {
1888
                    mjpeg_decode_app(s);
1889
                    /* Comment */
1890
                } else if (start_code == COM){
1891
                    mjpeg_decode_com(s);
1892
                }
1893

    
1894
                switch(start_code) {
1895
                case SOI:
1896
                    s->restart_interval = 0;
1897
                    s->restart_count = 0;
1898
                    /* nothing to do on SOI */
1899
                    break;
1900
                case DQT:
1901
                    mjpeg_decode_dqt(s);
1902
                    break;
1903
                case DHT:
1904
                    if(mjpeg_decode_dht(s) < 0){
1905
                        av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n");
1906
                        return -1;
1907
                    }
1908
                    break;
1909
                case SOF0:
1910
                    s->lossless=0;
1911
                    if (mjpeg_decode_sof(s) < 0) 
1912
                        return -1;
1913
                    break;
1914
                case SOF3:
1915
                    s->lossless=1;
1916
                    if (mjpeg_decode_sof(s) < 0) 
1917
                        return -1;
1918
                    break;
1919
                case EOI:
1920
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval) 
1921
                        break;
1922
eoi_parser:
1923
                    {
1924
                        if (s->interlaced) {
1925
                            s->bottom_field ^= 1;
1926
                            /* if not bottom field, do not output image yet */
1927
                            if (s->bottom_field)
1928
                                goto not_the_end;
1929
                        }
1930
                        *picture = s->picture;
1931
                        *data_size = sizeof(AVFrame);
1932

    
1933
                        if(!s->lossless){
1934
                            picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 
1935
                            picture->qstride= 0;
1936
                            picture->qscale_table= s->qscale_table;
1937
                            memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1938
                            if(avctx->debug & FF_DEBUG_QP)
1939
                                av_log(s->avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
1940
                            picture->quality*= FF_QP2LAMBDA;
1941
                        }
1942
                        
1943
                        goto the_end;
1944
                    }
1945
                    break;
1946
                case SOS:
1947
                    mjpeg_decode_sos(s);
1948
                    /* buggy avid puts EOI every 10-20th frame */
1949
                    /* if restart period is over process EOI */
1950
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1951
                        goto eoi_parser;
1952
                    break;
1953
                case DRI:
1954
                    mjpeg_decode_dri(s);
1955
                    break;
1956
                case SOF1:
1957
                case SOF2:
1958
                case SOF5:
1959
                case SOF6:
1960
                case SOF7:
1961
                case SOF9:
1962
                case SOF10:
1963
                case SOF11:
1964
                case SOF13:
1965
                case SOF14:
1966
                case SOF15:
1967
                case JPG:
1968
                    av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
1969
                    break;
1970
//                default:
1971
//                    printf("mjpeg: unsupported marker (%x)\n", start_code);
1972
//                    break;
1973
                }
1974

    
1975
not_the_end:
1976
                /* eof process start code */
1977
                buf_ptr += (get_bits_count(&s->gb)+7)/8;
1978
                dprintf("marker parser used %d bytes (%d bits)\n",
1979
                    (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1980
            }
1981
        }
1982
    }
1983
the_end:
1984
    dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1985
//    return buf_end - buf_ptr;
1986
    return buf_ptr - buf;
1987
}
1988

    
1989
static int mjpegb_decode_frame(AVCodecContext *avctx, 
1990
                              void *data, int *data_size,
1991
                              uint8_t *buf, int buf_size)
1992
{
1993
    MJpegDecodeContext *s = avctx->priv_data;
1994
    uint8_t *buf_end, *buf_ptr;
1995
    AVFrame *picture = data;
1996
    GetBitContext hgb; /* for the header */
1997
    uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
1998
    uint32_t field_size, sod_offs;
1999

    
2000
    buf_ptr = buf;
2001
    buf_end = buf + buf_size;
2002
    
2003
read_header:
2004
    /* reset on every SOI */
2005
    s->restart_interval = 0;
2006
    s->restart_count = 0;
2007
    s->mjpb_skiptosod = 0;
2008

    
2009
    init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
2010

    
2011
    skip_bits(&hgb, 32); /* reserved zeros */
2012
    
2013
    if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
2014
    {
2015
        dprintf("not mjpeg-b (bad fourcc)\n");
2016
        return 0;
2017
    }
2018

    
2019
    field_size = get_bits_long(&hgb, 32); /* field size */
2020
    dprintf("field size: 0x%x\n", field_size);
2021
    skip_bits(&hgb, 32); /* padded field size */
2022
    second_field_offs = get_bits_long(&hgb, 32);
2023
    dprintf("second field offs: 0x%x\n", second_field_offs);
2024
    if (second_field_offs)
2025
        s->interlaced = 1;
2026

    
2027
    dqt_offs = get_bits_long(&hgb, 32);
2028
    dprintf("dqt offs: 0x%x\n", dqt_offs);
2029
    if (dqt_offs)
2030
    {
2031
        init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
2032
        s->start_code = DQT;
2033
        mjpeg_decode_dqt(s);
2034
    }
2035
    
2036
    dht_offs = get_bits_long(&hgb, 32);
2037
    dprintf("dht offs: 0x%x\n", dht_offs);
2038
    if (dht_offs)
2039
    {
2040
        init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
2041
        s->start_code = DHT;
2042
        mjpeg_decode_dht(s);
2043
    }
2044

    
2045
    sof_offs = get_bits_long(&hgb, 32);
2046
    dprintf("sof offs: 0x%x\n", sof_offs);
2047
    if (sof_offs)
2048
    {
2049
        init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
2050
        s->start_code = SOF0;
2051
        if (mjpeg_decode_sof(s) < 0)
2052
            return -1;
2053
    }
2054

    
2055
    sos_offs = get_bits_long(&hgb, 32);
2056
    dprintf("sos offs: 0x%x\n", sos_offs);
2057
    sod_offs = get_bits_long(&hgb, 32);
2058
    dprintf("sod offs: 0x%x\n", sod_offs);
2059
    if (sos_offs)
2060
    {
2061
//        init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2062
        init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2063
        s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
2064
        s->start_code = SOS;
2065
        mjpeg_decode_sos(s);
2066
    }
2067

    
2068
    if (s->interlaced) {
2069
        s->bottom_field ^= 1;
2070
        /* if not bottom field, do not output image yet */
2071
        if (s->bottom_field && second_field_offs)
2072
        {
2073
            buf_ptr = buf + second_field_offs;
2074
            second_field_offs = 0;
2075
            goto read_header;
2076
            }
2077
    }
2078

    
2079
    //XXX FIXME factorize, this looks very similar to the EOI code
2080

    
2081
    *picture= s->picture;
2082
    *data_size = sizeof(AVFrame);
2083
    
2084
    if(!s->lossless){
2085
        picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 
2086
        picture->qstride= 0;
2087
        picture->qscale_table= s->qscale_table;
2088
        memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2089
        if(avctx->debug & FF_DEBUG_QP)
2090
            av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2091
        picture->quality*= FF_QP2LAMBDA;
2092
    }
2093

    
2094
    return buf_ptr - buf;
2095
}
2096

    
2097
#include "sp5x.h"
2098

    
2099
static int sp5x_decode_frame(AVCodecContext *avctx, 
2100
                              void *data, int *data_size,
2101
                              uint8_t *buf, int buf_size)
2102
{
2103
#if 0
2104
    MJpegDecodeContext *s = avctx->priv_data;
2105
#endif
2106
    const int qscale = 5;
2107
    uint8_t *buf_ptr, *buf_end, *recoded;
2108
    int i = 0, j = 0;
2109

    
2110
    if (!avctx->width || !avctx->height)
2111
        return -1;
2112

    
2113
    buf_ptr = buf;
2114
    buf_end = buf + buf_size;
2115

    
2116
#if 1
2117
    recoded = av_mallocz(buf_size + 1024);
2118
    if (!recoded)
2119
        return -1;
2120

    
2121
    /* SOI */
2122
    recoded[j++] = 0xFF;
2123
    recoded[j++] = 0xD8;
2124

    
2125
    memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2126
    memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2127
    memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2128
    j += sizeof(sp5x_data_dqt);
2129

    
2130
    memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2131
    j += sizeof(sp5x_data_dht);
2132

    
2133
    memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2134
    recoded[j+5] = (avctx->coded_height >> 8) & 0xFF;
2135
    recoded[j+6] = avctx->coded_height & 0xFF;
2136
    recoded[j+7] = (avctx->coded_width >> 8) & 0xFF;
2137
    recoded[j+8] = avctx->coded_width & 0xFF;
2138
    j += sizeof(sp5x_data_sof);
2139

    
2140
    memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2141
    j += sizeof(sp5x_data_sos);
2142

    
2143
    for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2144
    {
2145
        recoded[j++] = buf[i];
2146
        if (buf[i] == 0xff)
2147
            recoded[j++] = 0;
2148
    }
2149

    
2150
    /* EOI */
2151
    recoded[j++] = 0xFF;
2152
    recoded[j++] = 0xD9;
2153

    
2154
    i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2155

    
2156
    av_free(recoded);
2157

    
2158
#else
2159
    /* SOF */
2160
    s->bits = 8;
2161
    s->width  = avctx->coded_width;
2162
    s->height = avctx->coded_height;
2163
    s->nb_components = 3;
2164
    s->component_id[0] = 0;
2165
    s->h_count[0] = 2;
2166
    s->v_count[0] = 2;
2167
    s->quant_index[0] = 0;
2168
    s->component_id[1] = 1;
2169
    s->h_count[1] = 1;
2170
    s->v_count[1] = 1;
2171
    s->quant_index[1] = 1;
2172
    s->component_id[2] = 2;
2173
    s->h_count[2] = 1;
2174
    s->v_count[2] = 1;
2175
    s->quant_index[2] = 1;
2176
    s->h_max = 2;
2177
    s->v_max = 2;
2178
    
2179
    s->qscale_table = av_mallocz((s->width+15)/16);
2180
    avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420;
2181
    s->interlaced = 0;
2182
    
2183
    s->picture.reference = 0;
2184
    if (avctx->get_buffer(avctx, &s->picture) < 0)
2185
    {
2186
        fprintf(stderr, "get_buffer() failed\n");
2187
        return -1;
2188
    }
2189

    
2190
    s->picture.pict_type = I_TYPE;
2191
    s->picture.key_frame = 1;
2192

    
2193
    for (i = 0; i < 3; i++)
2194
        s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2195

    
2196
    /* DQT */
2197
    for (i = 0; i < 64; i++)
2198
    {
2199
        j = s->scantable.permutated[i];
2200
        s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2201
    }
2202
    s->qscale[0] = FFMAX(
2203
        s->quant_matrixes[0][s->scantable.permutated[1]],
2204
        s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2205

    
2206
    for (i = 0; i < 64; i++)
2207
    {
2208
        j = s->scantable.permutated[i];
2209
        s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2210
    }
2211
    s->qscale[1] = FFMAX(
2212
        s->quant_matrixes[1][s->scantable.permutated[1]],
2213
        s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2214

    
2215
    /* DHT */
2216

    
2217
    /* SOS */
2218
    s->comp_index[0] = 0;
2219
    s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2220
    s->h_scount[0] = s->h_count[0];
2221
    s->v_scount[0] = s->v_count[0];
2222
    s->dc_index[0] = 0;
2223
    s->ac_index[0] = 0;
2224

    
2225
    s->comp_index[1] = 1;
2226
    s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2227
    s->h_scount[1] = s->h_count[1];
2228
    s->v_scount[1] = s->v_count[1];
2229
    s->dc_index[1] = 1;
2230
    s->ac_index[1] = 1;
2231

    
2232
    s->comp_index[2] = 2;
2233
    s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2234
    s->h_scount[2] = s->h_count[2];
2235
    s->v_scount[2] = s->v_count[2];
2236
    s->dc_index[2] = 1;
2237
    s->ac_index[2] = 1;
2238
    
2239
    for (i = 0; i < 3; i++)
2240
        s->last_dc[i] = 1024;
2241

    
2242
    s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2243
    s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2244

    
2245
    init_get_bits(&s->gb, buf+14, (buf_size-14)*8);
2246
    
2247
    return mjpeg_decode_scan(s);
2248
#endif
2249

    
2250
    return i;
2251
}
2252

    
2253
static int mjpeg_decode_end(AVCodecContext *avctx)
2254
{
2255
    MJpegDecodeContext *s = avctx->priv_data;
2256
    int i, j;
2257

    
2258
    av_free(s->buffer);
2259
    av_free(s->qscale_table);
2260
    
2261
    for(i=0;i<2;i++) {
2262
        for(j=0;j<4;j++)
2263
            free_vlc(&s->vlcs[i][j]);
2264
    }
2265
    return 0;
2266
}
2267

    
2268
AVCodec mjpeg_decoder = {
2269
    "mjpeg",
2270
    CODEC_TYPE_VIDEO,
2271
    CODEC_ID_MJPEG,
2272
    sizeof(MJpegDecodeContext),
2273
    mjpeg_decode_init,
2274
    NULL,
2275
    mjpeg_decode_end,
2276
    mjpeg_decode_frame,
2277
    CODEC_CAP_DR1,
2278
    NULL
2279
};
2280

    
2281
AVCodec mjpegb_decoder = {
2282
    "mjpegb",
2283
    CODEC_TYPE_VIDEO,
2284
    CODEC_ID_MJPEGB,
2285
    sizeof(MJpegDecodeContext),
2286
    mjpeg_decode_init,
2287
    NULL,
2288
    mjpeg_decode_end,
2289
    mjpegb_decode_frame,
2290
    CODEC_CAP_DR1,
2291
    NULL
2292
};
2293

    
2294
AVCodec sp5x_decoder = {
2295
    "sp5x",
2296
    CODEC_TYPE_VIDEO,
2297
    CODEC_ID_SP5X,
2298
    sizeof(MJpegDecodeContext),
2299
    mjpeg_decode_init,
2300
    NULL,
2301
    mjpeg_decode_end,
2302
    sp5x_decode_frame,
2303
    CODEC_CAP_DR1,
2304
    NULL
2305
};
2306

    
2307
#ifdef CONFIG_ENCODERS
2308
AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2309
    "ljpeg",
2310
    CODEC_TYPE_VIDEO,
2311
    CODEC_ID_LJPEG,
2312
    sizeof(MpegEncContext),
2313
    MPV_encode_init,
2314
    encode_picture_lossless,
2315
    MPV_encode_end,
2316
};
2317
#endif
2318

    
2319
AVCodecParser mjpeg_parser = {
2320
    { CODEC_ID_MJPEG },
2321
    sizeof(ParseContext),
2322
    NULL,
2323
    jpeg_parse,
2324
    ff_parse_close,
2325
};
2326