Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mjpeg.c @ 1106e4ab

History | View | Annotate | Download (83.2 KB)

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

    
28
/**
29
 * @file mjpeg.c
30
 * MJPEG encoder and decoder.
31
 */
32

    
33
//#define DEBUG
34
#include <assert.h>
35

    
36
#include "avcodec.h"
37
#include "dsputil.h"
38
#include "mpegvideo.h"
39
#include "bytestream.h"
40

    
41
/* use two quantizer tables (one for luminance and one for chrominance) */
42
/* not yet working */
43
#undef TWOMATRIXES
44

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

    
51
    uint8_t huff_size_ac_luminance[256];
52
    uint16_t huff_code_ac_luminance[256];
53
    uint8_t huff_size_ac_chrominance[256];
54
    uint16_t huff_code_ac_chrominance[256];
55
} MJpegContext;
56

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

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

    
73
    SOF13 = 0xcd,       /* differential sequential, arithmetic */
74
    SOF14 = 0xce,       /* differential progressive, arithmetic */
75
    SOF15 = 0xcf,       /* differential lossless, arithmetic */
76

    
77
    DHT   = 0xc4,       /* define huffman tables */
78

    
79
    DAC   = 0xcc,       /* define arithmetic-coding conditioning */
80

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

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

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

    
117
    JPG0  = 0xf0,
118
    JPG1  = 0xf1,
119
    JPG2  = 0xf2,
120
    JPG3  = 0xf3,
121
    JPG4  = 0xf4,
122
    JPG5  = 0xf5,
123
    JPG6  = 0xf6,
124
    SOF48 = 0xf7,       ///< JPEG-LS
125
    LSE   = 0xf8,       ///< JPEG-LS extension parameters
126
    JPG9  = 0xf9,
127
    JPG10 = 0xfa,
128
    JPG11 = 0xfb,
129
    JPG12 = 0xfc,
130
    JPG13 = 0xfd,
131

    
132
    COM   = 0xfe,       /* comment */
133

    
134
    TEM   = 0x01,       /* temporary private use for arithmetic coding */
135

    
136
    /* 0x02 -> 0xbf reserved */
137
} JPEG_MARKER;
138

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

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

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

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

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

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

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

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

    
251
#ifdef CONFIG_ENCODERS
252
int mjpeg_init(MpegEncContext *s)
253
{
254
    MJpegContext *m;
255

    
256
    m = av_malloc(sizeof(MJpegContext));
257
    if (!m)
258
        return -1;
259

    
260
    s->min_qcoeff=-1023;
261
    s->max_qcoeff= 1023;
262

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

    
281
    s->mjpeg_ctx = m;
282
    return 0;
283
}
284

    
285
void mjpeg_close(MpegEncContext *s)
286
{
287
    av_free(s->mjpeg_ctx);
288
}
289
#endif //CONFIG_ENCODERS
290

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

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

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

    
317
    put_bits(p, 4, table_class);
318
    put_bits(p, 4, table_id);
319

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

    
326
    for(i=0;i<n;i++)
327
        put_bits(p, 8, value_table[i]);
328

    
329
    return n + 17;
330
}
331

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

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

    
360
    /* huffman table */
361
    put_marker(p, DHT);
362
    flush_put_bits(p);
363
    ptr = pbBufPtr(p);
364
    put_bits(p, 16, 0); /* patched later */
365
    size = 2;
366
    size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
367
    size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
368

    
369
    size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
370
    size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
371
    ptr[0] = size >> 8;
372
    ptr[1] = size;
373
}
374

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

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

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

    
407
    if(  s->avctx->pix_fmt == PIX_FMT_YUV420P
408
       ||s->avctx->pix_fmt == PIX_FMT_YUV422P
409
       ||s->avctx->pix_fmt == PIX_FMT_YUV444P){
410
        put_marker(p, COM);
411
        flush_put_bits(p);
412
        ptr = pbBufPtr(p);
413
        put_bits(p, 16, 0); /* patched later */
414
        ff_put_string(p, "CS=ITU601", 1);
415
        size = strlen("CS=ITU601")+3;
416
        ptr[0] = size >> 8;
417
        ptr[1] = size;
418
    }
419
}
420

    
421
void mjpeg_picture_header(MpegEncContext *s)
422
{
423
    const int lossless= s->avctx->codec_id != CODEC_ID_MJPEG;
424
    const int ls      = s->avctx->codec_id == CODEC_ID_JPEGLS;
425

    
426
    assert(!(ls && s->mjpeg_write_tables));
427

    
428
    put_marker(&s->pb, SOI);
429

    
430
    if (!s->mjpeg_data_only_frames)
431
    {
432
    jpeg_put_comments(s);
433

    
434
    if (s->mjpeg_write_tables) jpeg_table_header(s);
435

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

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

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

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

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

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

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

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

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

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

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

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

    
510
    //FIXME DC/AC entropy table selectors stuff in jpegls
511
}
512

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

    
520
    assert((size&7) == 0);
521
    size >>= 3;
522

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

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

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

    
548
    if(ff_count==0) return;
549

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

    
556
    for(i=size-1; ff_count; i--){
557
        int v= buf[i];
558

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

    
565
        buf[i+ff_count]= v;
566
    }
567
}
568

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

    
576
void mjpeg_picture_trailer(MpegEncContext *s)
577
{
578
    ff_mjpeg_stuffing(&s->pb);
579
    flush_put_bits(&s->pb);
580

    
581
    assert((s->header_bits&7)==0);
582

    
583
    escape_FF(s, s->header_bits>>3);
584

    
585
    put_marker(&s->pb, EOI);
586
}
587

    
588
static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
589
                                   uint8_t *huff_size, uint16_t *huff_code)
590
{
591
    int mant, nbits;
592

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

    
602
        nbits= av_log2_16bit(val) + 1;
603

    
604
        put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
605

    
606
        put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
607
    }
608
}
609

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

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

    
633
    /* AC coefs */
634

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

    
653
            nbits= av_log2(val) + 1;
654
            code = (run << 4) | nbits;
655

    
656
            put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
657

    
658
            put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
659
            run = 0;
660
        }
661
    }
662

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

    
668
void mjpeg_encode_mb(MpegEncContext *s,
669
                     DCTELEM block[6][64])
670
{
671
    int i;
672
    for(i=0;i<5;i++) {
673
        encode_block(s, block[i], i);
674
    }
675
    if (s->chroma_format == CHROMA_420) {
676
        encode_block(s, block[5], 5);
677
    } else {
678
        encode_block(s, block[6], 6);
679
        encode_block(s, block[5], 5);
680
        encode_block(s, block[7], 7);
681
    }
682
}
683

    
684
static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
685
    MpegEncContext * const s = avctx->priv_data;
686
    MJpegContext * const m = s->mjpeg_ctx;
687
    AVFrame *pict = data;
688
    const int width= s->width;
689
    const int height= s->height;
690
    AVFrame * const p= (AVFrame*)&s->current_picture;
691
    const int predictor= avctx->prediction_method+1;
692

    
693
    init_put_bits(&s->pb, buf, buf_size);
694

    
695
    *p = *pict;
696
    p->pict_type= FF_I_TYPE;
697
    p->key_frame= 1;
698

    
699
    mjpeg_picture_header(s);
700

    
701
    s->header_bits= put_bits_count(&s->pb);
702

    
703
    if(avctx->pix_fmt == PIX_FMT_RGB32){
704
        int x, y, i;
705
        const int linesize= p->linesize[0];
706
        uint16_t (*buffer)[4]= (void *) s->rd_scratchpad;
707
        int left[3], top[3], topleft[3];
708

    
709
        for(i=0; i<3; i++){
710
            buffer[0][i]= 1 << (9 - 1);
711
        }
712

    
713
        for(y = 0; y < height; y++) {
714
            const int modified_predictor= y ? predictor : 1;
715
            uint8_t *ptr = p->data[0] + (linesize * y);
716

    
717
            if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < width*3*4){
718
                av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
719
                return -1;
720
            }
721

    
722
            for(i=0; i<3; i++){
723
                top[i]= left[i]= topleft[i]= buffer[0][i];
724
            }
725
            for(x = 0; x < width; x++) {
726
                buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
727
                buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
728
                buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
729

    
730
                for(i=0;i<3;i++) {
731
                    int pred, diff;
732

    
733
                    PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
734

    
735
                    topleft[i]= top[i];
736
                    top[i]= buffer[x+1][i];
737

    
738
                    left[i]= buffer[x][i];
739

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

    
742
                    if(i==0)
743
                        mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
744
                    else
745
                        mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
746
                }
747
            }
748
        }
749
    }else{
750
        int mb_x, mb_y, i;
751
        const int mb_width  = (width  + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
752
        const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
753

    
754
        for(mb_y = 0; mb_y < mb_height; mb_y++) {
755
            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]){
756
                av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
757
                return -1;
758
            }
759
            for(mb_x = 0; mb_x < mb_width; mb_x++) {
760
                if(mb_x==0 || mb_y==0){
761
                    for(i=0;i<3;i++) {
762
                        uint8_t *ptr;
763
                        int x, y, h, v, linesize;
764
                        h = s->mjpeg_hsample[i];
765
                        v = s->mjpeg_vsample[i];
766
                        linesize= p->linesize[i];
767

    
768
                        for(y=0; y<v; y++){
769
                            for(x=0; x<h; x++){
770
                                int pred;
771

    
772
                                ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
773
                                if(y==0 && mb_y==0){
774
                                    if(x==0 && mb_x==0){
775
                                        pred= 128;
776
                                    }else{
777
                                        pred= ptr[-1];
778
                                    }
779
                                }else{
780
                                    if(x==0 && mb_x==0){
781
                                        pred= ptr[-linesize];
782
                                    }else{
783
                                        PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
784
                                    }
785
                                }
786

    
787
                                if(i==0)
788
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
789
                                else
790
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
791
                            }
792
                        }
793
                    }
794
                }else{
795
                    for(i=0;i<3;i++) {
796
                        uint8_t *ptr;
797
                        int x, y, h, v, linesize;
798
                        h = s->mjpeg_hsample[i];
799
                        v = s->mjpeg_vsample[i];
800
                        linesize= p->linesize[i];
801

    
802
                        for(y=0; y<v; y++){
803
                            for(x=0; x<h; x++){
804
                                int pred;
805

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

    
810
                                if(i==0)
811
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
812
                                else
813
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
814
                            }
815
                        }
816
                    }
817
                }
818
            }
819
        }
820
    }
821

    
822
    emms_c();
823

    
824
    mjpeg_picture_trailer(s);
825
    s->picture_number++;
826

    
827
    flush_put_bits(&s->pb);
828
    return pbBufPtr(&s->pb) - s->pb.buf;
829
//    return (put_bits_count(&f->pb)+7)/8;
830
}
831

    
832
#endif //CONFIG_ENCODERS
833

    
834
/******************************************/
835
/* decoding */
836

    
837
#define MAX_COMPONENTS 4
838

    
839
typedef struct MJpegDecodeContext {
840
    AVCodecContext *avctx;
841
    GetBitContext gb;
842

    
843
    int start_code; /* current start code */
844
    int buffer_size;
845
    uint8_t *buffer;
846

    
847
    int16_t quant_matrixes[4][64];
848
    VLC vlcs[2][4];
849
    int qscale[4];      ///< quantizer scale calculated from quant_matrixes
850

    
851
    int org_height;  /* size given at codec init */
852
    int first_picture;    /* true if decoding first picture */
853
    int interlaced;     /* true if interlaced */
854
    int bottom_field;   /* true if bottom field */
855
    int lossless;
856
    int ls;
857
    int progressive;
858
    int rgb;
859
    int rct;            /* standard rct */
860
    int pegasus_rct;    /* pegasus reversible colorspace transform */
861
    int bits;           /* bits per component */
862

    
863
    int maxval;
864
    int near;         ///< near lossless bound (si 0 for lossless)
865
    int t1,t2,t3;
866
    int reset;        ///< context halfing intervall ?rename
867

    
868
    int width, height;
869
    int mb_width, mb_height;
870
    int nb_components;
871
    int component_id[MAX_COMPONENTS];
872
    int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
873
    int v_count[MAX_COMPONENTS];
874
    int comp_index[MAX_COMPONENTS];
875
    int dc_index[MAX_COMPONENTS];
876
    int ac_index[MAX_COMPONENTS];
877
    int nb_blocks[MAX_COMPONENTS];
878
    int h_scount[MAX_COMPONENTS];
879
    int v_scount[MAX_COMPONENTS];
880
    int h_max, v_max; /* maximum h and v counts */
881
    int quant_index[4];   /* quant table index for each component */
882
    int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
883
    AVFrame picture; /* picture structure */
884
    int linesize[MAX_COMPONENTS];                   ///< linesize << interlaced
885
    int8_t *qscale_table;
886
    DECLARE_ALIGNED_8(DCTELEM, block[64]);
887
    ScanTable scantable;
888
    DSPContext dsp;
889

    
890
    int restart_interval;
891
    int restart_count;
892

    
893
    int buggy_avid;
894
    int cs_itu601;
895
    int interlace_polarity;
896

    
897
    int mjpb_skiptosod;
898

    
899
    int cur_scan; /* current scan, used by JPEG-LS */
900
} MJpegDecodeContext;
901

    
902
#include "jpeg_ls.c" //FIXME make jpeg-ls more independent
903

    
904
static int mjpeg_decode_dht(MJpegDecodeContext *s);
905

    
906
static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,
907
                      int nb_codes, int use_static, int is_ac)
908
{
909
    uint8_t huff_size[256+16];
910
    uint16_t huff_code[256+16];
911

    
912
    assert(nb_codes <= 256);
913

    
914
    memset(huff_size, 0, sizeof(huff_size));
915
    build_huffman_codes(huff_size, huff_code, bits_table, val_table);
916

    
917
    if(is_ac){
918
        memmove(huff_size+16, huff_size, sizeof(uint8_t)*nb_codes);
919
        memmove(huff_code+16, huff_code, sizeof(uint16_t)*nb_codes);
920
        memset(huff_size, 0, sizeof(uint8_t)*16);
921
        memset(huff_code, 0, sizeof(uint16_t)*16);
922
        nb_codes += 16;
923
    }
924

    
925
    return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2, use_static);
926
}
927

    
928
static int mjpeg_decode_init(AVCodecContext *avctx)
929
{
930
    MJpegDecodeContext *s = avctx->priv_data;
931

    
932
    s->avctx = avctx;
933
    dsputil_init(&s->dsp, avctx);
934
    ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct);
935
    s->buffer_size = 0;
936
    s->buffer = NULL;
937
    s->start_code = -1;
938
    s->first_picture = 1;
939
    s->org_height = avctx->coded_height;
940

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

    
946
    if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
947
    {
948
        av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
949
        init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
950
        mjpeg_decode_dht(s);
951
        /* should check for error - but dunno */
952
    }
953
    if (avctx->extradata_size > 9 &&
954
        AV_RL32(avctx->extradata + 4) == MKTAG('f','i','e','l')) {
955
        if (avctx->extradata[9] == 6) { /* quicktime icefloe 019 */
956
            s->interlace_polarity = 1; /* bottom field first */
957
            av_log(avctx, AV_LOG_DEBUG, "mjpeg bottom field first\n");
958
        }
959
    }
960

    
961
    return 0;
962
}
963

    
964

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

    
973
    vop_found= pc->frame_start_found;
974
    state= pc->state;
975

    
976
    i=0;
977
    if(!vop_found){
978
        for(i=0; i<buf_size; i++){
979
            state= (state<<8) | buf[i];
980
            if(state == 0xFFD8){
981
                i++;
982
                vop_found=1;
983
                break;
984
            }
985
        }
986
    }
987

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

    
1006
static int jpeg_parse(AVCodecParserContext *s,
1007
                           AVCodecContext *avctx,
1008
                           uint8_t **poutbuf, int *poutbuf_size,
1009
                           const uint8_t *buf, int buf_size)
1010
{
1011
    ParseContext *pc = s->priv_data;
1012
    int next;
1013

    
1014
    next= find_frame_end(pc, buf, buf_size);
1015

    
1016
    if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
1017
        *poutbuf = NULL;
1018
        *poutbuf_size = 0;
1019
        return buf_size;
1020
    }
1021

    
1022
    *poutbuf = (uint8_t *)buf;
1023
    *poutbuf_size = buf_size;
1024
    return next;
1025
}
1026

    
1027
/* quantize tables */
1028
static int mjpeg_decode_dqt(MJpegDecodeContext *s)
1029
{
1030
    int len, index, i, j;
1031

    
1032
    len = get_bits(&s->gb, 16) - 2;
1033

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

    
1051
        //XXX FIXME finetune, and perhaps add dc too
1052
        s->qscale[index]= FFMAX(
1053
            s->quant_matrixes[index][s->scantable.permutated[1]],
1054
            s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
1055
        av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n", index, s->qscale[index]);
1056
        len -= 65;
1057
    }
1058

    
1059
    return 0;
1060
}
1061

    
1062
/* decode huffman tables and build VLC decoders */
1063
static int mjpeg_decode_dht(MJpegDecodeContext *s)
1064
{
1065
    int len, index, i, class, n, v, code_max;
1066
    uint8_t bits_table[17];
1067
    uint8_t val_table[256];
1068

    
1069
    len = get_bits(&s->gb, 16) - 2;
1070

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

    
1089
        code_max = 0;
1090
        for(i=0;i<n;i++) {
1091
            v = get_bits(&s->gb, 8);
1092
            if (v > code_max)
1093
                code_max = v;
1094
            val_table[i] = v;
1095
        }
1096
        len -= n;
1097

    
1098
        /* build VLC and flush previous vlc if present */
1099
        free_vlc(&s->vlcs[class][index]);
1100
        av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
1101
               class, index, code_max + 1);
1102
        if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0, class > 0) < 0){
1103
            return -1;
1104
        }
1105
    }
1106
    return 0;
1107
}
1108

    
1109
static int mjpeg_decode_sof(MJpegDecodeContext *s)
1110
{
1111
    int len, nb_components, i, width, height, pix_fmt_id;
1112

    
1113
    /* XXX: verify len field validity */
1114
    len = get_bits(&s->gb, 16);
1115
    s->bits= get_bits(&s->gb, 8);
1116

    
1117
    if(s->pegasus_rct) s->bits=9;
1118
    if(s->bits==9 && !s->pegasus_rct) s->rct=1;    //FIXME ugly
1119

    
1120
    if (s->bits != 8 && !s->lossless){
1121
        av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
1122
        return -1;
1123
    }
1124

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

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

    
1132
    nb_components = get_bits(&s->gb, 8);
1133
    if (nb_components <= 0 ||
1134
        nb_components > MAX_COMPONENTS)
1135
        return -1;
1136
    if (s->ls && !(s->bits <= 8 || nb_components == 1)){
1137
        av_log(s->avctx, AV_LOG_ERROR, "only <= 8 bits/component or 16-bit gray accepted for JPEG-LS\n");
1138
        return -1;
1139
    }
1140
    s->nb_components = nb_components;
1141
    s->h_max = 1;
1142
    s->v_max = 1;
1143
    for(i=0;i<nb_components;i++) {
1144
        /* component id */
1145
        s->component_id[i] = get_bits(&s->gb, 8) - 1;
1146
        s->h_count[i] = get_bits(&s->gb, 4);
1147
        s->v_count[i] = get_bits(&s->gb, 4);
1148
        /* compute hmax and vmax (only used in interleaved case) */
1149
        if (s->h_count[i] > s->h_max)
1150
            s->h_max = s->h_count[i];
1151
        if (s->v_count[i] > s->v_max)
1152
            s->v_max = s->v_count[i];
1153
        s->quant_index[i] = get_bits(&s->gb, 8);
1154
        if (s->quant_index[i] >= 4)
1155
            return -1;
1156
        av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1157
               s->v_count[i], s->component_id[i], s->quant_index[i]);
1158
    }
1159

    
1160
    if(s->ls && (s->h_max > 1 || s->v_max > 1)) {
1161
        av_log(s->avctx, AV_LOG_ERROR, "Subsampling in JPEG-LS is not supported.\n");
1162
        return -1;
1163
    }
1164

    
1165
    if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1166

    
1167
    /* if different size, realloc/alloc picture */
1168
    /* XXX: also check h_count and v_count */
1169
    if (width != s->width || height != s->height) {
1170
        av_freep(&s->qscale_table);
1171

    
1172
        s->width = width;
1173
        s->height = height;
1174

    
1175
        /* test interlaced mode */
1176
        if (s->first_picture &&
1177
            s->org_height != 0 &&
1178
            s->height < ((s->org_height * 3) / 4)) {
1179
            s->interlaced = 1;
1180
            s->bottom_field = s->interlace_polarity;
1181
            s->picture.interlaced_frame = 1;
1182
            s->picture.top_field_first = !s->interlace_polarity;
1183
            height *= 2;
1184
        }
1185

    
1186
        avcodec_set_dimensions(s->avctx, width, height);
1187

    
1188
        s->qscale_table= av_mallocz((s->width+15)/16);
1189

    
1190
        s->first_picture = 0;
1191
    }
1192

    
1193
    if(s->interlaced && (s->bottom_field == !s->interlace_polarity))
1194
        return 0;
1195

    
1196
    /* XXX: not complete test ! */
1197
    pix_fmt_id = (s->h_count[0] << 20) | (s->v_count[0] << 16) |
1198
                 (s->h_count[1] << 12) | (s->v_count[1] <<  8) |
1199
                 (s->h_count[2] <<  4) |  s->v_count[2];
1200
    av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);
1201
    switch(pix_fmt_id){
1202
    case 0x222222:
1203
    case 0x111111:
1204
        if(s->rgb){
1205
            s->avctx->pix_fmt = PIX_FMT_RGB32;
1206
        }else if(s->nb_components==3)
1207
            s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;
1208
        else
1209
            s->avctx->pix_fmt = PIX_FMT_GRAY8;
1210
        break;
1211
    case 0x211111:
1212
    case 0x221212:
1213
        s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P;
1214
        break;
1215
    default:
1216
    case 0x221111:
1217
        s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P;
1218
        break;
1219
    }
1220
    if(s->ls){
1221
        if(s->nb_components > 1)
1222
            s->avctx->pix_fmt = PIX_FMT_RGB24;
1223
        else if(s->bits <= 8)
1224
            s->avctx->pix_fmt = PIX_FMT_GRAY8;
1225
        else
1226
            s->avctx->pix_fmt = PIX_FMT_GRAY16;
1227
    }
1228

    
1229
    if(s->picture.data[0])
1230
        s->avctx->release_buffer(s->avctx, &s->picture);
1231

    
1232
    s->picture.reference= 0;
1233
    if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1234
        av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1235
        return -1;
1236
    }
1237
    s->picture.pict_type= I_TYPE;
1238
    s->picture.key_frame= 1;
1239

    
1240
    for(i=0; i<3; i++){
1241
        s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1242
    }
1243

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

    
1246
    if (len != (8+(3*nb_components)))
1247
    {
1248
        av_log(s->avctx, AV_LOG_DEBUG, "decode_sof0: error, len(%d) mismatch\n", len);
1249
    }
1250

    
1251
    /* totally blank picture as progressive JPEG will only add details to it */
1252
    if(s->progressive){
1253
        memset(s->picture.data[0], 0, s->picture.linesize[0] * s->height);
1254
        memset(s->picture.data[1], 0, s->picture.linesize[1] * s->height >> (s->v_max - s->v_count[1]));
1255
        memset(s->picture.data[2], 0, s->picture.linesize[2] * s->height >> (s->v_max - s->v_count[2]));
1256
    }
1257
    return 0;
1258
}
1259

    
1260
static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1261
{
1262
    int code;
1263
    code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1264
    if (code < 0)
1265
    {
1266
        av_log(s->avctx, AV_LOG_WARNING, "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1267
               &s->vlcs[0][dc_index]);
1268
        return 0xffff;
1269
    }
1270

    
1271
    if(code)
1272
        return get_xbits(&s->gb, code);
1273
    else
1274
        return 0;
1275
}
1276

    
1277
/* decode block and dequantize */
1278
static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1279
                        int component, int dc_index, int ac_index, int16_t *quant_matrix)
1280
{
1281
    int code, i, j, level, val;
1282

    
1283
    /* DC coef */
1284
    val = mjpeg_decode_dc(s, dc_index);
1285
    if (val == 0xffff) {
1286
        av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
1287
        return -1;
1288
    }
1289
    val = val * quant_matrix[0] + s->last_dc[component];
1290
    s->last_dc[component] = val;
1291
    block[0] = val;
1292
    /* AC coefs */
1293
    i = 0;
1294
    {OPEN_READER(re, &s->gb)
1295
    for(;;) {
1296
        UPDATE_CACHE(re, &s->gb);
1297
        GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)
1298

    
1299
        /* EOB */
1300
        if (code == 0x10)
1301
            break;
1302
        i += ((unsigned)code) >> 4;
1303
        if(code != 0x100){
1304
            code &= 0xf;
1305
            if(code > MIN_CACHE_BITS - 16){
1306
                UPDATE_CACHE(re, &s->gb)
1307
            }
1308
            {
1309
                int cache=GET_CACHE(re,&s->gb);
1310
                int sign=(~cache)>>31;
1311
                level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
1312
            }
1313

    
1314
            LAST_SKIP_BITS(re, &s->gb, code)
1315

    
1316
            if (i >= 63) {
1317
                if(i == 63){
1318
                    j = s->scantable.permutated[63];
1319
                    block[j] = level * quant_matrix[j];
1320
                    break;
1321
                }
1322
                av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
1323
                return -1;
1324
            }
1325
            j = s->scantable.permutated[i];
1326
            block[j] = level * quant_matrix[j];
1327
        }
1328
    }
1329
    CLOSE_READER(re, &s->gb)}
1330

    
1331
    return 0;
1332
}
1333

    
1334
/* decode block and dequantize - progressive JPEG version */
1335
static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block,
1336
                        int component, int dc_index, int ac_index, int16_t *quant_matrix,
1337
                        int ss, int se, int Ah, int Al, int *EOBRUN)
1338
{
1339
    int code, i, j, level, val, run;
1340

    
1341
    /* DC coef */
1342
    if(!ss){
1343
        val = mjpeg_decode_dc(s, dc_index);
1344
        if (val == 0xffff) {
1345
            av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
1346
            return -1;
1347
        }
1348
        val = (val * quant_matrix[0] << Al) + s->last_dc[component];
1349
    }else
1350
        val = 0;
1351
    s->last_dc[component] = val;
1352
    block[0] = val;
1353
    if(!se) return 0;
1354
    /* AC coefs */
1355
    if(*EOBRUN){
1356
        (*EOBRUN)--;
1357
        return 0;
1358
    }
1359
    {OPEN_READER(re, &s->gb)
1360
    for(i=ss;;i++) {
1361
        UPDATE_CACHE(re, &s->gb);
1362
        GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)
1363
        /* Progressive JPEG use AC coeffs from zero and this decoder sets offset 16 by default */
1364
        code -= 16;
1365
        if(code & 0xF) {
1366
            i += ((unsigned) code) >> 4;
1367
            code &= 0xf;
1368
            if(code > MIN_CACHE_BITS - 16){
1369
                UPDATE_CACHE(re, &s->gb)
1370
            }
1371
            {
1372
                int cache=GET_CACHE(re,&s->gb);
1373
                int sign=(~cache)>>31;
1374
                level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
1375
            }
1376

    
1377
            LAST_SKIP_BITS(re, &s->gb, code)
1378

    
1379
            if (i >= se) {
1380
                if(i == se){
1381
                    j = s->scantable.permutated[se];
1382
                    block[j] = level * quant_matrix[j] << Al;
1383
                    break;
1384
                }
1385
                av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
1386
                return -1;
1387
            }
1388
            j = s->scantable.permutated[i];
1389
            block[j] = level * quant_matrix[j] << Al;
1390
        }else{
1391
            run = ((unsigned) code) >> 4;
1392
            if(run == 0xF){// ZRL - skip 15 coefficients
1393
                i += 15;
1394
            }else{
1395
                val = run;
1396
                run = (1 << run);
1397
                UPDATE_CACHE(re, &s->gb);
1398
                run += (GET_CACHE(re, &s->gb) >> (32 - val)) & (run - 1);
1399
                if(val)
1400
                    LAST_SKIP_BITS(re, &s->gb, val);
1401
                *EOBRUN = run - 1;
1402
                break;
1403
            }
1404
        }
1405
    }
1406
    CLOSE_READER(re, &s->gb)}
1407

    
1408
    return 0;
1409
}
1410

    
1411
static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1412
    int i, mb_x, mb_y;
1413
    uint16_t buffer[32768][4];
1414
    int left[3], top[3], topleft[3];
1415
    const int linesize= s->linesize[0];
1416
    const int mask= (1<<s->bits)-1;
1417

    
1418
    if((unsigned)s->mb_width > 32768) //dynamic alloc
1419
        return -1;
1420

    
1421
    for(i=0; i<3; i++){
1422
        buffer[0][i]= 1 << (s->bits + point_transform - 1);
1423
    }
1424
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1425
        const int modified_predictor= mb_y ? predictor : 1;
1426
        uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1427

    
1428
        if (s->interlaced && s->bottom_field)
1429
            ptr += linesize >> 1;
1430

    
1431
        for(i=0; i<3; i++){
1432
            top[i]= left[i]= topleft[i]= buffer[0][i];
1433
        }
1434
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1435
            if (s->restart_interval && !s->restart_count)
1436
                s->restart_count = s->restart_interval;
1437

    
1438
            for(i=0;i<3;i++) {
1439
                int pred;
1440

    
1441
                topleft[i]= top[i];
1442
                top[i]= buffer[mb_x][i];
1443

    
1444
                PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1445

    
1446
                left[i]=
1447
                buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1448
            }
1449

    
1450
            if (s->restart_interval && !--s->restart_count) {
1451
                align_get_bits(&s->gb);
1452
                skip_bits(&s->gb, 16); /* skip RSTn */
1453
            }
1454
        }
1455

    
1456
        if(s->rct){
1457
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1458
                ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1459
                ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1460
                ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1461
            }
1462
        }else if(s->pegasus_rct){
1463
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1464
                ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1465
                ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1466
                ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1467
            }
1468
        }else{
1469
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1470
                ptr[4*mb_x+0] = buffer[mb_x][0];
1471
                ptr[4*mb_x+1] = buffer[mb_x][1];
1472
                ptr[4*mb_x+2] = buffer[mb_x][2];
1473
            }
1474
        }
1475
    }
1476
    return 0;
1477
}
1478

    
1479
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1480
    int i, mb_x, mb_y;
1481
    const int nb_components=3;
1482

    
1483
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1484
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1485
            if (s->restart_interval && !s->restart_count)
1486
                s->restart_count = s->restart_interval;
1487

    
1488
            if(mb_x==0 || mb_y==0 || s->interlaced){
1489
                for(i=0;i<nb_components;i++) {
1490
                    uint8_t *ptr;
1491
                    int n, h, v, x, y, c, j, linesize;
1492
                    n = s->nb_blocks[i];
1493
                    c = s->comp_index[i];
1494
                    h = s->h_scount[i];
1495
                    v = s->v_scount[i];
1496
                    x = 0;
1497
                    y = 0;
1498
                    linesize= s->linesize[c];
1499

    
1500
                    for(j=0; j<n; j++) {
1501
                        int pred;
1502

    
1503
                        ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1504
                        if(y==0 && mb_y==0){
1505
                            if(x==0 && mb_x==0){
1506
                                pred= 128 << point_transform;
1507
                            }else{
1508
                                pred= ptr[-1];
1509
                            }
1510
                        }else{
1511
                            if(x==0 && mb_x==0){
1512
                                pred= ptr[-linesize];
1513
                            }else{
1514
                                PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1515
                            }
1516
                        }
1517

    
1518
                        if (s->interlaced && s->bottom_field)
1519
                            ptr += linesize >> 1;
1520
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1521

    
1522
                        if (++x == h) {
1523
                            x = 0;
1524
                            y++;
1525
                        }
1526
                    }
1527
                }
1528
            }else{
1529
                for(i=0;i<nb_components;i++) {
1530
                    uint8_t *ptr;
1531
                    int n, h, v, x, y, c, j, linesize;
1532
                    n = s->nb_blocks[i];
1533
                    c = s->comp_index[i];
1534
                    h = s->h_scount[i];
1535
                    v = s->v_scount[i];
1536
                    x = 0;
1537
                    y = 0;
1538
                    linesize= s->linesize[c];
1539

    
1540
                    for(j=0; j<n; j++) {
1541
                        int pred;
1542

    
1543
                        ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1544
                        PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1545
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1546
                        if (++x == h) {
1547
                            x = 0;
1548
                            y++;
1549
                        }
1550
                    }
1551
                }
1552
            }
1553
            if (s->restart_interval && !--s->restart_count) {
1554
                align_get_bits(&s->gb);
1555
                skip_bits(&s->gb, 16); /* skip RSTn */
1556
            }
1557
        }
1558
    }
1559
    return 0;
1560
}
1561

    
1562
static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int ss, int se, int Ah, int Al){
1563
    int i, mb_x, mb_y;
1564
    int EOBRUN = 0;
1565

    
1566
    if(Ah) return 0; /* TODO decode refinement planes too */
1567
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1568
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1569
            if (s->restart_interval && !s->restart_count)
1570
                s->restart_count = s->restart_interval;
1571

    
1572
            for(i=0;i<nb_components;i++) {
1573
                uint8_t *ptr;
1574
                int n, h, v, x, y, c, j;
1575
                n = s->nb_blocks[i];
1576
                c = s->comp_index[i];
1577
                h = s->h_scount[i];
1578
                v = s->v_scount[i];
1579
                x = 0;
1580
                y = 0;
1581
                for(j=0;j<n;j++) {
1582
                    memset(s->block, 0, sizeof(s->block));
1583
                    if (!s->progressive && decode_block(s, s->block, i,
1584
                                     s->dc_index[i], s->ac_index[i],
1585
                                     s->quant_matrixes[ s->quant_index[c] ]) < 0) {
1586
                        av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
1587
                        return -1;
1588
                    }
1589
                    if (s->progressive && decode_block_progressive(s, s->block, i,
1590
                                     s->dc_index[i], s->ac_index[i],
1591
                                     s->quant_matrixes[ s->quant_index[c] ], ss, se, Ah, Al, &EOBRUN) < 0) {
1592
                        av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
1593
                        return -1;
1594
                    }
1595
//                    av_log(s->avctx, AV_LOG_DEBUG, "mb: %d %d processed\n", mb_y, mb_x);
1596
                    ptr = s->picture.data[c] +
1597
                        (((s->linesize[c] * (v * mb_y + y) * 8) +
1598
                        (h * mb_x + x) * 8) >> s->avctx->lowres);
1599
                    if (s->interlaced && s->bottom_field)
1600
                        ptr += s->linesize[c] >> 1;
1601
//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);
1602
                    if(!s->progressive)
1603
                        s->dsp.idct_put(ptr, s->linesize[c], s->block);
1604
                    else
1605
                        s->dsp.idct_add(ptr, s->linesize[c], s->block);
1606
                    if (++x == h) {
1607
                        x = 0;
1608
                        y++;
1609
                    }
1610
                }
1611
            }
1612
            /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1613
            if (s->restart_interval && (s->restart_interval < 1350) &&
1614
                !--s->restart_count) {
1615
                align_get_bits(&s->gb);
1616
                skip_bits(&s->gb, 16); /* skip RSTn */
1617
                for (i=0; i<nb_components; i++) /* reset dc */
1618
                    s->last_dc[i] = 1024;
1619
            }
1620
        }
1621
    }
1622
    return 0;
1623
}
1624

    
1625
static int mjpeg_decode_sos(MJpegDecodeContext *s)
1626
{
1627
    int len, nb_components, i, h, v, predictor, point_transform;
1628
    int vmax, hmax, index, id;
1629
    const int block_size= s->lossless ? 1 : 8;
1630
    int ilv, prev_shift;
1631

    
1632
    /* XXX: verify len field validity */
1633
    len = get_bits(&s->gb, 16);
1634
    nb_components = get_bits(&s->gb, 8);
1635
    if (len != 6+2*nb_components)
1636
    {
1637
        av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1638
        return -1;
1639
    }
1640
    vmax = 0;
1641
    hmax = 0;
1642
    for(i=0;i<nb_components;i++) {
1643
        id = get_bits(&s->gb, 8) - 1;
1644
        av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1645
        /* find component index */
1646
        for(index=0;index<s->nb_components;index++)
1647
            if (id == s->component_id[index])
1648
                break;
1649
        if (index == s->nb_components)
1650
        {
1651
            av_log(s->avctx, AV_LOG_ERROR, "decode_sos: index(%d) out of components\n", index);
1652
            return -1;
1653
        }
1654

    
1655
        s->comp_index[i] = index;
1656

    
1657
        s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1658
        s->h_scount[i] = s->h_count[index];
1659
        s->v_scount[i] = s->v_count[index];
1660

    
1661
        s->dc_index[i] = get_bits(&s->gb, 4);
1662
        s->ac_index[i] = get_bits(&s->gb, 4);
1663

    
1664
        if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1665
            s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1666
            goto out_of_range;
1667
#if 0 //buggy
1668
        switch(s->start_code)
1669
        {
1670
            case SOF0:
1671
                if (dc_index[i] > 1 || ac_index[i] > 1)
1672
                    goto out_of_range;
1673
                break;
1674
            case SOF1:
1675
            case SOF2:
1676
                if (dc_index[i] > 3 || ac_index[i] > 3)
1677
                    goto out_of_range;
1678
                break;
1679
            case SOF3:
1680
                if (dc_index[i] > 3 || ac_index[i] != 0)
1681
                    goto out_of_range;
1682
                break;
1683
        }
1684
#endif
1685
    }
1686

    
1687
    predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1688
    ilv= get_bits(&s->gb, 8);    /* JPEG Se / JPEG-LS ILV */
1689
    prev_shift = get_bits(&s->gb, 4); /* Ah */
1690
    point_transform= get_bits(&s->gb, 4); /* Al */
1691

    
1692
    for(i=0;i<nb_components;i++)
1693
        s->last_dc[i] = 1024;
1694

    
1695
    if (nb_components > 1) {
1696
        /* interleaved stream */
1697
        s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1698
        s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1699
    } else if(!s->ls) { /* skip this for JPEG-LS */
1700
        h = s->h_max / s->h_scount[0];
1701
        v = s->v_max / s->v_scount[0];
1702
        s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1703
        s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1704
        s->nb_blocks[0] = 1;
1705
        s->h_scount[0] = 1;
1706
        s->v_scount[0] = 1;
1707
    }
1708

    
1709
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1710
        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" : "",
1711
               predictor, point_transform, ilv, s->bits,
1712
               s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));
1713

    
1714

    
1715
    /* mjpeg-b can have padding bytes between sos and image data, skip them */
1716
    for (i = s->mjpb_skiptosod; i > 0; i--)
1717
        skip_bits(&s->gb, 8);
1718

    
1719
    if(s->lossless){
1720
        if(s->ls){
1721
//            for(){
1722
//            reset_ls_coding_parameters(s, 0);
1723

    
1724
            ls_decode_picture(s, predictor, point_transform, ilv);
1725
        }else{
1726
            if(s->rgb){
1727
                if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1728
                    return -1;
1729
            }else{
1730
                if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1731
                    return -1;
1732
            }
1733
        }
1734
    }else{
1735
        if(mjpeg_decode_scan(s, nb_components, predictor, ilv, prev_shift, point_transform) < 0)
1736
            return -1;
1737
    }
1738
    emms_c();
1739
    return 0;
1740
 out_of_range:
1741
    av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1742
    return -1;
1743
}
1744

    
1745
static int mjpeg_decode_dri(MJpegDecodeContext *s)
1746
{
1747
    if (get_bits(&s->gb, 16) != 4)
1748
        return -1;
1749
    s->restart_interval = get_bits(&s->gb, 16);
1750
    s->restart_count = 0;
1751
    av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n", s->restart_interval);
1752

    
1753
    return 0;
1754
}
1755

    
1756
static int mjpeg_decode_app(MJpegDecodeContext *s)
1757
{
1758
    int len, id;
1759

    
1760
    len = get_bits(&s->gb, 16);
1761
    if (len < 5)
1762
        return -1;
1763
    if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits)
1764
        return -1;
1765

    
1766
    id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1767
    id = be2me_32(id);
1768
    len -= 6;
1769

    
1770
    if(s->avctx->debug & FF_DEBUG_STARTCODE){
1771
        av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
1772
    }
1773

    
1774
    /* buggy AVID, it puts EOI only at every 10th frame */
1775
    /* also this fourcc is used by non-avid files too, it holds some
1776
       informations, but it's always present in AVID creates files */
1777
    if (id == ff_get_fourcc("AVI1"))
1778
    {
1779
        /* structure:
1780
            4bytes      AVI1
1781
            1bytes      polarity
1782
            1bytes      always zero
1783
            4bytes      field_size
1784
            4bytes      field_size_less_padding
1785
        */
1786
            s->buggy_avid = 1;
1787
//        if (s->first_picture)
1788
//            printf("mjpeg: workarounding buggy AVID\n");
1789
        s->interlace_polarity = get_bits(&s->gb, 8);
1790
#if 0
1791
        skip_bits(&s->gb, 8);
1792
        skip_bits(&s->gb, 32);
1793
        skip_bits(&s->gb, 32);
1794
        len -= 10;
1795
#endif
1796
//        if (s->interlace_polarity)
1797
//            printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1798
        goto out;
1799
    }
1800

    
1801
//    len -= 2;
1802

    
1803
    if (id == ff_get_fourcc("JFIF"))
1804
    {
1805
        int t_w, t_h, v1, v2;
1806
        skip_bits(&s->gb, 8); /* the trailing zero-byte */
1807
        v1= get_bits(&s->gb, 8);
1808
        v2= get_bits(&s->gb, 8);
1809
        skip_bits(&s->gb, 8);
1810

    
1811
        s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1812
        s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1813

    
1814
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1815
            av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1816
                v1, v2,
1817
                s->avctx->sample_aspect_ratio.num,
1818
                s->avctx->sample_aspect_ratio.den
1819
            );
1820

    
1821
        t_w = get_bits(&s->gb, 8);
1822
        t_h = get_bits(&s->gb, 8);
1823
        if (t_w && t_h)
1824
        {
1825
            /* skip thumbnail */
1826
            if (len-10-(t_w*t_h*3) > 0)
1827
                len -= t_w*t_h*3;
1828
        }
1829
        len -= 10;
1830
        goto out;
1831
    }
1832

    
1833
    if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1834
    {
1835
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1836
            av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1837
        skip_bits(&s->gb, 16); /* version */
1838
        skip_bits(&s->gb, 16); /* flags0 */
1839
        skip_bits(&s->gb, 16); /* flags1 */
1840
        skip_bits(&s->gb, 8);  /* transform */
1841
        len -= 7;
1842
        goto out;
1843
    }
1844

    
1845
    if (id == ff_get_fourcc("LJIF")){
1846
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1847
            av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1848
        skip_bits(&s->gb, 16); /* version ? */
1849
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1850
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1851
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1852
        switch( get_bits(&s->gb, 8)){
1853
        case 1:
1854
            s->rgb= 1;
1855
            s->pegasus_rct=0;
1856
            break;
1857
        case 2:
1858
            s->rgb= 1;
1859
            s->pegasus_rct=1;
1860
            break;
1861
        default:
1862
            av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1863
        }
1864
        len -= 9;
1865
        goto out;
1866
    }
1867

    
1868
    /* Apple MJPEG-A */
1869
    if ((s->start_code == APP1) && (len > (0x28 - 8)))
1870
    {
1871
        id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1872
        id = be2me_32(id);
1873
        len -= 4;
1874
        if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1875
        {
1876
#if 0
1877
            skip_bits(&s->gb, 32); /* field size */
1878
            skip_bits(&s->gb, 32); /* pad field size */
1879
            skip_bits(&s->gb, 32); /* next off */
1880
            skip_bits(&s->gb, 32); /* quant off */
1881
            skip_bits(&s->gb, 32); /* huff off */
1882
            skip_bits(&s->gb, 32); /* image off */
1883
            skip_bits(&s->gb, 32); /* scan off */
1884
            skip_bits(&s->gb, 32); /* data off */
1885
#endif
1886
            if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1887
                av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1888
        }
1889
    }
1890

    
1891
out:
1892
    /* slow but needed for extreme adobe jpegs */
1893
    if (len < 0)
1894
        av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1895
    while(--len > 0)
1896
        skip_bits(&s->gb, 8);
1897

    
1898
    return 0;
1899
}
1900

    
1901
static int mjpeg_decode_com(MJpegDecodeContext *s)
1902
{
1903
    int len = get_bits(&s->gb, 16);
1904
    if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) {
1905
        char *cbuf = av_malloc(len - 1);
1906
        if (cbuf) {
1907
            int i;
1908
            for (i = 0; i < len - 2; i++)
1909
                cbuf[i] = get_bits(&s->gb, 8);
1910
            if (i > 0 && cbuf[i-1] == '\n')
1911
                cbuf[i-1] = 0;
1912
            else
1913
                cbuf[i] = 0;
1914

    
1915
            if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1916
                av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1917

    
1918
            /* buggy avid, it puts EOI only at every 10th frame */
1919
            if (!strcmp(cbuf, "AVID"))
1920
            {
1921
                s->buggy_avid = 1;
1922
                //        if (s->first_picture)
1923
                //            printf("mjpeg: workarounding buggy AVID\n");
1924
            }
1925
            else if(!strcmp(cbuf, "CS=ITU601")){
1926
                s->cs_itu601= 1;
1927
            }
1928

    
1929
            av_free(cbuf);
1930
        }
1931
    }
1932

    
1933
    return 0;
1934
}
1935

    
1936
#if 0
1937
static int valid_marker_list[] =
1938
{
1939
        /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1940
/* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1941
/* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1942
/* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1943
/* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1944
/* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1945
/* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1946
/* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1947
/* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1948
/* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1949
/* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1950
/* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1951
/* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1952
/* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1953
/* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1954
/* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1955
/* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1956
}
1957
#endif
1958

    
1959
/* return the 8 bit start code value and update the search
1960
   state. Return -1 if no start code found */
1961
static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1962
{
1963
    uint8_t *buf_ptr;
1964
    unsigned int v, v2;
1965
    int val;
1966
#ifdef DEBUG
1967
    int skipped=0;
1968
#endif
1969

    
1970
    buf_ptr = *pbuf_ptr;
1971
    while (buf_ptr < buf_end) {
1972
        v = *buf_ptr++;
1973
        v2 = *buf_ptr;
1974
        if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1975
            val = *buf_ptr++;
1976
            goto found;
1977
        }
1978
#ifdef DEBUG
1979
        skipped++;
1980
#endif
1981
    }
1982
    val = -1;
1983
found:
1984
#ifdef DEBUG
1985
    av_log(NULL, AV_LOG_VERBOSE, "find_marker skipped %d bytes\n", skipped);
1986
#endif
1987
    *pbuf_ptr = buf_ptr;
1988
    return val;
1989
}
1990

    
1991
static int mjpeg_decode_frame(AVCodecContext *avctx,
1992
                              void *data, int *data_size,
1993
                              uint8_t *buf, int buf_size)
1994
{
1995
    MJpegDecodeContext *s = avctx->priv_data;
1996
    uint8_t *buf_end, *buf_ptr;
1997
    int start_code;
1998
    AVFrame *picture = data;
1999

    
2000
    buf_ptr = buf;
2001
    buf_end = buf + buf_size;
2002
    while (buf_ptr < buf_end) {
2003
        /* find start next marker */
2004
        start_code = find_marker(&buf_ptr, buf_end);
2005
        {
2006
            /* EOF */
2007
            if (start_code < 0) {
2008
                goto the_end;
2009
            } else {
2010
                av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
2011

    
2012
                if ((buf_end - buf_ptr) > s->buffer_size)
2013
                {
2014
                    av_free(s->buffer);
2015
                    s->buffer_size = buf_end-buf_ptr;
2016
                    s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
2017
                    av_log(avctx, AV_LOG_DEBUG, "buffer too small, expanding to %d bytes\n",
2018
                        s->buffer_size);
2019
                }
2020

    
2021
                /* unescape buffer of SOS, use special treatment for JPEG-LS */
2022
                if (start_code == SOS && !s->ls)
2023
                {
2024
                    uint8_t *src = buf_ptr;
2025
                    uint8_t *dst = s->buffer;
2026

    
2027
                    while (src<buf_end)
2028
                    {
2029
                        uint8_t x = *(src++);
2030

    
2031
                        *(dst++) = x;
2032
                        if (avctx->codec_id != CODEC_ID_THP)
2033
                        {
2034
                            if (x == 0xff) {
2035
                                while (src < buf_end && x == 0xff)
2036
                                    x = *(src++);
2037

    
2038
                                if (x >= 0xd0 && x <= 0xd7)
2039
                                    *(dst++) = x;
2040
                                else if (x)
2041
                                    break;
2042
                            }
2043
                        }
2044
                    }
2045
                    init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
2046

    
2047
                    av_log(avctx, AV_LOG_DEBUG, "escaping removed %d bytes\n",
2048
                           (buf_end - buf_ptr) - (dst - s->buffer));
2049
                }
2050
                else if(start_code == SOS && s->ls){
2051
                    uint8_t *src = buf_ptr;
2052
                    uint8_t *dst = s->buffer;
2053
                    int bit_count = 0;
2054
                    int t = 0, b = 0;
2055
                    PutBitContext pb;
2056

    
2057
                    s->cur_scan++;
2058

    
2059
                    /* find marker */
2060
                    while (src + t < buf_end){
2061
                        uint8_t x = src[t++];
2062
                        if (x == 0xff){
2063
                            while((src + t < buf_end) && x == 0xff)
2064
                                x = src[t++];
2065
                            if (x & 0x80) {
2066
                                t -= 2;
2067
                                break;
2068
                            }
2069
                        }
2070
                    }
2071
                    bit_count = t * 8;
2072

    
2073
                    init_put_bits(&pb, dst, t);
2074

    
2075
                    /* unescape bitstream */
2076
                    while(b < t){
2077
                        uint8_t x = src[b++];
2078
                        put_bits(&pb, 8, x);
2079
                        if(x == 0xFF){
2080
                            x = src[b++];
2081
                            put_bits(&pb, 7, x);
2082
                            bit_count--;
2083
                        }
2084
                    }
2085
                    flush_put_bits(&pb);
2086

    
2087
                    init_get_bits(&s->gb, dst, bit_count);
2088
                }
2089
                else
2090
                    init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
2091

    
2092
                s->start_code = start_code;
2093
                if(s->avctx->debug & FF_DEBUG_STARTCODE){
2094
                    av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2095
                }
2096

    
2097
                /* process markers */
2098
                if (start_code >= 0xd0 && start_code <= 0xd7) {
2099
                    av_log(avctx, AV_LOG_DEBUG, "restart marker: %d\n", start_code&0x0f);
2100
                    /* APP fields */
2101
                } else if (start_code >= APP0 && start_code <= APP15) {
2102
                    mjpeg_decode_app(s);
2103
                    /* Comment */
2104
                } else if (start_code == COM){
2105
                    mjpeg_decode_com(s);
2106
                }
2107

    
2108
                switch(start_code) {
2109
                case SOI:
2110
                    s->restart_interval = 0;
2111

    
2112
                    s->restart_count = 0;
2113
                    /* nothing to do on SOI */
2114
                    break;
2115
                case DQT:
2116
                    mjpeg_decode_dqt(s);
2117
                    break;
2118
                case DHT:
2119
                    if(mjpeg_decode_dht(s) < 0){
2120
                        av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
2121
                        return -1;
2122
                    }
2123
                    break;
2124
                case SOF0:
2125
                    s->lossless=0;
2126
                    s->ls=0;
2127
                    s->progressive=0;
2128
                    if (mjpeg_decode_sof(s) < 0)
2129
                        return -1;
2130
                    break;
2131
                case SOF2:
2132
                    s->lossless=0;
2133
                    s->ls=0;
2134
                    s->progressive=1;
2135
                    if (mjpeg_decode_sof(s) < 0)
2136
                        return -1;
2137
                    break;
2138
                case SOF3:
2139
                    s->lossless=1;
2140
                    s->ls=0;
2141
                    s->progressive=0;
2142
                    if (mjpeg_decode_sof(s) < 0)
2143
                        return -1;
2144
                    break;
2145
                case SOF48:
2146
                    s->lossless=1;
2147
                    s->ls=1;
2148
                    s->progressive=0;
2149
                    if (mjpeg_decode_sof(s) < 0)
2150
                        return -1;
2151
                    break;
2152
                case LSE:
2153
                    if (decode_lse(s) < 0)
2154
                        return -1;
2155
                    break;
2156
                case EOI:
2157
                    s->cur_scan = 0;
2158
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2159
                        break;
2160
eoi_parser:
2161
                    {
2162
                        if (s->interlaced) {
2163
                            s->bottom_field ^= 1;
2164
                            /* if not bottom field, do not output image yet */
2165
                            if (s->bottom_field == !s->interlace_polarity)
2166
                                goto not_the_end;
2167
                        }
2168
                        *picture = s->picture;
2169
                        *data_size = sizeof(AVFrame);
2170

    
2171
                        if(!s->lossless){
2172
                            picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2173
                            picture->qstride= 0;
2174
                            picture->qscale_table= s->qscale_table;
2175
                            memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2176
                            if(avctx->debug & FF_DEBUG_QP)
2177
                                av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2178
                            picture->quality*= FF_QP2LAMBDA;
2179
                        }
2180

    
2181
                        goto the_end;
2182
                    }
2183
                    break;
2184
                case SOS:
2185
                    mjpeg_decode_sos(s);
2186
                    /* buggy avid puts EOI every 10-20th frame */
2187
                    /* if restart period is over process EOI */
2188
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2189
                        goto eoi_parser;
2190
                    break;
2191
                case DRI:
2192
                    mjpeg_decode_dri(s);
2193
                    break;
2194
                case SOF1:
2195
                case SOF5:
2196
                case SOF6:
2197
                case SOF7:
2198
                case SOF9:
2199
                case SOF10:
2200
                case SOF11:
2201
                case SOF13:
2202
                case SOF14:
2203
                case SOF15:
2204
                case JPG:
2205
                    av_log(avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
2206
                    break;
2207
//                default:
2208
//                    printf("mjpeg: unsupported marker (%x)\n", start_code);
2209
//                    break;
2210
                }
2211

    
2212
not_the_end:
2213
                /* eof process start code */
2214
                buf_ptr += (get_bits_count(&s->gb)+7)/8;
2215
                av_log(avctx, AV_LOG_DEBUG, "marker parser used %d bytes (%d bits)\n",
2216
                       (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
2217
            }
2218
        }
2219
    }
2220
the_end:
2221
    av_log(avctx, AV_LOG_DEBUG, "mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
2222
//    return buf_end - buf_ptr;
2223
    return buf_ptr - buf;
2224
}
2225

    
2226
static int mjpegb_decode_frame(AVCodecContext *avctx,
2227
                              void *data, int *data_size,
2228
                              uint8_t *buf, int buf_size)
2229
{
2230
    MJpegDecodeContext *s = avctx->priv_data;
2231
    uint8_t *buf_end, *buf_ptr;
2232
    AVFrame *picture = data;
2233
    GetBitContext hgb; /* for the header */
2234
    uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
2235
    uint32_t field_size, sod_offs;
2236

    
2237
    buf_ptr = buf;
2238
    buf_end = buf + buf_size;
2239

    
2240
read_header:
2241
    /* reset on every SOI */
2242
    s->restart_interval = 0;
2243
    s->restart_count = 0;
2244
    s->mjpb_skiptosod = 0;
2245

    
2246
    init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
2247

    
2248
    skip_bits(&hgb, 32); /* reserved zeros */
2249

    
2250
    if (get_bits_long(&hgb, 32) != MKBETAG('m','j','p','g'))
2251
    {
2252
        av_log(avctx, AV_LOG_WARNING, "not mjpeg-b (bad fourcc)\n");
2253
        return 0;
2254
    }
2255

    
2256
    field_size = get_bits_long(&hgb, 32); /* field size */
2257
    av_log(avctx, AV_LOG_DEBUG, "field size: 0x%x\n", field_size);
2258
    skip_bits(&hgb, 32); /* padded field size */
2259
    second_field_offs = get_bits_long(&hgb, 32);
2260
    av_log(avctx, AV_LOG_DEBUG, "second field offs: 0x%x\n", second_field_offs);
2261
    if (second_field_offs)
2262
        s->interlaced = 1;
2263

    
2264
    dqt_offs = get_bits_long(&hgb, 32);
2265
    av_log(avctx, AV_LOG_DEBUG, "dqt offs: 0x%x\n", dqt_offs);
2266
    if (dqt_offs)
2267
    {
2268
        init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
2269
        s->start_code = DQT;
2270
        mjpeg_decode_dqt(s);
2271
    }
2272

    
2273
    dht_offs = get_bits_long(&hgb, 32);
2274
    av_log(avctx, AV_LOG_DEBUG, "dht offs: 0x%x\n", dht_offs);
2275
    if (dht_offs)
2276
    {
2277
        init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
2278
        s->start_code = DHT;
2279
        mjpeg_decode_dht(s);
2280
    }
2281

    
2282
    sof_offs = get_bits_long(&hgb, 32);
2283
    av_log(avctx, AV_LOG_DEBUG, "sof offs: 0x%x\n", sof_offs);
2284
    if (sof_offs)
2285
    {
2286
        init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
2287
        s->start_code = SOF0;
2288
        if (mjpeg_decode_sof(s) < 0)
2289
            return -1;
2290
    }
2291

    
2292
    sos_offs = get_bits_long(&hgb, 32);
2293
    av_log(avctx, AV_LOG_DEBUG, "sos offs: 0x%x\n", sos_offs);
2294
    sod_offs = get_bits_long(&hgb, 32);
2295
    av_log(avctx, AV_LOG_DEBUG, "sod offs: 0x%x\n", sod_offs);
2296
    if (sos_offs)
2297
    {
2298
//        init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2299
        init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2300
        s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
2301
        s->start_code = SOS;
2302
        mjpeg_decode_sos(s);
2303
    }
2304

    
2305
    if (s->interlaced) {
2306
        s->bottom_field ^= 1;
2307
        /* if not bottom field, do not output image yet */
2308
        if (s->bottom_field && second_field_offs)
2309
        {
2310
            buf_ptr = buf + second_field_offs;
2311
            second_field_offs = 0;
2312
            goto read_header;
2313
            }
2314
    }
2315

    
2316
    //XXX FIXME factorize, this looks very similar to the EOI code
2317

    
2318
    *picture= s->picture;
2319
    *data_size = sizeof(AVFrame);
2320

    
2321
    if(!s->lossless){
2322
        picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2323
        picture->qstride= 0;
2324
        picture->qscale_table= s->qscale_table;
2325
        memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2326
        if(avctx->debug & FF_DEBUG_QP)
2327
            av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2328
        picture->quality*= FF_QP2LAMBDA;
2329
    }
2330

    
2331
    return buf_ptr - buf;
2332
}
2333

    
2334
#include "sp5x.h"
2335

    
2336
static int sp5x_decode_frame(AVCodecContext *avctx,
2337
                              void *data, int *data_size,
2338
                              uint8_t *buf, int buf_size)
2339
{
2340
#if 0
2341
    MJpegDecodeContext *s = avctx->priv_data;
2342
#endif
2343
    const int qscale = 5;
2344
    uint8_t *buf_ptr, *buf_end, *recoded;
2345
    int i = 0, j = 0;
2346

    
2347
    if (!avctx->width || !avctx->height)
2348
        return -1;
2349

    
2350
    buf_ptr = buf;
2351
    buf_end = buf + buf_size;
2352

    
2353
#if 1
2354
    recoded = av_mallocz(buf_size + 1024);
2355
    if (!recoded)
2356
        return -1;
2357

    
2358
    /* SOI */
2359
    recoded[j++] = 0xFF;
2360
    recoded[j++] = 0xD8;
2361

    
2362
    memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2363
    memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2364
    memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2365
    j += sizeof(sp5x_data_dqt);
2366

    
2367
    memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2368
    j += sizeof(sp5x_data_dht);
2369

    
2370
    memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2371
    recoded[j+5] = (avctx->coded_height >> 8) & 0xFF;
2372
    recoded[j+6] = avctx->coded_height & 0xFF;
2373
    recoded[j+7] = (avctx->coded_width >> 8) & 0xFF;
2374
    recoded[j+8] = avctx->coded_width & 0xFF;
2375
    j += sizeof(sp5x_data_sof);
2376

    
2377
    memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2378
    j += sizeof(sp5x_data_sos);
2379

    
2380
    for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2381
    {
2382
        recoded[j++] = buf[i];
2383
        if (buf[i] == 0xff)
2384
            recoded[j++] = 0;
2385
    }
2386

    
2387
    /* EOI */
2388
    recoded[j++] = 0xFF;
2389
    recoded[j++] = 0xD9;
2390

    
2391
    i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2392

    
2393
    av_free(recoded);
2394

    
2395
#else
2396
    /* SOF */
2397
    s->bits = 8;
2398
    s->width  = avctx->coded_width;
2399
    s->height = avctx->coded_height;
2400
    s->nb_components = 3;
2401
    s->component_id[0] = 0;
2402
    s->h_count[0] = 2;
2403
    s->v_count[0] = 2;
2404
    s->quant_index[0] = 0;
2405
    s->component_id[1] = 1;
2406
    s->h_count[1] = 1;
2407
    s->v_count[1] = 1;
2408
    s->quant_index[1] = 1;
2409
    s->component_id[2] = 2;
2410
    s->h_count[2] = 1;
2411
    s->v_count[2] = 1;
2412
    s->quant_index[2] = 1;
2413
    s->h_max = 2;
2414
    s->v_max = 2;
2415

    
2416
    s->qscale_table = av_mallocz((s->width+15)/16);
2417
    avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420;
2418
    s->interlaced = 0;
2419

    
2420
    s->picture.reference = 0;
2421
    if (avctx->get_buffer(avctx, &s->picture) < 0)
2422
    {
2423
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2424
        return -1;
2425
    }
2426

    
2427
    s->picture.pict_type = I_TYPE;
2428
    s->picture.key_frame = 1;
2429

    
2430
    for (i = 0; i < 3; i++)
2431
        s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2432

    
2433
    /* DQT */
2434
    for (i = 0; i < 64; i++)
2435
    {
2436
        j = s->scantable.permutated[i];
2437
        s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2438
    }
2439
    s->qscale[0] = FFMAX(
2440
        s->quant_matrixes[0][s->scantable.permutated[1]],
2441
        s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2442

    
2443
    for (i = 0; i < 64; i++)
2444
    {
2445
        j = s->scantable.permutated[i];
2446
        s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2447
    }
2448
    s->qscale[1] = FFMAX(
2449
        s->quant_matrixes[1][s->scantable.permutated[1]],
2450
        s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2451

    
2452
    /* DHT */
2453

    
2454
    /* SOS */
2455
    s->comp_index[0] = 0;
2456
    s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2457
    s->h_scount[0] = s->h_count[0];
2458
    s->v_scount[0] = s->v_count[0];
2459
    s->dc_index[0] = 0;
2460
    s->ac_index[0] = 0;
2461

    
2462
    s->comp_index[1] = 1;
2463
    s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2464
    s->h_scount[1] = s->h_count[1];
2465
    s->v_scount[1] = s->v_count[1];
2466
    s->dc_index[1] = 1;
2467
    s->ac_index[1] = 1;
2468

    
2469
    s->comp_index[2] = 2;
2470
    s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2471
    s->h_scount[2] = s->h_count[2];
2472
    s->v_scount[2] = s->v_count[2];
2473
    s->dc_index[2] = 1;
2474
    s->ac_index[2] = 1;
2475

    
2476
    for (i = 0; i < 3; i++)
2477
        s->last_dc[i] = 1024;
2478

    
2479
    s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2480
    s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2481

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

    
2484
    return mjpeg_decode_scan(s);
2485
#endif
2486

    
2487
    return i;
2488
}
2489

    
2490
static int mjpeg_decode_end(AVCodecContext *avctx)
2491
{
2492
    MJpegDecodeContext *s = avctx->priv_data;
2493
    int i, j;
2494

    
2495
    av_free(s->buffer);
2496
    av_free(s->qscale_table);
2497

    
2498
    for(i=0;i<2;i++) {
2499
        for(j=0;j<4;j++)
2500
            free_vlc(&s->vlcs[i][j]);
2501
    }
2502
    return 0;
2503
}
2504

    
2505
static int mjpega_dump_header(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args,
2506
                              uint8_t **poutbuf, int *poutbuf_size,
2507
                              const uint8_t *buf, int buf_size, int keyframe)
2508
{
2509
    uint8_t *poutbufp;
2510
    int i;
2511

    
2512
    if (avctx->codec_id != CODEC_ID_MJPEG) {
2513
        av_log(avctx, AV_LOG_ERROR, "mjpega bitstream filter only applies to mjpeg codec\n");
2514
        return 0;
2515
    }
2516

    
2517
    *poutbuf_size = 0;
2518
    *poutbuf = av_malloc(buf_size + 44 + FF_INPUT_BUFFER_PADDING_SIZE);
2519
    poutbufp = *poutbuf;
2520
    bytestream_put_byte(&poutbufp, 0xff);
2521
    bytestream_put_byte(&poutbufp, SOI);
2522
    bytestream_put_byte(&poutbufp, 0xff);
2523
    bytestream_put_byte(&poutbufp, APP1);
2524
    bytestream_put_be16(&poutbufp, 42); /* size */
2525
    bytestream_put_be32(&poutbufp, 0);
2526
    bytestream_put_buffer(&poutbufp, "mjpg", 4);
2527
    bytestream_put_be32(&poutbufp, buf_size + 44); /* field size */
2528
    bytestream_put_be32(&poutbufp, buf_size + 44); /* pad field size */
2529
    bytestream_put_be32(&poutbufp, 0);             /* next ptr */
2530

    
2531
    for (i = 0; i < buf_size - 1; i++) {
2532
        if (buf[i] == 0xff) {
2533
            switch (buf[i + 1]) {
2534
            case DQT:  /* quant off */
2535
            case DHT:  /* huff  off */
2536
            case SOF0: /* image off */
2537
                bytestream_put_be32(&poutbufp, i + 46);
2538
                break;
2539
            case SOS:
2540
                bytestream_put_be32(&poutbufp, i + 46); /* scan off */
2541
                bytestream_put_be32(&poutbufp, i + 46 + AV_RB16(buf + i + 2)); /* data off */
2542
                bytestream_put_buffer(&poutbufp, buf + 2, buf_size - 2); /* skip already written SOI */
2543
                *poutbuf_size = poutbufp - *poutbuf;
2544
                return 1;
2545
            case APP1:
2546
                if (i + 8 < buf_size && AV_RL32(buf + i + 8) == ff_get_fourcc("mjpg")) {
2547
                    av_log(avctx, AV_LOG_ERROR, "bitstream already formatted\n");
2548
                    memcpy(*poutbuf, buf, buf_size);
2549
                    *poutbuf_size = buf_size;
2550
                    return 1;
2551
                }
2552
            }
2553
        }
2554
    }
2555
    av_freep(poutbuf);
2556
    av_log(avctx, AV_LOG_ERROR, "could not find SOS marker in bitstream\n");
2557
    return 0;
2558
}
2559

    
2560
AVCodec mjpeg_decoder = {
2561
    "mjpeg",
2562
    CODEC_TYPE_VIDEO,
2563
    CODEC_ID_MJPEG,
2564
    sizeof(MJpegDecodeContext),
2565
    mjpeg_decode_init,
2566
    NULL,
2567
    mjpeg_decode_end,
2568
    mjpeg_decode_frame,
2569
    CODEC_CAP_DR1,
2570
    NULL
2571
};
2572

    
2573
AVCodec thp_decoder = {
2574
    "thp",
2575
    CODEC_TYPE_VIDEO,
2576
    CODEC_ID_THP,
2577
    sizeof(MJpegDecodeContext),
2578
    mjpeg_decode_init,
2579
    NULL,
2580
    mjpeg_decode_end,
2581
    mjpeg_decode_frame,
2582
    CODEC_CAP_DR1,
2583
    NULL
2584
};
2585

    
2586
AVCodec mjpegb_decoder = {
2587
    "mjpegb",
2588
    CODEC_TYPE_VIDEO,
2589
    CODEC_ID_MJPEGB,
2590
    sizeof(MJpegDecodeContext),
2591
    mjpeg_decode_init,
2592
    NULL,
2593
    mjpeg_decode_end,
2594
    mjpegb_decode_frame,
2595
    CODEC_CAP_DR1,
2596
    NULL
2597
};
2598

    
2599
AVCodec sp5x_decoder = {
2600
    "sp5x",
2601
    CODEC_TYPE_VIDEO,
2602
    CODEC_ID_SP5X,
2603
    sizeof(MJpegDecodeContext),
2604
    mjpeg_decode_init,
2605
    NULL,
2606
    mjpeg_decode_end,
2607
    sp5x_decode_frame,
2608
    CODEC_CAP_DR1,
2609
    NULL
2610
};
2611

    
2612
#ifdef CONFIG_ENCODERS
2613
AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2614
    "ljpeg",
2615
    CODEC_TYPE_VIDEO,
2616
    CODEC_ID_LJPEG,
2617
    sizeof(MpegEncContext),
2618
    MPV_encode_init,
2619
    encode_picture_lossless,
2620
    MPV_encode_end,
2621
};
2622
#endif
2623

    
2624
AVCodecParser mjpeg_parser = {
2625
    { CODEC_ID_MJPEG },
2626
    sizeof(ParseContext),
2627
    NULL,
2628
    jpeg_parse,
2629
    ff_parse_close,
2630
};
2631

    
2632
AVBitStreamFilter mjpega_dump_header_bsf = {
2633
    "mjpegadump",
2634
    0,
2635
    mjpega_dump_header,
2636
};