Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mjpeg.c @ 81ada1ce

History | View | Annotate | Download (43.5 KB)

1
/*
2
 * MJPEG encoder and decoder
3
 * Copyright (c) 2000, 2001 Fabrice Bellard.
4
 *
5
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9
 *
10
 * This library is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 *
19
 * Support for external huffman table, various fixes (AVID workaround),
20
 * aspecting and new decode_frame mechanism
21
 *                                  by Alex Beregszaszi <alex@naxine.org>
22
 */
23
//#define DEBUG
24
#include "avcodec.h"
25
#include "dsputil.h"
26
#include "mpegvideo.h"
27

    
28
/* use two quantizer tables (one for luminance and one for chrominance) */
29
/* not yet working */
30
#undef TWOMATRIXES
31

    
32
typedef struct MJpegContext {
33
    UINT8 huff_size_dc_luminance[12];
34
    UINT16 huff_code_dc_luminance[12];
35
    UINT8 huff_size_dc_chrominance[12];
36
    UINT16 huff_code_dc_chrominance[12];
37

    
38
    UINT8 huff_size_ac_luminance[256];
39
    UINT16 huff_code_ac_luminance[256];
40
    UINT8 huff_size_ac_chrominance[256];
41
    UINT16 huff_code_ac_chrominance[256];
42
} MJpegContext;
43

    
44
/* JPEG marker codes */
45
typedef enum {
46
    /* start of frame */
47
    SOF0  = 0xc0,        /* baseline */
48
    SOF1  = 0xc1,        /* extended sequential, huffman */
49
    SOF2  = 0xc2,        /* progressive, huffman */
50
    SOF3  = 0xc3,        /* lossless, huffman */
51

    
52
    SOF5  = 0xc5,        /* differential sequential, huffman */
53
    SOF6  = 0xc6,        /* differential progressive, huffman */
54
    SOF7  = 0xc7,        /* differential lossless, huffman */
55
    JPG   = 0xc8,        /* reserved for JPEG extension */
56
    SOF9  = 0xc9,        /* extended sequential, arithmetic */
57
    SOF10 = 0xca,        /* progressive, arithmetic */
58
    SOF11 = 0xcb,        /* lossless, arithmetic */
59

    
60
    SOF13 = 0xcd,        /* differential sequential, arithmetic */
61
    SOF14 = 0xce,        /* differential progressive, arithmetic */
62
    SOF15 = 0xcf,        /* differential lossless, arithmetic */
63

    
64
    DHT   = 0xc4,        /* define huffman tables */
65

    
66
    DAC   = 0xcc,        /* define arithmetic-coding conditioning */
67

    
68
    /* restart with modulo 8 count "m" */
69
    RST0  = 0xd0,
70
    RST1  = 0xd1,
71
    RST2  = 0xd2,
72
    RST3  = 0xd3,
73
    RST4  = 0xd4,
74
    RST5  = 0xd5,
75
    RST6  = 0xd6,
76
    RST7  = 0xd7,
77

    
78
    SOI   = 0xd8,        /* start of image */
79
    EOI   = 0xd9,        /* end of image */
80
    SOS   = 0xda,        /* start of scan */
81
    DQT   = 0xdb,        /* define quantization tables */
82
    DNL   = 0xdc,        /* define number of lines */
83
    DRI   = 0xdd,        /* define restart interval */
84
    DHP   = 0xde,        /* define hierarchical progression */
85
    EXP   = 0xdf,        /* expand reference components */
86

    
87
    APP0  = 0xe0,
88
    APP1  = 0xe1,
89
    APP2  = 0xe2,
90
    APP3  = 0xe3,
91
    APP4  = 0xe4,
92
    APP5  = 0xe5,
93
    APP6  = 0xe6,
94
    APP7  = 0xe7,
95
    APP8  = 0xe8,
96
    APP9  = 0xe9,
97
    APP10 = 0xea,
98
    APP11 = 0xeb,
99
    APP12 = 0xec,
100
    APP13 = 0xed,
101
    APP14 = 0xee,
102
    APP15 = 0xef,
103

    
104
    JPG0  = 0xf0,
105
    JPG1  = 0xf1,
106
    JPG2  = 0xf2,
107
    JPG3  = 0xf3,
108
    JPG4  = 0xf4,
109
    JPG5  = 0xf5,
110
    JPG6  = 0xf6,
111
    JPG7  = 0xf7,
112
    JPG8  = 0xf8,
113
    JPG9  = 0xf9,
114
    JPG10 = 0xfa,
115
    JPG11 = 0xfb,
116
    JPG12 = 0xfc,
117
    JPG13 = 0xfd,
118

    
119
    COM   = 0xfe,        /* comment */
120

    
121
    TEM   = 0x01,        /* temporary private use for arithmetic coding */
122

    
123
    /* 0x02 -> 0xbf reserved */
124
} JPEG_MARKER;
125

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

    
153
/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
154
/* IMPORTANT: these are only valid for 8-bit data precision! */
155
static const UINT8 bits_dc_luminance[17] =
156
{ /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
157
static const UINT8 val_dc_luminance[] =
158
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
159

    
160
static const UINT8 bits_dc_chrominance[17] =
161
{ /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
162
static const UINT8 val_dc_chrominance[] =
163
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
164

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

    
191
static const UINT8 bits_ac_chrominance[17] =
192
{ /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
193

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

    
218
/* isn't this function nicer than the one in the libjpeg ? */
219
static void build_huffman_codes(UINT8 *huff_size, UINT16 *huff_code,
220
                                const UINT8 *bits_table, const UINT8 *val_table)
221
{
222
    int i, j, k,nb, code, sym;
223

    
224
    code = 0;
225
    k = 0;
226
    for(i=1;i<=16;i++) {
227
        nb = bits_table[i];
228
        for(j=0;j<nb;j++) {
229
            sym = val_table[k++];
230
            huff_size[sym] = i;
231
            huff_code[sym] = code;
232
            code++;
233
        }
234
        code <<= 1;
235
    }
236
}
237

    
238
int mjpeg_init(MpegEncContext *s)
239
{
240
    MJpegContext *m;
241
    
242
    m = av_malloc(sizeof(MJpegContext));
243
    if (!m)
244
        return -1;
245
    
246
    s->min_qcoeff=-1023;
247
    s->max_qcoeff= 1023;
248
    s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
249

    
250
    /* build all the huffman tables */
251
    build_huffman_codes(m->huff_size_dc_luminance,
252
                        m->huff_code_dc_luminance,
253
                        bits_dc_luminance,
254
                        val_dc_luminance);
255
    build_huffman_codes(m->huff_size_dc_chrominance,
256
                        m->huff_code_dc_chrominance,
257
                        bits_dc_chrominance,
258
                        val_dc_chrominance);
259
    build_huffman_codes(m->huff_size_ac_luminance,
260
                        m->huff_code_ac_luminance,
261
                        bits_ac_luminance,
262
                        val_ac_luminance);
263
    build_huffman_codes(m->huff_size_ac_chrominance,
264
                        m->huff_code_ac_chrominance,
265
                        bits_ac_chrominance,
266
                        val_ac_chrominance);
267
    
268
    s->mjpeg_ctx = m;
269
    return 0;
270
}
271

    
272
void mjpeg_close(MpegEncContext *s)
273
{
274
    av_free(s->mjpeg_ctx);
275
}
276

    
277
static inline void put_marker(PutBitContext *p, int code)
278
{
279
    put_bits(p, 8, 0xff);
280
    put_bits(p, 8, code);
281
}
282

    
283
/* table_class: 0 = DC coef, 1 = AC coefs */
284
static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
285
                             const UINT8 *bits_table, const UINT8 *value_table)
286
{
287
    PutBitContext *p = &s->pb;
288
    int n, i;
289

    
290
    put_bits(p, 4, table_class);
291
    put_bits(p, 4, table_id);
292

    
293
    n = 0;
294
    for(i=1;i<=16;i++) {
295
        n += bits_table[i];
296
        put_bits(p, 8, bits_table[i]);
297
    }
298

    
299
    for(i=0;i<n;i++)
300
        put_bits(p, 8, value_table[i]);
301

    
302
    return n + 17;
303
}
304

    
305
static void jpeg_table_header(MpegEncContext *s)
306
{
307
    PutBitContext *p = &s->pb;
308
    int i, j, size;
309
    UINT8 *ptr;
310

    
311
    /* quant matrixes */
312
    put_marker(p, DQT);
313
#ifdef TWOMATRIXES
314
    put_bits(p, 16, 2 + 2 * (1 + 64));
315
#else
316
    put_bits(p, 16, 2 + 1 * (1 + 64));
317
#endif
318
    put_bits(p, 4, 0); /* 8 bit precision */
319
    put_bits(p, 4, 0); /* table 0 */
320
    for(i=0;i<64;i++) {
321
        j = s->intra_scantable.permutated[i];
322
        put_bits(p, 8, s->intra_matrix[j]);
323
    }
324
#ifdef TWOMATRIXES
325
    put_bits(p, 4, 0); /* 8 bit precision */
326
    put_bits(p, 4, 1); /* table 1 */
327
    for(i=0;i<64;i++) {
328
        j = s->intra_scantable.permutated[i];
329
        put_bits(p, 8, s->chroma_intra_matrix[j]);
330
    }
331
#endif
332

    
333
    /* huffman table */
334
    put_marker(p, DHT);
335
    flush_put_bits(p);
336
    ptr = pbBufPtr(p);
337
    put_bits(p, 16, 0); /* patched later */
338
    size = 2;
339
    size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
340
    size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
341
    
342
    size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
343
    size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
344
    ptr[0] = size >> 8;
345
    ptr[1] = size;
346
}
347

    
348
static void jpeg_put_comments(MpegEncContext *s)
349
{
350
    PutBitContext *p = &s->pb;
351
    int size;
352
    UINT8 *ptr;
353

    
354
    if (s->aspect_ratio_info)
355
    {
356
    /* JFIF header */
357
    put_marker(p, APP0);
358
    put_bits(p, 16, 16);
359
    put_string(p, "JFIF"); /* this puts the trailing zero-byte too */
360
    put_bits(p, 16, 0x0201); /* v 1.02 */
361
    put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
362
    switch(s->aspect_ratio_info)
363
    {
364
        case FF_ASPECT_4_3_625:
365
        case FF_ASPECT_4_3_525:
366
            put_bits(p, 16, 4); 
367
            put_bits(p, 16, 3);
368
            break;
369
        case FF_ASPECT_16_9_625:
370
        case FF_ASPECT_16_9_525:
371
            put_bits(p, 16, 16); 
372
            put_bits(p, 16, 9);
373
            break;
374
        case FF_ASPECT_EXTENDED:
375
            put_bits(p, 16, s->aspected_width);
376
            put_bits(p, 16, s->aspected_height);
377
            break;
378
        case FF_ASPECT_SQUARE:
379
        default:
380
            put_bits(p, 16, 1); /* aspect: 1:1 */
381
            put_bits(p, 16, 1);
382
            break;
383
    }
384
    put_bits(p, 8, 0); /* thumbnail width */
385
    put_bits(p, 8, 0); /* thumbnail height */
386
    }
387

    
388
    /* comment */
389
    if(!ff_bit_exact){
390
        put_marker(p, COM);
391
        flush_put_bits(p);
392
        ptr = pbBufPtr(p);
393
        put_bits(p, 16, 0); /* patched later */
394
#define MJPEG_VERSION "FFmpeg" LIBAVCODEC_VERSION "b" LIBAVCODEC_BUILD_STR
395
        put_string(p, MJPEG_VERSION);
396
        size = strlen(MJPEG_VERSION)+3;
397
#undef MJPEG_VERSION
398
        ptr[0] = size >> 8;
399
        ptr[1] = size;
400
    }
401
}
402

    
403
void mjpeg_picture_header(MpegEncContext *s)
404
{
405
    put_marker(&s->pb, SOI);
406

    
407
    if (!s->mjpeg_data_only_frames)
408
    {
409
    jpeg_put_comments(s);    
410

    
411
    if (s->mjpeg_write_tables) jpeg_table_header(s);
412

    
413
    put_marker(&s->pb, SOF0);
414

    
415
    put_bits(&s->pb, 16, 17);
416
    put_bits(&s->pb, 8, 8); /* 8 bits/component */
417
    put_bits(&s->pb, 16, s->height);
418
    put_bits(&s->pb, 16, s->width);
419
    put_bits(&s->pb, 8, 3); /* 3 components */
420
    
421
    /* Y component */
422
    put_bits(&s->pb, 8, 1); /* component number */
423
    put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
424
    put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
425
    put_bits(&s->pb, 8, 0); /* select matrix */
426
    
427
    /* Cb component */
428
    put_bits(&s->pb, 8, 2); /* component number */
429
    put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
430
    put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
431
#ifdef TWOMATRIXES
432
    put_bits(&s->pb, 8, 1); /* select matrix */
433
#else
434
    put_bits(&s->pb, 8, 0); /* select matrix */
435
#endif
436

    
437
    /* Cr component */
438
    put_bits(&s->pb, 8, 3); /* component number */
439
    put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
440
    put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
441
#ifdef TWOMATRIXES
442
    put_bits(&s->pb, 8, 1); /* select matrix */
443
#else
444
    put_bits(&s->pb, 8, 0); /* select matrix */
445
#endif
446
    }
447

    
448
    /* scan header */
449
    put_marker(&s->pb, SOS);
450
    put_bits(&s->pb, 16, 12); /* length */
451
    put_bits(&s->pb, 8, 3); /* 3 components */
452
    
453
    /* Y component */
454
    put_bits(&s->pb, 8, 1); /* index */
455
    put_bits(&s->pb, 4, 0); /* DC huffman table index */
456
    put_bits(&s->pb, 4, 0); /* AC huffman table index */
457
    
458
    /* Cb component */
459
    put_bits(&s->pb, 8, 2); /* index */
460
    put_bits(&s->pb, 4, 1); /* DC huffman table index */
461
    put_bits(&s->pb, 4, 1); /* AC huffman table index */
462
    
463
    /* Cr component */
464
    put_bits(&s->pb, 8, 3); /* index */
465
    put_bits(&s->pb, 4, 1); /* DC huffman table index */
466
    put_bits(&s->pb, 4, 1); /* AC huffman table index */
467

    
468
    put_bits(&s->pb, 8, 0); /* Ss (not used) */
469
    put_bits(&s->pb, 8, 63); /* Se (not used) */
470
    put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
471
}
472

    
473
static void escape_FF(MpegEncContext *s)
474
{
475
    int size= get_bit_count(&s->pb) - s->header_bits;
476
    int i, ff_count;
477
    uint8_t *buf= s->pb.buf + (s->header_bits>>3);
478
    int align= (-(int)(buf))&3;
479
    
480
    assert((size&7) == 0);
481
    size >>= 3;
482
    
483
    ff_count=0;
484
    for(i=0; i<size && i<align; i++){
485
        if(buf[i]==0xFF) ff_count++;
486
    }
487
    for(; i<size-15; i+=16){
488
        int acc, v;
489

    
490
        v= *(uint32_t*)(&buf[i]);
491
        acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
492
        v= *(uint32_t*)(&buf[i+4]);
493
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
494
        v= *(uint32_t*)(&buf[i+8]);
495
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
496
        v= *(uint32_t*)(&buf[i+12]);
497
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
498

    
499
        acc>>=4;
500
        acc+= (acc>>16);
501
        acc+= (acc>>8);
502
        ff_count+= acc&0xFF;
503
    }
504
    for(; i<size; i++){
505
        if(buf[i]==0xFF) ff_count++;
506
    }
507

    
508
    if(ff_count==0) return;
509
    
510
    /* skip put bits */
511
    for(i=0; i<ff_count-3; i+=4)
512
        put_bits(&s->pb, 32, 0);
513
    put_bits(&s->pb, (ff_count-i)*8, 0);
514
    flush_put_bits(&s->pb); 
515

    
516
    for(i=size-1; ff_count; i--){
517
        int v= buf[i];
518

    
519
        if(v==0xFF){
520
//printf("%d %d\n", i, ff_count);
521
            buf[i+ff_count]= 0;
522
            ff_count--;
523
        }
524

    
525
        buf[i+ff_count]= v;
526
    }
527
}
528

    
529
void mjpeg_picture_trailer(MpegEncContext *s)
530
{
531
    int pad= (-get_bit_count(&s->pb))&7;
532
    
533
    put_bits(&s->pb, pad,0xFF>>(8-pad));
534
    flush_put_bits(&s->pb);
535

    
536
    escape_FF(s);
537

    
538
    put_marker(&s->pb, EOI);
539
}
540

    
541
static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
542
                                   UINT8 *huff_size, UINT16 *huff_code)
543
{
544
    int mant, nbits;
545

    
546
    if (val == 0) {
547
        put_bits(&s->pb, huff_size[0], huff_code[0]);
548
    } else {
549
        mant = val;
550
        if (val < 0) {
551
            val = -val;
552
            mant--;
553
        }
554
        
555
        /* compute the log (XXX: optimize) */
556
        nbits = 0;
557
        while (val != 0) {
558
            val = val >> 1;
559
            nbits++;
560
        }
561
            
562
        put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
563
        
564
        put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
565
    }
566
}
567

    
568
static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
569
{
570
    int mant, nbits, code, i, j;
571
    int component, dc, run, last_index, val;
572
    MJpegContext *m = s->mjpeg_ctx;
573
    UINT8 *huff_size_ac;
574
    UINT16 *huff_code_ac;
575
    
576
    /* DC coef */
577
    component = (n <= 3 ? 0 : n - 4 + 1);
578
    dc = block[0]; /* overflow is impossible */
579
    val = dc - s->last_dc[component];
580
    if (n < 4) {
581
        mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
582
        huff_size_ac = m->huff_size_ac_luminance;
583
        huff_code_ac = m->huff_code_ac_luminance;
584
    } else {
585
        mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
586
        huff_size_ac = m->huff_size_ac_chrominance;
587
        huff_code_ac = m->huff_code_ac_chrominance;
588
    }
589
    s->last_dc[component] = dc;
590
    
591
    /* AC coefs */
592
    
593
    run = 0;
594
    last_index = s->block_last_index[n];
595
    for(i=1;i<=last_index;i++) {
596
        j = s->intra_scantable.permutated[i];
597
        val = block[j];
598
        if (val == 0) {
599
            run++;
600
        } else {
601
            while (run >= 16) {
602
                put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
603
                run -= 16;
604
            }
605
            mant = val;
606
            if (val < 0) {
607
                val = -val;
608
                mant--;
609
            }
610
            
611
            /* compute the log (XXX: optimize) */
612
            nbits = 0;
613
            while (val != 0) {
614
                val = val >> 1;
615
                nbits++;
616
            }
617
            code = (run << 4) | nbits;
618

    
619
            put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
620
        
621
            put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
622
            run = 0;
623
        }
624
    }
625

    
626
    /* output EOB only if not already 64 values */
627
    if (last_index < 63 || run != 0)
628
        put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
629
}
630

    
631
void mjpeg_encode_mb(MpegEncContext *s, 
632
                     DCTELEM block[6][64])
633
{
634
    int i;
635
    for(i=0;i<6;i++) {
636
        encode_block(s, block[i], i);
637
    }
638
}
639

    
640
/******************************************/
641
/* decoding */
642

    
643
#define MAX_COMPONENTS 4
644

    
645
typedef struct MJpegDecodeContext {
646
    AVCodecContext *avctx;
647
    GetBitContext gb;
648
    int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
649

    
650
    int start_code; /* current start code */
651
    int buffer_size;
652
    UINT8 *buffer;
653

    
654
    INT16 quant_matrixes[4][64];
655
    VLC vlcs[2][4];
656

    
657
    int org_width, org_height;  /* size given at codec init */
658
    int first_picture;    /* true if decoding first picture */
659
    int interlaced;     /* true if interlaced */
660
    int bottom_field;   /* true if bottom field */
661

    
662
    int width, height;
663
    int nb_components;
664
    int component_id[MAX_COMPONENTS];
665
    int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
666
    int v_count[MAX_COMPONENTS];
667
    int h_max, v_max; /* maximum h and v counts */
668
    int quant_index[4];   /* quant table index for each component */
669
    int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
670
    UINT8 *current_picture[MAX_COMPONENTS]; /* picture structure */
671
    int linesize[MAX_COMPONENTS];
672
    DCTELEM block[64] __align8;
673
    ScanTable scantable;
674
    void (*idct_put)(UINT8 *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
675

    
676
    int restart_interval;
677
    int restart_count;
678

    
679
    int buggy_avid;
680
    int interlace_polarity;
681
} MJpegDecodeContext;
682

    
683
static int mjpeg_decode_dht(MJpegDecodeContext *s);
684

    
685
static void build_vlc(VLC *vlc, const UINT8 *bits_table, const UINT8 *val_table, 
686
                      int nb_codes)
687
{
688
    UINT8 huff_size[256];
689
    UINT16 huff_code[256];
690

    
691
    memset(huff_size, 0, sizeof(huff_size));
692
    build_huffman_codes(huff_size, huff_code, bits_table, val_table);
693
    
694
    init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
695
}
696

    
697
static int mjpeg_decode_init(AVCodecContext *avctx)
698
{
699
    MJpegDecodeContext *s = avctx->priv_data;
700
    MpegEncContext s2;
701

    
702
    s->avctx = avctx;
703

    
704
    /* ugly way to get the idct & scantable */
705
    memset(&s2, 0, sizeof(MpegEncContext));
706
    s2.flags= avctx->flags;
707
    s2.avctx= avctx;
708
//    s2->out_format = FMT_MJPEG;
709
    s2.width = 8;
710
    s2.height = 8;
711
    if (MPV_common_init(&s2) < 0)
712
       return -1;
713
    s->scantable= s2.intra_scantable;
714
    s->idct_put= s2.idct_put;
715
    MPV_common_end(&s2);
716

    
717
    s->mpeg_enc_ctx_allocated = 0;
718
    s->buffer_size = 102400; /* smaller buffer should be enough,
719
                                but photojpg files could ahive bigger sizes */
720
    s->buffer = av_malloc(s->buffer_size);
721
    s->start_code = -1;
722
    s->first_picture = 1;
723
    s->org_width = avctx->width;
724
    s->org_height = avctx->height;
725
    
726
    build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
727
    build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
728
    build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
729
    build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
730

    
731
    if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
732
    {
733
        printf("mjpeg: using external huffman table\n");
734
        init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size);
735
        mjpeg_decode_dht(s);
736
        /* should check for error - but dunno */
737
    }
738

    
739
    return 0;
740
}
741

    
742
/* quantize tables */
743
static int mjpeg_decode_dqt(MJpegDecodeContext *s)
744
{
745
    int len, index, i, j;
746
    
747
    len = get_bits(&s->gb, 16) - 2;
748

    
749
    while (len >= 65) {
750
        /* only 8 bit precision handled */
751
        if (get_bits(&s->gb, 4) != 0)
752
        {
753
            dprintf("dqt: 16bit precision\n");
754
            return -1;
755
        }
756
        index = get_bits(&s->gb, 4);
757
        if (index >= 4)
758
            return -1;
759
        dprintf("index=%d\n", index);
760
        /* read quant table */
761
        for(i=0;i<64;i++) {
762
            j = s->scantable.permutated[i];
763
            s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
764
        }
765
        len -= 65;
766
    }
767
    
768
    return 0;
769
}
770

    
771
/* decode huffman tables and build VLC decoders */
772
static int mjpeg_decode_dht(MJpegDecodeContext *s)
773
{
774
    int len, index, i, class, n, v, code_max;
775
    UINT8 bits_table[17];
776
    UINT8 val_table[256];
777
    
778
    len = get_bits(&s->gb, 16) - 2;
779

    
780
    while (len > 0) {
781
        if (len < 17)
782
            return -1;
783
        class = get_bits(&s->gb, 4);
784
        if (class >= 2)
785
            return -1;
786
        index = get_bits(&s->gb, 4);
787
        if (index >= 4)
788
            return -1;
789
        n = 0;
790
        for(i=1;i<=16;i++) {
791
            bits_table[i] = get_bits(&s->gb, 8);
792
            n += bits_table[i];
793
        }
794
        len -= 17;
795
        if (len < n || n > 256)
796
            return -1;
797

    
798
        code_max = 0;
799
        for(i=0;i<n;i++) {
800
            v = get_bits(&s->gb, 8);
801
            if (v > code_max)
802
                code_max = v;
803
            val_table[i] = v;
804
        }
805
        len -= n;
806

    
807
        /* build VLC and flush previous vlc if present */
808
        free_vlc(&s->vlcs[class][index]);
809
        dprintf("class=%d index=%d nb_codes=%d\n",
810
               class, index, code_max + 1);
811
        build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1);
812
    }
813
    return 0;
814
}
815

    
816
static int mjpeg_decode_sof0(MJpegDecodeContext *s)
817
{
818
    int len, nb_components, i, width, height;
819

    
820
    /* XXX: verify len field validity */
821
    len = get_bits(&s->gb, 16);
822
    /* only 8 bits/component accepted */
823
    if (get_bits(&s->gb, 8) != 8)
824
        return -1;
825
    height = get_bits(&s->gb, 16);
826
    width = get_bits(&s->gb, 16);
827
    dprintf("sof0: picture: %dx%d\n", width, height);
828

    
829
    nb_components = get_bits(&s->gb, 8);
830
    if (nb_components <= 0 ||
831
        nb_components > MAX_COMPONENTS)
832
        return -1;
833
    s->nb_components = nb_components;
834
    s->h_max = 1;
835
    s->v_max = 1;
836
    for(i=0;i<nb_components;i++) {
837
        /* component id */
838
        s->component_id[i] = get_bits(&s->gb, 8) - 1;
839
        s->h_count[i] = get_bits(&s->gb, 4);
840
        s->v_count[i] = get_bits(&s->gb, 4);
841
        /* compute hmax and vmax (only used in interleaved case) */
842
        if (s->h_count[i] > s->h_max)
843
            s->h_max = s->h_count[i];
844
        if (s->v_count[i] > s->v_max)
845
            s->v_max = s->v_count[i];
846
        s->quant_index[i] = get_bits(&s->gb, 8);
847
        if (s->quant_index[i] >= 4)
848
            return -1;
849
        dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
850
            s->v_count[i], s->component_id[i], s->quant_index[i]);
851
    }
852

    
853
    /* if different size, realloc/alloc picture */
854
    /* XXX: also check h_count and v_count */
855
    if (width != s->width || height != s->height) {
856
        for(i=0;i<MAX_COMPONENTS;i++)
857
            av_freep(&s->current_picture[i]);
858
        s->width = width;
859
        s->height = height;
860
        /* test interlaced mode */
861
        if (s->first_picture &&
862
            s->org_height != 0 &&
863
            s->height < ((s->org_height * 3) / 4)) {
864
            s->interlaced = 1;
865
//            s->bottom_field = (s->interlace_polarity) ? 1 : 0;
866
            s->bottom_field = 0;
867
        }
868

    
869
        for(i=0;i<nb_components;i++) {
870
            int w, h;
871
            w = (s->width  + 8 * s->h_max - 1) / (8 * s->h_max);
872
            h = (s->height + 8 * s->v_max - 1) / (8 * s->v_max);
873
            w = w * 8 * s->h_count[i];
874
            h = h * 8 * s->v_count[i];
875
            if (s->interlaced)
876
                w *= 2;
877
            s->linesize[i] = w;
878
            /* memory test is done in mjpeg_decode_sos() */
879
            s->current_picture[i] = av_mallocz(w * h);
880
        }
881
        s->first_picture = 0;
882
    }
883

    
884
    if (len != (8+(3*nb_components)))
885
    {
886
        dprintf("decode_sof0: error, len(%d) mismatch\n", len);
887
    }
888
    
889
    return 0;
890
}
891

    
892
static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
893
{
894
    int code, diff;
895
#if 1
896
    code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
897
#else
898
    code = get_vlc(&s->gb, &s->vlcs[0][dc_index]);
899
#endif
900
    if (code < 0)
901
    {
902
        dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
903
                &s->vlcs[0][dc_index]);
904
        return 0xffff;
905
    }
906
    if (code == 0) {
907
        diff = 0;
908
    } else {
909
        diff = get_bits(&s->gb, code);
910
        if ((diff & (1 << (code - 1))) == 0) 
911
            diff = (-1 << code) | (diff + 1);
912
    }
913
    return diff;
914
}
915

    
916
/* decode block and dequantize */
917
static int decode_block(MJpegDecodeContext *s, DCTELEM *block, 
918
                        int component, int dc_index, int ac_index, int quant_index)
919
{
920
    int nbits, code, i, j, level;
921
    int run, val;
922
    VLC *ac_vlc;
923
    INT16 *quant_matrix;
924

    
925
    /* DC coef */
926
    val = mjpeg_decode_dc(s, dc_index);
927
    if (val == 0xffff) {
928
        dprintf("error dc\n");
929
        return -1;
930
    }
931
    quant_matrix = s->quant_matrixes[quant_index];
932
    val = val * quant_matrix[0] + s->last_dc[component];
933
    s->last_dc[component] = val;
934
    block[0] = val;
935
    /* AC coefs */
936
    ac_vlc = &s->vlcs[1][ac_index];
937
    i = 1;
938
    for(;;) {
939
#if 1
940
        code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
941
#else
942
        code = get_vlc(&s->gb, ac_vlc);
943
#endif
944
        if (code < 0) {
945
            dprintf("error ac\n");
946
            return -1;
947
        }
948
        /* EOB */
949
        if (code == 0)
950
            break;
951
        if (code == 0xf0) {
952
            i += 16;
953
        } else {
954
            run = code >> 4;
955
            nbits = code & 0xf;
956
            level = get_bits(&s->gb, nbits);
957
            if ((level & (1 << (nbits - 1))) == 0) 
958
                level = (-1 << nbits) | (level + 1);
959
            i += run;
960
            if (i >= 64) {
961
                dprintf("error count: %d\n", i);
962
                return -1;
963
            }
964
            j = s->scantable.permutated[i];
965
            block[j] = level * quant_matrix[j];
966
            i++;
967
            if (i >= 64)
968
                break;
969
        }
970
    }
971
    return 0;
972
}
973

    
974
static int mjpeg_decode_sos(MJpegDecodeContext *s)
975
{
976
    int len, nb_components, i, j, n, h, v, ret;
977
    int mb_width, mb_height, mb_x, mb_y, vmax, hmax, index, id;
978
    int comp_index[4];
979
    int dc_index[4];
980
    int ac_index[4];
981
    int nb_blocks[4];
982
    int h_count[4];
983
    int v_count[4];
984
    
985
    /* XXX: verify len field validity */
986
    len = get_bits(&s->gb, 16);
987
    nb_components = get_bits(&s->gb, 8);
988
    if (len != 6+2*nb_components)
989
    {
990
        dprintf("decode_sos: invalid len (%d)\n", len);
991
        return -1;
992
    }
993
    /* XXX: only interleaved scan accepted */
994
    if (nb_components != 3)
995
    {
996
        dprintf("decode_sos: components(%d) mismatch\n", nb_components);
997
        return -1;
998
    }
999
    vmax = 0;
1000
    hmax = 0;
1001
    for(i=0;i<nb_components;i++) {
1002
        id = get_bits(&s->gb, 8) - 1;
1003
        dprintf("component: %d\n", id);
1004
        /* find component index */
1005
        for(index=0;index<s->nb_components;index++)
1006
            if (id == s->component_id[index])
1007
                break;
1008
        if (index == s->nb_components)
1009
        {
1010
            dprintf("decode_sos: index(%d) out of components\n", index);
1011
            return -1;
1012
        }
1013

    
1014
        comp_index[i] = index;
1015
        nb_blocks[i] = s->h_count[index] * s->v_count[index];
1016
        h_count[i] = s->h_count[index];
1017
        v_count[i] = s->v_count[index];
1018

    
1019
        dc_index[i] = get_bits(&s->gb, 4);
1020
        ac_index[i] = get_bits(&s->gb, 4);
1021

    
1022
        if (dc_index[i] < 0 || ac_index[i] < 0 ||
1023
            dc_index[i] >= 4 || ac_index[i] >= 4)
1024
            goto out_of_range;
1025
        switch(s->start_code)
1026
        {
1027
            case SOF0:
1028
                if (dc_index[i] > 1 || ac_index[i] > 1)
1029
                    goto out_of_range;
1030
                break;
1031
            case SOF1:
1032
            case SOF2:
1033
                if (dc_index[i] > 3 || ac_index[i] > 3)
1034
                    goto out_of_range;
1035
                break;
1036
            case SOF3:
1037
                if (dc_index[i] > 3 || ac_index[i] != 0)
1038
                    goto out_of_range;
1039
                break;        
1040
        }
1041
    }
1042
    skip_bits(&s->gb, 8); /* Ss */
1043
    skip_bits(&s->gb, 8); /* Se */
1044
    skip_bits(&s->gb, 8); /* Ah and Al (each are 4 bits) */
1045

    
1046
    for(i=0;i<nb_components;i++) 
1047
        s->last_dc[i] = 1024;
1048

    
1049
    if (nb_components > 1) {
1050
        /* interleaved stream */
1051
        mb_width = (s->width + s->h_max * 8 - 1) / (s->h_max * 8);
1052
        mb_height = (s->height + s->v_max * 8 - 1) / (s->v_max * 8);
1053
    } else {
1054
        h = s->h_max / s->h_count[comp_index[0]];
1055
        v = s->v_max / s->v_count[comp_index[0]];
1056
        mb_width = (s->width + h * 8 - 1) / (h * 8);
1057
        mb_height = (s->height + v * 8 - 1) / (v * 8);
1058
        nb_blocks[0] = 1;
1059
        h_count[0] = 1;
1060
        v_count[0] = 1;
1061
    }
1062

    
1063
    for(mb_y = 0; mb_y < mb_height; mb_y++) {
1064
        for(mb_x = 0; mb_x < mb_width; mb_x++) {
1065
            for(i=0;i<nb_components;i++) {
1066
                UINT8 *ptr;
1067
                int x, y, c;
1068
                n = nb_blocks[i];
1069
                c = comp_index[i];
1070
                h = h_count[i];
1071
                v = v_count[i];
1072
                x = 0;
1073
                y = 0;
1074
                if (s->restart_interval && !s->restart_count)
1075
                    s->restart_count = s->restart_interval;
1076
                for(j=0;j<n;j++) {
1077
                    memset(s->block, 0, sizeof(s->block));
1078
                    if (decode_block(s, s->block, i, 
1079
                                     dc_index[i], ac_index[i], 
1080
                                     s->quant_index[c]) < 0) {
1081
                        dprintf("error y=%d x=%d\n", mb_y, mb_x);
1082
                        ret = -1;
1083
                        goto the_end;
1084
                    }
1085
//                    dprintf("mb: %d %d processed\n", mb_y, mb_x);
1086
                    ptr = s->current_picture[c] + 
1087
                        (s->linesize[c] * (v * mb_y + y) * 8) + 
1088
                        (h * mb_x + x) * 8;
1089
                    if (s->interlaced && s->bottom_field)
1090
                        ptr += s->linesize[c] >> 1;
1091
                    s->idct_put(ptr, s->linesize[c], s->block);
1092
                    if (++x == h) {
1093
                        x = 0;
1094
                        y++;
1095
                    }
1096
                }
1097
            }
1098
            /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1099
            
1100
            if ((s->restart_interval < 1350) && !--s->restart_count) {
1101
                align_get_bits(&s->gb);
1102
                skip_bits(&s->gb, 16); /* skip RSTn */
1103
                for (j=0; j<nb_components; j++) /* reset dc */
1104
                    s->last_dc[j] = 1024;
1105
            }
1106
        }
1107
    }
1108
    ret = 0;
1109
 the_end:
1110
    emms_c();
1111
    return ret;
1112
 out_of_range:
1113
    dprintf("decode_sos: ac/dc index out of range\n");
1114
    return -1;
1115
}
1116

    
1117
static int mjpeg_decode_dri(MJpegDecodeContext *s)
1118
{
1119
    if (get_bits(&s->gb, 16) != 4)
1120
        return -1;
1121
    s->restart_interval = get_bits(&s->gb, 16);
1122
    dprintf("restart interval: %d\n", s->restart_interval);
1123

    
1124
    return 0;
1125
}
1126

    
1127
static int mjpeg_decode_app(MJpegDecodeContext *s)
1128
{
1129
    int len, id;
1130

    
1131
    /* XXX: verify len field validity */
1132
    len = get_bits(&s->gb, 16);
1133
    if (len < 5)
1134
        return -1;
1135

    
1136
    id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1137
    id = be2me_32(id);
1138
    len -= 6;
1139

    
1140
    /* buggy AVID, it puts EOI only at every 10th frame */
1141
    /* also this fourcc is used by non-avid files too, it holds some
1142
       informations, but it's always present in AVID creates files */
1143
    if (id == ff_get_fourcc("AVI1"))
1144
    {
1145
        /* structure:
1146
            4bytes        AVI1
1147
            1bytes        polarity
1148
            1bytes        always zero
1149
            4bytes        field_size
1150
            4bytes        field_size_less_padding
1151
        */
1152
            s->buggy_avid = 1;
1153
//        if (s->first_picture)
1154
//            printf("mjpeg: workarounding buggy AVID\n");
1155
        s->interlace_polarity = get_bits(&s->gb, 8);
1156
#if 0
1157
        skip_bits(&s->gb, 8);
1158
        skip_bits(&s->gb, 32);
1159
        skip_bits(&s->gb, 32);
1160
        len -= 10;
1161
#endif
1162
//        if (s->interlace_polarity)
1163
//            printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1164
        goto out;
1165
    }
1166
    
1167
//    len -= 2;
1168
    
1169
    if (id == ff_get_fourcc("JFIF"))
1170
    {
1171
        int t_w, t_h;
1172
        skip_bits(&s->gb, 8); /* the trailing zero-byte */
1173
        printf("mjpeg: JFIF header found (version: %x.%x)\n",
1174
            get_bits(&s->gb, 8), get_bits(&s->gb, 8));
1175
        if (get_bits(&s->gb, 8) == 0)
1176
        {
1177
            s->avctx->aspect_ratio_info = FF_ASPECT_EXTENDED;
1178
            s->avctx->aspected_width = get_bits(&s->gb, 16);
1179
            s->avctx->aspected_height = get_bits(&s->gb, 16);
1180
        }
1181
        else
1182
        {
1183
            skip_bits(&s->gb, 16);
1184
            skip_bits(&s->gb, 16);
1185
        }
1186
        t_w = get_bits(&s->gb, 8);
1187
        t_h = get_bits(&s->gb, 8);
1188
        if (t_w && t_h)
1189
        {
1190
            /* skip thumbnail */
1191
            if (len-10-(t_w*t_h*3) > 0)
1192
                len -= t_w*t_h*3;
1193
        }
1194
        len -= 10;
1195
        goto out;
1196
    }
1197
    
1198
    if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1199
    {
1200
        printf("mjpeg: Adobe header found\n");
1201
        skip_bits(&s->gb, 16); /* version */
1202
        skip_bits(&s->gb, 16); /* flags0 */
1203
        skip_bits(&s->gb, 16); /* flags1 */
1204
        skip_bits(&s->gb, 8); /* transform */
1205
        len -= 7;
1206
        goto out;
1207
    }
1208
    
1209
    /* Apple MJPEG-A */
1210
    if ((s->start_code == APP1) && (len > (0x28 - 8)))
1211
    {
1212
        id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1213
        id = be2me_32(id);
1214
        len -= 4;
1215
        if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1216
        {
1217
#if 0
1218
            skip_bits(&s->gb, 32); /* field size */
1219
            skip_bits(&s->gb, 32); /* pad field size */
1220
            skip_bits(&s->gb, 32); /* next off */
1221
            skip_bits(&s->gb, 32); /* quant off */
1222
            skip_bits(&s->gb, 32); /* huff off */
1223
            skip_bits(&s->gb, 32); /* image off */
1224
            skip_bits(&s->gb, 32); /* scan off */
1225
            skip_bits(&s->gb, 32); /* data off */
1226
#endif
1227
            if (s->first_picture)
1228
                printf("mjpeg: Apple MJPEG-A header found\n");
1229
        }
1230
    }
1231

    
1232
out:
1233
    /* slow but needed for extreme adobe jpegs */
1234
    if (len < 0)
1235
        printf("mjpeg: error, decode_app parser read over the end\n");
1236
    while(--len > 0)
1237
        skip_bits(&s->gb, 8);
1238

    
1239
    return 0;
1240
}
1241

    
1242
static int mjpeg_decode_com(MJpegDecodeContext *s)
1243
{
1244
    int len, i;
1245
    UINT8 *cbuf;
1246

    
1247
    /* XXX: verify len field validity */
1248
    len = get_bits(&s->gb, 16)-2;
1249
    cbuf = av_malloc(len+1);
1250

    
1251
    for (i = 0; i < len; i++)
1252
        cbuf[i] = get_bits(&s->gb, 8);
1253
    if (cbuf[i-1] == '\n')
1254
        cbuf[i-1] = 0;
1255
    else
1256
        cbuf[i] = 0;
1257

    
1258
    printf("mjpeg comment: '%s'\n", cbuf);
1259

    
1260
    /* buggy avid, it puts EOI only at every 10th frame */
1261
    if (!strcmp(cbuf, "AVID"))
1262
    {
1263
        s->buggy_avid = 1;
1264
//        if (s->first_picture)
1265
//            printf("mjpeg: workarounding buggy AVID\n");
1266
    }
1267
    
1268
    av_free(cbuf);
1269

    
1270
    return 0;
1271
}
1272

    
1273
#if 0
1274
static int valid_marker_list[] =
1275
{
1276
        /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1277
/* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1278
/* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1279
/* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1280
/* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1281
/* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1282
/* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1283
/* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1284
/* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1285
/* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1286
/* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1287
/* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1288
/* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1289
/* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1290
/* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1291
/* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1292
/* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1293
}
1294
#endif
1295

    
1296
/* return the 8 bit start code value and update the search
1297
   state. Return -1 if no start code found */
1298
static int find_marker(UINT8 **pbuf_ptr, UINT8 *buf_end)
1299
{
1300
    UINT8 *buf_ptr;
1301
    unsigned int v, v2;
1302
    int val;
1303
#ifdef DEBUG
1304
    int skipped=0;
1305
#endif
1306

    
1307
    buf_ptr = *pbuf_ptr;
1308
    while (buf_ptr < buf_end) {
1309
        v = *buf_ptr++;
1310
        v2 = *buf_ptr;
1311
        if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe)) {
1312
            val = *buf_ptr++;
1313
            goto found;
1314
        }
1315
#ifdef DEBUG
1316
        skipped++;
1317
#endif
1318
    }
1319
    val = -1;
1320
found:
1321
#ifdef DEBUG
1322
    dprintf("find_marker skipped %d bytes\n", skipped);
1323
#endif
1324
    *pbuf_ptr = buf_ptr;
1325
    return val;
1326
}
1327

    
1328
static int mjpeg_decode_frame(AVCodecContext *avctx, 
1329
                              void *data, int *data_size,
1330
                              UINT8 *buf, int buf_size)
1331
{
1332
    MJpegDecodeContext *s = avctx->priv_data;
1333
    UINT8 *buf_end, *buf_ptr;
1334
    int i, start_code;
1335
    AVPicture *picture = data;
1336

    
1337
    *data_size = 0;
1338

    
1339
    /* no supplementary picture */
1340
    if (buf_size == 0)
1341
        return 0;
1342

    
1343
    buf_ptr = buf;
1344
    buf_end = buf + buf_size;
1345
    while (buf_ptr < buf_end) {
1346
        /* find start next marker */
1347
        start_code = find_marker(&buf_ptr, buf_end);
1348
        {
1349
            /* EOF */
1350
            if (start_code < 0) {
1351
                goto the_end;
1352
            } else {
1353
                dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1354
                
1355
                if ((buf_end - buf_ptr) > s->buffer_size)
1356
                {
1357
                    av_free(s->buffer);
1358
                    s->buffer_size = buf_end-buf_ptr;
1359
                    s->buffer = av_malloc(s->buffer_size);
1360
                    dprintf("buffer too small, expanding to %d bytes\n",
1361
                        s->buffer_size);
1362
                }
1363
                
1364
                /* unescape buffer of SOS */
1365
                if (start_code == SOS)
1366
                {
1367
                    UINT8 *src = buf_ptr;
1368
                    UINT8 *dst = s->buffer;
1369

    
1370
                    while (src<buf_end)
1371
                    {
1372
                        UINT8 x = *(src++);
1373

    
1374
#if 0
1375
                        if (x == 0xff && *src == 0xff)
1376
                            break;
1377
#endif
1378
                        *(dst++) = x;
1379
                        if (x == 0xff)
1380
                        {
1381
                            while(*src == 0xff) src++;
1382

    
1383
                            x = *(src++);
1384
                            if (x >= 0xd0 && x <= 0xd7)
1385
                                *(dst++) = x;
1386
                            else if (x)
1387
                                break;
1388
                        }
1389
                    }
1390
                    init_get_bits(&s->gb, s->buffer, dst - s->buffer);
1391
                    
1392
                    dprintf("escaping removed %d bytes\n",
1393
                        (buf_end - buf_ptr) - (dst - s->buffer));
1394
                }
1395
                else
1396
                    init_get_bits(&s->gb, buf_ptr, buf_end - buf_ptr);
1397
                
1398
                s->start_code = start_code;
1399

    
1400
                /* process markers */
1401
                if (start_code >= 0xd0 && start_code <= 0xd7) {
1402
                    dprintf("restart marker: %d\n", start_code&0x0f);
1403
                } else if (s->first_picture) {
1404
                    /* APP fields */
1405
                    if (start_code >= 0xe0 && start_code <= 0xef)
1406
                        mjpeg_decode_app(s);
1407
                    /* Comment */
1408
                    else if (start_code == COM)
1409
                        mjpeg_decode_com(s);
1410
                }
1411

    
1412
                switch(start_code) {
1413
                case SOI:
1414
                    s->restart_interval = 0;
1415
                    /* nothing to do on SOI */
1416
                    break;
1417
                case DQT:
1418
                    mjpeg_decode_dqt(s);
1419
                    break;
1420
                case DHT:
1421
                    mjpeg_decode_dht(s);
1422
                    break;
1423
                case SOF0:
1424
                    mjpeg_decode_sof0(s);
1425
                    break;
1426
                case EOI:
1427
eoi_parser:
1428
                    {
1429
                        int l;
1430
                        if (s->interlaced) {
1431
                            s->bottom_field ^= 1;
1432
                            /* if not bottom field, do not output image yet */
1433
                            if (s->bottom_field)
1434
                                goto not_the_end;
1435
                        }
1436
                        for(i=0;i<3;i++) {
1437
                            picture->data[i] = s->current_picture[i];
1438
#if 1
1439
                            l = s->linesize[i];
1440
                            if (s->interlaced)
1441
                                l >>= 1;
1442
                            picture->linesize[i] = l;
1443
#else
1444
                            picture->linesize[i] = (s->interlaced) ?
1445
                                s->linesize[i] >> 1 : s->linesize[i];
1446
#endif
1447
                        }
1448
                        *data_size = sizeof(AVPicture);
1449
                        avctx->height = s->height;
1450
                        if (s->interlaced)
1451
                            avctx->height *= 2;
1452
                        avctx->width = s->width;
1453
                        /* XXX: not complete test ! */
1454
                        switch((s->h_count[0] << 4) | s->v_count[0]) {
1455
                        case 0x11:
1456
                            avctx->pix_fmt = PIX_FMT_YUV444P;
1457
                            break;
1458
                        case 0x21:
1459
                            avctx->pix_fmt = PIX_FMT_YUV422P;
1460
                            break;
1461
                        default:
1462
                        case 0x22:
1463
                            avctx->pix_fmt = PIX_FMT_YUV420P;
1464
                            break;
1465
                        }
1466
                        /* dummy quality */
1467
                        /* XXX: infer it with matrix */
1468
                            avctx->quality = 3; 
1469
                        goto the_end;
1470
                    }
1471
                    break;
1472
                case SOS:
1473
                    mjpeg_decode_sos(s);
1474
                    /* buggy avid puts EOI every 10-20th frame */
1475
                    /* if restart period is over process EOI */
1476
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1477
                        goto eoi_parser;
1478
                    break;
1479
                case DRI:
1480
                    mjpeg_decode_dri(s);
1481
                    break;
1482
                case SOF1:
1483
                case SOF2:
1484
                case SOF3:
1485
                case SOF5:
1486
                case SOF6:
1487
                case SOF7:
1488
                case SOF9:
1489
                case SOF10:
1490
                case SOF11:
1491
                case SOF13:
1492
                case SOF14:
1493
                case SOF15:
1494
                case JPG:
1495
                    printf("mjpeg: unsupported coding type (%x)\n", start_code);
1496
                    break;
1497
//                default:
1498
//                    printf("mjpeg: unsupported marker (%x)\n", start_code);
1499
//                    break;
1500
                }
1501

    
1502
not_the_end:
1503
                /* eof process start code */
1504
                buf_ptr += (get_bits_count(&s->gb)+7)/8;
1505
                dprintf("marker parser used %d bytes (%d bits)\n",
1506
                    (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1507
            }
1508
        }
1509
    }
1510
the_end:
1511

    
1512
    dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1513
//    return buf_end - buf_ptr;
1514
    return buf_ptr - buf;
1515
}
1516

    
1517
static int mjpeg_decode_end(AVCodecContext *avctx)
1518
{
1519
    MJpegDecodeContext *s = avctx->priv_data;
1520
    int i, j;
1521

    
1522
    av_free(s->buffer);
1523
    for(i=0;i<MAX_COMPONENTS;i++)
1524
        av_free(s->current_picture[i]);
1525
    for(i=0;i<2;i++) {
1526
        for(j=0;j<4;j++)
1527
            free_vlc(&s->vlcs[i][j]);
1528
    }
1529
    return 0;
1530
}
1531

    
1532
AVCodec mjpeg_decoder = {
1533
    "mjpeg",
1534
    CODEC_TYPE_VIDEO,
1535
    CODEC_ID_MJPEG,
1536
    sizeof(MJpegDecodeContext),
1537
    mjpeg_decode_init,
1538
    NULL,
1539
    mjpeg_decode_end,
1540
    mjpeg_decode_frame,
1541
    0,
1542
    NULL
1543
};