Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mjpeg.c @ c53d2d90

History | View | Annotate | Download (83.4 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
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
                           const 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, &buf, &buf_size) < 0) {
1017
        *poutbuf = NULL;
1018
        *poutbuf_size = 0;
1019
        return buf_size;
1020
    }
1021

    
1022
    *poutbuf = 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
    //HACK for odd_height.mov
1129
    if(s->interlaced && s->width == width && s->height == height + 1)
1130
        height= s->height;
1131

    
1132
    av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
1133
    if(avcodec_check_dimensions(s->avctx, width, height))
1134
        return -1;
1135

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

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

    
1169
    if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1170

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

    
1176
        s->width = width;
1177
        s->height = height;
1178
        s->interlaced = 0;
1179

    
1180
        /* test interlaced mode */
1181
        if (s->first_picture &&
1182
            s->org_height != 0 &&
1183
            s->height < ((s->org_height * 3) / 4)) {
1184
            s->interlaced = 1;
1185
            s->bottom_field = s->interlace_polarity;
1186
            s->picture.interlaced_frame = 1;
1187
            s->picture.top_field_first = !s->interlace_polarity;
1188
            height *= 2;
1189
        }
1190

    
1191
        avcodec_set_dimensions(s->avctx, width, height);
1192

    
1193
        s->qscale_table= av_mallocz((s->width+15)/16);
1194

    
1195
        s->first_picture = 0;
1196
    }
1197

    
1198
    if(s->interlaced && (s->bottom_field == !s->interlace_polarity))
1199
        return 0;
1200

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

    
1234
    if(s->picture.data[0])
1235
        s->avctx->release_buffer(s->avctx, &s->picture);
1236

    
1237
    s->picture.reference= 0;
1238
    if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1239
        av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1240
        return -1;
1241
    }
1242
    s->picture.pict_type= I_TYPE;
1243
    s->picture.key_frame= 1;
1244

    
1245
    for(i=0; i<3; i++){
1246
        s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1247
    }
1248

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

    
1251
    if (len != (8+(3*nb_components)))
1252
    {
1253
        av_log(s->avctx, AV_LOG_DEBUG, "decode_sof0: error, len(%d) mismatch\n", len);
1254
    }
1255

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

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

    
1276
    if(code)
1277
        return get_xbits(&s->gb, code);
1278
    else
1279
        return 0;
1280
}
1281

    
1282
/* decode block and dequantize */
1283
static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1284
                        int component, int dc_index, int ac_index, int16_t *quant_matrix)
1285
{
1286
    int code, i, j, level, val;
1287

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

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

    
1319
            LAST_SKIP_BITS(re, &s->gb, code)
1320

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

    
1336
    return 0;
1337
}
1338

    
1339
/* decode block and dequantize - progressive JPEG version */
1340
static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block,
1341
                        int component, int dc_index, int ac_index, int16_t *quant_matrix,
1342
                        int ss, int se, int Ah, int Al, int *EOBRUN)
1343
{
1344
    int code, i, j, level, val, run;
1345

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

    
1382
            LAST_SKIP_BITS(re, &s->gb, code)
1383

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

    
1413
    return 0;
1414
}
1415

    
1416
static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1417
    int i, mb_x, mb_y;
1418
    uint16_t buffer[32768][4];
1419
    int left[3], top[3], topleft[3];
1420
    const int linesize= s->linesize[0];
1421
    const int mask= (1<<s->bits)-1;
1422

    
1423
    if((unsigned)s->mb_width > 32768) //dynamic alloc
1424
        return -1;
1425

    
1426
    for(i=0; i<3; i++){
1427
        buffer[0][i]= 1 << (s->bits + point_transform - 1);
1428
    }
1429
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1430
        const int modified_predictor= mb_y ? predictor : 1;
1431
        uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1432

    
1433
        if (s->interlaced && s->bottom_field)
1434
            ptr += linesize >> 1;
1435

    
1436
        for(i=0; i<3; i++){
1437
            top[i]= left[i]= topleft[i]= buffer[0][i];
1438
        }
1439
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1440
            if (s->restart_interval && !s->restart_count)
1441
                s->restart_count = s->restart_interval;
1442

    
1443
            for(i=0;i<3;i++) {
1444
                int pred;
1445

    
1446
                topleft[i]= top[i];
1447
                top[i]= buffer[mb_x][i];
1448

    
1449
                PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1450

    
1451
                left[i]=
1452
                buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1453
            }
1454

    
1455
            if (s->restart_interval && !--s->restart_count) {
1456
                align_get_bits(&s->gb);
1457
                skip_bits(&s->gb, 16); /* skip RSTn */
1458
            }
1459
        }
1460

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

    
1484
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1485
    int i, mb_x, mb_y;
1486
    const int nb_components=3;
1487

    
1488
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1489
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1490
            if (s->restart_interval && !s->restart_count)
1491
                s->restart_count = s->restart_interval;
1492

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

    
1505
                    for(j=0; j<n; j++) {
1506
                        int pred;
1507

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

    
1523
                        if (s->interlaced && s->bottom_field)
1524
                            ptr += linesize >> 1;
1525
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1526

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

    
1545
                    for(j=0; j<n; j++) {
1546
                        int pred;
1547

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

    
1567
static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int ss, int se, int Ah, int Al){
1568
    int i, mb_x, mb_y;
1569
    int EOBRUN = 0;
1570

    
1571
    if(Ah) return 0; /* TODO decode refinement planes too */
1572
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1573
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1574
            if (s->restart_interval && !s->restart_count)
1575
                s->restart_count = s->restart_interval;
1576

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

    
1630
static int mjpeg_decode_sos(MJpegDecodeContext *s)
1631
{
1632
    int len, nb_components, i, h, v, predictor, point_transform;
1633
    int vmax, hmax, index, id;
1634
    const int block_size= s->lossless ? 1 : 8;
1635
    int ilv, prev_shift;
1636

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

    
1660
        s->comp_index[i] = index;
1661

    
1662
        s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1663
        s->h_scount[i] = s->h_count[index];
1664
        s->v_scount[i] = s->v_count[index];
1665

    
1666
        s->dc_index[i] = get_bits(&s->gb, 4);
1667
        s->ac_index[i] = get_bits(&s->gb, 4);
1668

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

    
1692
    predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1693
    ilv= get_bits(&s->gb, 8);    /* JPEG Se / JPEG-LS ILV */
1694
    prev_shift = get_bits(&s->gb, 4); /* Ah */
1695
    point_transform= get_bits(&s->gb, 4); /* Al */
1696

    
1697
    for(i=0;i<nb_components;i++)
1698
        s->last_dc[i] = 1024;
1699

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

    
1714
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1715
        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" : "",
1716
               predictor, point_transform, ilv, s->bits,
1717
               s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));
1718

    
1719

    
1720
    /* mjpeg-b can have padding bytes between sos and image data, skip them */
1721
    for (i = s->mjpb_skiptosod; i > 0; i--)
1722
        skip_bits(&s->gb, 8);
1723

    
1724
    if(s->lossless){
1725
        if(s->ls){
1726
//            for(){
1727
//            reset_ls_coding_parameters(s, 0);
1728

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

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

    
1758
    return 0;
1759
}
1760

    
1761
static int mjpeg_decode_app(MJpegDecodeContext *s)
1762
{
1763
    int len, id, i;
1764

    
1765
    len = get_bits(&s->gb, 16);
1766
    if (len < 5)
1767
        return -1;
1768
    if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits)
1769
        return -1;
1770

    
1771
    id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1772
    id = be2me_32(id);
1773
    len -= 6;
1774

    
1775
    if(s->avctx->debug & FF_DEBUG_STARTCODE){
1776
        av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
1777
    }
1778

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

    
1808
//    len -= 2;
1809

    
1810
    if (id == ff_get_fourcc("JFIF"))
1811
    {
1812
        int t_w, t_h, v1, v2;
1813
        skip_bits(&s->gb, 8); /* the trailing zero-byte */
1814
        v1= get_bits(&s->gb, 8);
1815
        v2= get_bits(&s->gb, 8);
1816
        skip_bits(&s->gb, 8);
1817

    
1818
        s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1819
        s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1820

    
1821
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1822
            av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1823
                v1, v2,
1824
                s->avctx->sample_aspect_ratio.num,
1825
                s->avctx->sample_aspect_ratio.den
1826
            );
1827

    
1828
        t_w = get_bits(&s->gb, 8);
1829
        t_h = get_bits(&s->gb, 8);
1830
        if (t_w && t_h)
1831
        {
1832
            /* skip thumbnail */
1833
            if (len-10-(t_w*t_h*3) > 0)
1834
                len -= t_w*t_h*3;
1835
        }
1836
        len -= 10;
1837
        goto out;
1838
    }
1839

    
1840
    if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1841
    {
1842
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1843
            av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1844
        skip_bits(&s->gb, 16); /* version */
1845
        skip_bits(&s->gb, 16); /* flags0 */
1846
        skip_bits(&s->gb, 16); /* flags1 */
1847
        skip_bits(&s->gb, 8);  /* transform */
1848
        len -= 7;
1849
        goto out;
1850
    }
1851

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

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

    
1898
out:
1899
    /* slow but needed for extreme adobe jpegs */
1900
    if (len < 0)
1901
        av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1902
    while(--len > 0)
1903
        skip_bits(&s->gb, 8);
1904

    
1905
    return 0;
1906
}
1907

    
1908
static int mjpeg_decode_com(MJpegDecodeContext *s)
1909
{
1910
    int len = get_bits(&s->gb, 16);
1911
    if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) {
1912
        char *cbuf = av_malloc(len - 1);
1913
        if (cbuf) {
1914
            int i;
1915
            for (i = 0; i < len - 2; i++)
1916
                cbuf[i] = get_bits(&s->gb, 8);
1917
            if (i > 0 && cbuf[i-1] == '\n')
1918
                cbuf[i-1] = 0;
1919
            else
1920
                cbuf[i] = 0;
1921

    
1922
            if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1923
                av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1924

    
1925
            /* buggy avid, it puts EOI only at every 10th frame */
1926
            if (!strcmp(cbuf, "AVID"))
1927
            {
1928
                s->buggy_avid = 1;
1929
                //        if (s->first_picture)
1930
                //            printf("mjpeg: workarounding buggy AVID\n");
1931
            }
1932
            else if(!strcmp(cbuf, "CS=ITU601")){
1933
                s->cs_itu601= 1;
1934
            }
1935

    
1936
            av_free(cbuf);
1937
        }
1938
    }
1939

    
1940
    return 0;
1941
}
1942

    
1943
#if 0
1944
static int valid_marker_list[] =
1945
{
1946
        /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1947
/* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1948
/* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1949
/* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1950
/* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1951
/* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1952
/* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1953
/* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1954
/* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1955
/* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1956
/* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1957
/* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1958
/* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1959
/* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1960
/* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1961
/* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1962
/* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1963
}
1964
#endif
1965

    
1966
/* return the 8 bit start code value and update the search
1967
   state. Return -1 if no start code found */
1968
static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1969
{
1970
    uint8_t *buf_ptr;
1971
    unsigned int v, v2;
1972
    int val;
1973
#ifdef DEBUG
1974
    int skipped=0;
1975
#endif
1976

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

    
1998
static int mjpeg_decode_frame(AVCodecContext *avctx,
1999
                              void *data, int *data_size,
2000
                              uint8_t *buf, int buf_size)
2001
{
2002
    MJpegDecodeContext *s = avctx->priv_data;
2003
    uint8_t *buf_end, *buf_ptr;
2004
    int start_code;
2005
    AVFrame *picture = data;
2006

    
2007
    buf_ptr = buf;
2008
    buf_end = buf + buf_size;
2009
    while (buf_ptr < buf_end) {
2010
        /* find start next marker */
2011
        start_code = find_marker(&buf_ptr, buf_end);
2012
        {
2013
            /* EOF */
2014
            if (start_code < 0) {
2015
                goto the_end;
2016
            } else {
2017
                av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
2018

    
2019
                if ((buf_end - buf_ptr) > s->buffer_size)
2020
                {
2021
                    av_free(s->buffer);
2022
                    s->buffer_size = buf_end-buf_ptr;
2023
                    s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
2024
                    av_log(avctx, AV_LOG_DEBUG, "buffer too small, expanding to %d bytes\n",
2025
                        s->buffer_size);
2026
                }
2027

    
2028
                /* unescape buffer of SOS, use special treatment for JPEG-LS */
2029
                if (start_code == SOS && !s->ls)
2030
                {
2031
                    uint8_t *src = buf_ptr;
2032
                    uint8_t *dst = s->buffer;
2033

    
2034
                    while (src<buf_end)
2035
                    {
2036
                        uint8_t x = *(src++);
2037

    
2038
                        *(dst++) = x;
2039
                        if (avctx->codec_id != CODEC_ID_THP)
2040
                        {
2041
                            if (x == 0xff) {
2042
                                while (src < buf_end && x == 0xff)
2043
                                    x = *(src++);
2044

    
2045
                                if (x >= 0xd0 && x <= 0xd7)
2046
                                    *(dst++) = x;
2047
                                else if (x)
2048
                                    break;
2049
                            }
2050
                        }
2051
                    }
2052
                    init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
2053

    
2054
                    av_log(avctx, AV_LOG_DEBUG, "escaping removed %d bytes\n",
2055
                           (buf_end - buf_ptr) - (dst - s->buffer));
2056
                }
2057
                else if(start_code == SOS && s->ls){
2058
                    uint8_t *src = buf_ptr;
2059
                    uint8_t *dst = s->buffer;
2060
                    int bit_count = 0;
2061
                    int t = 0, b = 0;
2062
                    PutBitContext pb;
2063

    
2064
                    s->cur_scan++;
2065

    
2066
                    /* find marker */
2067
                    while (src + t < buf_end){
2068
                        uint8_t x = src[t++];
2069
                        if (x == 0xff){
2070
                            while((src + t < buf_end) && x == 0xff)
2071
                                x = src[t++];
2072
                            if (x & 0x80) {
2073
                                t -= 2;
2074
                                break;
2075
                            }
2076
                        }
2077
                    }
2078
                    bit_count = t * 8;
2079

    
2080
                    init_put_bits(&pb, dst, t);
2081

    
2082
                    /* unescape bitstream */
2083
                    while(b < t){
2084
                        uint8_t x = src[b++];
2085
                        put_bits(&pb, 8, x);
2086
                        if(x == 0xFF){
2087
                            x = src[b++];
2088
                            put_bits(&pb, 7, x);
2089
                            bit_count--;
2090
                        }
2091
                    }
2092
                    flush_put_bits(&pb);
2093

    
2094
                    init_get_bits(&s->gb, dst, bit_count);
2095
                }
2096
                else
2097
                    init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
2098

    
2099
                s->start_code = start_code;
2100
                if(s->avctx->debug & FF_DEBUG_STARTCODE){
2101
                    av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2102
                }
2103

    
2104
                /* process markers */
2105
                if (start_code >= 0xd0 && start_code <= 0xd7) {
2106
                    av_log(avctx, AV_LOG_DEBUG, "restart marker: %d\n", start_code&0x0f);
2107
                    /* APP fields */
2108
                } else if (start_code >= APP0 && start_code <= APP15) {
2109
                    mjpeg_decode_app(s);
2110
                    /* Comment */
2111
                } else if (start_code == COM){
2112
                    mjpeg_decode_com(s);
2113
                }
2114

    
2115
                switch(start_code) {
2116
                case SOI:
2117
                    s->restart_interval = 0;
2118

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

    
2178
                        if(!s->lossless){
2179
                            picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2180
                            picture->qstride= 0;
2181
                            picture->qscale_table= s->qscale_table;
2182
                            memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2183
                            if(avctx->debug & FF_DEBUG_QP)
2184
                                av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2185
                            picture->quality*= FF_QP2LAMBDA;
2186
                        }
2187

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

    
2219
not_the_end:
2220
                /* eof process start code */
2221
                buf_ptr += (get_bits_count(&s->gb)+7)/8;
2222
                av_log(avctx, AV_LOG_DEBUG, "marker parser used %d bytes (%d bits)\n",
2223
                       (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
2224
            }
2225
        }
2226
    }
2227
the_end:
2228
    av_log(avctx, AV_LOG_DEBUG, "mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
2229
//    return buf_end - buf_ptr;
2230
    return buf_ptr - buf;
2231
}
2232

    
2233
static int mjpegb_decode_frame(AVCodecContext *avctx,
2234
                              void *data, int *data_size,
2235
                              uint8_t *buf, int buf_size)
2236
{
2237
    MJpegDecodeContext *s = avctx->priv_data;
2238
    uint8_t *buf_end, *buf_ptr;
2239
    AVFrame *picture = data;
2240
    GetBitContext hgb; /* for the header */
2241
    uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
2242
    uint32_t field_size, sod_offs;
2243

    
2244
    buf_ptr = buf;
2245
    buf_end = buf + buf_size;
2246

    
2247
read_header:
2248
    /* reset on every SOI */
2249
    s->restart_interval = 0;
2250
    s->restart_count = 0;
2251
    s->mjpb_skiptosod = 0;
2252

    
2253
    init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
2254

    
2255
    skip_bits(&hgb, 32); /* reserved zeros */
2256

    
2257
    if (get_bits_long(&hgb, 32) != MKBETAG('m','j','p','g'))
2258
    {
2259
        av_log(avctx, AV_LOG_WARNING, "not mjpeg-b (bad fourcc)\n");
2260
        return 0;
2261
    }
2262

    
2263
    field_size = get_bits_long(&hgb, 32); /* field size */
2264
    av_log(avctx, AV_LOG_DEBUG, "field size: 0x%x\n", field_size);
2265
    skip_bits(&hgb, 32); /* padded field size */
2266
    second_field_offs = get_bits_long(&hgb, 32);
2267
    av_log(avctx, AV_LOG_DEBUG, "second field offs: 0x%x\n", second_field_offs);
2268

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

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

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

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

    
2310
    if (s->interlaced) {
2311
        s->bottom_field ^= 1;
2312
        /* if not bottom field, do not output image yet */
2313
        if (s->bottom_field && second_field_offs)
2314
        {
2315
            buf_ptr = buf + second_field_offs;
2316
            second_field_offs = 0;
2317
            goto read_header;
2318
            }
2319
    }
2320

    
2321
    //XXX FIXME factorize, this looks very similar to the EOI code
2322

    
2323
    *picture= s->picture;
2324
    *data_size = sizeof(AVFrame);
2325

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

    
2336
    return buf_ptr - buf;
2337
}
2338

    
2339
#include "sp5x.h"
2340

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

    
2352
    if (!avctx->width || !avctx->height)
2353
        return -1;
2354

    
2355
    buf_ptr = buf;
2356
    buf_end = buf + buf_size;
2357

    
2358
#if 1
2359
    recoded = av_mallocz(buf_size + 1024);
2360
    if (!recoded)
2361
        return -1;
2362

    
2363
    /* SOI */
2364
    recoded[j++] = 0xFF;
2365
    recoded[j++] = 0xD8;
2366

    
2367
    memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2368
    memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2369
    memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2370
    j += sizeof(sp5x_data_dqt);
2371

    
2372
    memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2373
    j += sizeof(sp5x_data_dht);
2374

    
2375
    memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2376
    recoded[j+5] = (avctx->coded_height >> 8) & 0xFF;
2377
    recoded[j+6] = avctx->coded_height & 0xFF;
2378
    recoded[j+7] = (avctx->coded_width >> 8) & 0xFF;
2379
    recoded[j+8] = avctx->coded_width & 0xFF;
2380
    j += sizeof(sp5x_data_sof);
2381

    
2382
    memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2383
    j += sizeof(sp5x_data_sos);
2384

    
2385
    for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2386
    {
2387
        recoded[j++] = buf[i];
2388
        if (buf[i] == 0xff)
2389
            recoded[j++] = 0;
2390
    }
2391

    
2392
    /* EOI */
2393
    recoded[j++] = 0xFF;
2394
    recoded[j++] = 0xD9;
2395

    
2396
    i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2397

    
2398
    av_free(recoded);
2399

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

    
2421
    s->qscale_table = av_mallocz((s->width+15)/16);
2422
    avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420;
2423
    s->interlaced = 0;
2424

    
2425
    s->picture.reference = 0;
2426
    if (avctx->get_buffer(avctx, &s->picture) < 0)
2427
    {
2428
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2429
        return -1;
2430
    }
2431

    
2432
    s->picture.pict_type = I_TYPE;
2433
    s->picture.key_frame = 1;
2434

    
2435
    for (i = 0; i < 3; i++)
2436
        s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2437

    
2438
    /* DQT */
2439
    for (i = 0; i < 64; i++)
2440
    {
2441
        j = s->scantable.permutated[i];
2442
        s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2443
    }
2444
    s->qscale[0] = FFMAX(
2445
        s->quant_matrixes[0][s->scantable.permutated[1]],
2446
        s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2447

    
2448
    for (i = 0; i < 64; i++)
2449
    {
2450
        j = s->scantable.permutated[i];
2451
        s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2452
    }
2453
    s->qscale[1] = FFMAX(
2454
        s->quant_matrixes[1][s->scantable.permutated[1]],
2455
        s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2456

    
2457
    /* DHT */
2458

    
2459
    /* SOS */
2460
    s->comp_index[0] = 0;
2461
    s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2462
    s->h_scount[0] = s->h_count[0];
2463
    s->v_scount[0] = s->v_count[0];
2464
    s->dc_index[0] = 0;
2465
    s->ac_index[0] = 0;
2466

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

    
2474
    s->comp_index[2] = 2;
2475
    s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2476
    s->h_scount[2] = s->h_count[2];
2477
    s->v_scount[2] = s->v_count[2];
2478
    s->dc_index[2] = 1;
2479
    s->ac_index[2] = 1;
2480

    
2481
    for (i = 0; i < 3; i++)
2482
        s->last_dc[i] = 1024;
2483

    
2484
    s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2485
    s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2486

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

    
2489
    return mjpeg_decode_scan(s);
2490
#endif
2491

    
2492
    return i;
2493
}
2494

    
2495
static int mjpeg_decode_end(AVCodecContext *avctx)
2496
{
2497
    MJpegDecodeContext *s = avctx->priv_data;
2498
    int i, j;
2499

    
2500
    av_free(s->buffer);
2501
    av_free(s->qscale_table);
2502

    
2503
    for(i=0;i<2;i++) {
2504
        for(j=0;j<4;j++)
2505
            free_vlc(&s->vlcs[i][j]);
2506
    }
2507
    return 0;
2508
}
2509

    
2510
static int mjpega_dump_header(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args,
2511
                              uint8_t **poutbuf, int *poutbuf_size,
2512
                              const uint8_t *buf, int buf_size, int keyframe)
2513
{
2514
    uint8_t *poutbufp;
2515
    int i;
2516

    
2517
    if (avctx->codec_id != CODEC_ID_MJPEG) {
2518
        av_log(avctx, AV_LOG_ERROR, "mjpega bitstream filter only applies to mjpeg codec\n");
2519
        return 0;
2520
    }
2521

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

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

    
2565
AVCodec mjpeg_decoder = {
2566
    "mjpeg",
2567
    CODEC_TYPE_VIDEO,
2568
    CODEC_ID_MJPEG,
2569
    sizeof(MJpegDecodeContext),
2570
    mjpeg_decode_init,
2571
    NULL,
2572
    mjpeg_decode_end,
2573
    mjpeg_decode_frame,
2574
    CODEC_CAP_DR1,
2575
    NULL
2576
};
2577

    
2578
AVCodec thp_decoder = {
2579
    "thp",
2580
    CODEC_TYPE_VIDEO,
2581
    CODEC_ID_THP,
2582
    sizeof(MJpegDecodeContext),
2583
    mjpeg_decode_init,
2584
    NULL,
2585
    mjpeg_decode_end,
2586
    mjpeg_decode_frame,
2587
    CODEC_CAP_DR1,
2588
    NULL
2589
};
2590

    
2591
AVCodec mjpegb_decoder = {
2592
    "mjpegb",
2593
    CODEC_TYPE_VIDEO,
2594
    CODEC_ID_MJPEGB,
2595
    sizeof(MJpegDecodeContext),
2596
    mjpeg_decode_init,
2597
    NULL,
2598
    mjpeg_decode_end,
2599
    mjpegb_decode_frame,
2600
    CODEC_CAP_DR1,
2601
    NULL
2602
};
2603

    
2604
AVCodec sp5x_decoder = {
2605
    "sp5x",
2606
    CODEC_TYPE_VIDEO,
2607
    CODEC_ID_SP5X,
2608
    sizeof(MJpegDecodeContext),
2609
    mjpeg_decode_init,
2610
    NULL,
2611
    mjpeg_decode_end,
2612
    sp5x_decode_frame,
2613
    CODEC_CAP_DR1,
2614
    NULL
2615
};
2616

    
2617
#ifdef CONFIG_ENCODERS
2618
AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2619
    "ljpeg",
2620
    CODEC_TYPE_VIDEO,
2621
    CODEC_ID_LJPEG,
2622
    sizeof(MpegEncContext),
2623
    MPV_encode_init,
2624
    encode_picture_lossless,
2625
    MPV_encode_end,
2626
};
2627
#endif
2628

    
2629
#ifdef CONFIG_MJPEG_PARSER
2630
AVCodecParser mjpeg_parser = {
2631
    { CODEC_ID_MJPEG },
2632
    sizeof(ParseContext),
2633
    NULL,
2634
    jpeg_parse,
2635
    ff_parse_close,
2636
};
2637
#endif
2638

    
2639
AVBitStreamFilter mjpega_dump_header_bsf = {
2640
    "mjpegadump",
2641
    0,
2642
    mjpega_dump_header,
2643
};