Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mjpeg.c @ 764ef400

History | View | Annotate | Download (66.3 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, new decode_frame mechanism and apple mjpeg-b support
21
 *                                  by Alex Beregszaszi <alex@naxine.org>
22
 */
23

    
24
/**
25
 * @file mjpeg.c
26
 * MJPEG encoder and decoder.
27
 */
28
 
29
//#define DEBUG
30
#include <assert.h>
31

    
32
#include "avcodec.h"
33
#include "dsputil.h"
34
#include "mpegvideo.h"
35

    
36
/* use two quantizer tables (one for luminance and one for chrominance) */
37
/* not yet working */
38
#undef TWOMATRIXES
39

    
40
typedef struct MJpegContext {
41
    uint8_t huff_size_dc_luminance[12]; //FIXME use array [3] instead of lumi / chrom, for easier addressing 
42
    uint16_t huff_code_dc_luminance[12];
43
    uint8_t huff_size_dc_chrominance[12];
44
    uint16_t huff_code_dc_chrominance[12];
45

    
46
    uint8_t huff_size_ac_luminance[256];
47
    uint16_t huff_code_ac_luminance[256];
48
    uint8_t huff_size_ac_chrominance[256];
49
    uint16_t huff_code_ac_chrominance[256];
50
} MJpegContext;
51

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

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

    
68
    SOF13 = 0xcd,        /* differential sequential, arithmetic */
69
    SOF14 = 0xce,        /* differential progressive, arithmetic */
70
    SOF15 = 0xcf,        /* differential lossless, arithmetic */
71

    
72
    DHT   = 0xc4,        /* define huffman tables */
73

    
74
    DAC   = 0xcc,        /* define arithmetic-coding conditioning */
75

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

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

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

    
112
    JPG0  = 0xf0,
113
    JPG1  = 0xf1,
114
    JPG2  = 0xf2,
115
    JPG3  = 0xf3,
116
    JPG4  = 0xf4,
117
    JPG5  = 0xf5,
118
    JPG6  = 0xf6,
119
    JPG7  = 0xf7,
120
    JPG8  = 0xf8,
121
    JPG9  = 0xf9,
122
    JPG10 = 0xfa,
123
    JPG11 = 0xfb,
124
    JPG12 = 0xfc,
125
    JPG13 = 0xfd,
126

    
127
    COM   = 0xfe,        /* comment */
128

    
129
    TEM   = 0x01,        /* temporary private use for arithmetic coding */
130

    
131
    /* 0x02 -> 0xbf reserved */
132
} JPEG_MARKER;
133

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

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

    
168
static const uint8_t bits_dc_chrominance[17] =
169
{ /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
170
static const uint8_t val_dc_chrominance[] =
171
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
172

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

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

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

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

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

    
246
#ifdef CONFIG_ENCODERS
247
int mjpeg_init(MpegEncContext *s)
248
{
249
    MJpegContext *m;
250
    
251
    m = av_malloc(sizeof(MJpegContext));
252
    if (!m)
253
        return -1;
254
    
255
    s->min_qcoeff=-1023;
256
    s->max_qcoeff= 1023;
257

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

    
280
void mjpeg_close(MpegEncContext *s)
281
{
282
    av_free(s->mjpeg_ctx);
283
}
284
#endif //CONFIG_ENCODERS
285

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

    
298
#ifdef CONFIG_ENCODERS
299
static inline void put_marker(PutBitContext *p, int code)
300
{
301
    put_bits(p, 8, 0xff);
302
    put_bits(p, 8, code);
303
}
304

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

    
312
    put_bits(p, 4, table_class);
313
    put_bits(p, 4, table_id);
314

    
315
    n = 0;
316
    for(i=1;i<=16;i++) {
317
        n += bits_table[i];
318
        put_bits(p, 8, bits_table[i]);
319
    }
320

    
321
    for(i=0;i<n;i++)
322
        put_bits(p, 8, value_table[i]);
323

    
324
    return n + 17;
325
}
326

    
327
static void jpeg_table_header(MpegEncContext *s)
328
{
329
    PutBitContext *p = &s->pb;
330
    int i, j, size;
331
    uint8_t *ptr;
332

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

    
355
    /* huffman table */
356
    put_marker(p, DHT);
357
    flush_put_bits(p);
358
    ptr = pbBufPtr(p);
359
    put_bits(p, 16, 0); /* patched later */
360
    size = 2;
361
    size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
362
    size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
363
    
364
    size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
365
    size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
366
    ptr[0] = size >> 8;
367
    ptr[1] = size;
368
}
369

    
370
static void jpeg_put_comments(MpegEncContext *s)
371
{
372
    PutBitContext *p = &s->pb;
373
    int size;
374
    uint8_t *ptr;
375

    
376
    if (s->aspect_ratio_info /* && !lossless */)
377
    {
378
    /* JFIF header */
379
    put_marker(p, APP0);
380
    put_bits(p, 16, 16);
381
    put_string(p, "JFIF"); /* this puts the trailing zero-byte too */
382
    put_bits(p, 16, 0x0201); /* v 1.02 */
383
    put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
384
    switch(s->aspect_ratio_info)
385
    {
386
        case FF_ASPECT_4_3_625:
387
        case FF_ASPECT_4_3_525:
388
            put_bits(p, 16, 4); 
389
            put_bits(p, 16, 3);
390
            break;
391
        case FF_ASPECT_16_9_625:
392
        case FF_ASPECT_16_9_525:
393
            put_bits(p, 16, 16); 
394
            put_bits(p, 16, 9);
395
            break;
396
        case FF_ASPECT_EXTENDED:
397
            put_bits(p, 16, s->aspected_width);
398
            put_bits(p, 16, s->aspected_height);
399
            break;
400
        case FF_ASPECT_SQUARE:
401
        default:
402
            put_bits(p, 16, 1); /* aspect: 1:1 */
403
            put_bits(p, 16, 1);
404
            break;
405
    }
406
    put_bits(p, 8, 0); /* thumbnail width */
407
    put_bits(p, 8, 0); /* thumbnail height */
408
    }
409

    
410
    /* comment */
411
    if(!(s->flags & CODEC_FLAG_BITEXACT)){
412
        put_marker(p, COM);
413
        flush_put_bits(p);
414
        ptr = pbBufPtr(p);
415
        put_bits(p, 16, 0); /* patched later */
416
        put_string(p, LIBAVCODEC_IDENT);
417
        size = strlen(LIBAVCODEC_IDENT)+3;
418
        ptr[0] = size >> 8;
419
        ptr[1] = size;
420
    }
421
}
422

    
423
void mjpeg_picture_header(MpegEncContext *s)
424
{
425
    const int lossless= s->avctx->codec_id == CODEC_ID_LJPEG;
426

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

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

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

    
435
    put_marker(&s->pb, lossless ? SOF3 : SOF0);
436

    
437
    put_bits(&s->pb, 16, 17);
438
    if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32)
439
        put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
440
    else
441
        put_bits(&s->pb, 8, 8); /* 8 bits/component */
442
    put_bits(&s->pb, 16, s->height);
443
    put_bits(&s->pb, 16, s->width);
444
    put_bits(&s->pb, 8, 3); /* 3 components */
445
    
446
    /* Y component */
447
    put_bits(&s->pb, 8, 1); /* component number */
448
    put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
449
    put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
450
    put_bits(&s->pb, 8, 0); /* select matrix */
451
    
452
    /* Cb component */
453
    put_bits(&s->pb, 8, 2); /* component number */
454
    put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
455
    put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
456
#ifdef TWOMATRIXES
457
    put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
458
#else
459
    put_bits(&s->pb, 8, 0); /* select matrix */
460
#endif
461

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

    
473
    /* scan header */
474
    put_marker(&s->pb, SOS);
475
    put_bits(&s->pb, 16, 12); /* length */
476
    put_bits(&s->pb, 8, 3); /* 3 components */
477
    
478
    /* Y component */
479
    put_bits(&s->pb, 8, 1); /* index */
480
    put_bits(&s->pb, 4, 0); /* DC huffman table index */
481
    put_bits(&s->pb, 4, 0); /* AC huffman table index */
482
    
483
    /* Cb component */
484
    put_bits(&s->pb, 8, 2); /* index */
485
    put_bits(&s->pb, 4, 1); /* DC huffman table index */
486
    put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
487
    
488
    /* Cr component */
489
    put_bits(&s->pb, 8, 3); /* index */
490
    put_bits(&s->pb, 4, 1); /* DC huffman table index */
491
    put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
492

    
493
    put_bits(&s->pb, 8, lossless ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
494
    put_bits(&s->pb, 8, lossless ? 0 : 63); /* Se (not used) */
495
    put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
496
}
497

    
498
static void escape_FF(MpegEncContext *s, int start)
499
{
500
    int size= get_bit_count(&s->pb) - start*8;
501
    int i, ff_count;
502
    uint8_t *buf= s->pb.buf + start;
503
    int align= (-(size_t)(buf))&3;
504
    
505
    assert((size&7) == 0);
506
    size >>= 3;
507
    
508
    ff_count=0;
509
    for(i=0; i<size && i<align; i++){
510
        if(buf[i]==0xFF) ff_count++;
511
    }
512
    for(; i<size-15; i+=16){
513
        int acc, v;
514

    
515
        v= *(uint32_t*)(&buf[i]);
516
        acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
517
        v= *(uint32_t*)(&buf[i+4]);
518
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
519
        v= *(uint32_t*)(&buf[i+8]);
520
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
521
        v= *(uint32_t*)(&buf[i+12]);
522
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
523

    
524
        acc>>=4;
525
        acc+= (acc>>16);
526
        acc+= (acc>>8);
527
        ff_count+= acc&0xFF;
528
    }
529
    for(; i<size; i++){
530
        if(buf[i]==0xFF) ff_count++;
531
    }
532

    
533
    if(ff_count==0) return;
534
    
535
    /* skip put bits */
536
    for(i=0; i<ff_count-3; i+=4)
537
        put_bits(&s->pb, 32, 0);
538
    put_bits(&s->pb, (ff_count-i)*8, 0);
539
    flush_put_bits(&s->pb); 
540

    
541
    for(i=size-1; ff_count; i--){
542
        int v= buf[i];
543

    
544
        if(v==0xFF){
545
//printf("%d %d\n", i, ff_count);
546
            buf[i+ff_count]= 0;
547
            ff_count--;
548
        }
549

    
550
        buf[i+ff_count]= v;
551
    }
552
}
553

    
554
void mjpeg_picture_trailer(MpegEncContext *s)
555
{
556
    int pad= (-get_bit_count(&s->pb))&7;
557
    
558
    put_bits(&s->pb, pad,0xFF>>(8-pad));
559
    flush_put_bits(&s->pb);
560

    
561
    assert((s->header_bits&7)==0);
562
    
563
    escape_FF(s, s->header_bits>>3);
564

    
565
    put_marker(&s->pb, EOI);
566
}
567

    
568
static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
569
                                   uint8_t *huff_size, uint16_t *huff_code)
570
{
571
    int mant, nbits;
572

    
573
    if (val == 0) {
574
        put_bits(&s->pb, huff_size[0], huff_code[0]);
575
    } else {
576
        mant = val;
577
        if (val < 0) {
578
            val = -val;
579
            mant--;
580
        }
581
        
582
        nbits= av_log2_16bit(val) + 1;
583
            
584
        put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
585
        
586
        put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
587
    }
588
}
589

    
590
static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
591
{
592
    int mant, nbits, code, i, j;
593
    int component, dc, run, last_index, val;
594
    MJpegContext *m = s->mjpeg_ctx;
595
    uint8_t *huff_size_ac;
596
    uint16_t *huff_code_ac;
597
    
598
    /* DC coef */
599
    component = (n <= 3 ? 0 : n - 4 + 1);
600
    dc = block[0]; /* overflow is impossible */
601
    val = dc - s->last_dc[component];
602
    if (n < 4) {
603
        mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
604
        huff_size_ac = m->huff_size_ac_luminance;
605
        huff_code_ac = m->huff_code_ac_luminance;
606
    } else {
607
        mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
608
        huff_size_ac = m->huff_size_ac_chrominance;
609
        huff_code_ac = m->huff_code_ac_chrominance;
610
    }
611
    s->last_dc[component] = dc;
612
    
613
    /* AC coefs */
614
    
615
    run = 0;
616
    last_index = s->block_last_index[n];
617
    for(i=1;i<=last_index;i++) {
618
        j = s->intra_scantable.permutated[i];
619
        val = block[j];
620
        if (val == 0) {
621
            run++;
622
        } else {
623
            while (run >= 16) {
624
                put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
625
                run -= 16;
626
            }
627
            mant = val;
628
            if (val < 0) {
629
                val = -val;
630
                mant--;
631
            }
632
            
633
            nbits= av_log2(val) + 1;
634
            code = (run << 4) | nbits;
635

    
636
            put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
637
        
638
            put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
639
            run = 0;
640
        }
641
    }
642

    
643
    /* output EOB only if not already 64 values */
644
    if (last_index < 63 || run != 0)
645
        put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
646
}
647

    
648
void mjpeg_encode_mb(MpegEncContext *s, 
649
                     DCTELEM block[6][64])
650
{
651
    int i;
652
    for(i=0;i<6;i++) {
653
        encode_block(s, block[i], i);
654
    }
655
}
656

    
657
static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
658
    MpegEncContext * const s = avctx->priv_data;
659
    MJpegContext * const m = s->mjpeg_ctx;
660
    AVFrame *pict = data;
661
    const int width= s->width;
662
    const int height= s->height;
663
    AVFrame * const p= (AVFrame*)&s->current_picture;
664
    const int predictor= avctx->prediction_method+1;
665

    
666
    init_put_bits(&s->pb, buf, buf_size);
667

    
668
    *p = *pict;
669
    p->pict_type= FF_I_TYPE;
670
    p->key_frame= 1;
671
    
672
    mjpeg_picture_header(s);
673

    
674
    s->header_bits= get_bit_count(&s->pb);
675

    
676
    if(avctx->pix_fmt == PIX_FMT_RGBA32){
677
        int x, y, i;
678
        const int linesize= p->linesize[0];
679
        uint16_t buffer[2048][4];
680
        int left[3], top[3], topleft[3];
681

    
682
        for(i=0; i<3; i++){
683
            buffer[0][i]= 1 << (9 - 1);
684
        }
685

    
686
        for(y = 0; y < height; y++) {
687
            const int modified_predictor= y ? predictor : 1;
688
            uint8_t *ptr = p->data[0] + (linesize * y);
689

    
690
            for(i=0; i<3; i++){
691
                top[i]= left[i]= topleft[i]= buffer[0][i];
692
            }
693
            for(x = 0; x < width; x++) {
694
                buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
695
                buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
696
                buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
697

    
698
                for(i=0;i<3;i++) {
699
                    int pred, diff;
700

    
701
                    PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
702
                        
703
                    topleft[i]= top[i];
704
                    top[i]= buffer[x+1][i];
705
                    
706
                    left[i]= buffer[x][i];
707

    
708
                    diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
709
                    
710
                    if(i==0)
711
                        mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
712
                    else
713
                        mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
714
                }
715
            }
716
        }
717
    }else{
718
        int mb_x, mb_y, i;
719
        const int mb_width  = (width  + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
720
        const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
721
        
722
        for(mb_y = 0; mb_y < mb_height; mb_y++) {
723
            for(mb_x = 0; mb_x < mb_width; mb_x++) {
724
                if(mb_x==0 || mb_y==0){
725
                    for(i=0;i<3;i++) {
726
                        uint8_t *ptr;
727
                        int x, y, h, v, linesize;
728
                        h = s->mjpeg_hsample[i];
729
                        v = s->mjpeg_vsample[i];
730
                        linesize= p->linesize[i];
731

    
732
                        for(y=0; y<v; y++){
733
                            for(x=0; x<h; x++){
734
                                int pred;
735

    
736
                                ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
737
                                if(y==0 && mb_y==0){
738
                                    if(x==0 && mb_x==0){
739
                                        pred= 128;
740
                                    }else{
741
                                        pred= ptr[-1];
742
                                    }
743
                                }else{
744
                                    if(x==0 && mb_x==0){
745
                                        pred= ptr[-linesize];
746
                                    }else{
747
                                        PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
748
                                    }
749
                                }
750
                                
751
                                if(i==0)
752
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
753
                                else
754
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
755
                            }
756
                        }
757
                    }
758
                }else{
759
                    for(i=0;i<3;i++) {
760
                        uint8_t *ptr;
761
                        int x, y, h, v, linesize;
762
                        h = s->mjpeg_hsample[i];
763
                        v = s->mjpeg_vsample[i];
764
                        linesize= p->linesize[i];
765
                             
766
                        for(y=0; y<v; y++){
767
                            for(x=0; x<h; x++){
768
                                int pred;
769

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

    
774
                                if(i==0)
775
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
776
                                else
777
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
778
                            }
779
                        }
780
                    }
781
                }
782
            }
783
        }
784
    }
785

    
786
    emms_c();
787
    
788
    mjpeg_picture_trailer(s);
789
    s->picture_number++;
790

    
791
    flush_put_bits(&s->pb);
792
    return pbBufPtr(&s->pb) - s->pb.buf;
793
//    return (get_bit_count(&f->pb)+7)/8;
794
}
795

    
796
#endif //CONFIG_ENCODERS
797

    
798
/******************************************/
799
/* decoding */
800

    
801
#define MAX_COMPONENTS 4
802

    
803
typedef struct MJpegDecodeContext {
804
    AVCodecContext *avctx;
805
    GetBitContext gb;
806
    int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
807

    
808
    int start_code; /* current start code */
809
    int buffer_size;
810
    uint8_t *buffer;
811

    
812
    int16_t quant_matrixes[4][64];
813
    VLC vlcs[2][4];
814
    int qscale[4];      ///< quantizer scale calculated from quant_matrixes
815

    
816
    int org_width, org_height;  /* size given at codec init */
817
    int first_picture;    /* true if decoding first picture */
818
    int interlaced;     /* true if interlaced */
819
    int bottom_field;   /* true if bottom field */
820
    int lossless;
821
    int rgb;
822
    int rct;            /* standard rct */  
823
    int pegasus_rct;    /* pegasus reversible colorspace transform */  
824
    int bits;           /* bits per component */
825

    
826
    int width, height;
827
    int mb_width, mb_height;
828
    int nb_components;
829
    int component_id[MAX_COMPONENTS];
830
    int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
831
    int v_count[MAX_COMPONENTS];
832
    int comp_index[MAX_COMPONENTS];
833
    int dc_index[MAX_COMPONENTS];
834
    int ac_index[MAX_COMPONENTS];
835
    int nb_blocks[MAX_COMPONENTS];
836
    int h_scount[MAX_COMPONENTS];
837
    int v_scount[MAX_COMPONENTS];
838
    int h_max, v_max; /* maximum h and v counts */
839
    int quant_index[4];   /* quant table index for each component */
840
    int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
841
    AVFrame picture; /* picture structure */
842
    int linesize[MAX_COMPONENTS];                   ///< linesize << interlaced
843
    uint8_t *qscale_table;
844
    DCTELEM block[64] __align8;
845
    ScanTable scantable;
846
    void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
847

    
848
    int restart_interval;
849
    int restart_count;
850

    
851
    int buggy_avid;
852
    int interlace_polarity;
853
} MJpegDecodeContext;
854

    
855
static int mjpeg_decode_dht(MJpegDecodeContext *s);
856

    
857
static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table, 
858
                      int nb_codes)
859
{
860
    uint8_t huff_size[256];
861
    uint16_t huff_code[256];
862

    
863
    memset(huff_size, 0, sizeof(huff_size));
864
    build_huffman_codes(huff_size, huff_code, bits_table, val_table);
865
    
866
    return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
867
}
868

    
869
static int mjpeg_decode_init(AVCodecContext *avctx)
870
{
871
    MJpegDecodeContext *s = avctx->priv_data;
872
    MpegEncContext s2;
873

    
874
    s->avctx = avctx;
875

    
876
    /* ugly way to get the idct & scantable FIXME */
877
    memset(&s2, 0, sizeof(MpegEncContext));
878
    s2.flags= avctx->flags;
879
    s2.avctx= avctx;
880
//    s2->out_format = FMT_MJPEG;
881
    s2.width = 8;
882
    s2.height = 8;
883
    if (MPV_common_init(&s2) < 0)
884
       return -1;
885
    s->scantable= s2.intra_scantable;
886
    s->idct_put= s2.dsp.idct_put;
887
    MPV_common_end(&s2);
888

    
889
    s->mpeg_enc_ctx_allocated = 0;
890
    s->buffer_size = 102400; /* smaller buffer should be enough,
891
                                but photojpg files could ahive bigger sizes */
892
    s->buffer = av_malloc(s->buffer_size);
893
    if (!s->buffer)
894
        return -1;
895
    s->start_code = -1;
896
    s->first_picture = 1;
897
    s->org_width = avctx->width;
898
    s->org_height = avctx->height;
899
    
900
    build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
901
    build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
902
    build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
903
    build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
904

    
905
    if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
906
    {
907
        printf("mjpeg: using external huffman table\n");
908
        init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
909
        mjpeg_decode_dht(s);
910
        /* should check for error - but dunno */
911
    }
912

    
913
    return 0;
914
}
915

    
916
/* quantize tables */
917
static int mjpeg_decode_dqt(MJpegDecodeContext *s)
918
{
919
    int len, index, i, j;
920
    
921
    len = get_bits(&s->gb, 16) - 2;
922

    
923
    while (len >= 65) {
924
        /* only 8 bit precision handled */
925
        if (get_bits(&s->gb, 4) != 0)
926
        {
927
            dprintf("dqt: 16bit precision\n");
928
            return -1;
929
        }
930
        index = get_bits(&s->gb, 4);
931
        if (index >= 4)
932
            return -1;
933
        dprintf("index=%d\n", index);
934
        /* read quant table */
935
        for(i=0;i<64;i++) {
936
            j = s->scantable.permutated[i];
937
            s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
938
        }
939

    
940
        //XXX FIXME finetune, and perhaps add dc too
941
        s->qscale[index]= FFMAX(
942
            s->quant_matrixes[index][s->scantable.permutated[1]],
943
            s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
944
        dprintf("qscale[%d]: %d\n", index, s->qscale[index]);
945
        len -= 65;
946
    }
947
    
948
    return 0;
949
}
950

    
951
/* decode huffman tables and build VLC decoders */
952
static int mjpeg_decode_dht(MJpegDecodeContext *s)
953
{
954
    int len, index, i, class, n, v, code_max;
955
    uint8_t bits_table[17];
956
    uint8_t val_table[256];
957
    
958
    len = get_bits(&s->gb, 16) - 2;
959

    
960
    while (len > 0) {
961
        if (len < 17)
962
            return -1;
963
        class = get_bits(&s->gb, 4);
964
        if (class >= 2)
965
            return -1;
966
        index = get_bits(&s->gb, 4);
967
        if (index >= 4)
968
            return -1;
969
        n = 0;
970
        for(i=1;i<=16;i++) {
971
            bits_table[i] = get_bits(&s->gb, 8);
972
            n += bits_table[i];
973
        }
974
        len -= 17;
975
        if (len < n || n > 256)
976
            return -1;
977

    
978
        code_max = 0;
979
        for(i=0;i<n;i++) {
980
            v = get_bits(&s->gb, 8);
981
            if (v > code_max)
982
                code_max = v;
983
            val_table[i] = v;
984
        }
985
        len -= n;
986

    
987
        /* build VLC and flush previous vlc if present */
988
        free_vlc(&s->vlcs[class][index]);
989
        dprintf("class=%d index=%d nb_codes=%d\n",
990
               class, index, code_max + 1);
991
        if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1) < 0){
992
            return -1;
993
        }
994
    }
995
    return 0;
996
}
997

    
998
static int mjpeg_decode_sof(MJpegDecodeContext *s)
999
{
1000
    int len, nb_components, i, width, height;
1001

    
1002
    /* XXX: verify len field validity */
1003
    len = get_bits(&s->gb, 16);
1004
    s->bits= get_bits(&s->gb, 8);
1005
    
1006
    if(s->pegasus_rct) s->bits=9;  
1007
    if(s->bits==9 && !s->pegasus_rct) s->rct=1;    //FIXME ugly
1008

    
1009
    if (s->bits != 8 && !s->lossless){
1010
        printf("only 8 bits/component accepted\n");
1011
        return -1;
1012
    }
1013
    height = get_bits(&s->gb, 16);
1014
    width = get_bits(&s->gb, 16);
1015
    dprintf("sof0: picture: %dx%d\n", width, height);
1016

    
1017
    nb_components = get_bits(&s->gb, 8);
1018
    if (nb_components <= 0 ||
1019
        nb_components > MAX_COMPONENTS)
1020
        return -1;
1021
    s->nb_components = nb_components;
1022
    s->h_max = 1;
1023
    s->v_max = 1;
1024
    for(i=0;i<nb_components;i++) {
1025
        /* component id */
1026
        s->component_id[i] = get_bits(&s->gb, 8) - 1;
1027
        s->h_count[i] = get_bits(&s->gb, 4);
1028
        s->v_count[i] = get_bits(&s->gb, 4);
1029
        /* compute hmax and vmax (only used in interleaved case) */
1030
        if (s->h_count[i] > s->h_max)
1031
            s->h_max = s->h_count[i];
1032
        if (s->v_count[i] > s->v_max)
1033
            s->v_max = s->v_count[i];
1034
        s->quant_index[i] = get_bits(&s->gb, 8);
1035
        if (s->quant_index[i] >= 4)
1036
            return -1;
1037
        dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1038
            s->v_count[i], s->component_id[i], s->quant_index[i]);
1039
    }
1040
    
1041
    if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1042

    
1043
    /* if different size, realloc/alloc picture */
1044
    /* XXX: also check h_count and v_count */
1045
    if (width != s->width || height != s->height) {
1046
        av_freep(&s->qscale_table);
1047
            
1048
        s->width = width;
1049
        s->height = height;
1050
        /* test interlaced mode */
1051
        if (s->first_picture &&
1052
            s->org_height != 0 &&
1053
            s->height < ((s->org_height * 3) / 4)) {
1054
            s->interlaced = 1;
1055
//            s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1056
            s->bottom_field = 0;
1057
        }
1058

    
1059
        s->qscale_table= av_mallocz((s->width+15)/16);
1060

    
1061
        s->first_picture = 0;
1062
    }
1063
    
1064
    if(s->interlaced && s->bottom_field)
1065
        return 0;
1066
 
1067
    /* XXX: not complete test ! */
1068
    switch((s->h_count[0] << 4) | s->v_count[0]) {
1069
    case 0x11:
1070
        if(s->rgb){
1071
            s->avctx->pix_fmt = PIX_FMT_RGBA32;
1072
        }else
1073
            s->avctx->pix_fmt = PIX_FMT_YUV444P;
1074
        break;
1075
    case 0x21:
1076
        s->avctx->pix_fmt = PIX_FMT_YUV422P;
1077
        break;
1078
    default:
1079
    case 0x22:
1080
        s->avctx->pix_fmt = PIX_FMT_YUV420P;
1081
        break;
1082
    }
1083

    
1084
    if(s->picture.data[0])
1085
        s->avctx->release_buffer(s->avctx, &s->picture);
1086

    
1087
    s->picture.reference= 0;
1088
    if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1089
        fprintf(stderr, "get_buffer() failed\n");
1090
        return -1;
1091
    }
1092
    s->picture.pict_type= I_TYPE;
1093
    s->picture.key_frame= 1;
1094
    
1095
    for(i=0; i<3; i++){
1096
        s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1097
    }
1098

    
1099
//    printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1100
    
1101
    if (len != (8+(3*nb_components)))
1102
    {
1103
        dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1104
    }
1105
    
1106
    return 0;
1107
}
1108

    
1109
static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1110
{
1111
    int code;
1112
    code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1113
    if (code < 0)
1114
    {
1115
        dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1116
                &s->vlcs[0][dc_index]);
1117
        return 0xffff;
1118
    }
1119

    
1120
    if(code)
1121
        return get_xbits(&s->gb, code);
1122
    else
1123
        return 0;
1124
}
1125

    
1126
/* decode block and dequantize */
1127
static int decode_block(MJpegDecodeContext *s, DCTELEM *block, 
1128
                        int component, int dc_index, int ac_index, int quant_index)
1129
{
1130
    int code, i, j, level, val;
1131
    VLC *ac_vlc;
1132
    int16_t *quant_matrix;
1133

    
1134
    /* DC coef */
1135
    val = mjpeg_decode_dc(s, dc_index);
1136
    if (val == 0xffff) {
1137
        dprintf("error dc\n");
1138
        return -1;
1139
    }
1140
    quant_matrix = s->quant_matrixes[quant_index];
1141
    val = val * quant_matrix[0] + s->last_dc[component];
1142
    s->last_dc[component] = val;
1143
    block[0] = val;
1144
    /* AC coefs */
1145
    ac_vlc = &s->vlcs[1][ac_index];
1146
    i = 1;
1147
    for(;;) {
1148
        code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
1149

    
1150
        if (code < 0) {
1151
            dprintf("error ac\n");
1152
            return -1;
1153
        }
1154
        /* EOB */
1155
        if (code == 0)
1156
            break;
1157
        if (code == 0xf0) {
1158
            i += 16;
1159
        } else {
1160
            level = get_xbits(&s->gb, code & 0xf);
1161
            i += code >> 4;
1162
            if (i >= 64) {
1163
                dprintf("error count: %d\n", i);
1164
                return -1;
1165
            }
1166
            j = s->scantable.permutated[i];
1167
            block[j] = level * quant_matrix[j];
1168
            i++;
1169
            if (i >= 64)
1170
                break;
1171
        }
1172
    }
1173
    return 0;
1174
}
1175

    
1176
static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1177
    int i, mb_x, mb_y;
1178
    uint16_t buffer[2048][4];
1179
    int left[3], top[3], topleft[3];
1180
    const int linesize= s->linesize[0];
1181
    const int mask= (1<<s->bits)-1;
1182
    
1183
    for(i=0; i<3; i++){
1184
        buffer[0][i]= 1 << (s->bits + point_transform - 1);
1185
    }
1186
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1187
        const int modified_predictor= mb_y ? predictor : 1;
1188
        uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1189

    
1190
        if (s->interlaced && s->bottom_field)
1191
            ptr += linesize >> 1;
1192

    
1193
        for(i=0; i<3; i++){
1194
            top[i]= left[i]= topleft[i]= buffer[0][i];
1195
        }
1196
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1197
            if (s->restart_interval && !s->restart_count)
1198
                s->restart_count = s->restart_interval;
1199

    
1200
            for(i=0;i<3;i++) {
1201
                int pred;
1202

    
1203
                topleft[i]= top[i];
1204
                top[i]= buffer[mb_x][i];
1205

    
1206
                PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1207
                
1208
                left[i]= 
1209
                buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1210
            }
1211

    
1212
            if (s->restart_interval && !--s->restart_count) {
1213
                align_get_bits(&s->gb);
1214
                skip_bits(&s->gb, 16); /* skip RSTn */
1215
            }
1216
        }
1217

    
1218
        if(s->rct){
1219
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1220
                ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1221
                ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1222
                ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1223
            }
1224
        }else if(s->pegasus_rct){
1225
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1226
                ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1227
                ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1228
                ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1229
            }
1230
        }else{
1231
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1232
                ptr[4*mb_x+0] = buffer[mb_x][0];
1233
                ptr[4*mb_x+1] = buffer[mb_x][1];
1234
                ptr[4*mb_x+2] = buffer[mb_x][2];
1235
            }
1236
        }
1237
    }
1238
    return 0;
1239
}
1240

    
1241
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1242
    int i, mb_x, mb_y;
1243
    const int nb_components=3;
1244

    
1245
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1246
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1247
            if (s->restart_interval && !s->restart_count)
1248
                s->restart_count = s->restart_interval;
1249

    
1250
            if(mb_x==0 || mb_y==0 || s->interlaced){
1251
                for(i=0;i<nb_components;i++) {
1252
                    uint8_t *ptr;
1253
                    int n, h, v, x, y, c, j, linesize;
1254
                    n = s->nb_blocks[i];
1255
                    c = s->comp_index[i];
1256
                    h = s->h_scount[i];
1257
                    v = s->v_scount[i];
1258
                    x = 0;
1259
                    y = 0;
1260
                    linesize= s->linesize[c];
1261
                    
1262
                    for(j=0; j<n; j++) {
1263
                        int pred;
1264

    
1265
                        ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1266
                        if(y==0 && mb_y==0){
1267
                            if(x==0 && mb_x==0){
1268
                                pred= 128 << point_transform;
1269
                            }else{
1270
                                pred= ptr[-1];
1271
                            }
1272
                        }else{
1273
                            if(x==0 && mb_x==0){
1274
                                pred= ptr[-linesize];
1275
                            }else{
1276
                                PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1277
                            }
1278
                        }
1279
                        
1280
                        if (s->interlaced && s->bottom_field)
1281
                            ptr += linesize >> 1;
1282
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1283

    
1284
                        if (++x == h) {
1285
                            x = 0;
1286
                            y++;
1287
                        }
1288
                    }
1289
                }
1290
            }else{
1291
                for(i=0;i<nb_components;i++) {
1292
                    uint8_t *ptr;
1293
                    int n, h, v, x, y, c, j, linesize;
1294
                    n = s->nb_blocks[i];
1295
                    c = s->comp_index[i];
1296
                    h = s->h_scount[i];
1297
                    v = s->v_scount[i];
1298
                    x = 0;
1299
                    y = 0;
1300
                    linesize= s->linesize[c];
1301
                    
1302
                    for(j=0; j<n; j++) {
1303
                        int pred;
1304

    
1305
                        ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1306
                        PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1307
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1308
                        if (++x == h) {
1309
                            x = 0;
1310
                            y++;
1311
                        }
1312
                    }
1313
                }
1314
            }
1315
            if (s->restart_interval && !--s->restart_count) {
1316
                align_get_bits(&s->gb);
1317
                skip_bits(&s->gb, 16); /* skip RSTn */
1318
            }
1319
        }
1320
    }
1321
    return 0;
1322
}
1323

    
1324
static int mjpeg_decode_scan(MJpegDecodeContext *s){
1325
    int i, mb_x, mb_y;
1326
    const int nb_components=3;
1327

    
1328
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1329
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1330
            if (s->restart_interval && !s->restart_count)
1331
                s->restart_count = s->restart_interval;
1332

    
1333
            for(i=0;i<nb_components;i++) {
1334
                uint8_t *ptr;
1335
                int n, h, v, x, y, c, j;
1336
                n = s->nb_blocks[i];
1337
                c = s->comp_index[i];
1338
                h = s->h_scount[i];
1339
                v = s->v_scount[i];
1340
                x = 0;
1341
                y = 0;
1342
                for(j=0;j<n;j++) {
1343
                    memset(s->block, 0, sizeof(s->block));
1344
                    if (decode_block(s, s->block, i, 
1345
                                     s->dc_index[i], s->ac_index[i], 
1346
                                     s->quant_index[c]) < 0) {
1347
                        dprintf("error y=%d x=%d\n", mb_y, mb_x);
1348
                        return -1;
1349
                    }
1350
//                    dprintf("mb: %d %d processed\n", mb_y, mb_x);
1351
                    ptr = s->picture.data[c] + 
1352
                        (s->linesize[c] * (v * mb_y + y) * 8) + 
1353
                        (h * mb_x + x) * 8;
1354
                    if (s->interlaced && s->bottom_field)
1355
                        ptr += s->linesize[c] >> 1;
1356
//printf("%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);
1357
                    s->idct_put(ptr, s->linesize[c], s->block);
1358
                    if (++x == h) {
1359
                        x = 0;
1360
                        y++;
1361
                    }
1362
                }
1363
            }
1364
            /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1365
            if (s->restart_interval && (s->restart_interval < 1350) &&
1366
                !--s->restart_count) {
1367
                align_get_bits(&s->gb);
1368
                skip_bits(&s->gb, 16); /* skip RSTn */
1369
                for (i=0; i<nb_components; i++) /* reset dc */
1370
                    s->last_dc[i] = 1024;
1371
            }
1372
        }
1373
    }
1374
    return 0;
1375
}
1376

    
1377
static int mjpeg_decode_sos(MJpegDecodeContext *s)
1378
{
1379
    int len, nb_components, i, h, v, predictor, point_transform;
1380
    int vmax, hmax, index, id;
1381
    const int block_size= s->lossless ? 1 : 8;
1382

    
1383
    /* XXX: verify len field validity */
1384
    len = get_bits(&s->gb, 16);
1385
    nb_components = get_bits(&s->gb, 8);
1386
    if (len != 6+2*nb_components)
1387
    {
1388
        dprintf("decode_sos: invalid len (%d)\n", len);
1389
        return -1;
1390
    }
1391
    /* XXX: only interleaved scan accepted */
1392
    if (nb_components != 3)
1393
    {
1394
        dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1395
        return -1;
1396
    }
1397
    vmax = 0;
1398
    hmax = 0;
1399
    for(i=0;i<nb_components;i++) {
1400
        id = get_bits(&s->gb, 8) - 1;
1401
        dprintf("component: %d\n", id);
1402
        /* find component index */
1403
        for(index=0;index<s->nb_components;index++)
1404
            if (id == s->component_id[index])
1405
                break;
1406
        if (index == s->nb_components)
1407
        {
1408
            dprintf("decode_sos: index(%d) out of components\n", index);
1409
            return -1;
1410
        }
1411

    
1412
        s->comp_index[i] = index;
1413

    
1414
        s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1415
        s->h_scount[i] = s->h_count[index];
1416
        s->v_scount[i] = s->v_count[index];
1417

    
1418
        s->dc_index[i] = get_bits(&s->gb, 4);
1419
        s->ac_index[i] = get_bits(&s->gb, 4);
1420

    
1421
        if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1422
            s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1423
            goto out_of_range;
1424
#if 0 //buggy
1425
        switch(s->start_code)
1426
        {
1427
            case SOF0:
1428
                if (dc_index[i] > 1 || ac_index[i] > 1)
1429
                    goto out_of_range;
1430
                break;
1431
            case SOF1:
1432
            case SOF2:
1433
                if (dc_index[i] > 3 || ac_index[i] > 3)
1434
                    goto out_of_range;
1435
                break;
1436
            case SOF3:
1437
                if (dc_index[i] > 3 || ac_index[i] != 0)
1438
                    goto out_of_range;
1439
                break;        
1440
        }
1441
#endif
1442
    }
1443

    
1444
    predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */
1445
    skip_bits(&s->gb, 8); /* Se */
1446
    skip_bits(&s->gb, 4); /* Ah */
1447
    point_transform= get_bits(&s->gb, 4); /* Al */
1448

    
1449
    for(i=0;i<nb_components;i++) 
1450
        s->last_dc[i] = 1024;
1451

    
1452
    if (nb_components > 1) {
1453
        /* interleaved stream */
1454
        s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1455
        s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1456
    } else {
1457
        h = s->h_max / s->h_scount[s->comp_index[0]];
1458
        v = s->v_max / s->v_scount[s->comp_index[0]];
1459
        s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1460
        s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1461
        s->nb_blocks[0] = 1;
1462
        s->h_scount[0] = 1;
1463
        s->v_scount[0] = 1;
1464
    }
1465

    
1466
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1467
        printf("%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform);
1468
    
1469
    if(s->lossless){
1470
            if(s->rgb){
1471
                if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1472
                    return -1;
1473
            }else{
1474
                if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1475
                    return -1;
1476
            }
1477
    }else{
1478
        if(mjpeg_decode_scan(s) < 0)
1479
            return -1;
1480
    }
1481
    emms_c();
1482
    return 0;
1483
 out_of_range:
1484
    dprintf("decode_sos: ac/dc index out of range\n");
1485
    return -1;
1486
}
1487

    
1488
static int mjpeg_decode_dri(MJpegDecodeContext *s)
1489
{
1490
    if (get_bits(&s->gb, 16) != 4)
1491
        return -1;
1492
    s->restart_interval = get_bits(&s->gb, 16);
1493
    dprintf("restart interval: %d\n", s->restart_interval);
1494

    
1495
    return 0;
1496
}
1497

    
1498
static int mjpeg_decode_app(MJpegDecodeContext *s)
1499
{
1500
    int len, id;
1501

    
1502
    /* XXX: verify len field validity */
1503
    len = get_bits(&s->gb, 16);
1504
    if (len < 5)
1505
        return -1;
1506

    
1507
    id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1508
    id = be2me_32(id);
1509
    len -= 6;
1510

    
1511
    if(s->avctx->debug & FF_DEBUG_STARTCODE){
1512
        printf("APPx %8X\n", id); 
1513
    }
1514
    
1515
    /* buggy AVID, it puts EOI only at every 10th frame */
1516
    /* also this fourcc is used by non-avid files too, it holds some
1517
       informations, but it's always present in AVID creates files */
1518
    if (id == ff_get_fourcc("AVI1"))
1519
    {
1520
        /* structure:
1521
            4bytes        AVI1
1522
            1bytes        polarity
1523
            1bytes        always zero
1524
            4bytes        field_size
1525
            4bytes        field_size_less_padding
1526
        */
1527
            s->buggy_avid = 1;
1528
//        if (s->first_picture)
1529
//            printf("mjpeg: workarounding buggy AVID\n");
1530
        s->interlace_polarity = get_bits(&s->gb, 8);
1531
#if 0
1532
        skip_bits(&s->gb, 8);
1533
        skip_bits(&s->gb, 32);
1534
        skip_bits(&s->gb, 32);
1535
        len -= 10;
1536
#endif
1537
//        if (s->interlace_polarity)
1538
//            printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1539
        goto out;
1540
    }
1541
    
1542
//    len -= 2;
1543
    
1544
    if (id == ff_get_fourcc("JFIF"))
1545
    {
1546
        int t_w, t_h;
1547
        skip_bits(&s->gb, 8); /* the trailing zero-byte */
1548
        printf("mjpeg: JFIF header found (version: %x.%x)\n",
1549
            get_bits(&s->gb, 8), get_bits(&s->gb, 8));
1550
        if (get_bits(&s->gb, 8) == 0)
1551
        {
1552
            int x_density, y_density; 
1553
            x_density = get_bits(&s->gb, 16);
1554
            y_density = get_bits(&s->gb, 16);
1555

    
1556
            dprintf("x/y density: %d (%f), %d (%f)\n", x_density,
1557
                (float)x_density, y_density, (float)y_density);
1558
#if 0
1559
            //MN: needs to be checked
1560
            if(x_density)
1561
//                s->avctx->aspect_ratio= s->width*y_density/((float)s->height*x_density);
1562
                s->avctx->aspect_ratio = (float)x_density/y_density;
1563
                /* it's better, but every JFIF I have seen stores 1:1 */
1564
            else
1565
                s->avctx->aspect_ratio= 0.0;
1566
#endif
1567
        }
1568
        else
1569
        {
1570
            skip_bits(&s->gb, 16);
1571
            skip_bits(&s->gb, 16);
1572
        }
1573

    
1574
        t_w = get_bits(&s->gb, 8);
1575
        t_h = get_bits(&s->gb, 8);
1576
        if (t_w && t_h)
1577
        {
1578
            /* skip thumbnail */
1579
            if (len-10-(t_w*t_h*3) > 0)
1580
                len -= t_w*t_h*3;
1581
        }
1582
        len -= 10;
1583
        goto out;
1584
    }
1585
    
1586
    if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1587
    {
1588
        printf("mjpeg: Adobe header found\n");
1589
        skip_bits(&s->gb, 16); /* version */
1590
        skip_bits(&s->gb, 16); /* flags0 */
1591
        skip_bits(&s->gb, 16); /* flags1 */
1592
        skip_bits(&s->gb, 8); /* transform */
1593
        len -= 7;
1594
        goto out;
1595
    }
1596

    
1597
    if (id == ff_get_fourcc("LJIF")){
1598
        printf("Pegasus lossless jpeg header found\n");
1599
        skip_bits(&s->gb, 16); /* version ? */
1600
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1601
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1602
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1603
        switch( get_bits(&s->gb, 8)){
1604
        case 1:
1605
            s->rgb= 1;
1606
            s->pegasus_rct=0;
1607
            break;
1608
        case 2:
1609
            s->rgb= 1;
1610
            s->pegasus_rct=1;
1611
            break;
1612
        default:
1613
            printf("unknown colorspace\n");
1614
        }
1615
        len -= 9;
1616
        goto out;
1617
    }
1618
    
1619
    /* Apple MJPEG-A */
1620
    if ((s->start_code == APP1) && (len > (0x28 - 8)))
1621
    {
1622
        id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1623
        id = be2me_32(id);
1624
        len -= 4;
1625
        if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1626
        {
1627
#if 0
1628
            skip_bits(&s->gb, 32); /* field size */
1629
            skip_bits(&s->gb, 32); /* pad field size */
1630
            skip_bits(&s->gb, 32); /* next off */
1631
            skip_bits(&s->gb, 32); /* quant off */
1632
            skip_bits(&s->gb, 32); /* huff off */
1633
            skip_bits(&s->gb, 32); /* image off */
1634
            skip_bits(&s->gb, 32); /* scan off */
1635
            skip_bits(&s->gb, 32); /* data off */
1636
#endif
1637
            if (s->first_picture)
1638
                printf("mjpeg: Apple MJPEG-A header found\n");
1639
        }
1640
    }
1641

    
1642
out:
1643
    /* slow but needed for extreme adobe jpegs */
1644
    if (len < 0)
1645
        printf("mjpeg: error, decode_app parser read over the end\n");
1646
    while(--len > 0)
1647
        skip_bits(&s->gb, 8);
1648

    
1649
    return 0;
1650
}
1651

    
1652
static int mjpeg_decode_com(MJpegDecodeContext *s)
1653
{
1654
    /* XXX: verify len field validity */
1655
    int len = get_bits(&s->gb, 16);
1656
    if (len >= 2 && len < 32768) {
1657
        /* XXX: any better upper bound */
1658
        uint8_t *cbuf = av_malloc(len - 1);
1659
        if (cbuf) {
1660
            int i;
1661
            for (i = 0; i < len - 2; i++)
1662
                cbuf[i] = get_bits(&s->gb, 8);
1663
            if (i > 0 && cbuf[i-1] == '\n')
1664
                cbuf[i-1] = 0;
1665
            else
1666
                cbuf[i] = 0;
1667

    
1668
            printf("mjpeg comment: '%s'\n", cbuf);
1669

    
1670
            /* buggy avid, it puts EOI only at every 10th frame */
1671
            if (!strcmp(cbuf, "AVID"))
1672
            {
1673
                s->buggy_avid = 1;
1674
                //        if (s->first_picture)
1675
                //            printf("mjpeg: workarounding buggy AVID\n");
1676
            }
1677

    
1678
            av_free(cbuf);
1679
        }
1680
    }
1681

    
1682
    return 0;
1683
}
1684

    
1685
#if 0
1686
static int valid_marker_list[] =
1687
{
1688
        /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1689
/* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1690
/* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1691
/* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1692
/* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1693
/* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1694
/* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1695
/* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1696
/* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1697
/* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1698
/* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1699
/* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1700
/* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1701
/* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1702
/* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1703
/* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1704
/* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1705
}
1706
#endif
1707

    
1708
/* return the 8 bit start code value and update the search
1709
   state. Return -1 if no start code found */
1710
static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1711
{
1712
    uint8_t *buf_ptr;
1713
    unsigned int v, v2;
1714
    int val;
1715
#ifdef DEBUG
1716
    int skipped=0;
1717
#endif
1718

    
1719
    buf_ptr = *pbuf_ptr;
1720
    while (buf_ptr < buf_end) {
1721
        v = *buf_ptr++;
1722
        v2 = *buf_ptr;
1723
        if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe)) {
1724
            val = *buf_ptr++;
1725
            goto found;
1726
        }
1727
#ifdef DEBUG
1728
        skipped++;
1729
#endif
1730
    }
1731
    val = -1;
1732
found:
1733
#ifdef DEBUG
1734
    dprintf("find_marker skipped %d bytes\n", skipped);
1735
#endif
1736
    *pbuf_ptr = buf_ptr;
1737
    return val;
1738
}
1739

    
1740
static int mjpeg_decode_frame(AVCodecContext *avctx, 
1741
                              void *data, int *data_size,
1742
                              uint8_t *buf, int buf_size)
1743
{
1744
    MJpegDecodeContext *s = avctx->priv_data;
1745
    uint8_t *buf_end, *buf_ptr;
1746
    int start_code;
1747
    AVFrame *picture = data;
1748

    
1749
    *data_size = 0;
1750

    
1751
    /* no supplementary picture */
1752
    if (buf_size == 0)
1753
        return 0;
1754

    
1755
    buf_ptr = buf;
1756
    buf_end = buf + buf_size;
1757
    while (buf_ptr < buf_end) {
1758
        /* find start next marker */
1759
        start_code = find_marker(&buf_ptr, buf_end);
1760
        {
1761
            /* EOF */
1762
            if (start_code < 0) {
1763
                goto the_end;
1764
            } else {
1765
                dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1766
                
1767
                if ((buf_end - buf_ptr) > s->buffer_size)
1768
                {
1769
                    av_free(s->buffer);
1770
                    s->buffer_size = buf_end-buf_ptr;
1771
                    s->buffer = av_malloc(s->buffer_size);
1772
                    dprintf("buffer too small, expanding to %d bytes\n",
1773
                        s->buffer_size);
1774
                }
1775
                
1776
                /* unescape buffer of SOS */
1777
                if (start_code == SOS)
1778
                {
1779
                    uint8_t *src = buf_ptr;
1780
                    uint8_t *dst = s->buffer;
1781

    
1782
                    while (src<buf_end)
1783
                    {
1784
                        uint8_t x = *(src++);
1785

    
1786
                        *(dst++) = x;
1787
                        if (x == 0xff)
1788
                        {
1789
                            while(*src == 0xff) src++;
1790

    
1791
                            x = *(src++);
1792
                            if (x >= 0xd0 && x <= 0xd7)
1793
                                *(dst++) = x;
1794
                            else if (x)
1795
                                break;
1796
                        }
1797
                    }
1798
                    init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1799
                    
1800
                    dprintf("escaping removed %d bytes\n",
1801
                        (buf_end - buf_ptr) - (dst - s->buffer));
1802
                }
1803
                else
1804
                    init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1805
                
1806
                s->start_code = start_code;
1807
                if(s->avctx->debug & FF_DEBUG_STARTCODE){
1808
                    printf("startcode: %X\n", start_code);
1809
                }
1810

    
1811
                /* process markers */
1812
                if (start_code >= 0xd0 && start_code <= 0xd7) {
1813
                    dprintf("restart marker: %d\n", start_code&0x0f);
1814
                } else if (s->first_picture) {
1815
                    /* APP fields */
1816
                    if (start_code >= 0xe0 && start_code <= 0xef)
1817
                        mjpeg_decode_app(s);
1818
                    /* Comment */
1819
                    else if (start_code == COM)
1820
                        mjpeg_decode_com(s);
1821
                }
1822

    
1823
                switch(start_code) {
1824
                case SOI:
1825
                    s->restart_interval = 0;
1826
                    /* nothing to do on SOI */
1827
                    break;
1828
                case DQT:
1829
                    mjpeg_decode_dqt(s);
1830
                    break;
1831
                case DHT:
1832
                    if(mjpeg_decode_dht(s) < 0){
1833
                        fprintf(stderr, "huffman table decode error\n");
1834
                        return -1;
1835
                    }
1836
                    break;
1837
                case SOF0:
1838
                    s->lossless=0;
1839
                    if (mjpeg_decode_sof(s) < 0) 
1840
                        return -1;
1841
                    break;
1842
                case SOF3:
1843
                    s->lossless=1;
1844
                    if (mjpeg_decode_sof(s) < 0) 
1845
                        return -1;
1846
                    break;
1847
                case EOI:
1848
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval) 
1849
                        break;
1850
eoi_parser:
1851
                    {
1852
                        if (s->interlaced) {
1853
                            s->bottom_field ^= 1;
1854
                            /* if not bottom field, do not output image yet */
1855
                            if (s->bottom_field)
1856
                                goto not_the_end;
1857
                        }
1858
                        *picture = s->picture;
1859
                        *data_size = sizeof(AVFrame);
1860
                        avctx->height = s->height;
1861
                        if (s->interlaced)
1862
                            avctx->height *= 2;
1863
                        avctx->width = s->width;
1864

    
1865
                        if(!s->lossless){
1866
                            picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 
1867
                            picture->qstride= 0;
1868
                            picture->qscale_table= s->qscale_table;
1869
                            memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1870
                            if(avctx->debug & FF_DEBUG_QP)
1871
                                printf("QP: %d\n", picture->quality);
1872
                            picture->quality*= FF_QP2LAMBDA;
1873
                        }
1874
                        
1875
                        goto the_end;
1876
                    }
1877
                    break;
1878
                case SOS:
1879
                    mjpeg_decode_sos(s);
1880
                    /* buggy avid puts EOI every 10-20th frame */
1881
                    /* if restart period is over process EOI */
1882
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1883
                        goto eoi_parser;
1884
                    break;
1885
                case DRI:
1886
                    mjpeg_decode_dri(s);
1887
                    break;
1888
                case SOF1:
1889
                case SOF2:
1890
                case SOF5:
1891
                case SOF6:
1892
                case SOF7:
1893
                case SOF9:
1894
                case SOF10:
1895
                case SOF11:
1896
                case SOF13:
1897
                case SOF14:
1898
                case SOF15:
1899
                case JPG:
1900
                    printf("mjpeg: unsupported coding type (%x)\n", start_code);
1901
                    break;
1902
//                default:
1903
//                    printf("mjpeg: unsupported marker (%x)\n", start_code);
1904
//                    break;
1905
                }
1906

    
1907
not_the_end:
1908
                /* eof process start code */
1909
                buf_ptr += (get_bits_count(&s->gb)+7)/8;
1910
                dprintf("marker parser used %d bytes (%d bits)\n",
1911
                    (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1912
            }
1913
        }
1914
    }
1915
the_end:
1916
    dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1917
//    return buf_end - buf_ptr;
1918
    return buf_ptr - buf;
1919
}
1920

    
1921
static int mjpegb_decode_frame(AVCodecContext *avctx, 
1922
                              void *data, int *data_size,
1923
                              uint8_t *buf, int buf_size)
1924
{
1925
    MJpegDecodeContext *s = avctx->priv_data;
1926
    uint8_t *buf_end, *buf_ptr;
1927
    AVFrame *picture = data;
1928
    GetBitContext hgb; /* for the header */
1929
    uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
1930
    uint32_t field_size;
1931

    
1932
    *data_size = 0;
1933

    
1934
    /* no supplementary picture */
1935
    if (buf_size == 0)
1936
        return 0;
1937

    
1938
    buf_ptr = buf;
1939
    buf_end = buf + buf_size;
1940
    
1941
read_header:
1942
    /* reset on every SOI */
1943
    s->restart_interval = 0;
1944

    
1945
    init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
1946

    
1947
    skip_bits(&hgb, 32); /* reserved zeros */
1948
    
1949
    if (get_bits(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
1950
    {
1951
        dprintf("not mjpeg-b (bad fourcc)\n");
1952
        return 0;
1953
    }
1954

    
1955
    field_size = get_bits(&hgb, 32); /* field size */
1956
    dprintf("field size: 0x%x\n", field_size);
1957
    skip_bits(&hgb, 32); /* padded field size */
1958
    second_field_offs = get_bits(&hgb, 32);
1959
    dprintf("second field offs: 0x%x\n", second_field_offs);
1960
    if (second_field_offs)
1961
        s->interlaced = 1;
1962

    
1963
    dqt_offs = get_bits(&hgb, 32);
1964
    dprintf("dqt offs: 0x%x\n", dqt_offs);
1965
    if (dqt_offs)
1966
    {
1967
        init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
1968
        s->start_code = DQT;
1969
        mjpeg_decode_dqt(s);
1970
    }
1971
    
1972
    dht_offs = get_bits(&hgb, 32);
1973
    dprintf("dht offs: 0x%x\n", dht_offs);
1974
    if (dht_offs)
1975
    {
1976
        init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
1977
        s->start_code = DHT;
1978
        mjpeg_decode_dht(s);
1979
    }
1980

    
1981
    sof_offs = get_bits(&hgb, 32);
1982
    dprintf("sof offs: 0x%x\n", sof_offs);
1983
    if (sof_offs)
1984
    {
1985
        init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
1986
        s->start_code = SOF0;
1987
        if (mjpeg_decode_sof(s) < 0)
1988
            return -1;
1989
    }
1990

    
1991
    sos_offs = get_bits(&hgb, 32);
1992
    dprintf("sos offs: 0x%x\n", sos_offs);
1993
    if (sos_offs)
1994
    {
1995
//        init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
1996
        init_get_bits(&s->gb, buf+sos_offs, field_size*8);
1997
        s->start_code = SOS;
1998
        mjpeg_decode_sos(s);
1999
    }
2000

    
2001
    skip_bits(&hgb, 32); /* start of data offset */
2002

    
2003
    if (s->interlaced) {
2004
        s->bottom_field ^= 1;
2005
        /* if not bottom field, do not output image yet */
2006
        if (s->bottom_field && second_field_offs)
2007
        {
2008
            buf_ptr = buf + second_field_offs;
2009
            second_field_offs = 0;
2010
            goto read_header;
2011
            }
2012
    }
2013

    
2014
    //XXX FIXME factorize, this looks very similar to the EOI code
2015

    
2016
    *picture= s->picture;
2017
    *data_size = sizeof(AVFrame);
2018
    avctx->height = s->height;
2019
    if (s->interlaced)
2020
        avctx->height *= 2;
2021
    avctx->width = s->width;
2022
    
2023
    if(!s->lossless){
2024
        picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 
2025
        picture->qstride= 0;
2026
        picture->qscale_table= s->qscale_table;
2027
        memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2028
        if(avctx->debug & FF_DEBUG_QP)
2029
            printf("QP: %d\n", picture->quality);
2030
        picture->quality*= FF_QP2LAMBDA;
2031
    }
2032

    
2033
    return buf_ptr - buf;
2034
}
2035

    
2036
#include "sp5x.h"
2037

    
2038
static int sp5x_decode_frame(AVCodecContext *avctx, 
2039
                              void *data, int *data_size,
2040
                              uint8_t *buf, int buf_size)
2041
{
2042
#if 0
2043
    MJpegDecodeContext *s = avctx->priv_data;
2044
#endif
2045
    const int qscale = 5;
2046
    uint8_t *buf_ptr, *buf_end, *recoded;
2047
    int i = 0, j = 0;
2048

    
2049
    *data_size = 0;
2050

    
2051
    /* no supplementary picture */
2052
    if (buf_size == 0)
2053
        return 0;
2054

    
2055
    if (!avctx->width || !avctx->height)
2056
        return -1;
2057

    
2058
    buf_ptr = buf;
2059
    buf_end = buf + buf_size;
2060

    
2061
#if 1
2062
    recoded = av_mallocz(buf_size + 1024);
2063
    if (!recoded)
2064
        return -1;
2065

    
2066
    /* SOI */
2067
    recoded[j++] = 0xFF;
2068
    recoded[j++] = 0xD8;
2069

    
2070
    memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2071
    memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2072
    memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2073
    j += sizeof(sp5x_data_dqt);
2074

    
2075
    memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2076
    j += sizeof(sp5x_data_dht);
2077

    
2078
    memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2079
    recoded[j+5] = (avctx->height >> 8) & 0xFF;
2080
    recoded[j+6] = avctx->height & 0xFF;
2081
    recoded[j+7] = (avctx->width >> 8) & 0xFF;
2082
    recoded[j+8] = avctx->width & 0xFF;
2083
    j += sizeof(sp5x_data_sof);
2084

    
2085
    memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2086
    j += sizeof(sp5x_data_sos);
2087

    
2088
    for (i = 14; i < buf_size, j < buf_size+1024-2; i++)
2089
    {
2090
        recoded[j++] = buf[i];
2091
        if (buf[i] == 0xff)
2092
            recoded[j++] = 0;
2093
    }
2094

    
2095
    /* EOI */
2096
    recoded[j++] = 0xFF;
2097
    recoded[j++] = 0xD9;
2098

    
2099
    i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2100

    
2101
    av_free(recoded);
2102

    
2103
#else
2104
    /* SOF */
2105
    s->bits = 8;
2106
    s->width = avctx->width;
2107
    s->height = avctx->height;
2108
    s->nb_components = 3;
2109
    s->component_id[0] = 0;
2110
    s->h_count[0] = 2;
2111
    s->v_count[0] = 2;
2112
    s->quant_index[0] = 0;
2113
    s->component_id[1] = 1;
2114
    s->h_count[1] = 1;
2115
    s->v_count[1] = 1;
2116
    s->quant_index[1] = 1;
2117
    s->component_id[2] = 2;
2118
    s->h_count[2] = 1;
2119
    s->v_count[2] = 1;
2120
    s->quant_index[2] = 1;
2121
    s->h_max = 2;
2122
    s->v_max = 2;
2123
    
2124
    s->qscale_table = av_mallocz((s->width+15)/16);
2125
    avctx->pix_fmt = PIX_FMT_YUV420P;
2126
    s->interlaced = 0;
2127
    
2128
    s->picture.reference = 0;
2129
    if (avctx->get_buffer(avctx, &s->picture) < 0)
2130
    {
2131
        fprintf(stderr, "get_buffer() failed\n");
2132
        return -1;
2133
    }
2134

    
2135
    s->picture.pict_type = I_TYPE;
2136
    s->picture.key_frame = 1;
2137

    
2138
    for (i = 0; i < 3; i++)
2139
        s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2140

    
2141
    /* DQT */
2142
    for (i = 0; i < 64; i++)
2143
    {
2144
        j = s->scantable.permutated[i];
2145
        s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2146
    }
2147
    s->qscale[0] = FFMAX(
2148
        s->quant_matrixes[0][s->scantable.permutated[1]],
2149
        s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2150

    
2151
    for (i = 0; i < 64; i++)
2152
    {
2153
        j = s->scantable.permutated[i];
2154
        s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2155
    }
2156
    s->qscale[1] = FFMAX(
2157
        s->quant_matrixes[1][s->scantable.permutated[1]],
2158
        s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2159

    
2160
    /* DHT */
2161

    
2162
    /* SOS */
2163
    s->comp_index[0] = 0;
2164
    s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2165
    s->h_scount[0] = s->h_count[0];
2166
    s->v_scount[0] = s->v_count[0];
2167
    s->dc_index[0] = 0;
2168
    s->ac_index[0] = 0;
2169

    
2170
    s->comp_index[1] = 1;
2171
    s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2172
    s->h_scount[1] = s->h_count[1];
2173
    s->v_scount[1] = s->v_count[1];
2174
    s->dc_index[1] = 1;
2175
    s->ac_index[1] = 1;
2176

    
2177
    s->comp_index[2] = 2;
2178
    s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2179
    s->h_scount[2] = s->h_count[2];
2180
    s->v_scount[2] = s->v_count[2];
2181
    s->dc_index[2] = 1;
2182
    s->ac_index[2] = 1;
2183
    
2184
    for (i = 0; i < 3; i++)
2185
        s->last_dc[i] = 1024;
2186

    
2187
    s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2188
    s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2189

    
2190
    init_get_bits(&s->gb, buf, buf_size*8);
2191
    
2192
    return mjpeg_decode_scan(s);
2193
#endif
2194

    
2195
    return i;
2196
}
2197

    
2198
static int mjpeg_decode_end(AVCodecContext *avctx)
2199
{
2200
    MJpegDecodeContext *s = avctx->priv_data;
2201
    int i, j;
2202

    
2203
    av_free(s->buffer);
2204
    av_free(s->qscale_table);
2205
    avcodec_default_free_buffers(avctx);
2206
    
2207
    for(i=0;i<2;i++) {
2208
        for(j=0;j<4;j++)
2209
            free_vlc(&s->vlcs[i][j]);
2210
    }
2211
    return 0;
2212
}
2213

    
2214
AVCodec mjpeg_decoder = {
2215
    "mjpeg",
2216
    CODEC_TYPE_VIDEO,
2217
    CODEC_ID_MJPEG,
2218
    sizeof(MJpegDecodeContext),
2219
    mjpeg_decode_init,
2220
    NULL,
2221
    mjpeg_decode_end,
2222
    mjpeg_decode_frame,
2223
    CODEC_CAP_DR1,
2224
    NULL
2225
};
2226

    
2227
AVCodec mjpegb_decoder = {
2228
    "mjpegb",
2229
    CODEC_TYPE_VIDEO,
2230
    CODEC_ID_MJPEGB,
2231
    sizeof(MJpegDecodeContext),
2232
    mjpeg_decode_init,
2233
    NULL,
2234
    mjpeg_decode_end,
2235
    mjpegb_decode_frame,
2236
    CODEC_CAP_DR1,
2237
    NULL
2238
};
2239

    
2240
AVCodec sp5x_decoder = {
2241
    "sp5x",
2242
    CODEC_TYPE_VIDEO,
2243
    CODEC_ID_SP5X,
2244
    sizeof(MJpegDecodeContext),
2245
    mjpeg_decode_init,
2246
    NULL,
2247
    mjpeg_decode_end,
2248
    sp5x_decode_frame,
2249
    CODEC_CAP_DR1,
2250
    NULL
2251
};
2252

    
2253
#ifdef CONFIG_ENCODERS
2254
AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2255
    "ljpeg",
2256
    CODEC_TYPE_VIDEO,
2257
    CODEC_ID_LJPEG,
2258
    sizeof(MpegEncContext),
2259
    MPV_encode_init,
2260
    encode_picture_lossless,
2261
    MPV_encode_end,
2262
};
2263
#endif