Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mjpeg.c @ 68b51e58

History | View | Annotate | Download (74.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
    DECLARE_ALIGNED_8(DCTELEM, block[64]);
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

    
889
    int cur_scan; /* current scan, used by JPEG-LS */
890
} MJpegDecodeContext;
891

    
892
#include "jpeg_ls.c" //FIXME make jpeg-ls more independant
893

    
894
static int mjpeg_decode_dht(MJpegDecodeContext *s);
895

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

    
902
    memset(huff_size, 0, sizeof(huff_size));
903
    build_huffman_codes(huff_size, huff_code, bits_table, val_table);
904

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

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

    
914
    s->avctx = avctx;
915

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

    
923
    s->scantable= s2.intra_scantable;
924
    s->idct_put= s2.dsp.idct_put;
925

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

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

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

    
946
    return 0;
947
}
948

    
949

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

    
958
    vop_found= pc->frame_start_found;
959
    state= pc->state;
960

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

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

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

    
999
    next= find_frame_end(pc, buf, buf_size);
1000

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

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

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

    
1017
    len = get_bits(&s->gb, 16) - 2;
1018

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

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

    
1044
    return 0;
1045
}
1046

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

    
1054
    len = get_bits(&s->gb, 16) - 2;
1055

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

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

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

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

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

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

    
1105
    if (s->bits != 8 && !s->lossless){
1106
        av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
1107
        return -1;
1108
    }
1109
    if (s->bits > 8 && s->ls){
1110
        av_log(s->avctx, AV_LOG_ERROR, "only <= 8 bits/component accepted for JPEG-LS\n");
1111
        return -1;
1112
    }
1113

    
1114
    height = get_bits(&s->gb, 16);
1115
    width = get_bits(&s->gb, 16);
1116

    
1117
    dprintf("sof0: picture: %dx%d\n", width, height);
1118
    if(avcodec_check_dimensions(s->avctx, width, height))
1119
        return -1;
1120

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

    
1145
    if(s->ls && (s->h_max > 1 || s->v_max > 1)) {
1146
        av_log(s->avctx, AV_LOG_ERROR, "Subsampling in JPEG-LS is not supported.\n");
1147
        return -1;
1148
    }
1149

    
1150
    if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1151

    
1152
    /* if different size, realloc/alloc picture */
1153
    /* XXX: also check h_count and v_count */
1154
    if (width != s->width || height != s->height) {
1155
        av_freep(&s->qscale_table);
1156

    
1157
        s->width = width;
1158
        s->height = height;
1159

    
1160
        /* test interlaced mode */
1161
        if (s->first_picture &&
1162
            s->org_height != 0 &&
1163
            s->height < ((s->org_height * 3) / 4)) {
1164
            s->interlaced = 1;
1165
//            s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1166
            s->bottom_field = 0;
1167
            height *= 2;
1168
        }
1169

    
1170
        avcodec_set_dimensions(s->avctx, width, height);
1171

    
1172
        s->qscale_table= av_mallocz((s->width+15)/16);
1173

    
1174
        s->first_picture = 0;
1175
    }
1176

    
1177
    if(s->interlaced && s->bottom_field)
1178
        return 0;
1179

    
1180
    /* XXX: not complete test ! */
1181
    switch((s->h_count[0] << 4) | s->v_count[0]) {
1182
    case 0x11:
1183
        if(s->rgb){
1184
            s->avctx->pix_fmt = PIX_FMT_RGBA32;
1185
        }else if(s->nb_components==3)
1186
            s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;
1187
        else
1188
            s->avctx->pix_fmt = PIX_FMT_GRAY8;
1189
        break;
1190
    case 0x21:
1191
        s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P;
1192
        break;
1193
    default:
1194
    case 0x22:
1195
        s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P;
1196
        break;
1197
    }
1198
    if(s->ls){
1199
        if(s->nb_components > 1)
1200
            s->avctx->pix_fmt = PIX_FMT_RGB24;
1201
        else
1202
            s->avctx->pix_fmt = PIX_FMT_GRAY8;
1203
    }
1204

    
1205
    if(s->picture.data[0])
1206
        s->avctx->release_buffer(s->avctx, &s->picture);
1207

    
1208
    s->picture.reference= 0;
1209
    if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1210
        av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1211
        return -1;
1212
    }
1213
    s->picture.pict_type= I_TYPE;
1214
    s->picture.key_frame= 1;
1215

    
1216
    for(i=0; i<3; i++){
1217
        s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1218
    }
1219

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

    
1222
    if (len != (8+(3*nb_components)))
1223
    {
1224
        dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1225
    }
1226

    
1227
    return 0;
1228
}
1229

    
1230
static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1231
{
1232
    int code;
1233
    code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1234
    if (code < 0)
1235
    {
1236
        dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1237
                &s->vlcs[0][dc_index]);
1238
        return 0xffff;
1239
    }
1240

    
1241
    if(code)
1242
        return get_xbits(&s->gb, code);
1243
    else
1244
        return 0;
1245
}
1246

    
1247
/* decode block and dequantize */
1248
static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1249
                        int component, int dc_index, int ac_index, int quant_index)
1250
{
1251
    int code, i, j, level, val;
1252
    VLC *ac_vlc;
1253
    int16_t *quant_matrix;
1254

    
1255
    /* DC coef */
1256
    val = mjpeg_decode_dc(s, dc_index);
1257
    if (val == 0xffff) {
1258
        dprintf("error dc\n");
1259
        return -1;
1260
    }
1261
    quant_matrix = s->quant_matrixes[quant_index];
1262
    val = val * quant_matrix[0] + s->last_dc[component];
1263
    s->last_dc[component] = val;
1264
    block[0] = val;
1265
    /* AC coefs */
1266
    ac_vlc = &s->vlcs[1][ac_index];
1267
    i = 1;
1268
    for(;;) {
1269
        code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
1270

    
1271
        if (code < 0) {
1272
            dprintf("error ac\n");
1273
            return -1;
1274
        }
1275
        /* EOB */
1276
        if (code == 0)
1277
            break;
1278
        if (code == 0xf0) {
1279
            i += 16;
1280
        } else {
1281
            level = get_xbits(&s->gb, code & 0xf);
1282
            i += code >> 4;
1283
            if (i >= 64) {
1284
                dprintf("error count: %d\n", i);
1285
                return -1;
1286
            }
1287
            j = s->scantable.permutated[i];
1288
            block[j] = level * quant_matrix[j];
1289
            i++;
1290
            if (i >= 64)
1291
                break;
1292
        }
1293
    }
1294
    return 0;
1295
}
1296

    
1297
static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1298
    int i, mb_x, mb_y;
1299
    uint16_t buffer[32768][4];
1300
    int left[3], top[3], topleft[3];
1301
    const int linesize= s->linesize[0];
1302
    const int mask= (1<<s->bits)-1;
1303

    
1304
    if((unsigned)s->mb_width > 32768) //dynamic alloc
1305
        return -1;
1306

    
1307
    for(i=0; i<3; i++){
1308
        buffer[0][i]= 1 << (s->bits + point_transform - 1);
1309
    }
1310
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1311
        const int modified_predictor= mb_y ? predictor : 1;
1312
        uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1313

    
1314
        if (s->interlaced && s->bottom_field)
1315
            ptr += linesize >> 1;
1316

    
1317
        for(i=0; i<3; i++){
1318
            top[i]= left[i]= topleft[i]= buffer[0][i];
1319
        }
1320
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1321
            if (s->restart_interval && !s->restart_count)
1322
                s->restart_count = s->restart_interval;
1323

    
1324
            for(i=0;i<3;i++) {
1325
                int pred;
1326

    
1327
                topleft[i]= top[i];
1328
                top[i]= buffer[mb_x][i];
1329

    
1330
                PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1331

    
1332
                left[i]=
1333
                buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1334
            }
1335

    
1336
            if (s->restart_interval && !--s->restart_count) {
1337
                align_get_bits(&s->gb);
1338
                skip_bits(&s->gb, 16); /* skip RSTn */
1339
            }
1340
        }
1341

    
1342
        if(s->rct){
1343
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1344
                ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1345
                ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1346
                ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1347
            }
1348
        }else if(s->pegasus_rct){
1349
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1350
                ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1351
                ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1352
                ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1353
            }
1354
        }else{
1355
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1356
                ptr[4*mb_x+0] = buffer[mb_x][0];
1357
                ptr[4*mb_x+1] = buffer[mb_x][1];
1358
                ptr[4*mb_x+2] = buffer[mb_x][2];
1359
            }
1360
        }
1361
    }
1362
    return 0;
1363
}
1364

    
1365
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1366
    int i, mb_x, mb_y;
1367
    const int nb_components=3;
1368

    
1369
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1370
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1371
            if (s->restart_interval && !s->restart_count)
1372
                s->restart_count = s->restart_interval;
1373

    
1374
            if(mb_x==0 || mb_y==0 || s->interlaced){
1375
                for(i=0;i<nb_components;i++) {
1376
                    uint8_t *ptr;
1377
                    int n, h, v, x, y, c, j, linesize;
1378
                    n = s->nb_blocks[i];
1379
                    c = s->comp_index[i];
1380
                    h = s->h_scount[i];
1381
                    v = s->v_scount[i];
1382
                    x = 0;
1383
                    y = 0;
1384
                    linesize= s->linesize[c];
1385

    
1386
                    for(j=0; j<n; j++) {
1387
                        int pred;
1388

    
1389
                        ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1390
                        if(y==0 && mb_y==0){
1391
                            if(x==0 && mb_x==0){
1392
                                pred= 128 << point_transform;
1393
                            }else{
1394
                                pred= ptr[-1];
1395
                            }
1396
                        }else{
1397
                            if(x==0 && mb_x==0){
1398
                                pred= ptr[-linesize];
1399
                            }else{
1400
                                PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1401
                            }
1402
                        }
1403

    
1404
                        if (s->interlaced && s->bottom_field)
1405
                            ptr += linesize >> 1;
1406
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1407

    
1408
                        if (++x == h) {
1409
                            x = 0;
1410
                            y++;
1411
                        }
1412
                    }
1413
                }
1414
            }else{
1415
                for(i=0;i<nb_components;i++) {
1416
                    uint8_t *ptr;
1417
                    int n, h, v, x, y, c, j, linesize;
1418
                    n = s->nb_blocks[i];
1419
                    c = s->comp_index[i];
1420
                    h = s->h_scount[i];
1421
                    v = s->v_scount[i];
1422
                    x = 0;
1423
                    y = 0;
1424
                    linesize= s->linesize[c];
1425

    
1426
                    for(j=0; j<n; j++) {
1427
                        int pred;
1428

    
1429
                        ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1430
                        PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1431
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1432
                        if (++x == h) {
1433
                            x = 0;
1434
                            y++;
1435
                        }
1436
                    }
1437
                }
1438
            }
1439
            if (s->restart_interval && !--s->restart_count) {
1440
                align_get_bits(&s->gb);
1441
                skip_bits(&s->gb, 16); /* skip RSTn */
1442
            }
1443
        }
1444
    }
1445
    return 0;
1446
}
1447

    
1448
static int mjpeg_decode_scan(MJpegDecodeContext *s){
1449
    int i, mb_x, mb_y;
1450
    const int nb_components=3;
1451

    
1452
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1453
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1454
            if (s->restart_interval && !s->restart_count)
1455
                s->restart_count = s->restart_interval;
1456

    
1457
            for(i=0;i<nb_components;i++) {
1458
                uint8_t *ptr;
1459
                int n, h, v, x, y, c, j;
1460
                n = s->nb_blocks[i];
1461
                c = s->comp_index[i];
1462
                h = s->h_scount[i];
1463
                v = s->v_scount[i];
1464
                x = 0;
1465
                y = 0;
1466
                for(j=0;j<n;j++) {
1467
                    memset(s->block, 0, sizeof(s->block));
1468
                    if (decode_block(s, s->block, i,
1469
                                     s->dc_index[i], s->ac_index[i],
1470
                                     s->quant_index[c]) < 0) {
1471
                        dprintf("error y=%d x=%d\n", mb_y, mb_x);
1472
                        return -1;
1473
                    }
1474
//                    dprintf("mb: %d %d processed\n", mb_y, mb_x);
1475
                    ptr = s->picture.data[c] +
1476
                        (((s->linesize[c] * (v * mb_y + y) * 8) +
1477
                        (h * mb_x + x) * 8) >> s->avctx->lowres);
1478
                    if (s->interlaced && s->bottom_field)
1479
                        ptr += s->linesize[c] >> 1;
1480
//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);
1481
                    s->idct_put(ptr, s->linesize[c], s->block);
1482
                    if (++x == h) {
1483
                        x = 0;
1484
                        y++;
1485
                    }
1486
                }
1487
            }
1488
            /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1489
            if (s->restart_interval && (s->restart_interval < 1350) &&
1490
                !--s->restart_count) {
1491
                align_get_bits(&s->gb);
1492
                skip_bits(&s->gb, 16); /* skip RSTn */
1493
                for (i=0; i<nb_components; i++) /* reset dc */
1494
                    s->last_dc[i] = 1024;
1495
            }
1496
        }
1497
    }
1498
    return 0;
1499
}
1500

    
1501
static int mjpeg_decode_sos(MJpegDecodeContext *s)
1502
{
1503
    int len, nb_components, i, h, v, predictor, point_transform;
1504
    int vmax, hmax, index, id;
1505
    const int block_size= s->lossless ? 1 : 8;
1506
    int ilv;
1507

    
1508
    /* XXX: verify len field validity */
1509
    len = get_bits(&s->gb, 16);
1510
    nb_components = get_bits(&s->gb, 8);
1511
    if (len != 6+2*nb_components)
1512
    {
1513
        dprintf("decode_sos: invalid len (%d)\n", len);
1514
        return -1;
1515
    }
1516
    /* XXX: only interleaved scan accepted */
1517
    if ((nb_components != s->nb_components) && !s->ls)
1518
    {
1519
        dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1520
        return -1;
1521
    }
1522
    vmax = 0;
1523
    hmax = 0;
1524
    for(i=0;i<nb_components;i++) {
1525
        id = get_bits(&s->gb, 8) - 1;
1526
        dprintf("component: %d\n", id);
1527
        /* find component index */
1528
        for(index=0;index<s->nb_components;index++)
1529
            if (id == s->component_id[index])
1530
                break;
1531
        if (index == s->nb_components)
1532
        {
1533
            dprintf("decode_sos: index(%d) out of components\n", index);
1534
            return -1;
1535
        }
1536

    
1537
        s->comp_index[i] = index;
1538

    
1539
        s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1540
        s->h_scount[i] = s->h_count[index];
1541
        s->v_scount[i] = s->v_count[index];
1542

    
1543
        s->dc_index[i] = get_bits(&s->gb, 4);
1544
        s->ac_index[i] = get_bits(&s->gb, 4);
1545

    
1546
        if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1547
            s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1548
            goto out_of_range;
1549
#if 0 //buggy
1550
        switch(s->start_code)
1551
        {
1552
            case SOF0:
1553
                if (dc_index[i] > 1 || ac_index[i] > 1)
1554
                    goto out_of_range;
1555
                break;
1556
            case SOF1:
1557
            case SOF2:
1558
                if (dc_index[i] > 3 || ac_index[i] > 3)
1559
                    goto out_of_range;
1560
                break;
1561
            case SOF3:
1562
                if (dc_index[i] > 3 || ac_index[i] != 0)
1563
                    goto out_of_range;
1564
                break;
1565
        }
1566
#endif
1567
    }
1568

    
1569
    predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1570
    ilv= get_bits(&s->gb, 8);    /* JPEG Se / JPEG-LS ILV */
1571
    skip_bits(&s->gb, 4); /* Ah */
1572
    point_transform= get_bits(&s->gb, 4); /* Al */
1573

    
1574
    for(i=0;i<nb_components;i++)
1575
        s->last_dc[i] = 1024;
1576

    
1577
    if (nb_components > 1) {
1578
        /* interleaved stream */
1579
        s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1580
        s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1581
    } else if(!s->ls) { /* skip this for JPEG-LS */
1582
        h = s->h_max / s->h_scount[s->comp_index[0]];
1583
        v = s->v_max / s->v_scount[s->comp_index[0]];
1584
        s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1585
        s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1586
        s->nb_blocks[0] = 1;
1587
        s->h_scount[0] = 1;
1588
        s->v_scount[0] = 1;
1589
    }
1590

    
1591
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1592
        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" : "",
1593
               predictor, point_transform, ilv, s->bits,
1594
               s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));
1595

    
1596

    
1597
    /* mjpeg-b can have padding bytes between sos and image data, skip them */
1598
    for (i = s->mjpb_skiptosod; i > 0; i--)
1599
        skip_bits(&s->gb, 8);
1600

    
1601
    if(s->lossless){
1602
        if(s->ls){
1603
//            for(){
1604
//            reset_ls_coding_parameters(s, 0);
1605

    
1606
            ls_decode_picture(s, predictor, point_transform, ilv);
1607
        }else{
1608
            if(s->rgb){
1609
                if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1610
                    return -1;
1611
            }else{
1612
                if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1613
                    return -1;
1614
            }
1615
        }
1616
    }else{
1617
        if(mjpeg_decode_scan(s) < 0)
1618
            return -1;
1619
    }
1620
    emms_c();
1621
    return 0;
1622
 out_of_range:
1623
    dprintf("decode_sos: ac/dc index out of range\n");
1624
    return -1;
1625
}
1626

    
1627
static int mjpeg_decode_dri(MJpegDecodeContext *s)
1628
{
1629
    if (get_bits(&s->gb, 16) != 4)
1630
        return -1;
1631
    s->restart_interval = get_bits(&s->gb, 16);
1632
    s->restart_count = 0;
1633
    dprintf("restart interval: %d\n", s->restart_interval);
1634

    
1635
    return 0;
1636
}
1637

    
1638
static int mjpeg_decode_app(MJpegDecodeContext *s)
1639
{
1640
    int len, id;
1641

    
1642
    len = get_bits(&s->gb, 16);
1643
    if (len < 5)
1644
        return -1;
1645
    if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits)
1646
        return -1;
1647

    
1648
    id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1649
    id = be2me_32(id);
1650
    len -= 6;
1651

    
1652
    if(s->avctx->debug & FF_DEBUG_STARTCODE){
1653
        av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
1654
    }
1655

    
1656
    /* buggy AVID, it puts EOI only at every 10th frame */
1657
    /* also this fourcc is used by non-avid files too, it holds some
1658
       informations, but it's always present in AVID creates files */
1659
    if (id == ff_get_fourcc("AVI1"))
1660
    {
1661
        /* structure:
1662
            4bytes      AVI1
1663
            1bytes      polarity
1664
            1bytes      always zero
1665
            4bytes      field_size
1666
            4bytes      field_size_less_padding
1667
        */
1668
            s->buggy_avid = 1;
1669
//        if (s->first_picture)
1670
//            printf("mjpeg: workarounding buggy AVID\n");
1671
        s->interlace_polarity = get_bits(&s->gb, 8);
1672
#if 0
1673
        skip_bits(&s->gb, 8);
1674
        skip_bits(&s->gb, 32);
1675
        skip_bits(&s->gb, 32);
1676
        len -= 10;
1677
#endif
1678
//        if (s->interlace_polarity)
1679
//            printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1680
        goto out;
1681
    }
1682

    
1683
//    len -= 2;
1684

    
1685
    if (id == ff_get_fourcc("JFIF"))
1686
    {
1687
        int t_w, t_h, v1, v2;
1688
        skip_bits(&s->gb, 8); /* the trailing zero-byte */
1689
        v1= get_bits(&s->gb, 8);
1690
        v2= get_bits(&s->gb, 8);
1691
        skip_bits(&s->gb, 8);
1692

    
1693
        s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1694
        s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1695

    
1696
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1697
            av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1698
                v1, v2,
1699
                s->avctx->sample_aspect_ratio.num,
1700
                s->avctx->sample_aspect_ratio.den
1701
            );
1702

    
1703
        t_w = get_bits(&s->gb, 8);
1704
        t_h = get_bits(&s->gb, 8);
1705
        if (t_w && t_h)
1706
        {
1707
            /* skip thumbnail */
1708
            if (len-10-(t_w*t_h*3) > 0)
1709
                len -= t_w*t_h*3;
1710
        }
1711
        len -= 10;
1712
        goto out;
1713
    }
1714

    
1715
    if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1716
    {
1717
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1718
            av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1719
        skip_bits(&s->gb, 16); /* version */
1720
        skip_bits(&s->gb, 16); /* flags0 */
1721
        skip_bits(&s->gb, 16); /* flags1 */
1722
        skip_bits(&s->gb, 8);  /* transform */
1723
        len -= 7;
1724
        goto out;
1725
    }
1726

    
1727
    if (id == ff_get_fourcc("LJIF")){
1728
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1729
            av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1730
        skip_bits(&s->gb, 16); /* version ? */
1731
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1732
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1733
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1734
        switch( get_bits(&s->gb, 8)){
1735
        case 1:
1736
            s->rgb= 1;
1737
            s->pegasus_rct=0;
1738
            break;
1739
        case 2:
1740
            s->rgb= 1;
1741
            s->pegasus_rct=1;
1742
            break;
1743
        default:
1744
            av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1745
        }
1746
        len -= 9;
1747
        goto out;
1748
    }
1749

    
1750
    /* Apple MJPEG-A */
1751
    if ((s->start_code == APP1) && (len > (0x28 - 8)))
1752
    {
1753
        id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1754
        id = be2me_32(id);
1755
        len -= 4;
1756
        if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1757
        {
1758
#if 0
1759
            skip_bits(&s->gb, 32); /* field size */
1760
            skip_bits(&s->gb, 32); /* pad field size */
1761
            skip_bits(&s->gb, 32); /* next off */
1762
            skip_bits(&s->gb, 32); /* quant off */
1763
            skip_bits(&s->gb, 32); /* huff off */
1764
            skip_bits(&s->gb, 32); /* image off */
1765
            skip_bits(&s->gb, 32); /* scan off */
1766
            skip_bits(&s->gb, 32); /* data off */
1767
#endif
1768
            if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1769
                av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1770
        }
1771
    }
1772

    
1773
out:
1774
    /* slow but needed for extreme adobe jpegs */
1775
    if (len < 0)
1776
        av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1777
    while(--len > 0)
1778
        skip_bits(&s->gb, 8);
1779

    
1780
    return 0;
1781
}
1782

    
1783
static int mjpeg_decode_com(MJpegDecodeContext *s)
1784
{
1785
    int len = get_bits(&s->gb, 16);
1786
    if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) {
1787
        uint8_t *cbuf = av_malloc(len - 1);
1788
        if (cbuf) {
1789
            int i;
1790
            for (i = 0; i < len - 2; i++)
1791
                cbuf[i] = get_bits(&s->gb, 8);
1792
            if (i > 0 && cbuf[i-1] == '\n')
1793
                cbuf[i-1] = 0;
1794
            else
1795
                cbuf[i] = 0;
1796

    
1797
            if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1798
                av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1799

    
1800
            /* buggy avid, it puts EOI only at every 10th frame */
1801
            if (!strcmp(cbuf, "AVID"))
1802
            {
1803
                s->buggy_avid = 1;
1804
                //        if (s->first_picture)
1805
                //            printf("mjpeg: workarounding buggy AVID\n");
1806
            }
1807
            else if(!strcmp(cbuf, "CS=ITU601")){
1808
                s->cs_itu601= 1;
1809
            }
1810

    
1811
            av_free(cbuf);
1812
        }
1813
    }
1814

    
1815
    return 0;
1816
}
1817

    
1818
#if 0
1819
static int valid_marker_list[] =
1820
{
1821
        /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1822
/* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1823
/* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1824
/* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1825
/* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1826
/* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1827
/* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1828
/* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1829
/* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1830
/* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1831
/* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1832
/* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1833
/* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1834
/* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1835
/* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1836
/* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1837
/* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1838
}
1839
#endif
1840

    
1841
/* return the 8 bit start code value and update the search
1842
   state. Return -1 if no start code found */
1843
static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1844
{
1845
    uint8_t *buf_ptr;
1846
    unsigned int v, v2;
1847
    int val;
1848
#ifdef DEBUG
1849
    int skipped=0;
1850
#endif
1851

    
1852
    buf_ptr = *pbuf_ptr;
1853
    while (buf_ptr < buf_end) {
1854
        v = *buf_ptr++;
1855
        v2 = *buf_ptr;
1856
        if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1857
            val = *buf_ptr++;
1858
            goto found;
1859
        }
1860
#ifdef DEBUG
1861
        skipped++;
1862
#endif
1863
    }
1864
    val = -1;
1865
found:
1866
#ifdef DEBUG
1867
    dprintf("find_marker skipped %d bytes\n", skipped);
1868
#endif
1869
    *pbuf_ptr = buf_ptr;
1870
    return val;
1871
}
1872

    
1873
static int mjpeg_decode_frame(AVCodecContext *avctx,
1874
                              void *data, int *data_size,
1875
                              uint8_t *buf, int buf_size)
1876
{
1877
    MJpegDecodeContext *s = avctx->priv_data;
1878
    uint8_t *buf_end, *buf_ptr;
1879
    int start_code;
1880
    AVFrame *picture = data;
1881

    
1882
    buf_ptr = buf;
1883
    buf_end = buf + buf_size;
1884
    while (buf_ptr < buf_end) {
1885
        /* find start next marker */
1886
        start_code = find_marker(&buf_ptr, buf_end);
1887
        {
1888
            /* EOF */
1889
            if (start_code < 0) {
1890
                goto the_end;
1891
            } else {
1892
                dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1893

    
1894
                if ((buf_end - buf_ptr) > s->buffer_size)
1895
                {
1896
                    av_free(s->buffer);
1897
                    s->buffer_size = buf_end-buf_ptr;
1898
                    s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
1899
                    dprintf("buffer too small, expanding to %d bytes\n",
1900
                        s->buffer_size);
1901
                }
1902

    
1903
                /* unescape buffer of SOS, use special treatment for JPEG-LS */
1904
                if (start_code == SOS && !s->ls)
1905
                {
1906
                    uint8_t *src = buf_ptr;
1907
                    uint8_t *dst = s->buffer;
1908

    
1909
                    while (src<buf_end)
1910
                    {
1911
                        uint8_t x = *(src++);
1912

    
1913
                        *(dst++) = x;
1914
                        if (x == 0xff)
1915
                        {
1916
                            while(src<buf_end && x == 0xff)
1917
                                x = *(src++);
1918

    
1919
                            if (x >= 0xd0 && x <= 0xd7)
1920
                                *(dst++) = x;
1921
                            else if (x)
1922
                                break;
1923
                        }
1924
                    }
1925
                    init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1926

    
1927
                    dprintf("escaping removed %d bytes\n",
1928
                        (buf_end - buf_ptr) - (dst - s->buffer));
1929
                }
1930
                else if(start_code == SOS && s->ls){
1931
                    uint8_t *src = buf_ptr;
1932
                    uint8_t *dst = s->buffer;
1933
                    int bit_count = 0;
1934
                    int t = 0, b = 0;
1935
                    PutBitContext pb;
1936

    
1937
                    s->cur_scan++;
1938

    
1939
                    /* find marker */
1940
                    while (src + t < buf_end){
1941
                        uint8_t x = src[t++];
1942
                        if (x == 0xff){
1943
                            while((src + t < buf_end) && x == 0xff)
1944
                                x = src[t++];
1945
                            if (x & 0x80) {
1946
                                t -= 2;
1947
                                break;
1948
                            }
1949
                        }
1950
                    }
1951
                    bit_count = t * 8;
1952

    
1953
                    init_put_bits(&pb, dst, t);
1954

    
1955
                    /* unescape bitstream */
1956
                    while(b < t){
1957
                        uint8_t x = src[b++];
1958
                        put_bits(&pb, 8, x);
1959
                        if(x == 0xFF){
1960
                            x = src[b++];
1961
                            put_bits(&pb, 7, x);
1962
                            bit_count--;
1963
                        }
1964
                    }
1965
                    flush_put_bits(&pb);
1966

    
1967
                    init_get_bits(&s->gb, dst, bit_count);
1968
                }
1969
                else
1970
                    init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1971

    
1972
                s->start_code = start_code;
1973
                if(s->avctx->debug & FF_DEBUG_STARTCODE){
1974
                    av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
1975
                }
1976

    
1977
                /* process markers */
1978
                if (start_code >= 0xd0 && start_code <= 0xd7) {
1979
                    dprintf("restart marker: %d\n", start_code&0x0f);
1980
                    /* APP fields */
1981
                } else if (start_code >= APP0 && start_code <= APP15) {
1982
                    mjpeg_decode_app(s);
1983
                    /* Comment */
1984
                } else if (start_code == COM){
1985
                    mjpeg_decode_com(s);
1986
                }
1987

    
1988
                switch(start_code) {
1989
                case SOI:
1990
                    s->restart_interval = 0;
1991

    
1992
                    s->restart_count = 0;
1993
                    /* nothing to do on SOI */
1994
                    break;
1995
                case DQT:
1996
                    mjpeg_decode_dqt(s);
1997
                    break;
1998
                case DHT:
1999
                    if(mjpeg_decode_dht(s) < 0){
2000
                        av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n");
2001
                        return -1;
2002
                    }
2003
                    break;
2004
                case SOF0:
2005
                    s->lossless=0;
2006
                    if (mjpeg_decode_sof(s) < 0)
2007
                        return -1;
2008
                    break;
2009
                case SOF3:
2010
                    s->lossless=1;
2011
                    if (mjpeg_decode_sof(s) < 0)
2012
                        return -1;
2013
                    break;
2014
                case SOF48:
2015
                    s->lossless=1;
2016
                    s->ls=1;
2017
                    if (mjpeg_decode_sof(s) < 0)
2018
                        return -1;
2019
                    break;
2020
                case LSE:
2021
                    if (decode_lse(s) < 0)
2022
                        return -1;
2023
                    break;
2024
                case EOI:
2025
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2026
                        break;
2027
eoi_parser:
2028
                    {
2029
                        if (s->interlaced) {
2030
                            s->bottom_field ^= 1;
2031
                            /* if not bottom field, do not output image yet */
2032
                            if (s->bottom_field)
2033
                                goto not_the_end;
2034
                        }
2035
                        *picture = s->picture;
2036
                        *data_size = sizeof(AVFrame);
2037

    
2038
                        if(!s->lossless){
2039
                            picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2040
                            picture->qstride= 0;
2041
                            picture->qscale_table= s->qscale_table;
2042
                            memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2043
                            if(avctx->debug & FF_DEBUG_QP)
2044
                                av_log(s->avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2045
                            picture->quality*= FF_QP2LAMBDA;
2046
                        }
2047

    
2048
                        goto the_end;
2049
                    }
2050
                    break;
2051
                case SOS:
2052
                    mjpeg_decode_sos(s);
2053
                    /* buggy avid puts EOI every 10-20th frame */
2054
                    /* if restart period is over process EOI */
2055
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2056
                        goto eoi_parser;
2057
                    break;
2058
                case DRI:
2059
                    mjpeg_decode_dri(s);
2060
                    break;
2061
                case SOF1:
2062
                case SOF2:
2063
                case SOF5:
2064
                case SOF6:
2065
                case SOF7:
2066
                case SOF9:
2067
                case SOF10:
2068
                case SOF11:
2069
                case SOF13:
2070
                case SOF14:
2071
                case SOF15:
2072
                case JPG:
2073
                    av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
2074
                    break;
2075
//                default:
2076
//                    printf("mjpeg: unsupported marker (%x)\n", start_code);
2077
//                    break;
2078
                }
2079

    
2080
not_the_end:
2081
                /* eof process start code */
2082
                buf_ptr += (get_bits_count(&s->gb)+7)/8;
2083
                dprintf("marker parser used %d bytes (%d bits)\n",
2084
                    (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
2085
            }
2086
        }
2087
    }
2088
the_end:
2089
    dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
2090
//    return buf_end - buf_ptr;
2091
    return buf_ptr - buf;
2092
}
2093

    
2094
static int mjpegb_decode_frame(AVCodecContext *avctx,
2095
                              void *data, int *data_size,
2096
                              uint8_t *buf, int buf_size)
2097
{
2098
    MJpegDecodeContext *s = avctx->priv_data;
2099
    uint8_t *buf_end, *buf_ptr;
2100
    AVFrame *picture = data;
2101
    GetBitContext hgb; /* for the header */
2102
    uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
2103
    uint32_t field_size, sod_offs;
2104

    
2105
    buf_ptr = buf;
2106
    buf_end = buf + buf_size;
2107

    
2108
read_header:
2109
    /* reset on every SOI */
2110
    s->restart_interval = 0;
2111
    s->restart_count = 0;
2112
    s->mjpb_skiptosod = 0;
2113

    
2114
    init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
2115

    
2116
    skip_bits(&hgb, 32); /* reserved zeros */
2117

    
2118
    if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
2119
    {
2120
        dprintf("not mjpeg-b (bad fourcc)\n");
2121
        return 0;
2122
    }
2123

    
2124
    field_size = get_bits_long(&hgb, 32); /* field size */
2125
    dprintf("field size: 0x%x\n", field_size);
2126
    skip_bits(&hgb, 32); /* padded field size */
2127
    second_field_offs = get_bits_long(&hgb, 32);
2128
    dprintf("second field offs: 0x%x\n", second_field_offs);
2129
    if (second_field_offs)
2130
        s->interlaced = 1;
2131

    
2132
    dqt_offs = get_bits_long(&hgb, 32);
2133
    dprintf("dqt offs: 0x%x\n", dqt_offs);
2134
    if (dqt_offs)
2135
    {
2136
        init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
2137
        s->start_code = DQT;
2138
        mjpeg_decode_dqt(s);
2139
    }
2140

    
2141
    dht_offs = get_bits_long(&hgb, 32);
2142
    dprintf("dht offs: 0x%x\n", dht_offs);
2143
    if (dht_offs)
2144
    {
2145
        init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
2146
        s->start_code = DHT;
2147
        mjpeg_decode_dht(s);
2148
    }
2149

    
2150
    sof_offs = get_bits_long(&hgb, 32);
2151
    dprintf("sof offs: 0x%x\n", sof_offs);
2152
    if (sof_offs)
2153
    {
2154
        init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
2155
        s->start_code = SOF0;
2156
        if (mjpeg_decode_sof(s) < 0)
2157
            return -1;
2158
    }
2159

    
2160
    sos_offs = get_bits_long(&hgb, 32);
2161
    dprintf("sos offs: 0x%x\n", sos_offs);
2162
    sod_offs = get_bits_long(&hgb, 32);
2163
    dprintf("sod offs: 0x%x\n", sod_offs);
2164
    if (sos_offs)
2165
    {
2166
//        init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2167
        init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2168
        s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
2169
        s->start_code = SOS;
2170
        mjpeg_decode_sos(s);
2171
    }
2172

    
2173
    if (s->interlaced) {
2174
        s->bottom_field ^= 1;
2175
        /* if not bottom field, do not output image yet */
2176
        if (s->bottom_field && second_field_offs)
2177
        {
2178
            buf_ptr = buf + second_field_offs;
2179
            second_field_offs = 0;
2180
            goto read_header;
2181
            }
2182
    }
2183

    
2184
    //XXX FIXME factorize, this looks very similar to the EOI code
2185

    
2186
    *picture= s->picture;
2187
    *data_size = sizeof(AVFrame);
2188

    
2189
    if(!s->lossless){
2190
        picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2191
        picture->qstride= 0;
2192
        picture->qscale_table= s->qscale_table;
2193
        memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2194
        if(avctx->debug & FF_DEBUG_QP)
2195
            av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2196
        picture->quality*= FF_QP2LAMBDA;
2197
    }
2198

    
2199
    return buf_ptr - buf;
2200
}
2201

    
2202
#include "sp5x.h"
2203

    
2204
static int sp5x_decode_frame(AVCodecContext *avctx,
2205
                              void *data, int *data_size,
2206
                              uint8_t *buf, int buf_size)
2207
{
2208
#if 0
2209
    MJpegDecodeContext *s = avctx->priv_data;
2210
#endif
2211
    const int qscale = 5;
2212
    uint8_t *buf_ptr, *buf_end, *recoded;
2213
    int i = 0, j = 0;
2214

    
2215
    if (!avctx->width || !avctx->height)
2216
        return -1;
2217

    
2218
    buf_ptr = buf;
2219
    buf_end = buf + buf_size;
2220

    
2221
#if 1
2222
    recoded = av_mallocz(buf_size + 1024);
2223
    if (!recoded)
2224
        return -1;
2225

    
2226
    /* SOI */
2227
    recoded[j++] = 0xFF;
2228
    recoded[j++] = 0xD8;
2229

    
2230
    memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2231
    memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2232
    memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2233
    j += sizeof(sp5x_data_dqt);
2234

    
2235
    memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2236
    j += sizeof(sp5x_data_dht);
2237

    
2238
    memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2239
    recoded[j+5] = (avctx->coded_height >> 8) & 0xFF;
2240
    recoded[j+6] = avctx->coded_height & 0xFF;
2241
    recoded[j+7] = (avctx->coded_width >> 8) & 0xFF;
2242
    recoded[j+8] = avctx->coded_width & 0xFF;
2243
    j += sizeof(sp5x_data_sof);
2244

    
2245
    memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2246
    j += sizeof(sp5x_data_sos);
2247

    
2248
    for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2249
    {
2250
        recoded[j++] = buf[i];
2251
        if (buf[i] == 0xff)
2252
            recoded[j++] = 0;
2253
    }
2254

    
2255
    /* EOI */
2256
    recoded[j++] = 0xFF;
2257
    recoded[j++] = 0xD9;
2258

    
2259
    i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2260

    
2261
    av_free(recoded);
2262

    
2263
#else
2264
    /* SOF */
2265
    s->bits = 8;
2266
    s->width  = avctx->coded_width;
2267
    s->height = avctx->coded_height;
2268
    s->nb_components = 3;
2269
    s->component_id[0] = 0;
2270
    s->h_count[0] = 2;
2271
    s->v_count[0] = 2;
2272
    s->quant_index[0] = 0;
2273
    s->component_id[1] = 1;
2274
    s->h_count[1] = 1;
2275
    s->v_count[1] = 1;
2276
    s->quant_index[1] = 1;
2277
    s->component_id[2] = 2;
2278
    s->h_count[2] = 1;
2279
    s->v_count[2] = 1;
2280
    s->quant_index[2] = 1;
2281
    s->h_max = 2;
2282
    s->v_max = 2;
2283

    
2284
    s->qscale_table = av_mallocz((s->width+15)/16);
2285
    avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420;
2286
    s->interlaced = 0;
2287

    
2288
    s->picture.reference = 0;
2289
    if (avctx->get_buffer(avctx, &s->picture) < 0)
2290
    {
2291
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2292
        return -1;
2293
    }
2294

    
2295
    s->picture.pict_type = I_TYPE;
2296
    s->picture.key_frame = 1;
2297

    
2298
    for (i = 0; i < 3; i++)
2299
        s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2300

    
2301
    /* DQT */
2302
    for (i = 0; i < 64; i++)
2303
    {
2304
        j = s->scantable.permutated[i];
2305
        s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2306
    }
2307
    s->qscale[0] = FFMAX(
2308
        s->quant_matrixes[0][s->scantable.permutated[1]],
2309
        s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2310

    
2311
    for (i = 0; i < 64; i++)
2312
    {
2313
        j = s->scantable.permutated[i];
2314
        s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2315
    }
2316
    s->qscale[1] = FFMAX(
2317
        s->quant_matrixes[1][s->scantable.permutated[1]],
2318
        s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2319

    
2320
    /* DHT */
2321

    
2322
    /* SOS */
2323
    s->comp_index[0] = 0;
2324
    s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2325
    s->h_scount[0] = s->h_count[0];
2326
    s->v_scount[0] = s->v_count[0];
2327
    s->dc_index[0] = 0;
2328
    s->ac_index[0] = 0;
2329

    
2330
    s->comp_index[1] = 1;
2331
    s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2332
    s->h_scount[1] = s->h_count[1];
2333
    s->v_scount[1] = s->v_count[1];
2334
    s->dc_index[1] = 1;
2335
    s->ac_index[1] = 1;
2336

    
2337
    s->comp_index[2] = 2;
2338
    s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2339
    s->h_scount[2] = s->h_count[2];
2340
    s->v_scount[2] = s->v_count[2];
2341
    s->dc_index[2] = 1;
2342
    s->ac_index[2] = 1;
2343

    
2344
    for (i = 0; i < 3; i++)
2345
        s->last_dc[i] = 1024;
2346

    
2347
    s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2348
    s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2349

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

    
2352
    return mjpeg_decode_scan(s);
2353
#endif
2354

    
2355
    return i;
2356
}
2357

    
2358
static int mjpeg_decode_end(AVCodecContext *avctx)
2359
{
2360
    MJpegDecodeContext *s = avctx->priv_data;
2361
    int i, j;
2362

    
2363
    av_free(s->buffer);
2364
    av_free(s->qscale_table);
2365

    
2366
    for(i=0;i<2;i++) {
2367
        for(j=0;j<4;j++)
2368
            free_vlc(&s->vlcs[i][j]);
2369
    }
2370
    return 0;
2371
}
2372

    
2373
AVCodec mjpeg_decoder = {
2374
    "mjpeg",
2375
    CODEC_TYPE_VIDEO,
2376
    CODEC_ID_MJPEG,
2377
    sizeof(MJpegDecodeContext),
2378
    mjpeg_decode_init,
2379
    NULL,
2380
    mjpeg_decode_end,
2381
    mjpeg_decode_frame,
2382
    CODEC_CAP_DR1,
2383
    NULL
2384
};
2385

    
2386
AVCodec mjpegb_decoder = {
2387
    "mjpegb",
2388
    CODEC_TYPE_VIDEO,
2389
    CODEC_ID_MJPEGB,
2390
    sizeof(MJpegDecodeContext),
2391
    mjpeg_decode_init,
2392
    NULL,
2393
    mjpeg_decode_end,
2394
    mjpegb_decode_frame,
2395
    CODEC_CAP_DR1,
2396
    NULL
2397
};
2398

    
2399
AVCodec sp5x_decoder = {
2400
    "sp5x",
2401
    CODEC_TYPE_VIDEO,
2402
    CODEC_ID_SP5X,
2403
    sizeof(MJpegDecodeContext),
2404
    mjpeg_decode_init,
2405
    NULL,
2406
    mjpeg_decode_end,
2407
    sp5x_decode_frame,
2408
    CODEC_CAP_DR1,
2409
    NULL
2410
};
2411

    
2412
#ifdef CONFIG_ENCODERS
2413
AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2414
    "ljpeg",
2415
    CODEC_TYPE_VIDEO,
2416
    CODEC_ID_LJPEG,
2417
    sizeof(MpegEncContext),
2418
    MPV_encode_init,
2419
    encode_picture_lossless,
2420
    MPV_encode_end,
2421
};
2422
#endif
2423

    
2424
AVCodecParser mjpeg_parser = {
2425
    { CODEC_ID_MJPEG },
2426
    sizeof(ParseContext),
2427
    NULL,
2428
    jpeg_parse,
2429
    ff_parse_close,
2430
};
2431