Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mjpeg.c @ 7fcf4109

History | View | Annotate | Download (77 KB)

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

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

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

    
36
#include "avcodec.h"
37
#include "dsputil.h"
38
#include "mpegvideo.h"
39
#include "bytestream.h"
40
#include "mjpeg.h"
41
#include "jpeglsdec.h"
42

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

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

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

    
59
#if 0
60
/* These are the sample quantization tables given in JPEG spec section K.1.
61
 * The spec says that the values given produce "good" quality, and
62
 * when divided by 2, "very good" quality.
63
 */
64
static const unsigned char std_luminance_quant_tbl[64] = {
65
    16,  11,  10,  16,  24,  40,  51,  61,
66
    12,  12,  14,  19,  26,  58,  60,  55,
67
    14,  13,  16,  24,  40,  57,  69,  56,
68
    14,  17,  22,  29,  51,  87,  80,  62,
69
    18,  22,  37,  56,  68, 109, 103,  77,
70
    24,  35,  55,  64,  81, 104, 113,  92,
71
    49,  64,  78,  87, 103, 121, 120, 101,
72
    72,  92,  95,  98, 112, 100, 103,  99
73
};
74
static const unsigned char std_chrominance_quant_tbl[64] = {
75
    17,  18,  24,  47,  99,  99,  99,  99,
76
    18,  21,  26,  66,  99,  99,  99,  99,
77
    24,  26,  56,  99,  99,  99,  99,  99,
78
    47,  66,  99,  99,  99,  99,  99,  99,
79
    99,  99,  99,  99,  99,  99,  99,  99,
80
    99,  99,  99,  99,  99,  99,  99,  99,
81
    99,  99,  99,  99,  99,  99,  99,  99,
82
    99,  99,  99,  99,  99,  99,  99,  99
83
};
84
#endif
85

    
86
/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
87
/* IMPORTANT: these are only valid for 8-bit data precision! */
88
static const uint8_t bits_dc_luminance[17] =
89
{ /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
90
static const uint8_t val_dc_luminance[] =
91
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
92

    
93
static const uint8_t bits_dc_chrominance[17] =
94
{ /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
95
static const uint8_t val_dc_chrominance[] =
96
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
97

    
98
static const uint8_t bits_ac_luminance[17] =
99
{ /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
100
static const uint8_t val_ac_luminance[] =
101
{ 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
102
  0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
103
  0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
104
  0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
105
  0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
106
  0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
107
  0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
108
  0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
109
  0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
110
  0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
111
  0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
112
  0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
113
  0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
114
  0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
115
  0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
116
  0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
117
  0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
118
  0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
119
  0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
120
  0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
121
  0xf9, 0xfa
122
};
123

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

    
127
static const uint8_t val_ac_chrominance[] =
128
{ 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
129
  0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
130
  0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
131
  0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
132
  0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
133
  0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
134
  0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
135
  0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
136
  0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
137
  0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
138
  0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
139
  0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
140
  0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
141
  0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
142
  0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
143
  0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
144
  0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
145
  0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
146
  0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
147
  0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
148
  0xf9, 0xfa
149
};
150

    
151
/* isn't this function nicer than the one in the libjpeg ? */
152
static void build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code,
153
                                const uint8_t *bits_table, const uint8_t *val_table)
154
{
155
    int i, j, k,nb, code, sym;
156

    
157
    code = 0;
158
    k = 0;
159
    for(i=1;i<=16;i++) {
160
        nb = bits_table[i];
161
        for(j=0;j<nb;j++) {
162
            sym = val_table[k++];
163
            huff_size[sym] = i;
164
            huff_code[sym] = code;
165
            code++;
166
        }
167
        code <<= 1;
168
    }
169
}
170

    
171
#ifdef CONFIG_ENCODERS
172
int mjpeg_init(MpegEncContext *s)
173
{
174
    MJpegContext *m;
175

    
176
    m = av_malloc(sizeof(MJpegContext));
177
    if (!m)
178
        return -1;
179

    
180
    s->min_qcoeff=-1023;
181
    s->max_qcoeff= 1023;
182

    
183
    /* build all the huffman tables */
184
    build_huffman_codes(m->huff_size_dc_luminance,
185
                        m->huff_code_dc_luminance,
186
                        bits_dc_luminance,
187
                        val_dc_luminance);
188
    build_huffman_codes(m->huff_size_dc_chrominance,
189
                        m->huff_code_dc_chrominance,
190
                        bits_dc_chrominance,
191
                        val_dc_chrominance);
192
    build_huffman_codes(m->huff_size_ac_luminance,
193
                        m->huff_code_ac_luminance,
194
                        bits_ac_luminance,
195
                        val_ac_luminance);
196
    build_huffman_codes(m->huff_size_ac_chrominance,
197
                        m->huff_code_ac_chrominance,
198
                        bits_ac_chrominance,
199
                        val_ac_chrominance);
200

    
201
    s->mjpeg_ctx = m;
202
    return 0;
203
}
204

    
205
void mjpeg_close(MpegEncContext *s)
206
{
207
    av_free(s->mjpeg_ctx);
208
}
209
#endif //CONFIG_ENCODERS
210

    
211
#define PREDICT(ret, topleft, top, left, predictor)\
212
    switch(predictor){\
213
        case 1: ret= left; break;\
214
        case 2: ret= top; break;\
215
        case 3: ret= topleft; break;\
216
        case 4: ret= left   +   top - topleft; break;\
217
        case 5: ret= left   + ((top - topleft)>>1); break;\
218
        case 6: ret= top + ((left   - topleft)>>1); break;\
219
        default:\
220
        case 7: ret= (left + top)>>1; break;\
221
    }
222

    
223
#ifdef CONFIG_ENCODERS
224
/* table_class: 0 = DC coef, 1 = AC coefs */
225
static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
226
                             const uint8_t *bits_table, const uint8_t *value_table)
227
{
228
    PutBitContext *p = &s->pb;
229
    int n, i;
230

    
231
    put_bits(p, 4, table_class);
232
    put_bits(p, 4, table_id);
233

    
234
    n = 0;
235
    for(i=1;i<=16;i++) {
236
        n += bits_table[i];
237
        put_bits(p, 8, bits_table[i]);
238
    }
239

    
240
    for(i=0;i<n;i++)
241
        put_bits(p, 8, value_table[i]);
242

    
243
    return n + 17;
244
}
245

    
246
static void jpeg_table_header(MpegEncContext *s)
247
{
248
    PutBitContext *p = &s->pb;
249
    int i, j, size;
250
    uint8_t *ptr;
251

    
252
    /* quant matrixes */
253
    put_marker(p, DQT);
254
#ifdef TWOMATRIXES
255
    put_bits(p, 16, 2 + 2 * (1 + 64));
256
#else
257
    put_bits(p, 16, 2 + 1 * (1 + 64));
258
#endif
259
    put_bits(p, 4, 0); /* 8 bit precision */
260
    put_bits(p, 4, 0); /* table 0 */
261
    for(i=0;i<64;i++) {
262
        j = s->intra_scantable.permutated[i];
263
        put_bits(p, 8, s->intra_matrix[j]);
264
    }
265
#ifdef TWOMATRIXES
266
    put_bits(p, 4, 0); /* 8 bit precision */
267
    put_bits(p, 4, 1); /* table 1 */
268
    for(i=0;i<64;i++) {
269
        j = s->intra_scantable.permutated[i];
270
        put_bits(p, 8, s->chroma_intra_matrix[j]);
271
    }
272
#endif
273

    
274
    /* huffman table */
275
    put_marker(p, DHT);
276
    flush_put_bits(p);
277
    ptr = pbBufPtr(p);
278
    put_bits(p, 16, 0); /* patched later */
279
    size = 2;
280
    size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
281
    size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
282

    
283
    size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
284
    size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
285
    ptr[0] = size >> 8;
286
    ptr[1] = size;
287
}
288

    
289
static void jpeg_put_comments(MpegEncContext *s)
290
{
291
    PutBitContext *p = &s->pb;
292
    int size;
293
    uint8_t *ptr;
294

    
295
    if (s->aspect_ratio_info /* && !lossless */)
296
    {
297
    /* JFIF header */
298
    put_marker(p, APP0);
299
    put_bits(p, 16, 16);
300
    ff_put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */
301
    put_bits(p, 16, 0x0201); /* v 1.02 */
302
    put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
303
    put_bits(p, 16, s->avctx->sample_aspect_ratio.num);
304
    put_bits(p, 16, s->avctx->sample_aspect_ratio.den);
305
    put_bits(p, 8, 0); /* thumbnail width */
306
    put_bits(p, 8, 0); /* thumbnail height */
307
    }
308

    
309
    /* comment */
310
    if(!(s->flags & CODEC_FLAG_BITEXACT)){
311
        put_marker(p, COM);
312
        flush_put_bits(p);
313
        ptr = pbBufPtr(p);
314
        put_bits(p, 16, 0); /* patched later */
315
        ff_put_string(p, LIBAVCODEC_IDENT, 1);
316
        size = strlen(LIBAVCODEC_IDENT)+3;
317
        ptr[0] = size >> 8;
318
        ptr[1] = size;
319
    }
320

    
321
    if(  s->avctx->pix_fmt == PIX_FMT_YUV420P
322
       ||s->avctx->pix_fmt == PIX_FMT_YUV422P
323
       ||s->avctx->pix_fmt == PIX_FMT_YUV444P){
324
        put_marker(p, COM);
325
        flush_put_bits(p);
326
        ptr = pbBufPtr(p);
327
        put_bits(p, 16, 0); /* patched later */
328
        ff_put_string(p, "CS=ITU601", 1);
329
        size = strlen("CS=ITU601")+3;
330
        ptr[0] = size >> 8;
331
        ptr[1] = size;
332
    }
333
}
334

    
335
void mjpeg_picture_header(MpegEncContext *s)
336
{
337
    const int lossless= s->avctx->codec_id != CODEC_ID_MJPEG;
338

    
339
    put_marker(&s->pb, SOI);
340

    
341
    if (!s->mjpeg_data_only_frames)
342
    {
343
    jpeg_put_comments(s);
344

    
345
    if (s->mjpeg_write_tables) jpeg_table_header(s);
346

    
347
    switch(s->avctx->codec_id){
348
    case CODEC_ID_MJPEG:  put_marker(&s->pb, SOF0 ); break;
349
    case CODEC_ID_LJPEG:  put_marker(&s->pb, SOF3 ); break;
350
    default: assert(0);
351
    }
352

    
353
    put_bits(&s->pb, 16, 17);
354
    if(lossless && s->avctx->pix_fmt == PIX_FMT_RGB32)
355
        put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
356
    else
357
        put_bits(&s->pb, 8, 8); /* 8 bits/component */
358
    put_bits(&s->pb, 16, s->height);
359
    put_bits(&s->pb, 16, s->width);
360
    put_bits(&s->pb, 8, 3); /* 3 components */
361

    
362
    /* Y component */
363
    put_bits(&s->pb, 8, 1); /* component number */
364
    put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
365
    put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
366
    put_bits(&s->pb, 8, 0); /* select matrix */
367

    
368
    /* Cb component */
369
    put_bits(&s->pb, 8, 2); /* component number */
370
    put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
371
    put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
372
#ifdef TWOMATRIXES
373
    put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
374
#else
375
    put_bits(&s->pb, 8, 0); /* select matrix */
376
#endif
377

    
378
    /* Cr component */
379
    put_bits(&s->pb, 8, 3); /* component number */
380
    put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
381
    put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
382
#ifdef TWOMATRIXES
383
    put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
384
#else
385
    put_bits(&s->pb, 8, 0); /* select matrix */
386
#endif
387
    }
388

    
389
    /* scan header */
390
    put_marker(&s->pb, SOS);
391
    put_bits(&s->pb, 16, 12); /* length */
392
    put_bits(&s->pb, 8, 3); /* 3 components */
393

    
394
    /* Y component */
395
    put_bits(&s->pb, 8, 1); /* index */
396
    put_bits(&s->pb, 4, 0); /* DC huffman table index */
397
    put_bits(&s->pb, 4, 0); /* AC huffman table index */
398

    
399
    /* Cb component */
400
    put_bits(&s->pb, 8, 2); /* index */
401
    put_bits(&s->pb, 4, 1); /* DC huffman table index */
402
    put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
403

    
404
    /* Cr component */
405
    put_bits(&s->pb, 8, 3); /* index */
406
    put_bits(&s->pb, 4, 1); /* DC huffman table index */
407
    put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
408

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

    
411
    switch(s->avctx->codec_id){
412
    case CODEC_ID_MJPEG:  put_bits(&s->pb, 8, 63); break; /* Se (not used) */
413
    case CODEC_ID_LJPEG:  put_bits(&s->pb, 8,  0); break; /* not used */
414
    default: assert(0);
415
    }
416

    
417
    put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
418
}
419

    
420
static void escape_FF(MpegEncContext *s, int start)
421
{
422
    int size= put_bits_count(&s->pb) - start*8;
423
    int i, ff_count;
424
    uint8_t *buf= s->pb.buf + start;
425
    int align= (-(size_t)(buf))&3;
426

    
427
    assert((size&7) == 0);
428
    size >>= 3;
429

    
430
    ff_count=0;
431
    for(i=0; i<size && i<align; i++){
432
        if(buf[i]==0xFF) ff_count++;
433
    }
434
    for(; i<size-15; i+=16){
435
        int acc, v;
436

    
437
        v= *(uint32_t*)(&buf[i]);
438
        acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
439
        v= *(uint32_t*)(&buf[i+4]);
440
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
441
        v= *(uint32_t*)(&buf[i+8]);
442
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
443
        v= *(uint32_t*)(&buf[i+12]);
444
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
445

    
446
        acc>>=4;
447
        acc+= (acc>>16);
448
        acc+= (acc>>8);
449
        ff_count+= acc&0xFF;
450
    }
451
    for(; i<size; i++){
452
        if(buf[i]==0xFF) ff_count++;
453
    }
454

    
455
    if(ff_count==0) return;
456

    
457
    /* skip put bits */
458
    for(i=0; i<ff_count-3; i+=4)
459
        put_bits(&s->pb, 32, 0);
460
    put_bits(&s->pb, (ff_count-i)*8, 0);
461
    flush_put_bits(&s->pb);
462

    
463
    for(i=size-1; ff_count; i--){
464
        int v= buf[i];
465

    
466
        if(v==0xFF){
467
//printf("%d %d\n", i, ff_count);
468
            buf[i+ff_count]= 0;
469
            ff_count--;
470
        }
471

    
472
        buf[i+ff_count]= v;
473
    }
474
}
475

    
476
void ff_mjpeg_stuffing(PutBitContext * pbc)
477
{
478
    int length;
479
    length= (-put_bits_count(pbc))&7;
480
    if(length) put_bits(pbc, length, (1<<length)-1);
481
}
482

    
483
void mjpeg_picture_trailer(MpegEncContext *s)
484
{
485
    ff_mjpeg_stuffing(&s->pb);
486
    flush_put_bits(&s->pb);
487

    
488
    assert((s->header_bits&7)==0);
489

    
490
    escape_FF(s, s->header_bits>>3);
491

    
492
    put_marker(&s->pb, EOI);
493
}
494

    
495
static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
496
                                   uint8_t *huff_size, uint16_t *huff_code)
497
{
498
    int mant, nbits;
499

    
500
    if (val == 0) {
501
        put_bits(&s->pb, huff_size[0], huff_code[0]);
502
    } else {
503
        mant = val;
504
        if (val < 0) {
505
            val = -val;
506
            mant--;
507
        }
508

    
509
        nbits= av_log2_16bit(val) + 1;
510

    
511
        put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
512

    
513
        put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
514
    }
515
}
516

    
517
static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
518
{
519
    int mant, nbits, code, i, j;
520
    int component, dc, run, last_index, val;
521
    MJpegContext *m = s->mjpeg_ctx;
522
    uint8_t *huff_size_ac;
523
    uint16_t *huff_code_ac;
524

    
525
    /* DC coef */
526
    component = (n <= 3 ? 0 : (n&1) + 1);
527
    dc = block[0]; /* overflow is impossible */
528
    val = dc - s->last_dc[component];
529
    if (n < 4) {
530
        mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
531
        huff_size_ac = m->huff_size_ac_luminance;
532
        huff_code_ac = m->huff_code_ac_luminance;
533
    } else {
534
        mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
535
        huff_size_ac = m->huff_size_ac_chrominance;
536
        huff_code_ac = m->huff_code_ac_chrominance;
537
    }
538
    s->last_dc[component] = dc;
539

    
540
    /* AC coefs */
541

    
542
    run = 0;
543
    last_index = s->block_last_index[n];
544
    for(i=1;i<=last_index;i++) {
545
        j = s->intra_scantable.permutated[i];
546
        val = block[j];
547
        if (val == 0) {
548
            run++;
549
        } else {
550
            while (run >= 16) {
551
                put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
552
                run -= 16;
553
            }
554
            mant = val;
555
            if (val < 0) {
556
                val = -val;
557
                mant--;
558
            }
559

    
560
            nbits= av_log2(val) + 1;
561
            code = (run << 4) | nbits;
562

    
563
            put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
564

    
565
            put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
566
            run = 0;
567
        }
568
    }
569

    
570
    /* output EOB only if not already 64 values */
571
    if (last_index < 63 || run != 0)
572
        put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
573
}
574

    
575
void mjpeg_encode_mb(MpegEncContext *s,
576
                     DCTELEM block[6][64])
577
{
578
    int i;
579
    for(i=0;i<5;i++) {
580
        encode_block(s, block[i], i);
581
    }
582
    if (s->chroma_format == CHROMA_420) {
583
        encode_block(s, block[5], 5);
584
    } else {
585
        encode_block(s, block[6], 6);
586
        encode_block(s, block[5], 5);
587
        encode_block(s, block[7], 7);
588
    }
589
}
590

    
591
static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
592
    MpegEncContext * const s = avctx->priv_data;
593
    MJpegContext * const m = s->mjpeg_ctx;
594
    AVFrame *pict = data;
595
    const int width= s->width;
596
    const int height= s->height;
597
    AVFrame * const p= (AVFrame*)&s->current_picture;
598
    const int predictor= avctx->prediction_method+1;
599

    
600
    init_put_bits(&s->pb, buf, buf_size);
601

    
602
    *p = *pict;
603
    p->pict_type= FF_I_TYPE;
604
    p->key_frame= 1;
605

    
606
    mjpeg_picture_header(s);
607

    
608
    s->header_bits= put_bits_count(&s->pb);
609

    
610
    if(avctx->pix_fmt == PIX_FMT_RGB32){
611
        int x, y, i;
612
        const int linesize= p->linesize[0];
613
        uint16_t (*buffer)[4]= (void *) s->rd_scratchpad;
614
        int left[3], top[3], topleft[3];
615

    
616
        for(i=0; i<3; i++){
617
            buffer[0][i]= 1 << (9 - 1);
618
        }
619

    
620
        for(y = 0; y < height; y++) {
621
            const int modified_predictor= y ? predictor : 1;
622
            uint8_t *ptr = p->data[0] + (linesize * y);
623

    
624
            if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < width*3*4){
625
                av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
626
                return -1;
627
            }
628

    
629
            for(i=0; i<3; i++){
630
                top[i]= left[i]= topleft[i]= buffer[0][i];
631
            }
632
            for(x = 0; x < width; x++) {
633
                buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
634
                buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
635
                buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
636

    
637
                for(i=0;i<3;i++) {
638
                    int pred, diff;
639

    
640
                    PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
641

    
642
                    topleft[i]= top[i];
643
                    top[i]= buffer[x+1][i];
644

    
645
                    left[i]= buffer[x][i];
646

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

    
649
                    if(i==0)
650
                        mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
651
                    else
652
                        mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
653
                }
654
            }
655
        }
656
    }else{
657
        int mb_x, mb_y, i;
658
        const int mb_width  = (width  + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
659
        const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
660

    
661
        for(mb_y = 0; mb_y < mb_height; mb_y++) {
662
            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]){
663
                av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
664
                return -1;
665
            }
666
            for(mb_x = 0; mb_x < mb_width; mb_x++) {
667
                if(mb_x==0 || mb_y==0){
668
                    for(i=0;i<3;i++) {
669
                        uint8_t *ptr;
670
                        int x, y, h, v, linesize;
671
                        h = s->mjpeg_hsample[i];
672
                        v = s->mjpeg_vsample[i];
673
                        linesize= p->linesize[i];
674

    
675
                        for(y=0; y<v; y++){
676
                            for(x=0; x<h; x++){
677
                                int pred;
678

    
679
                                ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
680
                                if(y==0 && mb_y==0){
681
                                    if(x==0 && mb_x==0){
682
                                        pred= 128;
683
                                    }else{
684
                                        pred= ptr[-1];
685
                                    }
686
                                }else{
687
                                    if(x==0 && mb_x==0){
688
                                        pred= ptr[-linesize];
689
                                    }else{
690
                                        PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
691
                                    }
692
                                }
693

    
694
                                if(i==0)
695
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
696
                                else
697
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
698
                            }
699
                        }
700
                    }
701
                }else{
702
                    for(i=0;i<3;i++) {
703
                        uint8_t *ptr;
704
                        int x, y, h, v, linesize;
705
                        h = s->mjpeg_hsample[i];
706
                        v = s->mjpeg_vsample[i];
707
                        linesize= p->linesize[i];
708

    
709
                        for(y=0; y<v; y++){
710
                            for(x=0; x<h; x++){
711
                                int pred;
712

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

    
717
                                if(i==0)
718
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
719
                                else
720
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
721
                            }
722
                        }
723
                    }
724
                }
725
            }
726
        }
727
    }
728

    
729
    emms_c();
730

    
731
    mjpeg_picture_trailer(s);
732
    s->picture_number++;
733

    
734
    flush_put_bits(&s->pb);
735
    return pbBufPtr(&s->pb) - s->pb.buf;
736
//    return (put_bits_count(&f->pb)+7)/8;
737
}
738

    
739
#endif //CONFIG_ENCODERS
740

    
741
/******************************************/
742
/* decoding */
743

    
744
static int mjpeg_decode_dht(MJpegDecodeContext *s);
745

    
746
static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,
747
                      int nb_codes, int use_static, int is_ac)
748
{
749
    uint8_t huff_size[256+16];
750
    uint16_t huff_code[256+16];
751

    
752
    assert(nb_codes <= 256);
753

    
754
    memset(huff_size, 0, sizeof(huff_size));
755
    build_huffman_codes(huff_size, huff_code, bits_table, val_table);
756

    
757
    if(is_ac){
758
        memmove(huff_size+16, huff_size, sizeof(uint8_t)*nb_codes);
759
        memmove(huff_code+16, huff_code, sizeof(uint16_t)*nb_codes);
760
        memset(huff_size, 0, sizeof(uint8_t)*16);
761
        memset(huff_code, 0, sizeof(uint16_t)*16);
762
        nb_codes += 16;
763
    }
764

    
765
    return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2, use_static);
766
}
767

    
768
static int mjpeg_decode_init(AVCodecContext *avctx)
769
{
770
    MJpegDecodeContext *s = avctx->priv_data;
771

    
772
    s->avctx = avctx;
773
    dsputil_init(&s->dsp, avctx);
774
    ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct);
775
    s->buffer_size = 0;
776
    s->buffer = NULL;
777
    s->start_code = -1;
778
    s->first_picture = 1;
779
    s->org_height = avctx->coded_height;
780

    
781
    build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12, 0, 0);
782
    build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12, 0, 0);
783
    build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251, 0, 1);
784
    build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251, 0, 1);
785

    
786
    if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
787
    {
788
        av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
789
        init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
790
        mjpeg_decode_dht(s);
791
        /* should check for error - but dunno */
792
    }
793
    if (avctx->extradata_size > 9 &&
794
        AV_RL32(avctx->extradata + 4) == MKTAG('f','i','e','l')) {
795
        if (avctx->extradata[9] == 6) { /* quicktime icefloe 019 */
796
            s->interlace_polarity = 1; /* bottom field first */
797
            av_log(avctx, AV_LOG_DEBUG, "mjpeg bottom field first\n");
798
        }
799
    }
800

    
801
    return 0;
802
}
803

    
804

    
805
/* quantize tables */
806
static int mjpeg_decode_dqt(MJpegDecodeContext *s)
807
{
808
    int len, index, i, j;
809

    
810
    len = get_bits(&s->gb, 16) - 2;
811

    
812
    while (len >= 65) {
813
        /* only 8 bit precision handled */
814
        if (get_bits(&s->gb, 4) != 0)
815
        {
816
            av_log(s->avctx, AV_LOG_ERROR, "dqt: 16bit precision\n");
817
            return -1;
818
        }
819
        index = get_bits(&s->gb, 4);
820
        if (index >= 4)
821
            return -1;
822
        av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index);
823
        /* read quant table */
824
        for(i=0;i<64;i++) {
825
            j = s->scantable.permutated[i];
826
            s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
827
        }
828

    
829
        //XXX FIXME finetune, and perhaps add dc too
830
        s->qscale[index]= FFMAX(
831
            s->quant_matrixes[index][s->scantable.permutated[1]],
832
            s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
833
        av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n", index, s->qscale[index]);
834
        len -= 65;
835
    }
836

    
837
    return 0;
838
}
839

    
840
/* decode huffman tables and build VLC decoders */
841
static int mjpeg_decode_dht(MJpegDecodeContext *s)
842
{
843
    int len, index, i, class, n, v, code_max;
844
    uint8_t bits_table[17];
845
    uint8_t val_table[256];
846

    
847
    len = get_bits(&s->gb, 16) - 2;
848

    
849
    while (len > 0) {
850
        if (len < 17)
851
            return -1;
852
        class = get_bits(&s->gb, 4);
853
        if (class >= 2)
854
            return -1;
855
        index = get_bits(&s->gb, 4);
856
        if (index >= 4)
857
            return -1;
858
        n = 0;
859
        for(i=1;i<=16;i++) {
860
            bits_table[i] = get_bits(&s->gb, 8);
861
            n += bits_table[i];
862
        }
863
        len -= 17;
864
        if (len < n || n > 256)
865
            return -1;
866

    
867
        code_max = 0;
868
        for(i=0;i<n;i++) {
869
            v = get_bits(&s->gb, 8);
870
            if (v > code_max)
871
                code_max = v;
872
            val_table[i] = v;
873
        }
874
        len -= n;
875

    
876
        /* build VLC and flush previous vlc if present */
877
        free_vlc(&s->vlcs[class][index]);
878
        av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
879
               class, index, code_max + 1);
880
        if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0, class > 0) < 0){
881
            return -1;
882
        }
883
    }
884
    return 0;
885
}
886

    
887
static int mjpeg_decode_sof(MJpegDecodeContext *s)
888
{
889
    int len, nb_components, i, width, height, pix_fmt_id;
890

    
891
    /* XXX: verify len field validity */
892
    len = get_bits(&s->gb, 16);
893
    s->bits= get_bits(&s->gb, 8);
894

    
895
    if(s->pegasus_rct) s->bits=9;
896
    if(s->bits==9 && !s->pegasus_rct) s->rct=1;    //FIXME ugly
897

    
898
    if (s->bits != 8 && !s->lossless){
899
        av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
900
        return -1;
901
    }
902

    
903
    height = get_bits(&s->gb, 16);
904
    width = get_bits(&s->gb, 16);
905

    
906
    //HACK for odd_height.mov
907
    if(s->interlaced && s->width == width && s->height == height + 1)
908
        height= s->height;
909

    
910
    av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
911
    if(avcodec_check_dimensions(s->avctx, width, height))
912
        return -1;
913

    
914
    nb_components = get_bits(&s->gb, 8);
915
    if (nb_components <= 0 ||
916
        nb_components > MAX_COMPONENTS)
917
        return -1;
918
    if (s->ls && !(s->bits <= 8 || nb_components == 1)){
919
        av_log(s->avctx, AV_LOG_ERROR, "only <= 8 bits/component or 16-bit gray accepted for JPEG-LS\n");
920
        return -1;
921
    }
922
    s->nb_components = nb_components;
923
    s->h_max = 1;
924
    s->v_max = 1;
925
    for(i=0;i<nb_components;i++) {
926
        /* component id */
927
        s->component_id[i] = get_bits(&s->gb, 8) - 1;
928
        s->h_count[i] = get_bits(&s->gb, 4);
929
        s->v_count[i] = get_bits(&s->gb, 4);
930
        /* compute hmax and vmax (only used in interleaved case) */
931
        if (s->h_count[i] > s->h_max)
932
            s->h_max = s->h_count[i];
933
        if (s->v_count[i] > s->v_max)
934
            s->v_max = s->v_count[i];
935
        s->quant_index[i] = get_bits(&s->gb, 8);
936
        if (s->quant_index[i] >= 4)
937
            return -1;
938
        av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
939
               s->v_count[i], s->component_id[i], s->quant_index[i]);
940
    }
941

    
942
    if(s->ls && (s->h_max > 1 || s->v_max > 1)) {
943
        av_log(s->avctx, AV_LOG_ERROR, "Subsampling in JPEG-LS is not supported.\n");
944
        return -1;
945
    }
946

    
947
    if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
948

    
949
    /* if different size, realloc/alloc picture */
950
    /* XXX: also check h_count and v_count */
951
    if (width != s->width || height != s->height) {
952
        av_freep(&s->qscale_table);
953

    
954
        s->width = width;
955
        s->height = height;
956
        s->interlaced = 0;
957

    
958
        /* test interlaced mode */
959
        if (s->first_picture &&
960
            s->org_height != 0 &&
961
            s->height < ((s->org_height * 3) / 4)) {
962
            s->interlaced = 1;
963
            s->bottom_field = s->interlace_polarity;
964
            s->picture.interlaced_frame = 1;
965
            s->picture.top_field_first = !s->interlace_polarity;
966
            height *= 2;
967
        }
968

    
969
        avcodec_set_dimensions(s->avctx, width, height);
970

    
971
        s->qscale_table= av_mallocz((s->width+15)/16);
972

    
973
        s->first_picture = 0;
974
    }
975

    
976
    if(s->interlaced && (s->bottom_field == !s->interlace_polarity))
977
        return 0;
978

    
979
    /* XXX: not complete test ! */
980
    pix_fmt_id = (s->h_count[0] << 20) | (s->v_count[0] << 16) |
981
                 (s->h_count[1] << 12) | (s->v_count[1] <<  8) |
982
                 (s->h_count[2] <<  4) |  s->v_count[2];
983
    av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);
984
    switch(pix_fmt_id){
985
    case 0x222222:
986
    case 0x111111:
987
        if(s->rgb){
988
            s->avctx->pix_fmt = PIX_FMT_RGB32;
989
        }else if(s->nb_components==3)
990
            s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;
991
        else
992
            s->avctx->pix_fmt = PIX_FMT_GRAY8;
993
        break;
994
    case 0x211111:
995
    case 0x221212:
996
        s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P;
997
        break;
998
    default:
999
    case 0x221111:
1000
        s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P;
1001
        break;
1002
    }
1003
    if(s->ls){
1004
        if(s->nb_components > 1)
1005
            s->avctx->pix_fmt = PIX_FMT_RGB24;
1006
        else if(s->bits <= 8)
1007
            s->avctx->pix_fmt = PIX_FMT_GRAY8;
1008
        else
1009
            s->avctx->pix_fmt = PIX_FMT_GRAY16;
1010
    }
1011

    
1012
    if(s->picture.data[0])
1013
        s->avctx->release_buffer(s->avctx, &s->picture);
1014

    
1015
    s->picture.reference= 0;
1016
    if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1017
        av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1018
        return -1;
1019
    }
1020
    s->picture.pict_type= I_TYPE;
1021
    s->picture.key_frame= 1;
1022

    
1023
    for(i=0; i<3; i++){
1024
        s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1025
    }
1026

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

    
1029
    if (len != (8+(3*nb_components)))
1030
    {
1031
        av_log(s->avctx, AV_LOG_DEBUG, "decode_sof0: error, len(%d) mismatch\n", len);
1032
    }
1033

    
1034
    /* totally blank picture as progressive JPEG will only add details to it */
1035
    if(s->progressive){
1036
        memset(s->picture.data[0], 0, s->picture.linesize[0] * s->height);
1037
        memset(s->picture.data[1], 0, s->picture.linesize[1] * s->height >> (s->v_max - s->v_count[1]));
1038
        memset(s->picture.data[2], 0, s->picture.linesize[2] * s->height >> (s->v_max - s->v_count[2]));
1039
    }
1040
    return 0;
1041
}
1042

    
1043
static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1044
{
1045
    int code;
1046
    code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1047
    if (code < 0)
1048
    {
1049
        av_log(s->avctx, AV_LOG_WARNING, "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1050
               &s->vlcs[0][dc_index]);
1051
        return 0xffff;
1052
    }
1053

    
1054
    if(code)
1055
        return get_xbits(&s->gb, code);
1056
    else
1057
        return 0;
1058
}
1059

    
1060
/* decode block and dequantize */
1061
static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1062
                        int component, int dc_index, int ac_index, int16_t *quant_matrix)
1063
{
1064
    int code, i, j, level, val;
1065

    
1066
    /* DC coef */
1067
    val = mjpeg_decode_dc(s, dc_index);
1068
    if (val == 0xffff) {
1069
        av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
1070
        return -1;
1071
    }
1072
    val = val * quant_matrix[0] + s->last_dc[component];
1073
    s->last_dc[component] = val;
1074
    block[0] = val;
1075
    /* AC coefs */
1076
    i = 0;
1077
    {OPEN_READER(re, &s->gb)
1078
    for(;;) {
1079
        UPDATE_CACHE(re, &s->gb);
1080
        GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)
1081

    
1082
        /* EOB */
1083
        if (code == 0x10)
1084
            break;
1085
        i += ((unsigned)code) >> 4;
1086
        if(code != 0x100){
1087
            code &= 0xf;
1088
            if(code > MIN_CACHE_BITS - 16){
1089
                UPDATE_CACHE(re, &s->gb)
1090
            }
1091
            {
1092
                int cache=GET_CACHE(re,&s->gb);
1093
                int sign=(~cache)>>31;
1094
                level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
1095
            }
1096

    
1097
            LAST_SKIP_BITS(re, &s->gb, code)
1098

    
1099
            if (i >= 63) {
1100
                if(i == 63){
1101
                    j = s->scantable.permutated[63];
1102
                    block[j] = level * quant_matrix[j];
1103
                    break;
1104
                }
1105
                av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
1106
                return -1;
1107
            }
1108
            j = s->scantable.permutated[i];
1109
            block[j] = level * quant_matrix[j];
1110
        }
1111
    }
1112
    CLOSE_READER(re, &s->gb)}
1113

    
1114
    return 0;
1115
}
1116

    
1117
/* decode block and dequantize - progressive JPEG version */
1118
static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block,
1119
                        int component, int dc_index, int ac_index, int16_t *quant_matrix,
1120
                        int ss, int se, int Ah, int Al, int *EOBRUN)
1121
{
1122
    int code, i, j, level, val, run;
1123

    
1124
    /* DC coef */
1125
    if(!ss){
1126
        val = mjpeg_decode_dc(s, dc_index);
1127
        if (val == 0xffff) {
1128
            av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
1129
            return -1;
1130
        }
1131
        val = (val * quant_matrix[0] << Al) + s->last_dc[component];
1132
    }else
1133
        val = 0;
1134
    s->last_dc[component] = val;
1135
    block[0] = val;
1136
    if(!se) return 0;
1137
    /* AC coefs */
1138
    if(*EOBRUN){
1139
        (*EOBRUN)--;
1140
        return 0;
1141
    }
1142
    {OPEN_READER(re, &s->gb)
1143
    for(i=ss;;i++) {
1144
        UPDATE_CACHE(re, &s->gb);
1145
        GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)
1146
        /* Progressive JPEG use AC coeffs from zero and this decoder sets offset 16 by default */
1147
        code -= 16;
1148
        if(code & 0xF) {
1149
            i += ((unsigned) code) >> 4;
1150
            code &= 0xf;
1151
            if(code > MIN_CACHE_BITS - 16){
1152
                UPDATE_CACHE(re, &s->gb)
1153
            }
1154
            {
1155
                int cache=GET_CACHE(re,&s->gb);
1156
                int sign=(~cache)>>31;
1157
                level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
1158
            }
1159

    
1160
            LAST_SKIP_BITS(re, &s->gb, code)
1161

    
1162
            if (i >= se) {
1163
                if(i == se){
1164
                    j = s->scantable.permutated[se];
1165
                    block[j] = level * quant_matrix[j] << Al;
1166
                    break;
1167
                }
1168
                av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
1169
                return -1;
1170
            }
1171
            j = s->scantable.permutated[i];
1172
            block[j] = level * quant_matrix[j] << Al;
1173
        }else{
1174
            run = ((unsigned) code) >> 4;
1175
            if(run == 0xF){// ZRL - skip 15 coefficients
1176
                i += 15;
1177
            }else{
1178
                val = run;
1179
                run = (1 << run);
1180
                UPDATE_CACHE(re, &s->gb);
1181
                run += (GET_CACHE(re, &s->gb) >> (32 - val)) & (run - 1);
1182
                if(val)
1183
                    LAST_SKIP_BITS(re, &s->gb, val);
1184
                *EOBRUN = run - 1;
1185
                break;
1186
            }
1187
        }
1188
    }
1189
    CLOSE_READER(re, &s->gb)}
1190

    
1191
    return 0;
1192
}
1193

    
1194
static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1195
    int i, mb_x, mb_y;
1196
    uint16_t buffer[32768][4];
1197
    int left[3], top[3], topleft[3];
1198
    const int linesize= s->linesize[0];
1199
    const int mask= (1<<s->bits)-1;
1200

    
1201
    if((unsigned)s->mb_width > 32768) //dynamic alloc
1202
        return -1;
1203

    
1204
    for(i=0; i<3; i++){
1205
        buffer[0][i]= 1 << (s->bits + point_transform - 1);
1206
    }
1207
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1208
        const int modified_predictor= mb_y ? predictor : 1;
1209
        uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1210

    
1211
        if (s->interlaced && s->bottom_field)
1212
            ptr += linesize >> 1;
1213

    
1214
        for(i=0; i<3; i++){
1215
            top[i]= left[i]= topleft[i]= buffer[0][i];
1216
        }
1217
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1218
            if (s->restart_interval && !s->restart_count)
1219
                s->restart_count = s->restart_interval;
1220

    
1221
            for(i=0;i<3;i++) {
1222
                int pred;
1223

    
1224
                topleft[i]= top[i];
1225
                top[i]= buffer[mb_x][i];
1226

    
1227
                PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1228

    
1229
                left[i]=
1230
                buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1231
            }
1232

    
1233
            if (s->restart_interval && !--s->restart_count) {
1234
                align_get_bits(&s->gb);
1235
                skip_bits(&s->gb, 16); /* skip RSTn */
1236
            }
1237
        }
1238

    
1239
        if(s->rct){
1240
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1241
                ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1242
                ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1243
                ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1244
            }
1245
        }else if(s->pegasus_rct){
1246
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1247
                ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1248
                ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1249
                ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1250
            }
1251
        }else{
1252
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1253
                ptr[4*mb_x+0] = buffer[mb_x][0];
1254
                ptr[4*mb_x+1] = buffer[mb_x][1];
1255
                ptr[4*mb_x+2] = buffer[mb_x][2];
1256
            }
1257
        }
1258
    }
1259
    return 0;
1260
}
1261

    
1262
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1263
    int i, mb_x, mb_y;
1264
    const int nb_components=3;
1265

    
1266
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1267
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1268
            if (s->restart_interval && !s->restart_count)
1269
                s->restart_count = s->restart_interval;
1270

    
1271
            if(mb_x==0 || mb_y==0 || s->interlaced){
1272
                for(i=0;i<nb_components;i++) {
1273
                    uint8_t *ptr;
1274
                    int n, h, v, x, y, c, j, linesize;
1275
                    n = s->nb_blocks[i];
1276
                    c = s->comp_index[i];
1277
                    h = s->h_scount[i];
1278
                    v = s->v_scount[i];
1279
                    x = 0;
1280
                    y = 0;
1281
                    linesize= s->linesize[c];
1282

    
1283
                    for(j=0; j<n; j++) {
1284
                        int pred;
1285

    
1286
                        ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1287
                        if(y==0 && mb_y==0){
1288
                            if(x==0 && mb_x==0){
1289
                                pred= 128 << point_transform;
1290
                            }else{
1291
                                pred= ptr[-1];
1292
                            }
1293
                        }else{
1294
                            if(x==0 && mb_x==0){
1295
                                pred= ptr[-linesize];
1296
                            }else{
1297
                                PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1298
                            }
1299
                        }
1300

    
1301
                        if (s->interlaced && s->bottom_field)
1302
                            ptr += linesize >> 1;
1303
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1304

    
1305
                        if (++x == h) {
1306
                            x = 0;
1307
                            y++;
1308
                        }
1309
                    }
1310
                }
1311
            }else{
1312
                for(i=0;i<nb_components;i++) {
1313
                    uint8_t *ptr;
1314
                    int n, h, v, x, y, c, j, linesize;
1315
                    n = s->nb_blocks[i];
1316
                    c = s->comp_index[i];
1317
                    h = s->h_scount[i];
1318
                    v = s->v_scount[i];
1319
                    x = 0;
1320
                    y = 0;
1321
                    linesize= s->linesize[c];
1322

    
1323
                    for(j=0; j<n; j++) {
1324
                        int pred;
1325

    
1326
                        ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1327
                        PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1328
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1329
                        if (++x == h) {
1330
                            x = 0;
1331
                            y++;
1332
                        }
1333
                    }
1334
                }
1335
            }
1336
            if (s->restart_interval && !--s->restart_count) {
1337
                align_get_bits(&s->gb);
1338
                skip_bits(&s->gb, 16); /* skip RSTn */
1339
            }
1340
        }
1341
    }
1342
    return 0;
1343
}
1344

    
1345
static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int ss, int se, int Ah, int Al){
1346
    int i, mb_x, mb_y;
1347
    int EOBRUN = 0;
1348

    
1349
    if(Ah) return 0; /* TODO decode refinement planes too */
1350
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1351
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1352
            if (s->restart_interval && !s->restart_count)
1353
                s->restart_count = s->restart_interval;
1354

    
1355
            for(i=0;i<nb_components;i++) {
1356
                uint8_t *ptr;
1357
                int n, h, v, x, y, c, j;
1358
                n = s->nb_blocks[i];
1359
                c = s->comp_index[i];
1360
                h = s->h_scount[i];
1361
                v = s->v_scount[i];
1362
                x = 0;
1363
                y = 0;
1364
                for(j=0;j<n;j++) {
1365
                    memset(s->block, 0, sizeof(s->block));
1366
                    if (!s->progressive && decode_block(s, s->block, i,
1367
                                     s->dc_index[i], s->ac_index[i],
1368
                                     s->quant_matrixes[ s->quant_index[c] ]) < 0) {
1369
                        av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
1370
                        return -1;
1371
                    }
1372
                    if (s->progressive && decode_block_progressive(s, s->block, i,
1373
                                     s->dc_index[i], s->ac_index[i],
1374
                                     s->quant_matrixes[ s->quant_index[c] ], ss, se, Ah, Al, &EOBRUN) < 0) {
1375
                        av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
1376
                        return -1;
1377
                    }
1378
//                    av_log(s->avctx, AV_LOG_DEBUG, "mb: %d %d processed\n", mb_y, mb_x);
1379
                    ptr = s->picture.data[c] +
1380
                        (((s->linesize[c] * (v * mb_y + y) * 8) +
1381
                        (h * mb_x + x) * 8) >> s->avctx->lowres);
1382
                    if (s->interlaced && s->bottom_field)
1383
                        ptr += s->linesize[c] >> 1;
1384
//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);
1385
                    if(!s->progressive)
1386
                        s->dsp.idct_put(ptr, s->linesize[c], s->block);
1387
                    else
1388
                        s->dsp.idct_add(ptr, s->linesize[c], s->block);
1389
                    if (++x == h) {
1390
                        x = 0;
1391
                        y++;
1392
                    }
1393
                }
1394
            }
1395
            /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1396
            if (s->restart_interval && (s->restart_interval < 1350) &&
1397
                !--s->restart_count) {
1398
                align_get_bits(&s->gb);
1399
                skip_bits(&s->gb, 16); /* skip RSTn */
1400
                for (i=0; i<nb_components; i++) /* reset dc */
1401
                    s->last_dc[i] = 1024;
1402
            }
1403
        }
1404
    }
1405
    return 0;
1406
}
1407

    
1408
static int mjpeg_decode_sos(MJpegDecodeContext *s)
1409
{
1410
    int len, nb_components, i, h, v, predictor, point_transform;
1411
    int vmax, hmax, index, id;
1412
    const int block_size= s->lossless ? 1 : 8;
1413
    int ilv, prev_shift;
1414

    
1415
    /* XXX: verify len field validity */
1416
    len = get_bits(&s->gb, 16);
1417
    nb_components = get_bits(&s->gb, 8);
1418
    if (len != 6+2*nb_components)
1419
    {
1420
        av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1421
        return -1;
1422
    }
1423
    vmax = 0;
1424
    hmax = 0;
1425
    for(i=0;i<nb_components;i++) {
1426
        id = get_bits(&s->gb, 8) - 1;
1427
        av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1428
        /* find component index */
1429
        for(index=0;index<s->nb_components;index++)
1430
            if (id == s->component_id[index])
1431
                break;
1432
        if (index == s->nb_components)
1433
        {
1434
            av_log(s->avctx, AV_LOG_ERROR, "decode_sos: index(%d) out of components\n", index);
1435
            return -1;
1436
        }
1437

    
1438
        s->comp_index[i] = index;
1439

    
1440
        s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1441
        s->h_scount[i] = s->h_count[index];
1442
        s->v_scount[i] = s->v_count[index];
1443

    
1444
        s->dc_index[i] = get_bits(&s->gb, 4);
1445
        s->ac_index[i] = get_bits(&s->gb, 4);
1446

    
1447
        if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1448
            s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1449
            goto out_of_range;
1450
#if 0 //buggy
1451
        switch(s->start_code)
1452
        {
1453
            case SOF0:
1454
                if (dc_index[i] > 1 || ac_index[i] > 1)
1455
                    goto out_of_range;
1456
                break;
1457
            case SOF1:
1458
            case SOF2:
1459
                if (dc_index[i] > 3 || ac_index[i] > 3)
1460
                    goto out_of_range;
1461
                break;
1462
            case SOF3:
1463
                if (dc_index[i] > 3 || ac_index[i] != 0)
1464
                    goto out_of_range;
1465
                break;
1466
        }
1467
#endif
1468
    }
1469

    
1470
    predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1471
    ilv= get_bits(&s->gb, 8);    /* JPEG Se / JPEG-LS ILV */
1472
    prev_shift = get_bits(&s->gb, 4); /* Ah */
1473
    point_transform= get_bits(&s->gb, 4); /* Al */
1474

    
1475
    for(i=0;i<nb_components;i++)
1476
        s->last_dc[i] = 1024;
1477

    
1478
    if (nb_components > 1) {
1479
        /* interleaved stream */
1480
        s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1481
        s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1482
    } else if(!s->ls) { /* skip this for JPEG-LS */
1483
        h = s->h_max / s->h_scount[0];
1484
        v = s->v_max / s->v_scount[0];
1485
        s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1486
        s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1487
        s->nb_blocks[0] = 1;
1488
        s->h_scount[0] = 1;
1489
        s->v_scount[0] = 1;
1490
    }
1491

    
1492
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1493
        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" : "",
1494
               predictor, point_transform, ilv, s->bits,
1495
               s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));
1496

    
1497

    
1498
    /* mjpeg-b can have padding bytes between sos and image data, skip them */
1499
    for (i = s->mjpb_skiptosod; i > 0; i--)
1500
        skip_bits(&s->gb, 8);
1501

    
1502
    if(s->lossless){
1503
        if(s->ls){
1504
//            for(){
1505
//            reset_ls_coding_parameters(s, 0);
1506

    
1507
            ff_jpegls_decode_picture(s, predictor, point_transform, ilv);
1508
        }else{
1509
            if(s->rgb){
1510
                if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1511
                    return -1;
1512
            }else{
1513
                if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1514
                    return -1;
1515
            }
1516
        }
1517
    }else{
1518
        if(mjpeg_decode_scan(s, nb_components, predictor, ilv, prev_shift, point_transform) < 0)
1519
            return -1;
1520
    }
1521
    emms_c();
1522
    return 0;
1523
 out_of_range:
1524
    av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1525
    return -1;
1526
}
1527

    
1528
static int mjpeg_decode_dri(MJpegDecodeContext *s)
1529
{
1530
    if (get_bits(&s->gb, 16) != 4)
1531
        return -1;
1532
    s->restart_interval = get_bits(&s->gb, 16);
1533
    s->restart_count = 0;
1534
    av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n", s->restart_interval);
1535

    
1536
    return 0;
1537
}
1538

    
1539
static int mjpeg_decode_app(MJpegDecodeContext *s)
1540
{
1541
    int len, id, i;
1542

    
1543
    len = get_bits(&s->gb, 16);
1544
    if (len < 5)
1545
        return -1;
1546
    if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits)
1547
        return -1;
1548

    
1549
    id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1550
    id = be2me_32(id);
1551
    len -= 6;
1552

    
1553
    if(s->avctx->debug & FF_DEBUG_STARTCODE){
1554
        av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
1555
    }
1556

    
1557
    /* buggy AVID, it puts EOI only at every 10th frame */
1558
    /* also this fourcc is used by non-avid files too, it holds some
1559
       informations, but it's always present in AVID creates files */
1560
    if (id == ff_get_fourcc("AVI1"))
1561
    {
1562
        /* structure:
1563
            4bytes      AVI1
1564
            1bytes      polarity
1565
            1bytes      always zero
1566
            4bytes      field_size
1567
            4bytes      field_size_less_padding
1568
        */
1569
            s->buggy_avid = 1;
1570
//        if (s->first_picture)
1571
//            printf("mjpeg: workarounding buggy AVID\n");
1572
        i = get_bits(&s->gb, 8);
1573
        if     (i==2) s->bottom_field= 1;
1574
        else if(i==1) s->bottom_field= 0;
1575
#if 0
1576
        skip_bits(&s->gb, 8);
1577
        skip_bits(&s->gb, 32);
1578
        skip_bits(&s->gb, 32);
1579
        len -= 10;
1580
#endif
1581
//        if (s->interlace_polarity)
1582
//            printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1583
        goto out;
1584
    }
1585

    
1586
//    len -= 2;
1587

    
1588
    if (id == ff_get_fourcc("JFIF"))
1589
    {
1590
        int t_w, t_h, v1, v2;
1591
        skip_bits(&s->gb, 8); /* the trailing zero-byte */
1592
        v1= get_bits(&s->gb, 8);
1593
        v2= get_bits(&s->gb, 8);
1594
        skip_bits(&s->gb, 8);
1595

    
1596
        s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1597
        s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1598

    
1599
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1600
            av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1601
                v1, v2,
1602
                s->avctx->sample_aspect_ratio.num,
1603
                s->avctx->sample_aspect_ratio.den
1604
            );
1605

    
1606
        t_w = get_bits(&s->gb, 8);
1607
        t_h = get_bits(&s->gb, 8);
1608
        if (t_w && t_h)
1609
        {
1610
            /* skip thumbnail */
1611
            if (len-10-(t_w*t_h*3) > 0)
1612
                len -= t_w*t_h*3;
1613
        }
1614
        len -= 10;
1615
        goto out;
1616
    }
1617

    
1618
    if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1619
    {
1620
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1621
            av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1622
        skip_bits(&s->gb, 16); /* version */
1623
        skip_bits(&s->gb, 16); /* flags0 */
1624
        skip_bits(&s->gb, 16); /* flags1 */
1625
        skip_bits(&s->gb, 8);  /* transform */
1626
        len -= 7;
1627
        goto out;
1628
    }
1629

    
1630
    if (id == ff_get_fourcc("LJIF")){
1631
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1632
            av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1633
        skip_bits(&s->gb, 16); /* version ? */
1634
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1635
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1636
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1637
        switch( get_bits(&s->gb, 8)){
1638
        case 1:
1639
            s->rgb= 1;
1640
            s->pegasus_rct=0;
1641
            break;
1642
        case 2:
1643
            s->rgb= 1;
1644
            s->pegasus_rct=1;
1645
            break;
1646
        default:
1647
            av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1648
        }
1649
        len -= 9;
1650
        goto out;
1651
    }
1652

    
1653
    /* Apple MJPEG-A */
1654
    if ((s->start_code == APP1) && (len > (0x28 - 8)))
1655
    {
1656
        id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1657
        id = be2me_32(id);
1658
        len -= 4;
1659
        if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1660
        {
1661
#if 0
1662
            skip_bits(&s->gb, 32); /* field size */
1663
            skip_bits(&s->gb, 32); /* pad field size */
1664
            skip_bits(&s->gb, 32); /* next off */
1665
            skip_bits(&s->gb, 32); /* quant off */
1666
            skip_bits(&s->gb, 32); /* huff off */
1667
            skip_bits(&s->gb, 32); /* image off */
1668
            skip_bits(&s->gb, 32); /* scan off */
1669
            skip_bits(&s->gb, 32); /* data off */
1670
#endif
1671
            if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1672
                av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1673
        }
1674
    }
1675

    
1676
out:
1677
    /* slow but needed for extreme adobe jpegs */
1678
    if (len < 0)
1679
        av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1680
    while(--len > 0)
1681
        skip_bits(&s->gb, 8);
1682

    
1683
    return 0;
1684
}
1685

    
1686
static int mjpeg_decode_com(MJpegDecodeContext *s)
1687
{
1688
    int len = get_bits(&s->gb, 16);
1689
    if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) {
1690
        char *cbuf = av_malloc(len - 1);
1691
        if (cbuf) {
1692
            int i;
1693
            for (i = 0; i < len - 2; i++)
1694
                cbuf[i] = get_bits(&s->gb, 8);
1695
            if (i > 0 && cbuf[i-1] == '\n')
1696
                cbuf[i-1] = 0;
1697
            else
1698
                cbuf[i] = 0;
1699

    
1700
            if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1701
                av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1702

    
1703
            /* buggy avid, it puts EOI only at every 10th frame */
1704
            if (!strcmp(cbuf, "AVID"))
1705
            {
1706
                s->buggy_avid = 1;
1707
                //        if (s->first_picture)
1708
                //            printf("mjpeg: workarounding buggy AVID\n");
1709
            }
1710
            else if(!strcmp(cbuf, "CS=ITU601")){
1711
                s->cs_itu601= 1;
1712
            }
1713

    
1714
            av_free(cbuf);
1715
        }
1716
    }
1717

    
1718
    return 0;
1719
}
1720

    
1721
#if 0
1722
static int valid_marker_list[] =
1723
{
1724
        /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1725
/* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1726
/* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1727
/* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1728
/* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1729
/* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1730
/* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1731
/* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1732
/* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1733
/* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1734
/* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1735
/* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1736
/* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1737
/* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1738
/* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1739
/* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1740
/* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1741
}
1742
#endif
1743

    
1744
/* return the 8 bit start code value and update the search
1745
   state. Return -1 if no start code found */
1746
static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1747
{
1748
    uint8_t *buf_ptr;
1749
    unsigned int v, v2;
1750
    int val;
1751
#ifdef DEBUG
1752
    int skipped=0;
1753
#endif
1754

    
1755
    buf_ptr = *pbuf_ptr;
1756
    while (buf_ptr < buf_end) {
1757
        v = *buf_ptr++;
1758
        v2 = *buf_ptr;
1759
        if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1760
            val = *buf_ptr++;
1761
            goto found;
1762
        }
1763
#ifdef DEBUG
1764
        skipped++;
1765
#endif
1766
    }
1767
    val = -1;
1768
found:
1769
#ifdef DEBUG
1770
    av_log(NULL, AV_LOG_VERBOSE, "find_marker skipped %d bytes\n", skipped);
1771
#endif
1772
    *pbuf_ptr = buf_ptr;
1773
    return val;
1774
}
1775

    
1776
static int mjpeg_decode_frame(AVCodecContext *avctx,
1777
                              void *data, int *data_size,
1778
                              uint8_t *buf, int buf_size)
1779
{
1780
    MJpegDecodeContext *s = avctx->priv_data;
1781
    uint8_t *buf_end, *buf_ptr;
1782
    int start_code;
1783
    AVFrame *picture = data;
1784

    
1785
    buf_ptr = buf;
1786
    buf_end = buf + buf_size;
1787
    while (buf_ptr < buf_end) {
1788
        /* find start next marker */
1789
        start_code = find_marker(&buf_ptr, buf_end);
1790
        {
1791
            /* EOF */
1792
            if (start_code < 0) {
1793
                goto the_end;
1794
            } else {
1795
                av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1796

    
1797
                if ((buf_end - buf_ptr) > s->buffer_size)
1798
                {
1799
                    av_free(s->buffer);
1800
                    s->buffer_size = buf_end-buf_ptr;
1801
                    s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
1802
                    av_log(avctx, AV_LOG_DEBUG, "buffer too small, expanding to %d bytes\n",
1803
                        s->buffer_size);
1804
                }
1805

    
1806
                /* unescape buffer of SOS, use special treatment for JPEG-LS */
1807
                if (start_code == SOS && !s->ls)
1808
                {
1809
                    uint8_t *src = buf_ptr;
1810
                    uint8_t *dst = s->buffer;
1811

    
1812
                    while (src<buf_end)
1813
                    {
1814
                        uint8_t x = *(src++);
1815

    
1816
                        *(dst++) = x;
1817
                        if (avctx->codec_id != CODEC_ID_THP)
1818
                        {
1819
                            if (x == 0xff) {
1820
                                while (src < buf_end && x == 0xff)
1821
                                    x = *(src++);
1822

    
1823
                                if (x >= 0xd0 && x <= 0xd7)
1824
                                    *(dst++) = x;
1825
                                else if (x)
1826
                                    break;
1827
                            }
1828
                        }
1829
                    }
1830
                    init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1831

    
1832
                    av_log(avctx, AV_LOG_DEBUG, "escaping removed %d bytes\n",
1833
                           (buf_end - buf_ptr) - (dst - s->buffer));
1834
                }
1835
                else if(start_code == SOS && s->ls){
1836
                    uint8_t *src = buf_ptr;
1837
                    uint8_t *dst = s->buffer;
1838
                    int bit_count = 0;
1839
                    int t = 0, b = 0;
1840
                    PutBitContext pb;
1841

    
1842
                    s->cur_scan++;
1843

    
1844
                    /* find marker */
1845
                    while (src + t < buf_end){
1846
                        uint8_t x = src[t++];
1847
                        if (x == 0xff){
1848
                            while((src + t < buf_end) && x == 0xff)
1849
                                x = src[t++];
1850
                            if (x & 0x80) {
1851
                                t -= 2;
1852
                                break;
1853
                            }
1854
                        }
1855
                    }
1856
                    bit_count = t * 8;
1857

    
1858
                    init_put_bits(&pb, dst, t);
1859

    
1860
                    /* unescape bitstream */
1861
                    while(b < t){
1862
                        uint8_t x = src[b++];
1863
                        put_bits(&pb, 8, x);
1864
                        if(x == 0xFF){
1865
                            x = src[b++];
1866
                            put_bits(&pb, 7, x);
1867
                            bit_count--;
1868
                        }
1869
                    }
1870
                    flush_put_bits(&pb);
1871

    
1872
                    init_get_bits(&s->gb, dst, bit_count);
1873
                }
1874
                else
1875
                    init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1876

    
1877
                s->start_code = start_code;
1878
                if(s->avctx->debug & FF_DEBUG_STARTCODE){
1879
                    av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
1880
                }
1881

    
1882
                /* process markers */
1883
                if (start_code >= 0xd0 && start_code <= 0xd7) {
1884
                    av_log(avctx, AV_LOG_DEBUG, "restart marker: %d\n", start_code&0x0f);
1885
                    /* APP fields */
1886
                } else if (start_code >= APP0 && start_code <= APP15) {
1887
                    mjpeg_decode_app(s);
1888
                    /* Comment */
1889
                } else if (start_code == COM){
1890
                    mjpeg_decode_com(s);
1891
                }
1892

    
1893
                switch(start_code) {
1894
                case SOI:
1895
                    s->restart_interval = 0;
1896

    
1897
                    s->restart_count = 0;
1898
                    /* nothing to do on SOI */
1899
                    break;
1900
                case DQT:
1901
                    mjpeg_decode_dqt(s);
1902
                    break;
1903
                case DHT:
1904
                    if(mjpeg_decode_dht(s) < 0){
1905
                        av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
1906
                        return -1;
1907
                    }
1908
                    break;
1909
                case SOF0:
1910
                    s->lossless=0;
1911
                    s->ls=0;
1912
                    s->progressive=0;
1913
                    if (mjpeg_decode_sof(s) < 0)
1914
                        return -1;
1915
                    break;
1916
                case SOF2:
1917
                    s->lossless=0;
1918
                    s->ls=0;
1919
                    s->progressive=1;
1920
                    if (mjpeg_decode_sof(s) < 0)
1921
                        return -1;
1922
                    break;
1923
                case SOF3:
1924
                    s->lossless=1;
1925
                    s->ls=0;
1926
                    s->progressive=0;
1927
                    if (mjpeg_decode_sof(s) < 0)
1928
                        return -1;
1929
                    break;
1930
                case SOF48:
1931
                    s->lossless=1;
1932
                    s->ls=1;
1933
                    s->progressive=0;
1934
                    if (mjpeg_decode_sof(s) < 0)
1935
                        return -1;
1936
                    break;
1937
                case LSE:
1938
                    if (ff_jpegls_decode_lse(s) < 0)
1939
                        return -1;
1940
                    break;
1941
                case EOI:
1942
                    s->cur_scan = 0;
1943
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1944
                        break;
1945
eoi_parser:
1946
                    {
1947
                        if (s->interlaced) {
1948
                            s->bottom_field ^= 1;
1949
                            /* if not bottom field, do not output image yet */
1950
                            if (s->bottom_field == !s->interlace_polarity)
1951
                                goto not_the_end;
1952
                        }
1953
                        *picture = s->picture;
1954
                        *data_size = sizeof(AVFrame);
1955

    
1956
                        if(!s->lossless){
1957
                            picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
1958
                            picture->qstride= 0;
1959
                            picture->qscale_table= s->qscale_table;
1960
                            memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1961
                            if(avctx->debug & FF_DEBUG_QP)
1962
                                av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
1963
                            picture->quality*= FF_QP2LAMBDA;
1964
                        }
1965

    
1966
                        goto the_end;
1967
                    }
1968
                    break;
1969
                case SOS:
1970
                    mjpeg_decode_sos(s);
1971
                    /* buggy avid puts EOI every 10-20th frame */
1972
                    /* if restart period is over process EOI */
1973
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1974
                        goto eoi_parser;
1975
                    break;
1976
                case DRI:
1977
                    mjpeg_decode_dri(s);
1978
                    break;
1979
                case SOF1:
1980
                case SOF5:
1981
                case SOF6:
1982
                case SOF7:
1983
                case SOF9:
1984
                case SOF10:
1985
                case SOF11:
1986
                case SOF13:
1987
                case SOF14:
1988
                case SOF15:
1989
                case JPG:
1990
                    av_log(avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
1991
                    break;
1992
//                default:
1993
//                    printf("mjpeg: unsupported marker (%x)\n", start_code);
1994
//                    break;
1995
                }
1996

    
1997
not_the_end:
1998
                /* eof process start code */
1999
                buf_ptr += (get_bits_count(&s->gb)+7)/8;
2000
                av_log(avctx, AV_LOG_DEBUG, "marker parser used %d bytes (%d bits)\n",
2001
                       (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
2002
            }
2003
        }
2004
    }
2005
the_end:
2006
    av_log(avctx, AV_LOG_DEBUG, "mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
2007
//    return buf_end - buf_ptr;
2008
    return buf_ptr - buf;
2009
}
2010

    
2011
static int mjpegb_decode_frame(AVCodecContext *avctx,
2012
                              void *data, int *data_size,
2013
                              uint8_t *buf, int buf_size)
2014
{
2015
    MJpegDecodeContext *s = avctx->priv_data;
2016
    uint8_t *buf_end, *buf_ptr;
2017
    AVFrame *picture = data;
2018
    GetBitContext hgb; /* for the header */
2019
    uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
2020
    uint32_t field_size, sod_offs;
2021

    
2022
    buf_ptr = buf;
2023
    buf_end = buf + buf_size;
2024

    
2025
read_header:
2026
    /* reset on every SOI */
2027
    s->restart_interval = 0;
2028
    s->restart_count = 0;
2029
    s->mjpb_skiptosod = 0;
2030

    
2031
    init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
2032

    
2033
    skip_bits(&hgb, 32); /* reserved zeros */
2034

    
2035
    if (get_bits_long(&hgb, 32) != MKBETAG('m','j','p','g'))
2036
    {
2037
        av_log(avctx, AV_LOG_WARNING, "not mjpeg-b (bad fourcc)\n");
2038
        return 0;
2039
    }
2040

    
2041
    field_size = get_bits_long(&hgb, 32); /* field size */
2042
    av_log(avctx, AV_LOG_DEBUG, "field size: 0x%x\n", field_size);
2043
    skip_bits(&hgb, 32); /* padded field size */
2044
    second_field_offs = get_bits_long(&hgb, 32);
2045
    av_log(avctx, AV_LOG_DEBUG, "second field offs: 0x%x\n", second_field_offs);
2046

    
2047
    dqt_offs = get_bits_long(&hgb, 32);
2048
    av_log(avctx, AV_LOG_DEBUG, "dqt offs: 0x%x\n", dqt_offs);
2049
    if (dqt_offs)
2050
    {
2051
        init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
2052
        s->start_code = DQT;
2053
        mjpeg_decode_dqt(s);
2054
    }
2055

    
2056
    dht_offs = get_bits_long(&hgb, 32);
2057
    av_log(avctx, AV_LOG_DEBUG, "dht offs: 0x%x\n", dht_offs);
2058
    if (dht_offs)
2059
    {
2060
        init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
2061
        s->start_code = DHT;
2062
        mjpeg_decode_dht(s);
2063
    }
2064

    
2065
    sof_offs = get_bits_long(&hgb, 32);
2066
    av_log(avctx, AV_LOG_DEBUG, "sof offs: 0x%x\n", sof_offs);
2067
    if (sof_offs)
2068
    {
2069
        init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
2070
        s->start_code = SOF0;
2071
        if (mjpeg_decode_sof(s) < 0)
2072
            return -1;
2073
    }
2074

    
2075
    sos_offs = get_bits_long(&hgb, 32);
2076
    av_log(avctx, AV_LOG_DEBUG, "sos offs: 0x%x\n", sos_offs);
2077
    sod_offs = get_bits_long(&hgb, 32);
2078
    av_log(avctx, AV_LOG_DEBUG, "sod offs: 0x%x\n", sod_offs);
2079
    if (sos_offs)
2080
    {
2081
//        init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2082
        init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2083
        s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
2084
        s->start_code = SOS;
2085
        mjpeg_decode_sos(s);
2086
    }
2087

    
2088
    if (s->interlaced) {
2089
        s->bottom_field ^= 1;
2090
        /* if not bottom field, do not output image yet */
2091
        if (s->bottom_field && second_field_offs)
2092
        {
2093
            buf_ptr = buf + second_field_offs;
2094
            second_field_offs = 0;
2095
            goto read_header;
2096
            }
2097
    }
2098

    
2099
    //XXX FIXME factorize, this looks very similar to the EOI code
2100

    
2101
    *picture= s->picture;
2102
    *data_size = sizeof(AVFrame);
2103

    
2104
    if(!s->lossless){
2105
        picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2106
        picture->qstride= 0;
2107
        picture->qscale_table= s->qscale_table;
2108
        memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2109
        if(avctx->debug & FF_DEBUG_QP)
2110
            av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2111
        picture->quality*= FF_QP2LAMBDA;
2112
    }
2113

    
2114
    return buf_ptr - buf;
2115
}
2116

    
2117
#include "sp5x.h"
2118

    
2119
static int sp5x_decode_frame(AVCodecContext *avctx,
2120
                              void *data, int *data_size,
2121
                              uint8_t *buf, int buf_size)
2122
{
2123
#if 0
2124
    MJpegDecodeContext *s = avctx->priv_data;
2125
#endif
2126
    const int qscale = 5;
2127
    uint8_t *buf_ptr, *buf_end, *recoded;
2128
    int i = 0, j = 0;
2129

    
2130
    if (!avctx->width || !avctx->height)
2131
        return -1;
2132

    
2133
    buf_ptr = buf;
2134
    buf_end = buf + buf_size;
2135

    
2136
#if 1
2137
    recoded = av_mallocz(buf_size + 1024);
2138
    if (!recoded)
2139
        return -1;
2140

    
2141
    /* SOI */
2142
    recoded[j++] = 0xFF;
2143
    recoded[j++] = 0xD8;
2144

    
2145
    memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2146
    memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2147
    memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2148
    j += sizeof(sp5x_data_dqt);
2149

    
2150
    memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2151
    j += sizeof(sp5x_data_dht);
2152

    
2153
    memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2154
    recoded[j+5] = (avctx->coded_height >> 8) & 0xFF;
2155
    recoded[j+6] = avctx->coded_height & 0xFF;
2156
    recoded[j+7] = (avctx->coded_width >> 8) & 0xFF;
2157
    recoded[j+8] = avctx->coded_width & 0xFF;
2158
    j += sizeof(sp5x_data_sof);
2159

    
2160
    memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2161
    j += sizeof(sp5x_data_sos);
2162

    
2163
    for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2164
    {
2165
        recoded[j++] = buf[i];
2166
        if (buf[i] == 0xff)
2167
            recoded[j++] = 0;
2168
    }
2169

    
2170
    /* EOI */
2171
    recoded[j++] = 0xFF;
2172
    recoded[j++] = 0xD9;
2173

    
2174
    i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2175

    
2176
    av_free(recoded);
2177

    
2178
#else
2179
    /* SOF */
2180
    s->bits = 8;
2181
    s->width  = avctx->coded_width;
2182
    s->height = avctx->coded_height;
2183
    s->nb_components = 3;
2184
    s->component_id[0] = 0;
2185
    s->h_count[0] = 2;
2186
    s->v_count[0] = 2;
2187
    s->quant_index[0] = 0;
2188
    s->component_id[1] = 1;
2189
    s->h_count[1] = 1;
2190
    s->v_count[1] = 1;
2191
    s->quant_index[1] = 1;
2192
    s->component_id[2] = 2;
2193
    s->h_count[2] = 1;
2194
    s->v_count[2] = 1;
2195
    s->quant_index[2] = 1;
2196
    s->h_max = 2;
2197
    s->v_max = 2;
2198

    
2199
    s->qscale_table = av_mallocz((s->width+15)/16);
2200
    avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420;
2201
    s->interlaced = 0;
2202

    
2203
    s->picture.reference = 0;
2204
    if (avctx->get_buffer(avctx, &s->picture) < 0)
2205
    {
2206
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2207
        return -1;
2208
    }
2209

    
2210
    s->picture.pict_type = I_TYPE;
2211
    s->picture.key_frame = 1;
2212

    
2213
    for (i = 0; i < 3; i++)
2214
        s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2215

    
2216
    /* DQT */
2217
    for (i = 0; i < 64; i++)
2218
    {
2219
        j = s->scantable.permutated[i];
2220
        s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2221
    }
2222
    s->qscale[0] = FFMAX(
2223
        s->quant_matrixes[0][s->scantable.permutated[1]],
2224
        s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2225

    
2226
    for (i = 0; i < 64; i++)
2227
    {
2228
        j = s->scantable.permutated[i];
2229
        s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2230
    }
2231
    s->qscale[1] = FFMAX(
2232
        s->quant_matrixes[1][s->scantable.permutated[1]],
2233
        s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2234

    
2235
    /* DHT */
2236

    
2237
    /* SOS */
2238
    s->comp_index[0] = 0;
2239
    s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2240
    s->h_scount[0] = s->h_count[0];
2241
    s->v_scount[0] = s->v_count[0];
2242
    s->dc_index[0] = 0;
2243
    s->ac_index[0] = 0;
2244

    
2245
    s->comp_index[1] = 1;
2246
    s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2247
    s->h_scount[1] = s->h_count[1];
2248
    s->v_scount[1] = s->v_count[1];
2249
    s->dc_index[1] = 1;
2250
    s->ac_index[1] = 1;
2251

    
2252
    s->comp_index[2] = 2;
2253
    s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2254
    s->h_scount[2] = s->h_count[2];
2255
    s->v_scount[2] = s->v_count[2];
2256
    s->dc_index[2] = 1;
2257
    s->ac_index[2] = 1;
2258

    
2259
    for (i = 0; i < 3; i++)
2260
        s->last_dc[i] = 1024;
2261

    
2262
    s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2263
    s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2264

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

    
2267
    return mjpeg_decode_scan(s);
2268
#endif
2269

    
2270
    return i;
2271
}
2272

    
2273
static int mjpeg_decode_end(AVCodecContext *avctx)
2274
{
2275
    MJpegDecodeContext *s = avctx->priv_data;
2276
    int i, j;
2277

    
2278
    av_free(s->buffer);
2279
    av_free(s->qscale_table);
2280

    
2281
    for(i=0;i<2;i++) {
2282
        for(j=0;j<4;j++)
2283
            free_vlc(&s->vlcs[i][j]);
2284
    }
2285
    return 0;
2286
}
2287

    
2288
static int mjpega_dump_header(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args,
2289
                              uint8_t **poutbuf, int *poutbuf_size,
2290
                              const uint8_t *buf, int buf_size, int keyframe)
2291
{
2292
    uint8_t *poutbufp;
2293
    int i;
2294

    
2295
    if (avctx->codec_id != CODEC_ID_MJPEG) {
2296
        av_log(avctx, AV_LOG_ERROR, "mjpega bitstream filter only applies to mjpeg codec\n");
2297
        return 0;
2298
    }
2299

    
2300
    *poutbuf_size = 0;
2301
    *poutbuf = av_malloc(buf_size + 44 + FF_INPUT_BUFFER_PADDING_SIZE);
2302
    poutbufp = *poutbuf;
2303
    bytestream_put_byte(&poutbufp, 0xff);
2304
    bytestream_put_byte(&poutbufp, SOI);
2305
    bytestream_put_byte(&poutbufp, 0xff);
2306
    bytestream_put_byte(&poutbufp, APP1);
2307
    bytestream_put_be16(&poutbufp, 42); /* size */
2308
    bytestream_put_be32(&poutbufp, 0);
2309
    bytestream_put_buffer(&poutbufp, "mjpg", 4);
2310
    bytestream_put_be32(&poutbufp, buf_size + 44); /* field size */
2311
    bytestream_put_be32(&poutbufp, buf_size + 44); /* pad field size */
2312
    bytestream_put_be32(&poutbufp, 0);             /* next ptr */
2313

    
2314
    for (i = 0; i < buf_size - 1; i++) {
2315
        if (buf[i] == 0xff) {
2316
            switch (buf[i + 1]) {
2317
            case DQT:  /* quant off */
2318
            case DHT:  /* huff  off */
2319
            case SOF0: /* image off */
2320
                bytestream_put_be32(&poutbufp, i + 46);
2321
                break;
2322
            case SOS:
2323
                bytestream_put_be32(&poutbufp, i + 46); /* scan off */
2324
                bytestream_put_be32(&poutbufp, i + 46 + AV_RB16(buf + i + 2)); /* data off */
2325
                bytestream_put_buffer(&poutbufp, buf + 2, buf_size - 2); /* skip already written SOI */
2326
                *poutbuf_size = poutbufp - *poutbuf;
2327
                return 1;
2328
            case APP1:
2329
                if (i + 8 < buf_size && AV_RL32(buf + i + 8) == ff_get_fourcc("mjpg")) {
2330
                    av_log(avctx, AV_LOG_ERROR, "bitstream already formatted\n");
2331
                    memcpy(*poutbuf, buf, buf_size);
2332
                    *poutbuf_size = buf_size;
2333
                    return 1;
2334
                }
2335
            }
2336
        }
2337
    }
2338
    av_freep(poutbuf);
2339
    av_log(avctx, AV_LOG_ERROR, "could not find SOS marker in bitstream\n");
2340
    return 0;
2341
}
2342

    
2343
AVCodec mjpeg_decoder = {
2344
    "mjpeg",
2345
    CODEC_TYPE_VIDEO,
2346
    CODEC_ID_MJPEG,
2347
    sizeof(MJpegDecodeContext),
2348
    mjpeg_decode_init,
2349
    NULL,
2350
    mjpeg_decode_end,
2351
    mjpeg_decode_frame,
2352
    CODEC_CAP_DR1,
2353
    NULL
2354
};
2355

    
2356
AVCodec thp_decoder = {
2357
    "thp",
2358
    CODEC_TYPE_VIDEO,
2359
    CODEC_ID_THP,
2360
    sizeof(MJpegDecodeContext),
2361
    mjpeg_decode_init,
2362
    NULL,
2363
    mjpeg_decode_end,
2364
    mjpeg_decode_frame,
2365
    CODEC_CAP_DR1,
2366
    NULL
2367
};
2368

    
2369
AVCodec mjpegb_decoder = {
2370
    "mjpegb",
2371
    CODEC_TYPE_VIDEO,
2372
    CODEC_ID_MJPEGB,
2373
    sizeof(MJpegDecodeContext),
2374
    mjpeg_decode_init,
2375
    NULL,
2376
    mjpeg_decode_end,
2377
    mjpegb_decode_frame,
2378
    CODEC_CAP_DR1,
2379
    NULL
2380
};
2381

    
2382
AVCodec sp5x_decoder = {
2383
    "sp5x",
2384
    CODEC_TYPE_VIDEO,
2385
    CODEC_ID_SP5X,
2386
    sizeof(MJpegDecodeContext),
2387
    mjpeg_decode_init,
2388
    NULL,
2389
    mjpeg_decode_end,
2390
    sp5x_decode_frame,
2391
    CODEC_CAP_DR1,
2392
    NULL
2393
};
2394

    
2395
#ifdef CONFIG_ENCODERS
2396
AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2397
    "ljpeg",
2398
    CODEC_TYPE_VIDEO,
2399
    CODEC_ID_LJPEG,
2400
    sizeof(MpegEncContext),
2401
    MPV_encode_init,
2402
    encode_picture_lossless,
2403
    MPV_encode_end,
2404
};
2405
#endif
2406

    
2407
#ifdef CONFIG_MJPEGA_DUMP_HEADER_BSF
2408
AVBitStreamFilter mjpega_dump_header_bsf = {
2409
    "mjpegadump",
2410
    0,
2411
    mjpega_dump_header,
2412
};
2413
#endif