Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mjpeg.c @ ad8812be

History | View | Annotate | Download (75.6 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, int is_ac)
898
{
899
    uint8_t huff_size[256+16];
900
    uint16_t huff_code[256+16];
901

    
902
    assert(nb_codes <= 256);
903

    
904
    memset(huff_size, 0, sizeof(huff_size));
905
    build_huffman_codes(huff_size, huff_code, bits_table, val_table);
906

    
907
    if(is_ac){
908
        memmove(huff_size+16, huff_size, sizeof(uint8_t)*nb_codes);
909
        memmove(huff_code+16, huff_code, sizeof(uint16_t)*nb_codes);
910
        memset(huff_size, 0, sizeof(uint8_t)*16);
911
        memset(huff_code, 0, sizeof(uint16_t)*16);
912
        nb_codes += 16;
913
    }
914

    
915
    return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2, use_static);
916
}
917

    
918
static int mjpeg_decode_init(AVCodecContext *avctx)
919
{
920
    MJpegDecodeContext *s = avctx->priv_data;
921
    MpegEncContext s2;
922
    memset(s, 0, sizeof(MJpegDecodeContext));
923

    
924
    s->avctx = avctx;
925

    
926
    /* ugly way to get the idct & scantable FIXME */
927
    memset(&s2, 0, sizeof(MpegEncContext));
928
    s2.avctx= avctx;
929
//    s2->out_format = FMT_MJPEG;
930
    dsputil_init(&s2.dsp, avctx);
931
    DCT_common_init(&s2);
932

    
933
    s->scantable= s2.intra_scantable;
934
    s->idct_put= s2.dsp.idct_put;
935

    
936
    s->mpeg_enc_ctx_allocated = 0;
937
    s->buffer_size = 0;
938
    s->buffer = NULL;
939
    s->start_code = -1;
940
    s->first_picture = 1;
941
    s->org_height = avctx->coded_height;
942

    
943
    build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12, 0, 0);
944
    build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12, 0, 0);
945
    build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251, 0, 1);
946
    build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251, 0, 1);
947

    
948
    if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
949
    {
950
        av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
951
        init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
952
        mjpeg_decode_dht(s);
953
        /* should check for error - but dunno */
954
    }
955

    
956
    return 0;
957
}
958

    
959

    
960
/**
961
 * finds the end of the current frame in the bitstream.
962
 * @return the position of the first byte of the next frame, or -1
963
 */
964
static int find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size){
965
    int vop_found, i;
966
    uint16_t state;
967

    
968
    vop_found= pc->frame_start_found;
969
    state= pc->state;
970

    
971
    i=0;
972
    if(!vop_found){
973
        for(i=0; i<buf_size; i++){
974
            state= (state<<8) | buf[i];
975
            if(state == 0xFFD8){
976
                i++;
977
                vop_found=1;
978
                break;
979
            }
980
        }
981
    }
982

    
983
    if(vop_found){
984
        /* EOF considered as end of frame */
985
        if (buf_size == 0)
986
            return 0;
987
        for(; i<buf_size; i++){
988
            state= (state<<8) | buf[i];
989
            if(state == 0xFFD8){
990
                pc->frame_start_found=0;
991
                pc->state=0;
992
                return i-1;
993
            }
994
        }
995
    }
996
    pc->frame_start_found= vop_found;
997
    pc->state= state;
998
    return END_NOT_FOUND;
999
}
1000

    
1001
static int jpeg_parse(AVCodecParserContext *s,
1002
                           AVCodecContext *avctx,
1003
                           uint8_t **poutbuf, int *poutbuf_size,
1004
                           const uint8_t *buf, int buf_size)
1005
{
1006
    ParseContext *pc = s->priv_data;
1007
    int next;
1008

    
1009
    next= find_frame_end(pc, buf, buf_size);
1010

    
1011
    if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
1012
        *poutbuf = NULL;
1013
        *poutbuf_size = 0;
1014
        return buf_size;
1015
    }
1016

    
1017
    *poutbuf = (uint8_t *)buf;
1018
    *poutbuf_size = buf_size;
1019
    return next;
1020
}
1021

    
1022
/* quantize tables */
1023
static int mjpeg_decode_dqt(MJpegDecodeContext *s)
1024
{
1025
    int len, index, i, j;
1026

    
1027
    len = get_bits(&s->gb, 16) - 2;
1028

    
1029
    while (len >= 65) {
1030
        /* only 8 bit precision handled */
1031
        if (get_bits(&s->gb, 4) != 0)
1032
        {
1033
            dprintf("dqt: 16bit precision\n");
1034
            return -1;
1035
        }
1036
        index = get_bits(&s->gb, 4);
1037
        if (index >= 4)
1038
            return -1;
1039
        dprintf("index=%d\n", index);
1040
        /* read quant table */
1041
        for(i=0;i<64;i++) {
1042
            j = s->scantable.permutated[i];
1043
            s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
1044
        }
1045

    
1046
        //XXX FIXME finetune, and perhaps add dc too
1047
        s->qscale[index]= FFMAX(
1048
            s->quant_matrixes[index][s->scantable.permutated[1]],
1049
            s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
1050
        dprintf("qscale[%d]: %d\n", index, s->qscale[index]);
1051
        len -= 65;
1052
    }
1053

    
1054
    return 0;
1055
}
1056

    
1057
/* decode huffman tables and build VLC decoders */
1058
static int mjpeg_decode_dht(MJpegDecodeContext *s)
1059
{
1060
    int len, index, i, class, n, v, code_max;
1061
    uint8_t bits_table[17];
1062
    uint8_t val_table[256];
1063

    
1064
    len = get_bits(&s->gb, 16) - 2;
1065

    
1066
    while (len > 0) {
1067
        if (len < 17)
1068
            return -1;
1069
        class = get_bits(&s->gb, 4);
1070
        if (class >= 2)
1071
            return -1;
1072
        index = get_bits(&s->gb, 4);
1073
        if (index >= 4)
1074
            return -1;
1075
        n = 0;
1076
        for(i=1;i<=16;i++) {
1077
            bits_table[i] = get_bits(&s->gb, 8);
1078
            n += bits_table[i];
1079
        }
1080
        len -= 17;
1081
        if (len < n || n > 256)
1082
            return -1;
1083

    
1084
        code_max = 0;
1085
        for(i=0;i<n;i++) {
1086
            v = get_bits(&s->gb, 8);
1087
            if (v > code_max)
1088
                code_max = v;
1089
            val_table[i] = v;
1090
        }
1091
        len -= n;
1092

    
1093
        /* build VLC and flush previous vlc if present */
1094
        free_vlc(&s->vlcs[class][index]);
1095
        dprintf("class=%d index=%d nb_codes=%d\n",
1096
               class, index, code_max + 1);
1097
        if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0, class > 0) < 0){
1098
            return -1;
1099
        }
1100
    }
1101
    return 0;
1102
}
1103

    
1104
static int mjpeg_decode_sof(MJpegDecodeContext *s)
1105
{
1106
    int len, nb_components, i, width, height;
1107

    
1108
    /* XXX: verify len field validity */
1109
    len = get_bits(&s->gb, 16);
1110
    s->bits= get_bits(&s->gb, 8);
1111

    
1112
    if(s->pegasus_rct) s->bits=9;
1113
    if(s->bits==9 && !s->pegasus_rct) s->rct=1;    //FIXME ugly
1114

    
1115
    if (s->bits != 8 && !s->lossless){
1116
        av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
1117
        return -1;
1118
    }
1119
    if (s->bits > 8 && s->ls){
1120
        av_log(s->avctx, AV_LOG_ERROR, "only <= 8 bits/component accepted for JPEG-LS\n");
1121
        return -1;
1122
    }
1123

    
1124
    height = get_bits(&s->gb, 16);
1125
    width = get_bits(&s->gb, 16);
1126

    
1127
    dprintf("sof0: picture: %dx%d\n", width, height);
1128
    if(avcodec_check_dimensions(s->avctx, width, height))
1129
        return -1;
1130

    
1131
    nb_components = get_bits(&s->gb, 8);
1132
    if (nb_components <= 0 ||
1133
        nb_components > MAX_COMPONENTS)
1134
        return -1;
1135
    s->nb_components = nb_components;
1136
    s->h_max = 1;
1137
    s->v_max = 1;
1138
    for(i=0;i<nb_components;i++) {
1139
        /* component id */
1140
        s->component_id[i] = get_bits(&s->gb, 8) - 1;
1141
        s->h_count[i] = get_bits(&s->gb, 4);
1142
        s->v_count[i] = get_bits(&s->gb, 4);
1143
        /* compute hmax and vmax (only used in interleaved case) */
1144
        if (s->h_count[i] > s->h_max)
1145
            s->h_max = s->h_count[i];
1146
        if (s->v_count[i] > s->v_max)
1147
            s->v_max = s->v_count[i];
1148
        s->quant_index[i] = get_bits(&s->gb, 8);
1149
        if (s->quant_index[i] >= 4)
1150
            return -1;
1151
        dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1152
            s->v_count[i], s->component_id[i], s->quant_index[i]);
1153
    }
1154

    
1155
    if(s->ls && (s->h_max > 1 || s->v_max > 1)) {
1156
        av_log(s->avctx, AV_LOG_ERROR, "Subsampling in JPEG-LS is not supported.\n");
1157
        return -1;
1158
    }
1159

    
1160
    if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1161

    
1162
    /* if different size, realloc/alloc picture */
1163
    /* XXX: also check h_count and v_count */
1164
    if (width != s->width || height != s->height) {
1165
        av_freep(&s->qscale_table);
1166

    
1167
        s->width = width;
1168
        s->height = height;
1169

    
1170
        /* test interlaced mode */
1171
        if (s->first_picture &&
1172
            s->org_height != 0 &&
1173
            s->height < ((s->org_height * 3) / 4)) {
1174
            s->interlaced = 1;
1175
//            s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1176
            s->bottom_field = 0;
1177
            height *= 2;
1178
        }
1179

    
1180
        avcodec_set_dimensions(s->avctx, width, height);
1181

    
1182
        s->qscale_table= av_mallocz((s->width+15)/16);
1183

    
1184
        s->first_picture = 0;
1185
    }
1186

    
1187
    if(s->interlaced && s->bottom_field)
1188
        return 0;
1189

    
1190
    /* XXX: not complete test ! */
1191
    switch((s->h_count[0] << 4) | s->v_count[0]) {
1192
    case 0x11:
1193
        if(s->rgb){
1194
            s->avctx->pix_fmt = PIX_FMT_RGBA32;
1195
        }else if(s->nb_components==3)
1196
            s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;
1197
        else
1198
            s->avctx->pix_fmt = PIX_FMT_GRAY8;
1199
        break;
1200
    case 0x21:
1201
        s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P;
1202
        break;
1203
    default:
1204
    case 0x22:
1205
        s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P;
1206
        break;
1207
    }
1208
    if(s->ls){
1209
        if(s->nb_components > 1)
1210
            s->avctx->pix_fmt = PIX_FMT_RGB24;
1211
        else
1212
            s->avctx->pix_fmt = PIX_FMT_GRAY8;
1213
    }
1214

    
1215
    if(s->picture.data[0])
1216
        s->avctx->release_buffer(s->avctx, &s->picture);
1217

    
1218
    s->picture.reference= 0;
1219
    if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1220
        av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1221
        return -1;
1222
    }
1223
    s->picture.pict_type= I_TYPE;
1224
    s->picture.key_frame= 1;
1225

    
1226
    for(i=0; i<3; i++){
1227
        s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1228
    }
1229

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

    
1232
    if (len != (8+(3*nb_components)))
1233
    {
1234
        dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1235
    }
1236

    
1237
    return 0;
1238
}
1239

    
1240
static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1241
{
1242
    int code;
1243
    code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1244
    if (code < 0)
1245
    {
1246
        dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1247
                &s->vlcs[0][dc_index]);
1248
        return 0xffff;
1249
    }
1250

    
1251
    if(code)
1252
        return get_xbits(&s->gb, code);
1253
    else
1254
        return 0;
1255
}
1256

    
1257
/* decode block and dequantize */
1258
static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1259
                        int component, int dc_index, int ac_index, int16_t *quant_matrix)
1260
{
1261
    int code, i, j, level, val;
1262

    
1263
    /* DC coef */
1264
    val = mjpeg_decode_dc(s, dc_index);
1265
    if (val == 0xffff) {
1266
        dprintf("error dc\n");
1267
        return -1;
1268
    }
1269
    val = val * quant_matrix[0] + s->last_dc[component];
1270
    s->last_dc[component] = val;
1271
    block[0] = val;
1272
    /* AC coefs */
1273
    i = 0;
1274
    {OPEN_READER(re, &s->gb)
1275
    for(;;) {
1276
        UPDATE_CACHE(re, &s->gb);
1277
        GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)
1278

    
1279
        /* EOB */
1280
        if (code == 0x10)
1281
            break;
1282
        i += ((unsigned)code) >> 4;
1283
        if(code != 0x100){
1284
            code &= 0xf;
1285
            if(code > MIN_CACHE_BITS - 16){
1286
                UPDATE_CACHE(re, &s->gb)
1287
            }
1288
            {
1289
                int cache=GET_CACHE(re,&s->gb);
1290
                int sign=(~cache)>>31;
1291
                level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
1292
            }
1293

    
1294
            LAST_SKIP_BITS(re, &s->gb, code)
1295

    
1296
            if (i >= 63) {
1297
                if(i == 63){
1298
                    j = s->scantable.permutated[63];
1299
                    block[j] = level * quant_matrix[j];
1300
                    break;
1301
                }
1302
                dprintf("error count: %d\n", i);
1303
                return -1;
1304
            }
1305
            j = s->scantable.permutated[i];
1306
            block[j] = level * quant_matrix[j];
1307
        }
1308
    }
1309
    CLOSE_READER(re, &s->gb)}
1310

    
1311
    return 0;
1312
}
1313

    
1314
static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1315
    int i, mb_x, mb_y;
1316
    uint16_t buffer[32768][4];
1317
    int left[3], top[3], topleft[3];
1318
    const int linesize= s->linesize[0];
1319
    const int mask= (1<<s->bits)-1;
1320

    
1321
    if((unsigned)s->mb_width > 32768) //dynamic alloc
1322
        return -1;
1323

    
1324
    for(i=0; i<3; i++){
1325
        buffer[0][i]= 1 << (s->bits + point_transform - 1);
1326
    }
1327
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1328
        const int modified_predictor= mb_y ? predictor : 1;
1329
        uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1330

    
1331
        if (s->interlaced && s->bottom_field)
1332
            ptr += linesize >> 1;
1333

    
1334
        for(i=0; i<3; i++){
1335
            top[i]= left[i]= topleft[i]= buffer[0][i];
1336
        }
1337
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1338
            if (s->restart_interval && !s->restart_count)
1339
                s->restart_count = s->restart_interval;
1340

    
1341
            for(i=0;i<3;i++) {
1342
                int pred;
1343

    
1344
                topleft[i]= top[i];
1345
                top[i]= buffer[mb_x][i];
1346

    
1347
                PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1348

    
1349
                left[i]=
1350
                buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1351
            }
1352

    
1353
            if (s->restart_interval && !--s->restart_count) {
1354
                align_get_bits(&s->gb);
1355
                skip_bits(&s->gb, 16); /* skip RSTn */
1356
            }
1357
        }
1358

    
1359
        if(s->rct){
1360
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1361
                ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1362
                ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1363
                ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1364
            }
1365
        }else if(s->pegasus_rct){
1366
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1367
                ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1368
                ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1369
                ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1370
            }
1371
        }else{
1372
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1373
                ptr[4*mb_x+0] = buffer[mb_x][0];
1374
                ptr[4*mb_x+1] = buffer[mb_x][1];
1375
                ptr[4*mb_x+2] = buffer[mb_x][2];
1376
            }
1377
        }
1378
    }
1379
    return 0;
1380
}
1381

    
1382
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1383
    int i, mb_x, mb_y;
1384
    const int nb_components=3;
1385

    
1386
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1387
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1388
            if (s->restart_interval && !s->restart_count)
1389
                s->restart_count = s->restart_interval;
1390

    
1391
            if(mb_x==0 || mb_y==0 || s->interlaced){
1392
                for(i=0;i<nb_components;i++) {
1393
                    uint8_t *ptr;
1394
                    int n, h, v, x, y, c, j, linesize;
1395
                    n = s->nb_blocks[i];
1396
                    c = s->comp_index[i];
1397
                    h = s->h_scount[i];
1398
                    v = s->v_scount[i];
1399
                    x = 0;
1400
                    y = 0;
1401
                    linesize= s->linesize[c];
1402

    
1403
                    for(j=0; j<n; j++) {
1404
                        int pred;
1405

    
1406
                        ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1407
                        if(y==0 && mb_y==0){
1408
                            if(x==0 && mb_x==0){
1409
                                pred= 128 << point_transform;
1410
                            }else{
1411
                                pred= ptr[-1];
1412
                            }
1413
                        }else{
1414
                            if(x==0 && mb_x==0){
1415
                                pred= ptr[-linesize];
1416
                            }else{
1417
                                PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1418
                            }
1419
                        }
1420

    
1421
                        if (s->interlaced && s->bottom_field)
1422
                            ptr += linesize >> 1;
1423
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1424

    
1425
                        if (++x == h) {
1426
                            x = 0;
1427
                            y++;
1428
                        }
1429
                    }
1430
                }
1431
            }else{
1432
                for(i=0;i<nb_components;i++) {
1433
                    uint8_t *ptr;
1434
                    int n, h, v, x, y, c, j, linesize;
1435
                    n = s->nb_blocks[i];
1436
                    c = s->comp_index[i];
1437
                    h = s->h_scount[i];
1438
                    v = s->v_scount[i];
1439
                    x = 0;
1440
                    y = 0;
1441
                    linesize= s->linesize[c];
1442

    
1443
                    for(j=0; j<n; j++) {
1444
                        int pred;
1445

    
1446
                        ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1447
                        PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1448
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1449
                        if (++x == h) {
1450
                            x = 0;
1451
                            y++;
1452
                        }
1453
                    }
1454
                }
1455
            }
1456
            if (s->restart_interval && !--s->restart_count) {
1457
                align_get_bits(&s->gb);
1458
                skip_bits(&s->gb, 16); /* skip RSTn */
1459
            }
1460
        }
1461
    }
1462
    return 0;
1463
}
1464

    
1465
static int mjpeg_decode_scan(MJpegDecodeContext *s){
1466
    int i, mb_x, mb_y;
1467
    const int nb_components=3;
1468

    
1469
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1470
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1471
            if (s->restart_interval && !s->restart_count)
1472
                s->restart_count = s->restart_interval;
1473

    
1474
            for(i=0;i<nb_components;i++) {
1475
                uint8_t *ptr;
1476
                int n, h, v, x, y, c, j;
1477
                n = s->nb_blocks[i];
1478
                c = s->comp_index[i];
1479
                h = s->h_scount[i];
1480
                v = s->v_scount[i];
1481
                x = 0;
1482
                y = 0;
1483
                for(j=0;j<n;j++) {
1484
                    memset(s->block, 0, sizeof(s->block));
1485
                    if (decode_block(s, s->block, i,
1486
                                     s->dc_index[i], s->ac_index[i],
1487
                                     s->quant_matrixes[ s->quant_index[c] ]) < 0) {
1488
                        dprintf("error y=%d x=%d\n", mb_y, mb_x);
1489
                        return -1;
1490
                    }
1491
//                    dprintf("mb: %d %d processed\n", mb_y, mb_x);
1492
                    ptr = s->picture.data[c] +
1493
                        (((s->linesize[c] * (v * mb_y + y) * 8) +
1494
                        (h * mb_x + x) * 8) >> s->avctx->lowres);
1495
                    if (s->interlaced && s->bottom_field)
1496
                        ptr += s->linesize[c] >> 1;
1497
//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);
1498
                    s->idct_put(ptr, s->linesize[c], s->block);
1499
                    if (++x == h) {
1500
                        x = 0;
1501
                        y++;
1502
                    }
1503
                }
1504
            }
1505
            /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1506
            if (s->restart_interval && (s->restart_interval < 1350) &&
1507
                !--s->restart_count) {
1508
                align_get_bits(&s->gb);
1509
                skip_bits(&s->gb, 16); /* skip RSTn */
1510
                for (i=0; i<nb_components; i++) /* reset dc */
1511
                    s->last_dc[i] = 1024;
1512
            }
1513
        }
1514
    }
1515
    return 0;
1516
}
1517

    
1518
static int mjpeg_decode_sos(MJpegDecodeContext *s)
1519
{
1520
    int len, nb_components, i, h, v, predictor, point_transform;
1521
    int vmax, hmax, index, id;
1522
    const int block_size= s->lossless ? 1 : 8;
1523
    int ilv;
1524

    
1525
    /* XXX: verify len field validity */
1526
    len = get_bits(&s->gb, 16);
1527
    nb_components = get_bits(&s->gb, 8);
1528
    if (len != 6+2*nb_components)
1529
    {
1530
        dprintf("decode_sos: invalid len (%d)\n", len);
1531
        return -1;
1532
    }
1533
    /* XXX: only interleaved scan accepted */
1534
    if ((nb_components != s->nb_components) && !s->ls)
1535
    {
1536
        dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1537
        return -1;
1538
    }
1539
    vmax = 0;
1540
    hmax = 0;
1541
    for(i=0;i<nb_components;i++) {
1542
        id = get_bits(&s->gb, 8) - 1;
1543
        dprintf("component: %d\n", id);
1544
        /* find component index */
1545
        for(index=0;index<s->nb_components;index++)
1546
            if (id == s->component_id[index])
1547
                break;
1548
        if (index == s->nb_components)
1549
        {
1550
            dprintf("decode_sos: index(%d) out of components\n", index);
1551
            return -1;
1552
        }
1553

    
1554
        s->comp_index[i] = index;
1555

    
1556
        s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1557
        s->h_scount[i] = s->h_count[index];
1558
        s->v_scount[i] = s->v_count[index];
1559

    
1560
        s->dc_index[i] = get_bits(&s->gb, 4);
1561
        s->ac_index[i] = get_bits(&s->gb, 4);
1562

    
1563
        if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1564
            s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1565
            goto out_of_range;
1566
#if 0 //buggy
1567
        switch(s->start_code)
1568
        {
1569
            case SOF0:
1570
                if (dc_index[i] > 1 || ac_index[i] > 1)
1571
                    goto out_of_range;
1572
                break;
1573
            case SOF1:
1574
            case SOF2:
1575
                if (dc_index[i] > 3 || ac_index[i] > 3)
1576
                    goto out_of_range;
1577
                break;
1578
            case SOF3:
1579
                if (dc_index[i] > 3 || ac_index[i] != 0)
1580
                    goto out_of_range;
1581
                break;
1582
        }
1583
#endif
1584
    }
1585

    
1586
    predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1587
    ilv= get_bits(&s->gb, 8);    /* JPEG Se / JPEG-LS ILV */
1588
    skip_bits(&s->gb, 4); /* Ah */
1589
    point_transform= get_bits(&s->gb, 4); /* Al */
1590

    
1591
    for(i=0;i<nb_components;i++)
1592
        s->last_dc[i] = 1024;
1593

    
1594
    if (nb_components > 1) {
1595
        /* interleaved stream */
1596
        s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1597
        s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1598
    } else if(!s->ls) { /* skip this for JPEG-LS */
1599
        h = s->h_max / s->h_scount[s->comp_index[0]];
1600
        v = s->v_max / s->v_scount[s->comp_index[0]];
1601
        s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1602
        s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1603
        s->nb_blocks[0] = 1;
1604
        s->h_scount[0] = 1;
1605
        s->v_scount[0] = 1;
1606
    }
1607

    
1608
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1609
        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" : "",
1610
               predictor, point_transform, ilv, s->bits,
1611
               s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));
1612

    
1613

    
1614
    /* mjpeg-b can have padding bytes between sos and image data, skip them */
1615
    for (i = s->mjpb_skiptosod; i > 0; i--)
1616
        skip_bits(&s->gb, 8);
1617

    
1618
    if(s->lossless){
1619
        if(s->ls){
1620
//            for(){
1621
//            reset_ls_coding_parameters(s, 0);
1622

    
1623
            ls_decode_picture(s, predictor, point_transform, ilv);
1624
        }else{
1625
            if(s->rgb){
1626
                if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1627
                    return -1;
1628
            }else{
1629
                if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1630
                    return -1;
1631
            }
1632
        }
1633
    }else{
1634
        if(mjpeg_decode_scan(s) < 0)
1635
            return -1;
1636
    }
1637
    emms_c();
1638
    return 0;
1639
 out_of_range:
1640
    dprintf("decode_sos: ac/dc index out of range\n");
1641
    return -1;
1642
}
1643

    
1644
static int mjpeg_decode_dri(MJpegDecodeContext *s)
1645
{
1646
    if (get_bits(&s->gb, 16) != 4)
1647
        return -1;
1648
    s->restart_interval = get_bits(&s->gb, 16);
1649
    s->restart_count = 0;
1650
    dprintf("restart interval: %d\n", s->restart_interval);
1651

    
1652
    return 0;
1653
}
1654

    
1655
static int mjpeg_decode_app(MJpegDecodeContext *s)
1656
{
1657
    int len, id;
1658

    
1659
    len = get_bits(&s->gb, 16);
1660
    if (len < 5)
1661
        return -1;
1662
    if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits)
1663
        return -1;
1664

    
1665
    id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1666
    id = be2me_32(id);
1667
    len -= 6;
1668

    
1669
    if(s->avctx->debug & FF_DEBUG_STARTCODE){
1670
        av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
1671
    }
1672

    
1673
    /* buggy AVID, it puts EOI only at every 10th frame */
1674
    /* also this fourcc is used by non-avid files too, it holds some
1675
       informations, but it's always present in AVID creates files */
1676
    if (id == ff_get_fourcc("AVI1"))
1677
    {
1678
        /* structure:
1679
            4bytes      AVI1
1680
            1bytes      polarity
1681
            1bytes      always zero
1682
            4bytes      field_size
1683
            4bytes      field_size_less_padding
1684
        */
1685
            s->buggy_avid = 1;
1686
//        if (s->first_picture)
1687
//            printf("mjpeg: workarounding buggy AVID\n");
1688
        s->interlace_polarity = get_bits(&s->gb, 8);
1689
#if 0
1690
        skip_bits(&s->gb, 8);
1691
        skip_bits(&s->gb, 32);
1692
        skip_bits(&s->gb, 32);
1693
        len -= 10;
1694
#endif
1695
//        if (s->interlace_polarity)
1696
//            printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1697
        goto out;
1698
    }
1699

    
1700
//    len -= 2;
1701

    
1702
    if (id == ff_get_fourcc("JFIF"))
1703
    {
1704
        int t_w, t_h, v1, v2;
1705
        skip_bits(&s->gb, 8); /* the trailing zero-byte */
1706
        v1= get_bits(&s->gb, 8);
1707
        v2= get_bits(&s->gb, 8);
1708
        skip_bits(&s->gb, 8);
1709

    
1710
        s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1711
        s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1712

    
1713
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1714
            av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1715
                v1, v2,
1716
                s->avctx->sample_aspect_ratio.num,
1717
                s->avctx->sample_aspect_ratio.den
1718
            );
1719

    
1720
        t_w = get_bits(&s->gb, 8);
1721
        t_h = get_bits(&s->gb, 8);
1722
        if (t_w && t_h)
1723
        {
1724
            /* skip thumbnail */
1725
            if (len-10-(t_w*t_h*3) > 0)
1726
                len -= t_w*t_h*3;
1727
        }
1728
        len -= 10;
1729
        goto out;
1730
    }
1731

    
1732
    if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1733
    {
1734
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1735
            av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1736
        skip_bits(&s->gb, 16); /* version */
1737
        skip_bits(&s->gb, 16); /* flags0 */
1738
        skip_bits(&s->gb, 16); /* flags1 */
1739
        skip_bits(&s->gb, 8);  /* transform */
1740
        len -= 7;
1741
        goto out;
1742
    }
1743

    
1744
    if (id == ff_get_fourcc("LJIF")){
1745
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1746
            av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1747
        skip_bits(&s->gb, 16); /* version ? */
1748
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1749
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1750
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1751
        switch( get_bits(&s->gb, 8)){
1752
        case 1:
1753
            s->rgb= 1;
1754
            s->pegasus_rct=0;
1755
            break;
1756
        case 2:
1757
            s->rgb= 1;
1758
            s->pegasus_rct=1;
1759
            break;
1760
        default:
1761
            av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1762
        }
1763
        len -= 9;
1764
        goto out;
1765
    }
1766

    
1767
    /* Apple MJPEG-A */
1768
    if ((s->start_code == APP1) && (len > (0x28 - 8)))
1769
    {
1770
        id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1771
        id = be2me_32(id);
1772
        len -= 4;
1773
        if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1774
        {
1775
#if 0
1776
            skip_bits(&s->gb, 32); /* field size */
1777
            skip_bits(&s->gb, 32); /* pad field size */
1778
            skip_bits(&s->gb, 32); /* next off */
1779
            skip_bits(&s->gb, 32); /* quant off */
1780
            skip_bits(&s->gb, 32); /* huff off */
1781
            skip_bits(&s->gb, 32); /* image off */
1782
            skip_bits(&s->gb, 32); /* scan off */
1783
            skip_bits(&s->gb, 32); /* data off */
1784
#endif
1785
            if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1786
                av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1787
        }
1788
    }
1789

    
1790
out:
1791
    /* slow but needed for extreme adobe jpegs */
1792
    if (len < 0)
1793
        av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1794
    while(--len > 0)
1795
        skip_bits(&s->gb, 8);
1796

    
1797
    return 0;
1798
}
1799

    
1800
static int mjpeg_decode_com(MJpegDecodeContext *s)
1801
{
1802
    int len = get_bits(&s->gb, 16);
1803
    if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) {
1804
        uint8_t *cbuf = av_malloc(len - 1);
1805
        if (cbuf) {
1806
            int i;
1807
            for (i = 0; i < len - 2; i++)
1808
                cbuf[i] = get_bits(&s->gb, 8);
1809
            if (i > 0 && cbuf[i-1] == '\n')
1810
                cbuf[i-1] = 0;
1811
            else
1812
                cbuf[i] = 0;
1813

    
1814
            if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1815
                av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1816

    
1817
            /* buggy avid, it puts EOI only at every 10th frame */
1818
            if (!strcmp(cbuf, "AVID"))
1819
            {
1820
                s->buggy_avid = 1;
1821
                //        if (s->first_picture)
1822
                //            printf("mjpeg: workarounding buggy AVID\n");
1823
            }
1824
            else if(!strcmp(cbuf, "CS=ITU601")){
1825
                s->cs_itu601= 1;
1826
            }
1827

    
1828
            av_free(cbuf);
1829
        }
1830
    }
1831

    
1832
    return 0;
1833
}
1834

    
1835
#if 0
1836
static int valid_marker_list[] =
1837
{
1838
        /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1839
/* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1840
/* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1841
/* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1842
/* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1843
/* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1844
/* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1845
/* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1846
/* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1847
/* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1848
/* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1849
/* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1850
/* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1851
/* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1852
/* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1853
/* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1854
/* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1855
}
1856
#endif
1857

    
1858
/* return the 8 bit start code value and update the search
1859
   state. Return -1 if no start code found */
1860
static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1861
{
1862
    uint8_t *buf_ptr;
1863
    unsigned int v, v2;
1864
    int val;
1865
#ifdef DEBUG
1866
    int skipped=0;
1867
#endif
1868

    
1869
    buf_ptr = *pbuf_ptr;
1870
    while (buf_ptr < buf_end) {
1871
        v = *buf_ptr++;
1872
        v2 = *buf_ptr;
1873
        if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1874
            val = *buf_ptr++;
1875
            goto found;
1876
        }
1877
#ifdef DEBUG
1878
        skipped++;
1879
#endif
1880
    }
1881
    val = -1;
1882
found:
1883
#ifdef DEBUG
1884
    dprintf("find_marker skipped %d bytes\n", skipped);
1885
#endif
1886
    *pbuf_ptr = buf_ptr;
1887
    return val;
1888
}
1889

    
1890
static int mjpeg_decode_frame(AVCodecContext *avctx,
1891
                              void *data, int *data_size,
1892
                              uint8_t *buf, int buf_size)
1893
{
1894
    MJpegDecodeContext *s = avctx->priv_data;
1895
    uint8_t *buf_end, *buf_ptr;
1896
    int start_code;
1897
    AVFrame *picture = data;
1898

    
1899
    buf_ptr = buf;
1900
    buf_end = buf + buf_size;
1901
    while (buf_ptr < buf_end) {
1902
        /* find start next marker */
1903
        start_code = find_marker(&buf_ptr, buf_end);
1904
        {
1905
            /* EOF */
1906
            if (start_code < 0) {
1907
                goto the_end;
1908
            } else {
1909
                dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1910

    
1911
                if ((buf_end - buf_ptr) > s->buffer_size)
1912
                {
1913
                    av_free(s->buffer);
1914
                    s->buffer_size = buf_end-buf_ptr;
1915
                    s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
1916
                    dprintf("buffer too small, expanding to %d bytes\n",
1917
                        s->buffer_size);
1918
                }
1919

    
1920
                /* unescape buffer of SOS, use special treatment for JPEG-LS */
1921
                if (start_code == SOS && !s->ls)
1922
                {
1923
                    uint8_t *src = buf_ptr;
1924
                    uint8_t *dst = s->buffer;
1925

    
1926
                    while (src<buf_end)
1927
                    {
1928
                        uint8_t x = *(src++);
1929

    
1930
                        *(dst++) = x;
1931
                        if (x == 0xff)
1932
                        {
1933
                            while(src<buf_end && x == 0xff)
1934
                                x = *(src++);
1935

    
1936
                            if (x >= 0xd0 && x <= 0xd7)
1937
                                *(dst++) = x;
1938
                            else if (x)
1939
                                break;
1940
                        }
1941
                    }
1942
                    init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1943

    
1944
                    dprintf("escaping removed %d bytes\n",
1945
                        (buf_end - buf_ptr) - (dst - s->buffer));
1946
                }
1947
                else if(start_code == SOS && s->ls){
1948
                    uint8_t *src = buf_ptr;
1949
                    uint8_t *dst = s->buffer;
1950
                    int bit_count = 0;
1951
                    int t = 0, b = 0;
1952
                    PutBitContext pb;
1953

    
1954
                    s->cur_scan++;
1955

    
1956
                    /* find marker */
1957
                    while (src + t < buf_end){
1958
                        uint8_t x = src[t++];
1959
                        if (x == 0xff){
1960
                            while((src + t < buf_end) && x == 0xff)
1961
                                x = src[t++];
1962
                            if (x & 0x80) {
1963
                                t -= 2;
1964
                                break;
1965
                            }
1966
                        }
1967
                    }
1968
                    bit_count = t * 8;
1969

    
1970
                    init_put_bits(&pb, dst, t);
1971

    
1972
                    /* unescape bitstream */
1973
                    while(b < t){
1974
                        uint8_t x = src[b++];
1975
                        put_bits(&pb, 8, x);
1976
                        if(x == 0xFF){
1977
                            x = src[b++];
1978
                            put_bits(&pb, 7, x);
1979
                            bit_count--;
1980
                        }
1981
                    }
1982
                    flush_put_bits(&pb);
1983

    
1984
                    init_get_bits(&s->gb, dst, bit_count);
1985
                }
1986
                else
1987
                    init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1988

    
1989
                s->start_code = start_code;
1990
                if(s->avctx->debug & FF_DEBUG_STARTCODE){
1991
                    av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
1992
                }
1993

    
1994
                /* process markers */
1995
                if (start_code >= 0xd0 && start_code <= 0xd7) {
1996
                    dprintf("restart marker: %d\n", start_code&0x0f);
1997
                    /* APP fields */
1998
                } else if (start_code >= APP0 && start_code <= APP15) {
1999
                    mjpeg_decode_app(s);
2000
                    /* Comment */
2001
                } else if (start_code == COM){
2002
                    mjpeg_decode_com(s);
2003
                }
2004

    
2005
                switch(start_code) {
2006
                case SOI:
2007
                    s->restart_interval = 0;
2008

    
2009
                    s->restart_count = 0;
2010
                    /* nothing to do on SOI */
2011
                    break;
2012
                case DQT:
2013
                    mjpeg_decode_dqt(s);
2014
                    break;
2015
                case DHT:
2016
                    if(mjpeg_decode_dht(s) < 0){
2017
                        av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n");
2018
                        return -1;
2019
                    }
2020
                    break;
2021
                case SOF0:
2022
                    s->lossless=0;
2023
                    if (mjpeg_decode_sof(s) < 0)
2024
                        return -1;
2025
                    break;
2026
                case SOF3:
2027
                    s->lossless=1;
2028
                    if (mjpeg_decode_sof(s) < 0)
2029
                        return -1;
2030
                    break;
2031
                case SOF48:
2032
                    s->lossless=1;
2033
                    s->ls=1;
2034
                    if (mjpeg_decode_sof(s) < 0)
2035
                        return -1;
2036
                    break;
2037
                case LSE:
2038
                    if (decode_lse(s) < 0)
2039
                        return -1;
2040
                    break;
2041
                case EOI:
2042
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2043
                        break;
2044
eoi_parser:
2045
                    {
2046
                        if (s->interlaced) {
2047
                            s->bottom_field ^= 1;
2048
                            /* if not bottom field, do not output image yet */
2049
                            if (s->bottom_field)
2050
                                goto not_the_end;
2051
                        }
2052
                        *picture = s->picture;
2053
                        *data_size = sizeof(AVFrame);
2054

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

    
2065
                        goto the_end;
2066
                    }
2067
                    break;
2068
                case SOS:
2069
                    mjpeg_decode_sos(s);
2070
                    /* buggy avid puts EOI every 10-20th frame */
2071
                    /* if restart period is over process EOI */
2072
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2073
                        goto eoi_parser;
2074
                    break;
2075
                case DRI:
2076
                    mjpeg_decode_dri(s);
2077
                    break;
2078
                case SOF1:
2079
                case SOF2:
2080
                case SOF5:
2081
                case SOF6:
2082
                case SOF7:
2083
                case SOF9:
2084
                case SOF10:
2085
                case SOF11:
2086
                case SOF13:
2087
                case SOF14:
2088
                case SOF15:
2089
                case JPG:
2090
                    av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
2091
                    break;
2092
//                default:
2093
//                    printf("mjpeg: unsupported marker (%x)\n", start_code);
2094
//                    break;
2095
                }
2096

    
2097
not_the_end:
2098
                /* eof process start code */
2099
                buf_ptr += (get_bits_count(&s->gb)+7)/8;
2100
                dprintf("marker parser used %d bytes (%d bits)\n",
2101
                    (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
2102
            }
2103
        }
2104
    }
2105
the_end:
2106
    dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
2107
//    return buf_end - buf_ptr;
2108
    return buf_ptr - buf;
2109
}
2110

    
2111
static int mjpegb_decode_frame(AVCodecContext *avctx,
2112
                              void *data, int *data_size,
2113
                              uint8_t *buf, int buf_size)
2114
{
2115
    MJpegDecodeContext *s = avctx->priv_data;
2116
    uint8_t *buf_end, *buf_ptr;
2117
    AVFrame *picture = data;
2118
    GetBitContext hgb; /* for the header */
2119
    uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
2120
    uint32_t field_size, sod_offs;
2121

    
2122
    buf_ptr = buf;
2123
    buf_end = buf + buf_size;
2124

    
2125
read_header:
2126
    /* reset on every SOI */
2127
    s->restart_interval = 0;
2128
    s->restart_count = 0;
2129
    s->mjpb_skiptosod = 0;
2130

    
2131
    init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
2132

    
2133
    skip_bits(&hgb, 32); /* reserved zeros */
2134

    
2135
    if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
2136
    {
2137
        dprintf("not mjpeg-b (bad fourcc)\n");
2138
        return 0;
2139
    }
2140

    
2141
    field_size = get_bits_long(&hgb, 32); /* field size */
2142
    dprintf("field size: 0x%x\n", field_size);
2143
    skip_bits(&hgb, 32); /* padded field size */
2144
    second_field_offs = get_bits_long(&hgb, 32);
2145
    dprintf("second field offs: 0x%x\n", second_field_offs);
2146
    if (second_field_offs)
2147
        s->interlaced = 1;
2148

    
2149
    dqt_offs = get_bits_long(&hgb, 32);
2150
    dprintf("dqt offs: 0x%x\n", dqt_offs);
2151
    if (dqt_offs)
2152
    {
2153
        init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
2154
        s->start_code = DQT;
2155
        mjpeg_decode_dqt(s);
2156
    }
2157

    
2158
    dht_offs = get_bits_long(&hgb, 32);
2159
    dprintf("dht offs: 0x%x\n", dht_offs);
2160
    if (dht_offs)
2161
    {
2162
        init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
2163
        s->start_code = DHT;
2164
        mjpeg_decode_dht(s);
2165
    }
2166

    
2167
    sof_offs = get_bits_long(&hgb, 32);
2168
    dprintf("sof offs: 0x%x\n", sof_offs);
2169
    if (sof_offs)
2170
    {
2171
        init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
2172
        s->start_code = SOF0;
2173
        if (mjpeg_decode_sof(s) < 0)
2174
            return -1;
2175
    }
2176

    
2177
    sos_offs = get_bits_long(&hgb, 32);
2178
    dprintf("sos offs: 0x%x\n", sos_offs);
2179
    sod_offs = get_bits_long(&hgb, 32);
2180
    dprintf("sod offs: 0x%x\n", sod_offs);
2181
    if (sos_offs)
2182
    {
2183
//        init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2184
        init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2185
        s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
2186
        s->start_code = SOS;
2187
        mjpeg_decode_sos(s);
2188
    }
2189

    
2190
    if (s->interlaced) {
2191
        s->bottom_field ^= 1;
2192
        /* if not bottom field, do not output image yet */
2193
        if (s->bottom_field && second_field_offs)
2194
        {
2195
            buf_ptr = buf + second_field_offs;
2196
            second_field_offs = 0;
2197
            goto read_header;
2198
            }
2199
    }
2200

    
2201
    //XXX FIXME factorize, this looks very similar to the EOI code
2202

    
2203
    *picture= s->picture;
2204
    *data_size = sizeof(AVFrame);
2205

    
2206
    if(!s->lossless){
2207
        picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2208
        picture->qstride= 0;
2209
        picture->qscale_table= s->qscale_table;
2210
        memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2211
        if(avctx->debug & FF_DEBUG_QP)
2212
            av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2213
        picture->quality*= FF_QP2LAMBDA;
2214
    }
2215

    
2216
    return buf_ptr - buf;
2217
}
2218

    
2219
#include "sp5x.h"
2220

    
2221
static int sp5x_decode_frame(AVCodecContext *avctx,
2222
                              void *data, int *data_size,
2223
                              uint8_t *buf, int buf_size)
2224
{
2225
#if 0
2226
    MJpegDecodeContext *s = avctx->priv_data;
2227
#endif
2228
    const int qscale = 5;
2229
    uint8_t *buf_ptr, *buf_end, *recoded;
2230
    int i = 0, j = 0;
2231

    
2232
    if (!avctx->width || !avctx->height)
2233
        return -1;
2234

    
2235
    buf_ptr = buf;
2236
    buf_end = buf + buf_size;
2237

    
2238
#if 1
2239
    recoded = av_mallocz(buf_size + 1024);
2240
    if (!recoded)
2241
        return -1;
2242

    
2243
    /* SOI */
2244
    recoded[j++] = 0xFF;
2245
    recoded[j++] = 0xD8;
2246

    
2247
    memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2248
    memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2249
    memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2250
    j += sizeof(sp5x_data_dqt);
2251

    
2252
    memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2253
    j += sizeof(sp5x_data_dht);
2254

    
2255
    memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2256
    recoded[j+5] = (avctx->coded_height >> 8) & 0xFF;
2257
    recoded[j+6] = avctx->coded_height & 0xFF;
2258
    recoded[j+7] = (avctx->coded_width >> 8) & 0xFF;
2259
    recoded[j+8] = avctx->coded_width & 0xFF;
2260
    j += sizeof(sp5x_data_sof);
2261

    
2262
    memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2263
    j += sizeof(sp5x_data_sos);
2264

    
2265
    for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2266
    {
2267
        recoded[j++] = buf[i];
2268
        if (buf[i] == 0xff)
2269
            recoded[j++] = 0;
2270
    }
2271

    
2272
    /* EOI */
2273
    recoded[j++] = 0xFF;
2274
    recoded[j++] = 0xD9;
2275

    
2276
    i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2277

    
2278
    av_free(recoded);
2279

    
2280
#else
2281
    /* SOF */
2282
    s->bits = 8;
2283
    s->width  = avctx->coded_width;
2284
    s->height = avctx->coded_height;
2285
    s->nb_components = 3;
2286
    s->component_id[0] = 0;
2287
    s->h_count[0] = 2;
2288
    s->v_count[0] = 2;
2289
    s->quant_index[0] = 0;
2290
    s->component_id[1] = 1;
2291
    s->h_count[1] = 1;
2292
    s->v_count[1] = 1;
2293
    s->quant_index[1] = 1;
2294
    s->component_id[2] = 2;
2295
    s->h_count[2] = 1;
2296
    s->v_count[2] = 1;
2297
    s->quant_index[2] = 1;
2298
    s->h_max = 2;
2299
    s->v_max = 2;
2300

    
2301
    s->qscale_table = av_mallocz((s->width+15)/16);
2302
    avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420;
2303
    s->interlaced = 0;
2304

    
2305
    s->picture.reference = 0;
2306
    if (avctx->get_buffer(avctx, &s->picture) < 0)
2307
    {
2308
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2309
        return -1;
2310
    }
2311

    
2312
    s->picture.pict_type = I_TYPE;
2313
    s->picture.key_frame = 1;
2314

    
2315
    for (i = 0; i < 3; i++)
2316
        s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2317

    
2318
    /* DQT */
2319
    for (i = 0; i < 64; i++)
2320
    {
2321
        j = s->scantable.permutated[i];
2322
        s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2323
    }
2324
    s->qscale[0] = FFMAX(
2325
        s->quant_matrixes[0][s->scantable.permutated[1]],
2326
        s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2327

    
2328
    for (i = 0; i < 64; i++)
2329
    {
2330
        j = s->scantable.permutated[i];
2331
        s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2332
    }
2333
    s->qscale[1] = FFMAX(
2334
        s->quant_matrixes[1][s->scantable.permutated[1]],
2335
        s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2336

    
2337
    /* DHT */
2338

    
2339
    /* SOS */
2340
    s->comp_index[0] = 0;
2341
    s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2342
    s->h_scount[0] = s->h_count[0];
2343
    s->v_scount[0] = s->v_count[0];
2344
    s->dc_index[0] = 0;
2345
    s->ac_index[0] = 0;
2346

    
2347
    s->comp_index[1] = 1;
2348
    s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2349
    s->h_scount[1] = s->h_count[1];
2350
    s->v_scount[1] = s->v_count[1];
2351
    s->dc_index[1] = 1;
2352
    s->ac_index[1] = 1;
2353

    
2354
    s->comp_index[2] = 2;
2355
    s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2356
    s->h_scount[2] = s->h_count[2];
2357
    s->v_scount[2] = s->v_count[2];
2358
    s->dc_index[2] = 1;
2359
    s->ac_index[2] = 1;
2360

    
2361
    for (i = 0; i < 3; i++)
2362
        s->last_dc[i] = 1024;
2363

    
2364
    s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2365
    s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2366

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

    
2369
    return mjpeg_decode_scan(s);
2370
#endif
2371

    
2372
    return i;
2373
}
2374

    
2375
static int mjpeg_decode_end(AVCodecContext *avctx)
2376
{
2377
    MJpegDecodeContext *s = avctx->priv_data;
2378
    int i, j;
2379

    
2380
    av_free(s->buffer);
2381
    av_free(s->qscale_table);
2382

    
2383
    for(i=0;i<2;i++) {
2384
        for(j=0;j<4;j++)
2385
            free_vlc(&s->vlcs[i][j]);
2386
    }
2387
    return 0;
2388
}
2389

    
2390
AVCodec mjpeg_decoder = {
2391
    "mjpeg",
2392
    CODEC_TYPE_VIDEO,
2393
    CODEC_ID_MJPEG,
2394
    sizeof(MJpegDecodeContext),
2395
    mjpeg_decode_init,
2396
    NULL,
2397
    mjpeg_decode_end,
2398
    mjpeg_decode_frame,
2399
    CODEC_CAP_DR1,
2400
    NULL
2401
};
2402

    
2403
AVCodec mjpegb_decoder = {
2404
    "mjpegb",
2405
    CODEC_TYPE_VIDEO,
2406
    CODEC_ID_MJPEGB,
2407
    sizeof(MJpegDecodeContext),
2408
    mjpeg_decode_init,
2409
    NULL,
2410
    mjpeg_decode_end,
2411
    mjpegb_decode_frame,
2412
    CODEC_CAP_DR1,
2413
    NULL
2414
};
2415

    
2416
AVCodec sp5x_decoder = {
2417
    "sp5x",
2418
    CODEC_TYPE_VIDEO,
2419
    CODEC_ID_SP5X,
2420
    sizeof(MJpegDecodeContext),
2421
    mjpeg_decode_init,
2422
    NULL,
2423
    mjpeg_decode_end,
2424
    sp5x_decode_frame,
2425
    CODEC_CAP_DR1,
2426
    NULL
2427
};
2428

    
2429
#ifdef CONFIG_ENCODERS
2430
AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2431
    "ljpeg",
2432
    CODEC_TYPE_VIDEO,
2433
    CODEC_ID_LJPEG,
2434
    sizeof(MpegEncContext),
2435
    MPV_encode_init,
2436
    encode_picture_lossless,
2437
    MPV_encode_end,
2438
};
2439
#endif
2440

    
2441
AVCodecParser mjpeg_parser = {
2442
    { CODEC_ID_MJPEG },
2443
    sizeof(ParseContext),
2444
    NULL,
2445
    jpeg_parse,
2446
    ff_parse_close,
2447
};
2448