Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mjpeg.c @ 5509bffa

History | View | Annotate | Download (72.9 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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
    SOF48 = 0xf7,       ///< JPEG-LS
122
    LSE   = 0xf8,       ///< JPEG-LS extension parameters
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
    ff_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
        ff_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
        ff_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_MJPEG;
421
    const int ls      = s->avctx->codec_id == CODEC_ID_JPEGLS;
422

    
423
    assert(!(ls && s->mjpeg_write_tables));
424

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

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

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

    
433
    switch(s->avctx->codec_id){
434
    case CODEC_ID_MJPEG:  put_marker(&s->pb, SOF0 ); break;
435
    case CODEC_ID_LJPEG:  put_marker(&s->pb, SOF3 ); break;
436
    case CODEC_ID_JPEGLS: put_marker(&s->pb, SOF48); break;
437
    default: assert(0);
438
    }
439

    
440
    put_bits(&s->pb, 16, 17);
441
    if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32)
442
        put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
443
    else
444
        put_bits(&s->pb, 8, 8); /* 8 bits/component */
445
    put_bits(&s->pb, 16, s->height);
446
    put_bits(&s->pb, 16, s->width);
447
    put_bits(&s->pb, 8, 3); /* 3 components */
448

    
449
    /* Y component */
450
    put_bits(&s->pb, 8, 1); /* component number */
451
    put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
452
    put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
453
    put_bits(&s->pb, 8, 0); /* select matrix */
454

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

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

    
476
    /* scan header */
477
    put_marker(&s->pb, SOS);
478
    put_bits(&s->pb, 16, 12); /* length */
479
    put_bits(&s->pb, 8, 3); /* 3 components */
480

    
481
    /* Y component */
482
    put_bits(&s->pb, 8, 1); /* index */
483
    put_bits(&s->pb, 4, 0); /* DC huffman table index */
484
    put_bits(&s->pb, 4, 0); /* AC huffman table index */
485

    
486
    /* Cb component */
487
    put_bits(&s->pb, 8, 2); /* index */
488
    put_bits(&s->pb, 4, 1); /* DC huffman table index */
489
    put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
490

    
491
    /* Cr component */
492
    put_bits(&s->pb, 8, 3); /* index */
493
    put_bits(&s->pb, 4, 1); /* DC huffman table index */
494
    put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
495

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

    
498
    switch(s->avctx->codec_id){
499
    case CODEC_ID_MJPEG:  put_bits(&s->pb, 8, 63); break; /* Se (not used) */
500
    case CODEC_ID_LJPEG:  put_bits(&s->pb, 8,  0); break; /* not used */
501
    case CODEC_ID_JPEGLS: put_bits(&s->pb, 8,  1); break; /* ILV = line interleaved */
502
    default: assert(0);
503
    }
504

    
505
    put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
506

    
507
    //FIXME DC/AC entropy table selectors stuff in jpegls
508
}
509

    
510
static void escape_FF(MpegEncContext *s, int start)
511
{
512
    int size= put_bits_count(&s->pb) - start*8;
513
    int i, ff_count;
514
    uint8_t *buf= s->pb.buf + start;
515
    int align= (-(size_t)(buf))&3;
516

    
517
    assert((size&7) == 0);
518
    size >>= 3;
519

    
520
    ff_count=0;
521
    for(i=0; i<size && i<align; i++){
522
        if(buf[i]==0xFF) ff_count++;
523
    }
524
    for(; i<size-15; i+=16){
525
        int acc, v;
526

    
527
        v= *(uint32_t*)(&buf[i]);
528
        acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
529
        v= *(uint32_t*)(&buf[i+4]);
530
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
531
        v= *(uint32_t*)(&buf[i+8]);
532
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
533
        v= *(uint32_t*)(&buf[i+12]);
534
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
535

    
536
        acc>>=4;
537
        acc+= (acc>>16);
538
        acc+= (acc>>8);
539
        ff_count+= acc&0xFF;
540
    }
541
    for(; i<size; i++){
542
        if(buf[i]==0xFF) ff_count++;
543
    }
544

    
545
    if(ff_count==0) return;
546

    
547
    /* skip put bits */
548
    for(i=0; i<ff_count-3; i+=4)
549
        put_bits(&s->pb, 32, 0);
550
    put_bits(&s->pb, (ff_count-i)*8, 0);
551
    flush_put_bits(&s->pb);
552

    
553
    for(i=size-1; ff_count; i--){
554
        int v= buf[i];
555

    
556
        if(v==0xFF){
557
//printf("%d %d\n", i, ff_count);
558
            buf[i+ff_count]= 0;
559
            ff_count--;
560
        }
561

    
562
        buf[i+ff_count]= v;
563
    }
564
}
565

    
566
void ff_mjpeg_stuffing(PutBitContext * pbc)
567
{
568
    int length;
569
    length= (-put_bits_count(pbc))&7;
570
    if(length) put_bits(pbc, length, (1<<length)-1);
571
}
572

    
573
void mjpeg_picture_trailer(MpegEncContext *s)
574
{
575
    ff_mjpeg_stuffing(&s->pb);
576
    flush_put_bits(&s->pb);
577

    
578
    assert((s->header_bits&7)==0);
579

    
580
    escape_FF(s, s->header_bits>>3);
581

    
582
    put_marker(&s->pb, EOI);
583
}
584

    
585
static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
586
                                   uint8_t *huff_size, uint16_t *huff_code)
587
{
588
    int mant, nbits;
589

    
590
    if (val == 0) {
591
        put_bits(&s->pb, huff_size[0], huff_code[0]);
592
    } else {
593
        mant = val;
594
        if (val < 0) {
595
            val = -val;
596
            mant--;
597
        }
598

    
599
        nbits= av_log2_16bit(val) + 1;
600

    
601
        put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
602

    
603
        put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
604
    }
605
}
606

    
607
static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
608
{
609
    int mant, nbits, code, i, j;
610
    int component, dc, run, last_index, val;
611
    MJpegContext *m = s->mjpeg_ctx;
612
    uint8_t *huff_size_ac;
613
    uint16_t *huff_code_ac;
614

    
615
    /* DC coef */
616
    component = (n <= 3 ? 0 : n - 4 + 1);
617
    dc = block[0]; /* overflow is impossible */
618
    val = dc - s->last_dc[component];
619
    if (n < 4) {
620
        mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
621
        huff_size_ac = m->huff_size_ac_luminance;
622
        huff_code_ac = m->huff_code_ac_luminance;
623
    } else {
624
        mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
625
        huff_size_ac = m->huff_size_ac_chrominance;
626
        huff_code_ac = m->huff_code_ac_chrominance;
627
    }
628
    s->last_dc[component] = dc;
629

    
630
    /* AC coefs */
631

    
632
    run = 0;
633
    last_index = s->block_last_index[n];
634
    for(i=1;i<=last_index;i++) {
635
        j = s->intra_scantable.permutated[i];
636
        val = block[j];
637
        if (val == 0) {
638
            run++;
639
        } else {
640
            while (run >= 16) {
641
                put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
642
                run -= 16;
643
            }
644
            mant = val;
645
            if (val < 0) {
646
                val = -val;
647
                mant--;
648
            }
649

    
650
            nbits= av_log2(val) + 1;
651
            code = (run << 4) | nbits;
652

    
653
            put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
654

    
655
            put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
656
            run = 0;
657
        }
658
    }
659

    
660
    /* output EOB only if not already 64 values */
661
    if (last_index < 63 || run != 0)
662
        put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
663
}
664

    
665
void mjpeg_encode_mb(MpegEncContext *s,
666
                     DCTELEM block[6][64])
667
{
668
    int i;
669
    for(i=0;i<6;i++) {
670
        encode_block(s, block[i], i);
671
    }
672
}
673

    
674
static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
675
    MpegEncContext * const s = avctx->priv_data;
676
    MJpegContext * const m = s->mjpeg_ctx;
677
    AVFrame *pict = data;
678
    const int width= s->width;
679
    const int height= s->height;
680
    AVFrame * const p= (AVFrame*)&s->current_picture;
681
    const int predictor= avctx->prediction_method+1;
682

    
683
    init_put_bits(&s->pb, buf, buf_size);
684

    
685
    *p = *pict;
686
    p->pict_type= FF_I_TYPE;
687
    p->key_frame= 1;
688

    
689
    mjpeg_picture_header(s);
690

    
691
    s->header_bits= put_bits_count(&s->pb);
692

    
693
    if(avctx->pix_fmt == PIX_FMT_RGBA32){
694
        int x, y, i;
695
        const int linesize= p->linesize[0];
696
        uint16_t (*buffer)[4]= (void *) s->rd_scratchpad;
697
        int left[3], top[3], topleft[3];
698

    
699
        for(i=0; i<3; i++){
700
            buffer[0][i]= 1 << (9 - 1);
701
        }
702

    
703
        for(y = 0; y < height; y++) {
704
            const int modified_predictor= y ? predictor : 1;
705
            uint8_t *ptr = p->data[0] + (linesize * y);
706

    
707
            if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < width*3*4){
708
                av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
709
                return -1;
710
            }
711

    
712
            for(i=0; i<3; i++){
713
                top[i]= left[i]= topleft[i]= buffer[0][i];
714
            }
715
            for(x = 0; x < width; x++) {
716
                buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
717
                buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
718
                buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
719

    
720
                for(i=0;i<3;i++) {
721
                    int pred, diff;
722

    
723
                    PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
724

    
725
                    topleft[i]= top[i];
726
                    top[i]= buffer[x+1][i];
727

    
728
                    left[i]= buffer[x][i];
729

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

    
732
                    if(i==0)
733
                        mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
734
                    else
735
                        mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
736
                }
737
            }
738
        }
739
    }else{
740
        int mb_x, mb_y, i;
741
        const int mb_width  = (width  + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
742
        const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
743

    
744
        for(mb_y = 0; mb_y < mb_height; mb_y++) {
745
            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]){
746
                av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
747
                return -1;
748
            }
749
            for(mb_x = 0; mb_x < mb_width; mb_x++) {
750
                if(mb_x==0 || mb_y==0){
751
                    for(i=0;i<3;i++) {
752
                        uint8_t *ptr;
753
                        int x, y, h, v, linesize;
754
                        h = s->mjpeg_hsample[i];
755
                        v = s->mjpeg_vsample[i];
756
                        linesize= p->linesize[i];
757

    
758
                        for(y=0; y<v; y++){
759
                            for(x=0; x<h; x++){
760
                                int pred;
761

    
762
                                ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
763
                                if(y==0 && mb_y==0){
764
                                    if(x==0 && mb_x==0){
765
                                        pred= 128;
766
                                    }else{
767
                                        pred= ptr[-1];
768
                                    }
769
                                }else{
770
                                    if(x==0 && mb_x==0){
771
                                        pred= ptr[-linesize];
772
                                    }else{
773
                                        PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
774
                                    }
775
                                }
776

    
777
                                if(i==0)
778
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
779
                                else
780
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
781
                            }
782
                        }
783
                    }
784
                }else{
785
                    for(i=0;i<3;i++) {
786
                        uint8_t *ptr;
787
                        int x, y, h, v, linesize;
788
                        h = s->mjpeg_hsample[i];
789
                        v = s->mjpeg_vsample[i];
790
                        linesize= p->linesize[i];
791

    
792
                        for(y=0; y<v; y++){
793
                            for(x=0; x<h; x++){
794
                                int pred;
795

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

    
800
                                if(i==0)
801
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
802
                                else
803
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
804
                            }
805
                        }
806
                    }
807
                }
808
            }
809
        }
810
    }
811

    
812
    emms_c();
813

    
814
    mjpeg_picture_trailer(s);
815
    s->picture_number++;
816

    
817
    flush_put_bits(&s->pb);
818
    return pbBufPtr(&s->pb) - s->pb.buf;
819
//    return (put_bits_count(&f->pb)+7)/8;
820
}
821

    
822
#endif //CONFIG_ENCODERS
823

    
824
/******************************************/
825
/* decoding */
826

    
827
#define MAX_COMPONENTS 4
828

    
829
typedef struct MJpegDecodeContext {
830
    AVCodecContext *avctx;
831
    GetBitContext gb;
832
    int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
833

    
834
    int start_code; /* current start code */
835
    int buffer_size;
836
    uint8_t *buffer;
837

    
838
    int16_t quant_matrixes[4][64];
839
    VLC vlcs[2][4];
840
    int qscale[4];      ///< quantizer scale calculated from quant_matrixes
841

    
842
    int org_height;  /* size given at codec init */
843
    int first_picture;    /* true if decoding first picture */
844
    int interlaced;     /* true if interlaced */
845
    int bottom_field;   /* true if bottom field */
846
    int lossless;
847
    int ls;
848
    int rgb;
849
    int rct;            /* standard rct */
850
    int pegasus_rct;    /* pegasus reversible colorspace transform */
851
    int bits;           /* bits per component */
852

    
853
    int maxval;
854
    int near;         ///< near lossless bound (si 0 for lossless)
855
    int t1,t2,t3;
856
    int reset;        ///< context halfing intervall ?rename
857

    
858
    int width, height;
859
    int mb_width, mb_height;
860
    int nb_components;
861
    int component_id[MAX_COMPONENTS];
862
    int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
863
    int v_count[MAX_COMPONENTS];
864
    int comp_index[MAX_COMPONENTS];
865
    int dc_index[MAX_COMPONENTS];
866
    int ac_index[MAX_COMPONENTS];
867
    int nb_blocks[MAX_COMPONENTS];
868
    int h_scount[MAX_COMPONENTS];
869
    int v_scount[MAX_COMPONENTS];
870
    int h_max, v_max; /* maximum h and v counts */
871
    int quant_index[4];   /* quant table index for each component */
872
    int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
873
    AVFrame picture; /* picture structure */
874
    int linesize[MAX_COMPONENTS];                   ///< linesize << interlaced
875
    int8_t *qscale_table;
876
    DCTELEM block[64] __align8;
877
    ScanTable scantable;
878
    void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
879

    
880
    int restart_interval;
881
    int restart_count;
882

    
883
    int buggy_avid;
884
    int cs_itu601;
885
    int interlace_polarity;
886

    
887
    int mjpb_skiptosod;
888
} MJpegDecodeContext;
889

    
890
#include "jpeg_ls.c" //FIXME make jpeg-ls more independant
891

    
892
static int mjpeg_decode_dht(MJpegDecodeContext *s);
893

    
894
static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,
895
                      int nb_codes, int use_static)
896
{
897
    uint8_t huff_size[256];
898
    uint16_t huff_code[256];
899

    
900
    memset(huff_size, 0, sizeof(huff_size));
901
    build_huffman_codes(huff_size, huff_code, bits_table, val_table);
902

    
903
    return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2, use_static);
904
}
905

    
906
static int mjpeg_decode_init(AVCodecContext *avctx)
907
{
908
    MJpegDecodeContext *s = avctx->priv_data;
909
    MpegEncContext s2;
910
    memset(s, 0, sizeof(MJpegDecodeContext));
911

    
912
    s->avctx = avctx;
913

    
914
    /* ugly way to get the idct & scantable FIXME */
915
    memset(&s2, 0, sizeof(MpegEncContext));
916
    s2.avctx= avctx;
917
//    s2->out_format = FMT_MJPEG;
918
    dsputil_init(&s2.dsp, avctx);
919
    DCT_common_init(&s2);
920

    
921
    s->scantable= s2.intra_scantable;
922
    s->idct_put= s2.dsp.idct_put;
923

    
924
    s->mpeg_enc_ctx_allocated = 0;
925
    s->buffer_size = 0;
926
    s->buffer = NULL;
927
    s->start_code = -1;
928
    s->first_picture = 1;
929
    s->org_height = avctx->coded_height;
930

    
931
    build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12, 0);
932
    build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12, 0);
933
    build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251, 0);
934
    build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251, 0);
935

    
936
    if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
937
    {
938
        av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
939
        init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
940
        mjpeg_decode_dht(s);
941
        /* should check for error - but dunno */
942
    }
943

    
944
    return 0;
945
}
946

    
947

    
948
/**
949
 * finds the end of the current frame in the bitstream.
950
 * @return the position of the first byte of the next frame, or -1
951
 */
952
static int find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size){
953
    int vop_found, i;
954
    uint16_t state;
955

    
956
    vop_found= pc->frame_start_found;
957
    state= pc->state;
958

    
959
    i=0;
960
    if(!vop_found){
961
        for(i=0; i<buf_size; i++){
962
            state= (state<<8) | buf[i];
963
            if(state == 0xFFD8){
964
                i++;
965
                vop_found=1;
966
                break;
967
            }
968
        }
969
    }
970

    
971
    if(vop_found){
972
        /* EOF considered as end of frame */
973
        if (buf_size == 0)
974
            return 0;
975
        for(; i<buf_size; i++){
976
            state= (state<<8) | buf[i];
977
            if(state == 0xFFD8){
978
                pc->frame_start_found=0;
979
                pc->state=0;
980
                return i-1;
981
            }
982
        }
983
    }
984
    pc->frame_start_found= vop_found;
985
    pc->state= state;
986
    return END_NOT_FOUND;
987
}
988

    
989
static int jpeg_parse(AVCodecParserContext *s,
990
                           AVCodecContext *avctx,
991
                           uint8_t **poutbuf, int *poutbuf_size,
992
                           const uint8_t *buf, int buf_size)
993
{
994
    ParseContext *pc = s->priv_data;
995
    int next;
996

    
997
    next= find_frame_end(pc, buf, buf_size);
998

    
999
    if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
1000
        *poutbuf = NULL;
1001
        *poutbuf_size = 0;
1002
        return buf_size;
1003
    }
1004

    
1005
    *poutbuf = (uint8_t *)buf;
1006
    *poutbuf_size = buf_size;
1007
    return next;
1008
}
1009

    
1010
/* quantize tables */
1011
static int mjpeg_decode_dqt(MJpegDecodeContext *s)
1012
{
1013
    int len, index, i, j;
1014

    
1015
    len = get_bits(&s->gb, 16) - 2;
1016

    
1017
    while (len >= 65) {
1018
        /* only 8 bit precision handled */
1019
        if (get_bits(&s->gb, 4) != 0)
1020
        {
1021
            dprintf("dqt: 16bit precision\n");
1022
            return -1;
1023
        }
1024
        index = get_bits(&s->gb, 4);
1025
        if (index >= 4)
1026
            return -1;
1027
        dprintf("index=%d\n", index);
1028
        /* read quant table */
1029
        for(i=0;i<64;i++) {
1030
            j = s->scantable.permutated[i];
1031
            s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
1032
        }
1033

    
1034
        //XXX FIXME finetune, and perhaps add dc too
1035
        s->qscale[index]= FFMAX(
1036
            s->quant_matrixes[index][s->scantable.permutated[1]],
1037
            s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
1038
        dprintf("qscale[%d]: %d\n", index, s->qscale[index]);
1039
        len -= 65;
1040
    }
1041

    
1042
    return 0;
1043
}
1044

    
1045
/* decode huffman tables and build VLC decoders */
1046
static int mjpeg_decode_dht(MJpegDecodeContext *s)
1047
{
1048
    int len, index, i, class, n, v, code_max;
1049
    uint8_t bits_table[17];
1050
    uint8_t val_table[256];
1051

    
1052
    len = get_bits(&s->gb, 16) - 2;
1053

    
1054
    while (len > 0) {
1055
        if (len < 17)
1056
            return -1;
1057
        class = get_bits(&s->gb, 4);
1058
        if (class >= 2)
1059
            return -1;
1060
        index = get_bits(&s->gb, 4);
1061
        if (index >= 4)
1062
            return -1;
1063
        n = 0;
1064
        for(i=1;i<=16;i++) {
1065
            bits_table[i] = get_bits(&s->gb, 8);
1066
            n += bits_table[i];
1067
        }
1068
        len -= 17;
1069
        if (len < n || n > 256)
1070
            return -1;
1071

    
1072
        code_max = 0;
1073
        for(i=0;i<n;i++) {
1074
            v = get_bits(&s->gb, 8);
1075
            if (v > code_max)
1076
                code_max = v;
1077
            val_table[i] = v;
1078
        }
1079
        len -= n;
1080

    
1081
        /* build VLC and flush previous vlc if present */
1082
        free_vlc(&s->vlcs[class][index]);
1083
        dprintf("class=%d index=%d nb_codes=%d\n",
1084
               class, index, code_max + 1);
1085
        if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0) < 0){
1086
            return -1;
1087
        }
1088
    }
1089
    return 0;
1090
}
1091

    
1092
static int mjpeg_decode_sof(MJpegDecodeContext *s)
1093
{
1094
    int len, nb_components, i, width, height;
1095

    
1096
    /* XXX: verify len field validity */
1097
    len = get_bits(&s->gb, 16);
1098
    s->bits= get_bits(&s->gb, 8);
1099

    
1100
    if(s->pegasus_rct) s->bits=9;
1101
    if(s->bits==9 && !s->pegasus_rct) s->rct=1;    //FIXME ugly
1102

    
1103
    if (s->bits != 8 && !s->lossless){
1104
        av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
1105
        return -1;
1106
    }
1107
    height = get_bits(&s->gb, 16);
1108
    width = get_bits(&s->gb, 16);
1109

    
1110
    dprintf("sof0: picture: %dx%d\n", width, height);
1111
    if(avcodec_check_dimensions(s->avctx, width, height))
1112
        return -1;
1113

    
1114
    nb_components = get_bits(&s->gb, 8);
1115
    if (nb_components <= 0 ||
1116
        nb_components > MAX_COMPONENTS)
1117
        return -1;
1118
    s->nb_components = nb_components;
1119
    s->h_max = 1;
1120
    s->v_max = 1;
1121
    for(i=0;i<nb_components;i++) {
1122
        /* component id */
1123
        s->component_id[i] = get_bits(&s->gb, 8) - 1;
1124
        s->h_count[i] = get_bits(&s->gb, 4);
1125
        s->v_count[i] = get_bits(&s->gb, 4);
1126
        /* compute hmax and vmax (only used in interleaved case) */
1127
        if (s->h_count[i] > s->h_max)
1128
            s->h_max = s->h_count[i];
1129
        if (s->v_count[i] > s->v_max)
1130
            s->v_max = s->v_count[i];
1131
        s->quant_index[i] = get_bits(&s->gb, 8);
1132
        if (s->quant_index[i] >= 4)
1133
            return -1;
1134
        dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1135
            s->v_count[i], s->component_id[i], s->quant_index[i]);
1136
    }
1137

    
1138
    if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1139

    
1140
    /* if different size, realloc/alloc picture */
1141
    /* XXX: also check h_count and v_count */
1142
    if (width != s->width || height != s->height) {
1143
        av_freep(&s->qscale_table);
1144

    
1145
        s->width = width;
1146
        s->height = height;
1147
        avcodec_set_dimensions(s->avctx, width, height);
1148

    
1149
        /* test interlaced mode */
1150
        if (s->first_picture &&
1151
            s->org_height != 0 &&
1152
            s->height < ((s->org_height * 3) / 4)) {
1153
            s->interlaced = 1;
1154
//            s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1155
            s->bottom_field = 0;
1156
            s->avctx->height *= 2;
1157
        }
1158

    
1159
        s->qscale_table= av_mallocz((s->width+15)/16);
1160

    
1161
        s->first_picture = 0;
1162
    }
1163

    
1164
    if(s->interlaced && s->bottom_field)
1165
        return 0;
1166

    
1167
    /* XXX: not complete test ! */
1168
    switch((s->h_count[0] << 4) | s->v_count[0]) {
1169
    case 0x11:
1170
        if(s->rgb){
1171
            s->avctx->pix_fmt = PIX_FMT_RGBA32;
1172
        }else if(s->nb_components==3)
1173
            s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;
1174
        else
1175
            s->avctx->pix_fmt = PIX_FMT_GRAY8;
1176
        break;
1177
    case 0x21:
1178
        s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P;
1179
        break;
1180
    default:
1181
    case 0x22:
1182
        s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P;
1183
        break;
1184
    }
1185

    
1186
    if(s->picture.data[0])
1187
        s->avctx->release_buffer(s->avctx, &s->picture);
1188

    
1189
    s->picture.reference= 0;
1190
    if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1191
        av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1192
        return -1;
1193
    }
1194
    s->picture.pict_type= I_TYPE;
1195
    s->picture.key_frame= 1;
1196

    
1197
    for(i=0; i<3; i++){
1198
        s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1199
    }
1200

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

    
1203
    if (len != (8+(3*nb_components)))
1204
    {
1205
        dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1206
    }
1207

    
1208
    return 0;
1209
}
1210

    
1211
static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1212
{
1213
    int code;
1214
    code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1215
    if (code < 0)
1216
    {
1217
        dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1218
                &s->vlcs[0][dc_index]);
1219
        return 0xffff;
1220
    }
1221

    
1222
    if(code)
1223
        return get_xbits(&s->gb, code);
1224
    else
1225
        return 0;
1226
}
1227

    
1228
/* decode block and dequantize */
1229
static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1230
                        int component, int dc_index, int ac_index, int quant_index)
1231
{
1232
    int code, i, j, level, val;
1233
    VLC *ac_vlc;
1234
    int16_t *quant_matrix;
1235

    
1236
    /* DC coef */
1237
    val = mjpeg_decode_dc(s, dc_index);
1238
    if (val == 0xffff) {
1239
        dprintf("error dc\n");
1240
        return -1;
1241
    }
1242
    quant_matrix = s->quant_matrixes[quant_index];
1243
    val = val * quant_matrix[0] + s->last_dc[component];
1244
    s->last_dc[component] = val;
1245
    block[0] = val;
1246
    /* AC coefs */
1247
    ac_vlc = &s->vlcs[1][ac_index];
1248
    i = 1;
1249
    for(;;) {
1250
        code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
1251

    
1252
        if (code < 0) {
1253
            dprintf("error ac\n");
1254
            return -1;
1255
        }
1256
        /* EOB */
1257
        if (code == 0)
1258
            break;
1259
        if (code == 0xf0) {
1260
            i += 16;
1261
        } else {
1262
            level = get_xbits(&s->gb, code & 0xf);
1263
            i += code >> 4;
1264
            if (i >= 64) {
1265
                dprintf("error count: %d\n", i);
1266
                return -1;
1267
            }
1268
            j = s->scantable.permutated[i];
1269
            block[j] = level * quant_matrix[j];
1270
            i++;
1271
            if (i >= 64)
1272
                break;
1273
        }
1274
    }
1275
    return 0;
1276
}
1277

    
1278
static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1279
    int i, mb_x, mb_y;
1280
    uint16_t buffer[32768][4];
1281
    int left[3], top[3], topleft[3];
1282
    const int linesize= s->linesize[0];
1283
    const int mask= (1<<s->bits)-1;
1284

    
1285
    if((unsigned)s->mb_width > 32768) //dynamic alloc
1286
        return -1;
1287

    
1288
    for(i=0; i<3; i++){
1289
        buffer[0][i]= 1 << (s->bits + point_transform - 1);
1290
    }
1291
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1292
        const int modified_predictor= mb_y ? predictor : 1;
1293
        uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1294

    
1295
        if (s->interlaced && s->bottom_field)
1296
            ptr += linesize >> 1;
1297

    
1298
        for(i=0; i<3; i++){
1299
            top[i]= left[i]= topleft[i]= buffer[0][i];
1300
        }
1301
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1302
            if (s->restart_interval && !s->restart_count)
1303
                s->restart_count = s->restart_interval;
1304

    
1305
            for(i=0;i<3;i++) {
1306
                int pred;
1307

    
1308
                topleft[i]= top[i];
1309
                top[i]= buffer[mb_x][i];
1310

    
1311
                PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1312

    
1313
                left[i]=
1314
                buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1315
            }
1316

    
1317
            if (s->restart_interval && !--s->restart_count) {
1318
                align_get_bits(&s->gb);
1319
                skip_bits(&s->gb, 16); /* skip RSTn */
1320
            }
1321
        }
1322

    
1323
        if(s->rct){
1324
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1325
                ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1326
                ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1327
                ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1328
            }
1329
        }else if(s->pegasus_rct){
1330
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1331
                ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1332
                ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1333
                ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1334
            }
1335
        }else{
1336
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1337
                ptr[4*mb_x+0] = buffer[mb_x][0];
1338
                ptr[4*mb_x+1] = buffer[mb_x][1];
1339
                ptr[4*mb_x+2] = buffer[mb_x][2];
1340
            }
1341
        }
1342
    }
1343
    return 0;
1344
}
1345

    
1346
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1347
    int i, mb_x, mb_y;
1348
    const int nb_components=3;
1349

    
1350
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1351
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1352
            if (s->restart_interval && !s->restart_count)
1353
                s->restart_count = s->restart_interval;
1354

    
1355
            if(mb_x==0 || mb_y==0 || s->interlaced){
1356
                for(i=0;i<nb_components;i++) {
1357
                    uint8_t *ptr;
1358
                    int n, h, v, x, y, c, j, linesize;
1359
                    n = s->nb_blocks[i];
1360
                    c = s->comp_index[i];
1361
                    h = s->h_scount[i];
1362
                    v = s->v_scount[i];
1363
                    x = 0;
1364
                    y = 0;
1365
                    linesize= s->linesize[c];
1366

    
1367
                    for(j=0; j<n; j++) {
1368
                        int pred;
1369

    
1370
                        ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1371
                        if(y==0 && mb_y==0){
1372
                            if(x==0 && mb_x==0){
1373
                                pred= 128 << point_transform;
1374
                            }else{
1375
                                pred= ptr[-1];
1376
                            }
1377
                        }else{
1378
                            if(x==0 && mb_x==0){
1379
                                pred= ptr[-linesize];
1380
                            }else{
1381
                                PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1382
                            }
1383
                        }
1384

    
1385
                        if (s->interlaced && s->bottom_field)
1386
                            ptr += linesize >> 1;
1387
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1388

    
1389
                        if (++x == h) {
1390
                            x = 0;
1391
                            y++;
1392
                        }
1393
                    }
1394
                }
1395
            }else{
1396
                for(i=0;i<nb_components;i++) {
1397
                    uint8_t *ptr;
1398
                    int n, h, v, x, y, c, j, linesize;
1399
                    n = s->nb_blocks[i];
1400
                    c = s->comp_index[i];
1401
                    h = s->h_scount[i];
1402
                    v = s->v_scount[i];
1403
                    x = 0;
1404
                    y = 0;
1405
                    linesize= s->linesize[c];
1406

    
1407
                    for(j=0; j<n; j++) {
1408
                        int pred;
1409

    
1410
                        ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1411
                        PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1412
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1413
                        if (++x == h) {
1414
                            x = 0;
1415
                            y++;
1416
                        }
1417
                    }
1418
                }
1419
            }
1420
            if (s->restart_interval && !--s->restart_count) {
1421
                align_get_bits(&s->gb);
1422
                skip_bits(&s->gb, 16); /* skip RSTn */
1423
            }
1424
        }
1425
    }
1426
    return 0;
1427
}
1428

    
1429
static int mjpeg_decode_scan(MJpegDecodeContext *s){
1430
    int i, mb_x, mb_y;
1431
    const int nb_components=3;
1432

    
1433
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1434
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1435
            if (s->restart_interval && !s->restart_count)
1436
                s->restart_count = s->restart_interval;
1437

    
1438
            for(i=0;i<nb_components;i++) {
1439
                uint8_t *ptr;
1440
                int n, h, v, x, y, c, j;
1441
                n = s->nb_blocks[i];
1442
                c = s->comp_index[i];
1443
                h = s->h_scount[i];
1444
                v = s->v_scount[i];
1445
                x = 0;
1446
                y = 0;
1447
                for(j=0;j<n;j++) {
1448
                    memset(s->block, 0, sizeof(s->block));
1449
                    if (decode_block(s, s->block, i,
1450
                                     s->dc_index[i], s->ac_index[i],
1451
                                     s->quant_index[c]) < 0) {
1452
                        dprintf("error y=%d x=%d\n", mb_y, mb_x);
1453
                        return -1;
1454
                    }
1455
//                    dprintf("mb: %d %d processed\n", mb_y, mb_x);
1456
                    ptr = s->picture.data[c] +
1457
                        (((s->linesize[c] * (v * mb_y + y) * 8) +
1458
                        (h * mb_x + x) * 8) >> s->avctx->lowres);
1459
                    if (s->interlaced && s->bottom_field)
1460
                        ptr += s->linesize[c] >> 1;
1461
//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);
1462
                    s->idct_put(ptr, s->linesize[c], s->block);
1463
                    if (++x == h) {
1464
                        x = 0;
1465
                        y++;
1466
                    }
1467
                }
1468
            }
1469
            /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1470
            if (s->restart_interval && (s->restart_interval < 1350) &&
1471
                !--s->restart_count) {
1472
                align_get_bits(&s->gb);
1473
                skip_bits(&s->gb, 16); /* skip RSTn */
1474
                for (i=0; i<nb_components; i++) /* reset dc */
1475
                    s->last_dc[i] = 1024;
1476
            }
1477
        }
1478
    }
1479
    return 0;
1480
}
1481

    
1482
static int mjpeg_decode_sos(MJpegDecodeContext *s)
1483
{
1484
    int len, nb_components, i, h, v, predictor, point_transform;
1485
    int vmax, hmax, index, id;
1486
    const int block_size= s->lossless ? 1 : 8;
1487
    int ilv;
1488

    
1489
    /* XXX: verify len field validity */
1490
    len = get_bits(&s->gb, 16);
1491
    nb_components = get_bits(&s->gb, 8);
1492
    if (len != 6+2*nb_components)
1493
    {
1494
        dprintf("decode_sos: invalid len (%d)\n", len);
1495
        return -1;
1496
    }
1497
    /* XXX: only interleaved scan accepted */
1498
    if (nb_components != s->nb_components)
1499
    {
1500
        dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1501
        return -1;
1502
    }
1503
    vmax = 0;
1504
    hmax = 0;
1505
    for(i=0;i<nb_components;i++) {
1506
        id = get_bits(&s->gb, 8) - 1;
1507
        dprintf("component: %d\n", id);
1508
        /* find component index */
1509
        for(index=0;index<s->nb_components;index++)
1510
            if (id == s->component_id[index])
1511
                break;
1512
        if (index == s->nb_components)
1513
        {
1514
            dprintf("decode_sos: index(%d) out of components\n", index);
1515
            return -1;
1516
        }
1517

    
1518
        s->comp_index[i] = index;
1519

    
1520
        s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1521
        s->h_scount[i] = s->h_count[index];
1522
        s->v_scount[i] = s->v_count[index];
1523

    
1524
        s->dc_index[i] = get_bits(&s->gb, 4);
1525
        s->ac_index[i] = get_bits(&s->gb, 4);
1526

    
1527
        if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1528
            s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1529
            goto out_of_range;
1530
#if 0 //buggy
1531
        switch(s->start_code)
1532
        {
1533
            case SOF0:
1534
                if (dc_index[i] > 1 || ac_index[i] > 1)
1535
                    goto out_of_range;
1536
                break;
1537
            case SOF1:
1538
            case SOF2:
1539
                if (dc_index[i] > 3 || ac_index[i] > 3)
1540
                    goto out_of_range;
1541
                break;
1542
            case SOF3:
1543
                if (dc_index[i] > 3 || ac_index[i] != 0)
1544
                    goto out_of_range;
1545
                break;
1546
        }
1547
#endif
1548
    }
1549

    
1550
    predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1551
    ilv= get_bits(&s->gb, 8);    /* JPEG Se / JPEG-LS ILV */
1552
    skip_bits(&s->gb, 4); /* Ah */
1553
    point_transform= get_bits(&s->gb, 4); /* Al */
1554

    
1555
    for(i=0;i<nb_components;i++)
1556
        s->last_dc[i] = 1024;
1557

    
1558
    if (nb_components > 1) {
1559
        /* interleaved stream */
1560
        s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1561
        s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1562
    } else {
1563
        h = s->h_max / s->h_scount[s->comp_index[0]];
1564
        v = s->v_max / s->v_scount[s->comp_index[0]];
1565
        s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1566
        s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1567
        s->nb_blocks[0] = 1;
1568
        s->h_scount[0] = 1;
1569
        s->v_scount[0] = 1;
1570
    }
1571

    
1572
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1573
        av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d %s\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "",
1574
               predictor, point_transform, ilv, s->bits,
1575
               s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));
1576

    
1577

    
1578
    /* mjpeg-b can have padding bytes between sos and image data, skip them */
1579
    for (i = s->mjpb_skiptosod; i > 0; i--)
1580
        skip_bits(&s->gb, 8);
1581

    
1582
    if(s->lossless){
1583
        if(s->ls){
1584
//            for(){
1585
        }else{
1586
            if(s->rgb){
1587
                if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1588
                    return -1;
1589
            }else{
1590
                if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1591
                    return -1;
1592
            }
1593
        }
1594
    }else{
1595
        if(mjpeg_decode_scan(s) < 0)
1596
            return -1;
1597
    }
1598
    emms_c();
1599
    return 0;
1600
 out_of_range:
1601
    dprintf("decode_sos: ac/dc index out of range\n");
1602
    return -1;
1603
}
1604

    
1605
static int mjpeg_decode_dri(MJpegDecodeContext *s)
1606
{
1607
    if (get_bits(&s->gb, 16) != 4)
1608
        return -1;
1609
    s->restart_interval = get_bits(&s->gb, 16);
1610
    s->restart_count = 0;
1611
    dprintf("restart interval: %d\n", s->restart_interval);
1612

    
1613
    return 0;
1614
}
1615

    
1616
static int mjpeg_decode_app(MJpegDecodeContext *s)
1617
{
1618
    int len, id;
1619

    
1620
    len = get_bits(&s->gb, 16);
1621
    if (len < 5)
1622
        return -1;
1623
    if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits)
1624
        return -1;
1625

    
1626
    id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1627
    id = be2me_32(id);
1628
    len -= 6;
1629

    
1630
    if(s->avctx->debug & FF_DEBUG_STARTCODE){
1631
        av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
1632
    }
1633

    
1634
    /* buggy AVID, it puts EOI only at every 10th frame */
1635
    /* also this fourcc is used by non-avid files too, it holds some
1636
       informations, but it's always present in AVID creates files */
1637
    if (id == ff_get_fourcc("AVI1"))
1638
    {
1639
        /* structure:
1640
            4bytes      AVI1
1641
            1bytes      polarity
1642
            1bytes      always zero
1643
            4bytes      field_size
1644
            4bytes      field_size_less_padding
1645
        */
1646
            s->buggy_avid = 1;
1647
//        if (s->first_picture)
1648
//            printf("mjpeg: workarounding buggy AVID\n");
1649
        s->interlace_polarity = get_bits(&s->gb, 8);
1650
#if 0
1651
        skip_bits(&s->gb, 8);
1652
        skip_bits(&s->gb, 32);
1653
        skip_bits(&s->gb, 32);
1654
        len -= 10;
1655
#endif
1656
//        if (s->interlace_polarity)
1657
//            printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1658
        goto out;
1659
    }
1660

    
1661
//    len -= 2;
1662

    
1663
    if (id == ff_get_fourcc("JFIF"))
1664
    {
1665
        int t_w, t_h, v1, v2;
1666
        skip_bits(&s->gb, 8); /* the trailing zero-byte */
1667
        v1= get_bits(&s->gb, 8);
1668
        v2= get_bits(&s->gb, 8);
1669
        skip_bits(&s->gb, 8);
1670

    
1671
        s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1672
        s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1673

    
1674
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1675
            av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1676
                v1, v2,
1677
                s->avctx->sample_aspect_ratio.num,
1678
                s->avctx->sample_aspect_ratio.den
1679
            );
1680

    
1681
        t_w = get_bits(&s->gb, 8);
1682
        t_h = get_bits(&s->gb, 8);
1683
        if (t_w && t_h)
1684
        {
1685
            /* skip thumbnail */
1686
            if (len-10-(t_w*t_h*3) > 0)
1687
                len -= t_w*t_h*3;
1688
        }
1689
        len -= 10;
1690
        goto out;
1691
    }
1692

    
1693
    if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1694
    {
1695
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1696
            av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1697
        skip_bits(&s->gb, 16); /* version */
1698
        skip_bits(&s->gb, 16); /* flags0 */
1699
        skip_bits(&s->gb, 16); /* flags1 */
1700
        skip_bits(&s->gb, 8);  /* transform */
1701
        len -= 7;
1702
        goto out;
1703
    }
1704

    
1705
    if (id == ff_get_fourcc("LJIF")){
1706
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1707
            av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1708
        skip_bits(&s->gb, 16); /* version ? */
1709
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1710
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1711
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1712
        switch( get_bits(&s->gb, 8)){
1713
        case 1:
1714
            s->rgb= 1;
1715
            s->pegasus_rct=0;
1716
            break;
1717
        case 2:
1718
            s->rgb= 1;
1719
            s->pegasus_rct=1;
1720
            break;
1721
        default:
1722
            av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1723
        }
1724
        len -= 9;
1725
        goto out;
1726
    }
1727

    
1728
    /* Apple MJPEG-A */
1729
    if ((s->start_code == APP1) && (len > (0x28 - 8)))
1730
    {
1731
        id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1732
        id = be2me_32(id);
1733
        len -= 4;
1734
        if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1735
        {
1736
#if 0
1737
            skip_bits(&s->gb, 32); /* field size */
1738
            skip_bits(&s->gb, 32); /* pad field size */
1739
            skip_bits(&s->gb, 32); /* next off */
1740
            skip_bits(&s->gb, 32); /* quant off */
1741
            skip_bits(&s->gb, 32); /* huff off */
1742
            skip_bits(&s->gb, 32); /* image off */
1743
            skip_bits(&s->gb, 32); /* scan off */
1744
            skip_bits(&s->gb, 32); /* data off */
1745
#endif
1746
            if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1747
                av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1748
        }
1749
    }
1750

    
1751
out:
1752
    /* slow but needed for extreme adobe jpegs */
1753
    if (len < 0)
1754
        av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1755
    while(--len > 0)
1756
        skip_bits(&s->gb, 8);
1757

    
1758
    return 0;
1759
}
1760

    
1761
static int mjpeg_decode_com(MJpegDecodeContext *s)
1762
{
1763
    int len = get_bits(&s->gb, 16);
1764
    if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) {
1765
        uint8_t *cbuf = av_malloc(len - 1);
1766
        if (cbuf) {
1767
            int i;
1768
            for (i = 0; i < len - 2; i++)
1769
                cbuf[i] = get_bits(&s->gb, 8);
1770
            if (i > 0 && cbuf[i-1] == '\n')
1771
                cbuf[i-1] = 0;
1772
            else
1773
                cbuf[i] = 0;
1774

    
1775
            if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1776
                av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1777

    
1778
            /* buggy avid, it puts EOI only at every 10th frame */
1779
            if (!strcmp(cbuf, "AVID"))
1780
            {
1781
                s->buggy_avid = 1;
1782
                //        if (s->first_picture)
1783
                //            printf("mjpeg: workarounding buggy AVID\n");
1784
            }
1785
            else if(!strcmp(cbuf, "CS=ITU601")){
1786
                s->cs_itu601= 1;
1787
            }
1788

    
1789
            av_free(cbuf);
1790
        }
1791
    }
1792

    
1793
    return 0;
1794
}
1795

    
1796
#if 0
1797
static int valid_marker_list[] =
1798
{
1799
        /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1800
/* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1801
/* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1802
/* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1803
/* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1804
/* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1805
/* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1806
/* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1807
/* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1808
/* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1809
/* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1810
/* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1811
/* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1812
/* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1813
/* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1814
/* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1815
/* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1816
}
1817
#endif
1818

    
1819
/* return the 8 bit start code value and update the search
1820
   state. Return -1 if no start code found */
1821
static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1822
{
1823
    uint8_t *buf_ptr;
1824
    unsigned int v, v2;
1825
    int val;
1826
#ifdef DEBUG
1827
    int skipped=0;
1828
#endif
1829

    
1830
    buf_ptr = *pbuf_ptr;
1831
    while (buf_ptr < buf_end) {
1832
        v = *buf_ptr++;
1833
        v2 = *buf_ptr;
1834
        if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1835
            val = *buf_ptr++;
1836
            goto found;
1837
        }
1838
#ifdef DEBUG
1839
        skipped++;
1840
#endif
1841
    }
1842
    val = -1;
1843
found:
1844
#ifdef DEBUG
1845
    dprintf("find_marker skipped %d bytes\n", skipped);
1846
#endif
1847
    *pbuf_ptr = buf_ptr;
1848
    return val;
1849
}
1850

    
1851
static int mjpeg_decode_frame(AVCodecContext *avctx,
1852
                              void *data, int *data_size,
1853
                              uint8_t *buf, int buf_size)
1854
{
1855
    MJpegDecodeContext *s = avctx->priv_data;
1856
    uint8_t *buf_end, *buf_ptr;
1857
    int start_code;
1858
    AVFrame *picture = data;
1859

    
1860
    buf_ptr = buf;
1861
    buf_end = buf + buf_size;
1862
    while (buf_ptr < buf_end) {
1863
        /* find start next marker */
1864
        start_code = find_marker(&buf_ptr, buf_end);
1865
        {
1866
            /* EOF */
1867
            if (start_code < 0) {
1868
                goto the_end;
1869
            } else {
1870
                dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1871

    
1872
                if ((buf_end - buf_ptr) > s->buffer_size)
1873
                {
1874
                    av_free(s->buffer);
1875
                    s->buffer_size = buf_end-buf_ptr;
1876
                    s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
1877
                    dprintf("buffer too small, expanding to %d bytes\n",
1878
                        s->buffer_size);
1879
                }
1880

    
1881
                /* unescape buffer of SOS */
1882
                if (start_code == SOS)
1883
                {
1884
                    uint8_t *src = buf_ptr;
1885
                    uint8_t *dst = s->buffer;
1886

    
1887
                    while (src<buf_end)
1888
                    {
1889
                        uint8_t x = *(src++);
1890

    
1891
                        *(dst++) = x;
1892
                        if (x == 0xff)
1893
                        {
1894
                            while(src<buf_end && x == 0xff)
1895
                                x = *(src++);
1896

    
1897
                            if (x >= 0xd0 && x <= 0xd7)
1898
                                *(dst++) = x;
1899
                            else if (x)
1900
                                break;
1901
                        }
1902
                    }
1903
                    init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1904

    
1905
                    dprintf("escaping removed %d bytes\n",
1906
                        (buf_end - buf_ptr) - (dst - s->buffer));
1907
                }
1908
                else
1909
                    init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1910

    
1911
                s->start_code = start_code;
1912
                if(s->avctx->debug & FF_DEBUG_STARTCODE){
1913
                    av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
1914
                }
1915

    
1916
                /* process markers */
1917
                if (start_code >= 0xd0 && start_code <= 0xd7) {
1918
                    dprintf("restart marker: %d\n", start_code&0x0f);
1919
                    /* APP fields */
1920
                } else if (start_code >= APP0 && start_code <= APP15) {
1921
                    mjpeg_decode_app(s);
1922
                    /* Comment */
1923
                } else if (start_code == COM){
1924
                    mjpeg_decode_com(s);
1925
                }
1926

    
1927
                switch(start_code) {
1928
                case SOI:
1929
                    s->restart_interval = 0;
1930
                    reset_ls_coding_parameters(s, 1);
1931

    
1932
                    s->restart_count = 0;
1933
                    /* nothing to do on SOI */
1934
                    break;
1935
                case DQT:
1936
                    mjpeg_decode_dqt(s);
1937
                    break;
1938
                case DHT:
1939
                    if(mjpeg_decode_dht(s) < 0){
1940
                        av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n");
1941
                        return -1;
1942
                    }
1943
                    break;
1944
                case SOF0:
1945
                    s->lossless=0;
1946
                    if (mjpeg_decode_sof(s) < 0)
1947
                        return -1;
1948
                    break;
1949
                case SOF3:
1950
                    s->lossless=1;
1951
                    if (mjpeg_decode_sof(s) < 0)
1952
                        return -1;
1953
                    break;
1954
                case SOF48:
1955
                    s->lossless=1;
1956
                    s->ls=1;
1957
                    if (mjpeg_decode_sof(s) < 0)
1958
                        return -1;
1959
                    break;
1960
                case LSE:
1961
                    if (decode_lse(s) < 0)
1962
                        return -1;
1963
                    break;
1964
                case EOI:
1965
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1966
                        break;
1967
eoi_parser:
1968
                    {
1969
                        if (s->interlaced) {
1970
                            s->bottom_field ^= 1;
1971
                            /* if not bottom field, do not output image yet */
1972
                            if (s->bottom_field)
1973
                                goto not_the_end;
1974
                        }
1975
                        *picture = s->picture;
1976
                        *data_size = sizeof(AVFrame);
1977

    
1978
                        if(!s->lossless){
1979
                            picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
1980
                            picture->qstride= 0;
1981
                            picture->qscale_table= s->qscale_table;
1982
                            memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1983
                            if(avctx->debug & FF_DEBUG_QP)
1984
                                av_log(s->avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
1985
                            picture->quality*= FF_QP2LAMBDA;
1986
                        }
1987

    
1988
                        goto the_end;
1989
                    }
1990
                    break;
1991
                case SOS:
1992
                    mjpeg_decode_sos(s);
1993
                    /* buggy avid puts EOI every 10-20th frame */
1994
                    /* if restart period is over process EOI */
1995
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1996
                        goto eoi_parser;
1997
                    break;
1998
                case DRI:
1999
                    mjpeg_decode_dri(s);
2000
                    break;
2001
                case SOF1:
2002
                case SOF2:
2003
                case SOF5:
2004
                case SOF6:
2005
                case SOF7:
2006
                case SOF9:
2007
                case SOF10:
2008
                case SOF11:
2009
                case SOF13:
2010
                case SOF14:
2011
                case SOF15:
2012
                case JPG:
2013
                    av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
2014
                    break;
2015
//                default:
2016
//                    printf("mjpeg: unsupported marker (%x)\n", start_code);
2017
//                    break;
2018
                }
2019

    
2020
not_the_end:
2021
                /* eof process start code */
2022
                buf_ptr += (get_bits_count(&s->gb)+7)/8;
2023
                dprintf("marker parser used %d bytes (%d bits)\n",
2024
                    (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
2025
            }
2026
        }
2027
    }
2028
the_end:
2029
    dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
2030
//    return buf_end - buf_ptr;
2031
    return buf_ptr - buf;
2032
}
2033

    
2034
static int mjpegb_decode_frame(AVCodecContext *avctx,
2035
                              void *data, int *data_size,
2036
                              uint8_t *buf, int buf_size)
2037
{
2038
    MJpegDecodeContext *s = avctx->priv_data;
2039
    uint8_t *buf_end, *buf_ptr;
2040
    AVFrame *picture = data;
2041
    GetBitContext hgb; /* for the header */
2042
    uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
2043
    uint32_t field_size, sod_offs;
2044

    
2045
    buf_ptr = buf;
2046
    buf_end = buf + buf_size;
2047

    
2048
read_header:
2049
    /* reset on every SOI */
2050
    s->restart_interval = 0;
2051
    s->restart_count = 0;
2052
    s->mjpb_skiptosod = 0;
2053

    
2054
    init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
2055

    
2056
    skip_bits(&hgb, 32); /* reserved zeros */
2057

    
2058
    if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
2059
    {
2060
        dprintf("not mjpeg-b (bad fourcc)\n");
2061
        return 0;
2062
    }
2063

    
2064
    field_size = get_bits_long(&hgb, 32); /* field size */
2065
    dprintf("field size: 0x%x\n", field_size);
2066
    skip_bits(&hgb, 32); /* padded field size */
2067
    second_field_offs = get_bits_long(&hgb, 32);
2068
    dprintf("second field offs: 0x%x\n", second_field_offs);
2069
    if (second_field_offs)
2070
        s->interlaced = 1;
2071

    
2072
    dqt_offs = get_bits_long(&hgb, 32);
2073
    dprintf("dqt offs: 0x%x\n", dqt_offs);
2074
    if (dqt_offs)
2075
    {
2076
        init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
2077
        s->start_code = DQT;
2078
        mjpeg_decode_dqt(s);
2079
    }
2080

    
2081
    dht_offs = get_bits_long(&hgb, 32);
2082
    dprintf("dht offs: 0x%x\n", dht_offs);
2083
    if (dht_offs)
2084
    {
2085
        init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
2086
        s->start_code = DHT;
2087
        mjpeg_decode_dht(s);
2088
    }
2089

    
2090
    sof_offs = get_bits_long(&hgb, 32);
2091
    dprintf("sof offs: 0x%x\n", sof_offs);
2092
    if (sof_offs)
2093
    {
2094
        init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
2095
        s->start_code = SOF0;
2096
        if (mjpeg_decode_sof(s) < 0)
2097
            return -1;
2098
    }
2099

    
2100
    sos_offs = get_bits_long(&hgb, 32);
2101
    dprintf("sos offs: 0x%x\n", sos_offs);
2102
    sod_offs = get_bits_long(&hgb, 32);
2103
    dprintf("sod offs: 0x%x\n", sod_offs);
2104
    if (sos_offs)
2105
    {
2106
//        init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2107
        init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2108
        s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
2109
        s->start_code = SOS;
2110
        mjpeg_decode_sos(s);
2111
    }
2112

    
2113
    if (s->interlaced) {
2114
        s->bottom_field ^= 1;
2115
        /* if not bottom field, do not output image yet */
2116
        if (s->bottom_field && second_field_offs)
2117
        {
2118
            buf_ptr = buf + second_field_offs;
2119
            second_field_offs = 0;
2120
            goto read_header;
2121
            }
2122
    }
2123

    
2124
    //XXX FIXME factorize, this looks very similar to the EOI code
2125

    
2126
    *picture= s->picture;
2127
    *data_size = sizeof(AVFrame);
2128

    
2129
    if(!s->lossless){
2130
        picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2131
        picture->qstride= 0;
2132
        picture->qscale_table= s->qscale_table;
2133
        memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2134
        if(avctx->debug & FF_DEBUG_QP)
2135
            av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2136
        picture->quality*= FF_QP2LAMBDA;
2137
    }
2138

    
2139
    return buf_ptr - buf;
2140
}
2141

    
2142
#include "sp5x.h"
2143

    
2144
static int sp5x_decode_frame(AVCodecContext *avctx,
2145
                              void *data, int *data_size,
2146
                              uint8_t *buf, int buf_size)
2147
{
2148
#if 0
2149
    MJpegDecodeContext *s = avctx->priv_data;
2150
#endif
2151
    const int qscale = 5;
2152
    uint8_t *buf_ptr, *buf_end, *recoded;
2153
    int i = 0, j = 0;
2154

    
2155
    if (!avctx->width || !avctx->height)
2156
        return -1;
2157

    
2158
    buf_ptr = buf;
2159
    buf_end = buf + buf_size;
2160

    
2161
#if 1
2162
    recoded = av_mallocz(buf_size + 1024);
2163
    if (!recoded)
2164
        return -1;
2165

    
2166
    /* SOI */
2167
    recoded[j++] = 0xFF;
2168
    recoded[j++] = 0xD8;
2169

    
2170
    memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2171
    memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2172
    memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2173
    j += sizeof(sp5x_data_dqt);
2174

    
2175
    memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2176
    j += sizeof(sp5x_data_dht);
2177

    
2178
    memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2179
    recoded[j+5] = (avctx->coded_height >> 8) & 0xFF;
2180
    recoded[j+6] = avctx->coded_height & 0xFF;
2181
    recoded[j+7] = (avctx->coded_width >> 8) & 0xFF;
2182
    recoded[j+8] = avctx->coded_width & 0xFF;
2183
    j += sizeof(sp5x_data_sof);
2184

    
2185
    memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2186
    j += sizeof(sp5x_data_sos);
2187

    
2188
    for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2189
    {
2190
        recoded[j++] = buf[i];
2191
        if (buf[i] == 0xff)
2192
            recoded[j++] = 0;
2193
    }
2194

    
2195
    /* EOI */
2196
    recoded[j++] = 0xFF;
2197
    recoded[j++] = 0xD9;
2198

    
2199
    i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2200

    
2201
    av_free(recoded);
2202

    
2203
#else
2204
    /* SOF */
2205
    s->bits = 8;
2206
    s->width  = avctx->coded_width;
2207
    s->height = avctx->coded_height;
2208
    s->nb_components = 3;
2209
    s->component_id[0] = 0;
2210
    s->h_count[0] = 2;
2211
    s->v_count[0] = 2;
2212
    s->quant_index[0] = 0;
2213
    s->component_id[1] = 1;
2214
    s->h_count[1] = 1;
2215
    s->v_count[1] = 1;
2216
    s->quant_index[1] = 1;
2217
    s->component_id[2] = 2;
2218
    s->h_count[2] = 1;
2219
    s->v_count[2] = 1;
2220
    s->quant_index[2] = 1;
2221
    s->h_max = 2;
2222
    s->v_max = 2;
2223

    
2224
    s->qscale_table = av_mallocz((s->width+15)/16);
2225
    avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420;
2226
    s->interlaced = 0;
2227

    
2228
    s->picture.reference = 0;
2229
    if (avctx->get_buffer(avctx, &s->picture) < 0)
2230
    {
2231
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2232
        return -1;
2233
    }
2234

    
2235
    s->picture.pict_type = I_TYPE;
2236
    s->picture.key_frame = 1;
2237

    
2238
    for (i = 0; i < 3; i++)
2239
        s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2240

    
2241
    /* DQT */
2242
    for (i = 0; i < 64; i++)
2243
    {
2244
        j = s->scantable.permutated[i];
2245
        s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2246
    }
2247
    s->qscale[0] = FFMAX(
2248
        s->quant_matrixes[0][s->scantable.permutated[1]],
2249
        s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2250

    
2251
    for (i = 0; i < 64; i++)
2252
    {
2253
        j = s->scantable.permutated[i];
2254
        s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2255
    }
2256
    s->qscale[1] = FFMAX(
2257
        s->quant_matrixes[1][s->scantable.permutated[1]],
2258
        s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2259

    
2260
    /* DHT */
2261

    
2262
    /* SOS */
2263
    s->comp_index[0] = 0;
2264
    s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2265
    s->h_scount[0] = s->h_count[0];
2266
    s->v_scount[0] = s->v_count[0];
2267
    s->dc_index[0] = 0;
2268
    s->ac_index[0] = 0;
2269

    
2270
    s->comp_index[1] = 1;
2271
    s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2272
    s->h_scount[1] = s->h_count[1];
2273
    s->v_scount[1] = s->v_count[1];
2274
    s->dc_index[1] = 1;
2275
    s->ac_index[1] = 1;
2276

    
2277
    s->comp_index[2] = 2;
2278
    s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2279
    s->h_scount[2] = s->h_count[2];
2280
    s->v_scount[2] = s->v_count[2];
2281
    s->dc_index[2] = 1;
2282
    s->ac_index[2] = 1;
2283

    
2284
    for (i = 0; i < 3; i++)
2285
        s->last_dc[i] = 1024;
2286

    
2287
    s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2288
    s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2289

    
2290
    init_get_bits(&s->gb, buf+14, (buf_size-14)*8);
2291

    
2292
    return mjpeg_decode_scan(s);
2293
#endif
2294

    
2295
    return i;
2296
}
2297

    
2298
static int mjpeg_decode_end(AVCodecContext *avctx)
2299
{
2300
    MJpegDecodeContext *s = avctx->priv_data;
2301
    int i, j;
2302

    
2303
    av_free(s->buffer);
2304
    av_free(s->qscale_table);
2305

    
2306
    for(i=0;i<2;i++) {
2307
        for(j=0;j<4;j++)
2308
            free_vlc(&s->vlcs[i][j]);
2309
    }
2310
    return 0;
2311
}
2312

    
2313
AVCodec mjpeg_decoder = {
2314
    "mjpeg",
2315
    CODEC_TYPE_VIDEO,
2316
    CODEC_ID_MJPEG,
2317
    sizeof(MJpegDecodeContext),
2318
    mjpeg_decode_init,
2319
    NULL,
2320
    mjpeg_decode_end,
2321
    mjpeg_decode_frame,
2322
    CODEC_CAP_DR1,
2323
    NULL
2324
};
2325

    
2326
AVCodec mjpegb_decoder = {
2327
    "mjpegb",
2328
    CODEC_TYPE_VIDEO,
2329
    CODEC_ID_MJPEGB,
2330
    sizeof(MJpegDecodeContext),
2331
    mjpeg_decode_init,
2332
    NULL,
2333
    mjpeg_decode_end,
2334
    mjpegb_decode_frame,
2335
    CODEC_CAP_DR1,
2336
    NULL
2337
};
2338

    
2339
AVCodec sp5x_decoder = {
2340
    "sp5x",
2341
    CODEC_TYPE_VIDEO,
2342
    CODEC_ID_SP5X,
2343
    sizeof(MJpegDecodeContext),
2344
    mjpeg_decode_init,
2345
    NULL,
2346
    mjpeg_decode_end,
2347
    sp5x_decode_frame,
2348
    CODEC_CAP_DR1,
2349
    NULL
2350
};
2351

    
2352
#ifdef CONFIG_ENCODERS
2353
AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2354
    "ljpeg",
2355
    CODEC_TYPE_VIDEO,
2356
    CODEC_ID_LJPEG,
2357
    sizeof(MpegEncContext),
2358
    MPV_encode_init,
2359
    encode_picture_lossless,
2360
    MPV_encode_end,
2361
};
2362
#endif
2363

    
2364
AVCodecParser mjpeg_parser = {
2365
    { CODEC_ID_MJPEG },
2366
    sizeof(ParseContext),
2367
    NULL,
2368
    jpeg_parse,
2369
    ff_parse_close,
2370
};
2371