Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mjpeg.c @ 426b11a8

History | View | Annotate | Download (79.8 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
328
    return n + 17;
329
}
330

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
547
    if(ff_count==0) return;
548

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

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

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

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

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

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

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

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

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

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

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

    
601
        nbits= av_log2_16bit(val) + 1;
602

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

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

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

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

    
632
    /* AC coefs */
633

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

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

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

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

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

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

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

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

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

    
698
    mjpeg_picture_header(s);
699

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
821
    emms_c();
822

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

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

    
831
#endif //CONFIG_ENCODERS
832

    
833
/******************************************/
834
/* decoding */
835

    
836
#define MAX_COMPONENTS 4
837

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

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

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

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

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

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

    
891
    int restart_interval;
892
    int restart_count;
893

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

    
898
    int mjpb_skiptosod;
899

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

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

    
905
static int mjpeg_decode_dht(MJpegDecodeContext *s);
906

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

    
913
    assert(nb_codes <= 256);
914

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

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

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

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

    
935
    s->avctx = avctx;
936

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

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

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

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

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

    
968
    return 0;
969
}
970

    
971

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

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

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

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

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

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

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

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

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

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

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

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

    
1066
    return 0;
1067
}
1068

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1196
        s->first_picture = 0;
1197
    }
1198

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

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

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

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

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

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

    
1252
    if (len != (8+(3*nb_components)))
1253
    {
1254
        dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1255
    }
1256

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

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

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

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

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

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

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

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

    
1337
    return 0;
1338
}
1339

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

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

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

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

    
1414
    return 0;
1415
}
1416

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1720

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

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

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

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

    
1759
    return 0;
1760
}
1761

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

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

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

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

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

    
1807
//    len -= 2;
1808

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

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

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

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

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

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

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

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

    
1904
    return 0;
1905
}
1906

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

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

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

    
1935
            av_free(cbuf);
1936
        }
1937
    }
1938

    
1939
    return 0;
1940
}
1941

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

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

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

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

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

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

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

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

    
2037
                        *(dst++) = x;
2038
                        if (x == 0xff)
2039
                        {
2040
                            while(src<buf_end && x == 0xff)
2041
                                x = *(src++);
2042

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

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

    
2061
                    s->cur_scan++;
2062

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2251
    if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
2252
    {
2253
        dprintf("not mjpeg-b (bad fourcc)\n");
2254
        return 0;
2255
    }
2256

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

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

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

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

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

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

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

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

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

    
2332
    return buf_ptr - buf;
2333
}
2334

    
2335
#include "sp5x.h"
2336

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

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

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

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

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

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

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

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

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

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

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

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

    
2394
    av_free(recoded);
2395

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

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

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

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

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

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

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

    
2453
    /* DHT */
2454

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

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

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

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

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

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

    
2485
    return mjpeg_decode_scan(s);
2486
#endif
2487

    
2488
    return i;
2489
}
2490

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

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

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

    
2506
AVCodec mjpeg_decoder = {
2507
    "mjpeg",
2508
    CODEC_TYPE_VIDEO,
2509
    CODEC_ID_MJPEG,
2510
    sizeof(MJpegDecodeContext),
2511
    mjpeg_decode_init,
2512
    NULL,
2513
    mjpeg_decode_end,
2514
    mjpeg_decode_frame,
2515
    CODEC_CAP_DR1,
2516
    NULL
2517
};
2518

    
2519
AVCodec mjpegb_decoder = {
2520
    "mjpegb",
2521
    CODEC_TYPE_VIDEO,
2522
    CODEC_ID_MJPEGB,
2523
    sizeof(MJpegDecodeContext),
2524
    mjpeg_decode_init,
2525
    NULL,
2526
    mjpeg_decode_end,
2527
    mjpegb_decode_frame,
2528
    CODEC_CAP_DR1,
2529
    NULL
2530
};
2531

    
2532
AVCodec sp5x_decoder = {
2533
    "sp5x",
2534
    CODEC_TYPE_VIDEO,
2535
    CODEC_ID_SP5X,
2536
    sizeof(MJpegDecodeContext),
2537
    mjpeg_decode_init,
2538
    NULL,
2539
    mjpeg_decode_end,
2540
    sp5x_decode_frame,
2541
    CODEC_CAP_DR1,
2542
    NULL
2543
};
2544

    
2545
#ifdef CONFIG_ENCODERS
2546
AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2547
    "ljpeg",
2548
    CODEC_TYPE_VIDEO,
2549
    CODEC_ID_LJPEG,
2550
    sizeof(MpegEncContext),
2551
    MPV_encode_init,
2552
    encode_picture_lossless,
2553
    MPV_encode_end,
2554
};
2555
#endif
2556

    
2557
AVCodecParser mjpeg_parser = {
2558
    { CODEC_ID_MJPEG },
2559
    sizeof(ParseContext),
2560
    NULL,
2561
    jpeg_parse,
2562
    ff_parse_close,
2563
};
2564