Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mjpeg.c @ 391fcef9

History | View | Annotate | Download (83 KB)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
329
    return n + 17;
330
}
331

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
548
    if(ff_count==0) return;
549

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

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

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

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

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

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

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

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

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

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

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

    
602
        nbits= av_log2_16bit(val) + 1;
603

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

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

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

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

    
633
    /* AC coefs */
634

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

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

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

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

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

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

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

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

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

    
699
    mjpeg_picture_header(s);
700

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
822
    emms_c();
823

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

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

    
832
#endif //CONFIG_ENCODERS
833

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

    
837
#define MAX_COMPONENTS 4
838

    
839
typedef struct MJpegDecodeContext {
840
    AVCodecContext *avctx;
841
    GetBitContext gb;
842
    int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
843

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

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

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

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

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

    
892
    int restart_interval;
893
    int restart_count;
894

    
895
    int buggy_avid;
896
    int cs_itu601;
897
    int interlace_polarity;
898

    
899
    int mjpb_skiptosod;
900

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

    
904
#include "jpeg_ls.c" //FIXME make jpeg-ls more independant
905

    
906
static int mjpeg_decode_dht(MJpegDecodeContext *s);
907

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

    
914
    assert(nb_codes <= 256);
915

    
916
    memset(huff_size, 0, sizeof(huff_size));
917
    build_huffman_codes(huff_size, huff_code, bits_table, val_table);
918

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

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

    
930
static int mjpeg_decode_init(AVCodecContext *avctx)
931
{
932
    MJpegDecodeContext *s = avctx->priv_data;
933
    MpegEncContext s2;
934
    memset(s, 0, sizeof(MJpegDecodeContext));
935

    
936
    s->avctx = avctx;
937

    
938
    /* ugly way to get the idct & scantable FIXME */
939
    memset(&s2, 0, sizeof(MpegEncContext));
940
    s2.avctx= avctx;
941
//    s2->out_format = FMT_MJPEG;
942
    dsputil_init(&s2.dsp, avctx);
943
    DCT_common_init(&s2);
944

    
945
    s->scantable= s2.intra_scantable;
946
    s->idct_put= s2.dsp.idct_put;
947
    s->idct_add= s2.dsp.idct_add;
948

    
949
    s->mpeg_enc_ctx_allocated = 0;
950
    s->buffer_size = 0;
951
    s->buffer = NULL;
952
    s->start_code = -1;
953
    s->first_picture = 1;
954
    s->org_height = avctx->coded_height;
955

    
956
    build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12, 0, 0);
957
    build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12, 0, 0);
958
    build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251, 0, 1);
959
    build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251, 0, 1);
960

    
961
    if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
962
    {
963
        av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
964
        init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
965
        mjpeg_decode_dht(s);
966
        /* should check for error - but dunno */
967
    }
968

    
969
    return 0;
970
}
971

    
972

    
973
/**
974
 * finds the end of the current frame in the bitstream.
975
 * @return the position of the first byte of the next frame, or -1
976
 */
977
static int find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size){
978
    int vop_found, i;
979
    uint16_t state;
980

    
981
    vop_found= pc->frame_start_found;
982
    state= pc->state;
983

    
984
    i=0;
985
    if(!vop_found){
986
        for(i=0; i<buf_size; i++){
987
            state= (state<<8) | buf[i];
988
            if(state == 0xFFD8){
989
                i++;
990
                vop_found=1;
991
                break;
992
            }
993
        }
994
    }
995

    
996
    if(vop_found){
997
        /* EOF considered as end of frame */
998
        if (buf_size == 0)
999
            return 0;
1000
        for(; i<buf_size; i++){
1001
            state= (state<<8) | buf[i];
1002
            if(state == 0xFFD8){
1003
                pc->frame_start_found=0;
1004
                pc->state=0;
1005
                return i-1;
1006
            }
1007
        }
1008
    }
1009
    pc->frame_start_found= vop_found;
1010
    pc->state= state;
1011
    return END_NOT_FOUND;
1012
}
1013

    
1014
static int jpeg_parse(AVCodecParserContext *s,
1015
                           AVCodecContext *avctx,
1016
                           uint8_t **poutbuf, int *poutbuf_size,
1017
                           const uint8_t *buf, int buf_size)
1018
{
1019
    ParseContext *pc = s->priv_data;
1020
    int next;
1021

    
1022
    next= find_frame_end(pc, buf, buf_size);
1023

    
1024
    if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
1025
        *poutbuf = NULL;
1026
        *poutbuf_size = 0;
1027
        return buf_size;
1028
    }
1029

    
1030
    *poutbuf = (uint8_t *)buf;
1031
    *poutbuf_size = buf_size;
1032
    return next;
1033
}
1034

    
1035
/* quantize tables */
1036
static int mjpeg_decode_dqt(MJpegDecodeContext *s)
1037
{
1038
    int len, index, i, j;
1039

    
1040
    len = get_bits(&s->gb, 16) - 2;
1041

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

    
1059
        //XXX FIXME finetune, and perhaps add dc too
1060
        s->qscale[index]= FFMAX(
1061
            s->quant_matrixes[index][s->scantable.permutated[1]],
1062
            s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
1063
        av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n", index, s->qscale[index]);
1064
        len -= 65;
1065
    }
1066

    
1067
    return 0;
1068
}
1069

    
1070
/* decode huffman tables and build VLC decoders */
1071
static int mjpeg_decode_dht(MJpegDecodeContext *s)
1072
{
1073
    int len, index, i, class, n, v, code_max;
1074
    uint8_t bits_table[17];
1075
    uint8_t val_table[256];
1076

    
1077
    len = get_bits(&s->gb, 16) - 2;
1078

    
1079
    while (len > 0) {
1080
        if (len < 17)
1081
            return -1;
1082
        class = get_bits(&s->gb, 4);
1083
        if (class >= 2)
1084
            return -1;
1085
        index = get_bits(&s->gb, 4);
1086
        if (index >= 4)
1087
            return -1;
1088
        n = 0;
1089
        for(i=1;i<=16;i++) {
1090
            bits_table[i] = get_bits(&s->gb, 8);
1091
            n += bits_table[i];
1092
        }
1093
        len -= 17;
1094
        if (len < n || n > 256)
1095
            return -1;
1096

    
1097
        code_max = 0;
1098
        for(i=0;i<n;i++) {
1099
            v = get_bits(&s->gb, 8);
1100
            if (v > code_max)
1101
                code_max = v;
1102
            val_table[i] = v;
1103
        }
1104
        len -= n;
1105

    
1106
        /* build VLC and flush previous vlc if present */
1107
        free_vlc(&s->vlcs[class][index]);
1108
        av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
1109
               class, index, code_max + 1);
1110
        if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0, class > 0) < 0){
1111
            return -1;
1112
        }
1113
    }
1114
    return 0;
1115
}
1116

    
1117
static int mjpeg_decode_sof(MJpegDecodeContext *s)
1118
{
1119
    int len, nb_components, i, width, height, pix_fmt_id;
1120

    
1121
    /* XXX: verify len field validity */
1122
    len = get_bits(&s->gb, 16);
1123
    s->bits= get_bits(&s->gb, 8);
1124

    
1125
    if(s->pegasus_rct) s->bits=9;
1126
    if(s->bits==9 && !s->pegasus_rct) s->rct=1;    //FIXME ugly
1127

    
1128
    if (s->bits != 8 && !s->lossless){
1129
        av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
1130
        return -1;
1131
    }
1132

    
1133
    height = get_bits(&s->gb, 16);
1134
    width = get_bits(&s->gb, 16);
1135

    
1136
    av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
1137
    if(avcodec_check_dimensions(s->avctx, width, height))
1138
        return -1;
1139

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

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

    
1173
    if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1174

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

    
1180
        s->width = width;
1181
        s->height = height;
1182

    
1183
        /* test interlaced mode */
1184
        if (s->first_picture &&
1185
            s->org_height != 0 &&
1186
            s->height < ((s->org_height * 3) / 4)) {
1187
            s->interlaced = 1;
1188
//            s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1189
            s->bottom_field = 0;
1190
            height *= 2;
1191
        }
1192

    
1193
        avcodec_set_dimensions(s->avctx, width, height);
1194

    
1195
        s->qscale_table= av_mallocz((s->width+15)/16);
1196

    
1197
        s->first_picture = 0;
1198
    }
1199

    
1200
    if(s->interlaced && s->bottom_field)
1201
        return 0;
1202

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

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

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

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

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

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

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

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

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

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

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

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

    
1321
            LAST_SKIP_BITS(re, &s->gb, code)
1322

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

    
1338
    return 0;
1339
}
1340

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

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

    
1384
            LAST_SKIP_BITS(re, &s->gb, code)
1385

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

    
1415
    return 0;
1416
}
1417

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

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

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

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

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

    
1445
            for(i=0;i<3;i++) {
1446
                int pred;
1447

    
1448
                topleft[i]= top[i];
1449
                top[i]= buffer[mb_x][i];
1450

    
1451
                PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1452

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

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

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

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

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

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

    
1507
                    for(j=0; j<n; j++) {
1508
                        int pred;
1509

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

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

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

    
1547
                    for(j=0; j<n; j++) {
1548
                        int pred;
1549

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

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

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

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

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

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

    
1662
        s->comp_index[i] = index;
1663

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

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

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

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

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

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

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

    
1721

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

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

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

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

    
1760
    return 0;
1761
}
1762

    
1763
static int mjpeg_decode_app(MJpegDecodeContext *s)
1764
{
1765
    int len, id;
1766

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

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

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

    
1781
    /* buggy AVID, it puts EOI only at every 10th frame */
1782
    /* also this fourcc is used by non-avid files too, it holds some
1783
       informations, but it's always present in AVID creates files */
1784
    if (id == ff_get_fourcc("AVI1"))
1785
    {
1786
        /* structure:
1787
            4bytes      AVI1
1788
            1bytes      polarity
1789
            1bytes      always zero
1790
            4bytes      field_size
1791
            4bytes      field_size_less_padding
1792
        */
1793
            s->buggy_avid = 1;
1794
//        if (s->first_picture)
1795
//            printf("mjpeg: workarounding buggy AVID\n");
1796
        s->interlace_polarity = get_bits(&s->gb, 8);
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 (x == 0xff)
2040
                        {
2041
                            while(src<buf_end && x == 0xff)
2042
                                x = *(src++);
2043

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

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

    
2062
                    s->cur_scan++;
2063

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

    
2078
                    init_put_bits(&pb, dst, t);
2079

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

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

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

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

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

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

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

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

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

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

    
2242
    buf_ptr = buf;
2243
    buf_end = buf + buf_size;
2244

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

    
2251
    init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
2252

    
2253
    skip_bits(&hgb, 32); /* reserved zeros */
2254

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

    
2261
    field_size = get_bits_long(&hgb, 32); /* field size */
2262
    av_log(avctx, AV_LOG_DEBUG, "field size: 0x%x\n", field_size);
2263
    skip_bits(&hgb, 32); /* padded field size */
2264
    second_field_offs = get_bits_long(&hgb, 32);
2265
    av_log(avctx, AV_LOG_DEBUG, "second field offs: 0x%x\n", second_field_offs);
2266
    if (second_field_offs)
2267
        s->interlaced = 1;
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 mjpegb_decoder = {
2579
    "mjpegb",
2580
    CODEC_TYPE_VIDEO,
2581
    CODEC_ID_MJPEGB,
2582
    sizeof(MJpegDecodeContext),
2583
    mjpeg_decode_init,
2584
    NULL,
2585
    mjpeg_decode_end,
2586
    mjpegb_decode_frame,
2587
    CODEC_CAP_DR1,
2588
    NULL
2589
};
2590

    
2591
AVCodec sp5x_decoder = {
2592
    "sp5x",
2593
    CODEC_TYPE_VIDEO,
2594
    CODEC_ID_SP5X,
2595
    sizeof(MJpegDecodeContext),
2596
    mjpeg_decode_init,
2597
    NULL,
2598
    mjpeg_decode_end,
2599
    sp5x_decode_frame,
2600
    CODEC_CAP_DR1,
2601
    NULL
2602
};
2603

    
2604
#ifdef CONFIG_ENCODERS
2605
AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2606
    "ljpeg",
2607
    CODEC_TYPE_VIDEO,
2608
    CODEC_ID_LJPEG,
2609
    sizeof(MpegEncContext),
2610
    MPV_encode_init,
2611
    encode_picture_lossless,
2612
    MPV_encode_end,
2613
};
2614
#endif
2615

    
2616
AVCodecParser mjpeg_parser = {
2617
    { CODEC_ID_MJPEG },
2618
    sizeof(ParseContext),
2619
    NULL,
2620
    jpeg_parse,
2621
    ff_parse_close,
2622
};
2623

    
2624
AVBitStreamFilter mjpega_dump_header_bsf = {
2625
    "mjpegadump",
2626
    0,
2627
    mjpega_dump_header,
2628
};