Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mjpeg.c @ 8a515d2d

History | View | Annotate | Download (66 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", 1); /* 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
    put_bits(p, 16, s->avctx->sample_aspect_ratio.num);
385
    put_bits(p, 16, s->avctx->sample_aspect_ratio.den);
386
    put_bits(p, 8, 0); /* thumbnail width */
387
    put_bits(p, 8, 0); /* thumbnail height */
388
    }
389

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

    
403
void mjpeg_picture_header(MpegEncContext *s)
404
{
405
    const int lossless= s->avctx->codec_id == CODEC_ID_LJPEG;
406

    
407
    put_marker(&s->pb, SOI);
408

    
409
    if (!s->mjpeg_data_only_frames)
410
    {
411
    jpeg_put_comments(s);    
412

    
413
    if (s->mjpeg_write_tables) jpeg_table_header(s);
414

    
415
    put_marker(&s->pb, lossless ? SOF3 : SOF0);
416

    
417
    put_bits(&s->pb, 16, 17);
418
    if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32)
419
        put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
420
    else
421
        put_bits(&s->pb, 8, 8); /* 8 bits/component */
422
    put_bits(&s->pb, 16, s->height);
423
    put_bits(&s->pb, 16, s->width);
424
    put_bits(&s->pb, 8, 3); /* 3 components */
425
    
426
    /* Y component */
427
    put_bits(&s->pb, 8, 1); /* component number */
428
    put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
429
    put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
430
    put_bits(&s->pb, 8, 0); /* select matrix */
431
    
432
    /* Cb component */
433
    put_bits(&s->pb, 8, 2); /* component number */
434
    put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
435
    put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
436
#ifdef TWOMATRIXES
437
    put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
438
#else
439
    put_bits(&s->pb, 8, 0); /* select matrix */
440
#endif
441

    
442
    /* Cr component */
443
    put_bits(&s->pb, 8, 3); /* component number */
444
    put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
445
    put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
446
#ifdef TWOMATRIXES
447
    put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
448
#else
449
    put_bits(&s->pb, 8, 0); /* select matrix */
450
#endif
451
    }
452

    
453
    /* scan header */
454
    put_marker(&s->pb, SOS);
455
    put_bits(&s->pb, 16, 12); /* length */
456
    put_bits(&s->pb, 8, 3); /* 3 components */
457
    
458
    /* Y component */
459
    put_bits(&s->pb, 8, 1); /* index */
460
    put_bits(&s->pb, 4, 0); /* DC huffman table index */
461
    put_bits(&s->pb, 4, 0); /* AC huffman table index */
462
    
463
    /* Cb component */
464
    put_bits(&s->pb, 8, 2); /* index */
465
    put_bits(&s->pb, 4, 1); /* DC huffman table index */
466
    put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
467
    
468
    /* Cr component */
469
    put_bits(&s->pb, 8, 3); /* index */
470
    put_bits(&s->pb, 4, 1); /* DC huffman table index */
471
    put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
472

    
473
    put_bits(&s->pb, 8, lossless ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
474
    put_bits(&s->pb, 8, lossless ? 0 : 63); /* Se (not used) */
475
    put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
476
}
477

    
478
static void escape_FF(MpegEncContext *s, int start)
479
{
480
    int size= put_bits_count(&s->pb) - start*8;
481
    int i, ff_count;
482
    uint8_t *buf= s->pb.buf + start;
483
    int align= (-(size_t)(buf))&3;
484
    
485
    assert((size&7) == 0);
486
    size >>= 3;
487
    
488
    ff_count=0;
489
    for(i=0; i<size && i<align; i++){
490
        if(buf[i]==0xFF) ff_count++;
491
    }
492
    for(; i<size-15; i+=16){
493
        int acc, v;
494

    
495
        v= *(uint32_t*)(&buf[i]);
496
        acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
497
        v= *(uint32_t*)(&buf[i+4]);
498
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
499
        v= *(uint32_t*)(&buf[i+8]);
500
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
501
        v= *(uint32_t*)(&buf[i+12]);
502
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
503

    
504
        acc>>=4;
505
        acc+= (acc>>16);
506
        acc+= (acc>>8);
507
        ff_count+= acc&0xFF;
508
    }
509
    for(; i<size; i++){
510
        if(buf[i]==0xFF) ff_count++;
511
    }
512

    
513
    if(ff_count==0) return;
514
    
515
    /* skip put bits */
516
    for(i=0; i<ff_count-3; i+=4)
517
        put_bits(&s->pb, 32, 0);
518
    put_bits(&s->pb, (ff_count-i)*8, 0);
519
    flush_put_bits(&s->pb); 
520

    
521
    for(i=size-1; ff_count; i--){
522
        int v= buf[i];
523

    
524
        if(v==0xFF){
525
//printf("%d %d\n", i, ff_count);
526
            buf[i+ff_count]= 0;
527
            ff_count--;
528
        }
529

    
530
        buf[i+ff_count]= v;
531
    }
532
}
533

    
534
void ff_mjpeg_stuffing(PutBitContext * pbc)
535
{
536
    int length;
537
    length= (-put_bits_count(pbc))&7;
538
    if(length) put_bits(pbc, length, (1<<length)-1);
539
}
540

    
541
void mjpeg_picture_trailer(MpegEncContext *s)
542
{
543
    ff_mjpeg_stuffing(&s->pb);
544
    flush_put_bits(&s->pb);
545

    
546
    assert((s->header_bits&7)==0);
547
    
548
    escape_FF(s, s->header_bits>>3);
549

    
550
    put_marker(&s->pb, EOI);
551
}
552

    
553
static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
554
                                   uint8_t *huff_size, uint16_t *huff_code)
555
{
556
    int mant, nbits;
557

    
558
    if (val == 0) {
559
        put_bits(&s->pb, huff_size[0], huff_code[0]);
560
    } else {
561
        mant = val;
562
        if (val < 0) {
563
            val = -val;
564
            mant--;
565
        }
566
        
567
        nbits= av_log2_16bit(val) + 1;
568
            
569
        put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
570
        
571
        put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
572
    }
573
}
574

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

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

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

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

    
642
static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
643
    MpegEncContext * const s = avctx->priv_data;
644
    MJpegContext * const m = s->mjpeg_ctx;
645
    AVFrame *pict = data;
646
    const int width= s->width;
647
    const int height= s->height;
648
    AVFrame * const p= (AVFrame*)&s->current_picture;
649
    const int predictor= avctx->prediction_method+1;
650

    
651
    init_put_bits(&s->pb, buf, buf_size);
652

    
653
    *p = *pict;
654
    p->pict_type= FF_I_TYPE;
655
    p->key_frame= 1;
656
    
657
    mjpeg_picture_header(s);
658

    
659
    s->header_bits= put_bits_count(&s->pb);
660

    
661
    if(avctx->pix_fmt == PIX_FMT_RGBA32){
662
        int x, y, i;
663
        const int linesize= p->linesize[0];
664
        uint16_t buffer[2048][4];
665
        int left[3], top[3], topleft[3];
666

    
667
        for(i=0; i<3; i++){
668
            buffer[0][i]= 1 << (9 - 1);
669
        }
670

    
671
        for(y = 0; y < height; y++) {
672
            const int modified_predictor= y ? predictor : 1;
673
            uint8_t *ptr = p->data[0] + (linesize * y);
674

    
675
            for(i=0; i<3; i++){
676
                top[i]= left[i]= topleft[i]= buffer[0][i];
677
            }
678
            for(x = 0; x < width; x++) {
679
                buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
680
                buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
681
                buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
682

    
683
                for(i=0;i<3;i++) {
684
                    int pred, diff;
685

    
686
                    PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
687
                        
688
                    topleft[i]= top[i];
689
                    top[i]= buffer[x+1][i];
690
                    
691
                    left[i]= buffer[x][i];
692

    
693
                    diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
694
                    
695
                    if(i==0)
696
                        mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
697
                    else
698
                        mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
699
                }
700
            }
701
        }
702
    }else{
703
        int mb_x, mb_y, i;
704
        const int mb_width  = (width  + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
705
        const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
706
        
707
        for(mb_y = 0; mb_y < mb_height; mb_y++) {
708
            for(mb_x = 0; mb_x < mb_width; mb_x++) {
709
                if(mb_x==0 || mb_y==0){
710
                    for(i=0;i<3;i++) {
711
                        uint8_t *ptr;
712
                        int x, y, h, v, linesize;
713
                        h = s->mjpeg_hsample[i];
714
                        v = s->mjpeg_vsample[i];
715
                        linesize= p->linesize[i];
716

    
717
                        for(y=0; y<v; y++){
718
                            for(x=0; x<h; x++){
719
                                int pred;
720

    
721
                                ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
722
                                if(y==0 && mb_y==0){
723
                                    if(x==0 && mb_x==0){
724
                                        pred= 128;
725
                                    }else{
726
                                        pred= ptr[-1];
727
                                    }
728
                                }else{
729
                                    if(x==0 && mb_x==0){
730
                                        pred= ptr[-linesize];
731
                                    }else{
732
                                        PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
733
                                    }
734
                                }
735
                                
736
                                if(i==0)
737
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
738
                                else
739
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
740
                            }
741
                        }
742
                    }
743
                }else{
744
                    for(i=0;i<3;i++) {
745
                        uint8_t *ptr;
746
                        int x, y, h, v, linesize;
747
                        h = s->mjpeg_hsample[i];
748
                        v = s->mjpeg_vsample[i];
749
                        linesize= p->linesize[i];
750
                             
751
                        for(y=0; y<v; y++){
752
                            for(x=0; x<h; x++){
753
                                int pred;
754

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

    
759
                                if(i==0)
760
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
761
                                else
762
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
763
                            }
764
                        }
765
                    }
766
                }
767
            }
768
        }
769
    }
770

    
771
    emms_c();
772
    
773
    mjpeg_picture_trailer(s);
774
    s->picture_number++;
775

    
776
    flush_put_bits(&s->pb);
777
    return pbBufPtr(&s->pb) - s->pb.buf;
778
//    return (put_bits_count(&f->pb)+7)/8;
779
}
780

    
781
#endif //CONFIG_ENCODERS
782

    
783
/******************************************/
784
/* decoding */
785

    
786
#define MAX_COMPONENTS 4
787

    
788
typedef struct MJpegDecodeContext {
789
    AVCodecContext *avctx;
790
    GetBitContext gb;
791
    int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
792

    
793
    int start_code; /* current start code */
794
    int buffer_size;
795
    uint8_t *buffer;
796

    
797
    int16_t quant_matrixes[4][64];
798
    VLC vlcs[2][4];
799
    int qscale[4];      ///< quantizer scale calculated from quant_matrixes
800

    
801
    int org_height;  /* size given at codec init */
802
    int first_picture;    /* true if decoding first picture */
803
    int interlaced;     /* true if interlaced */
804
    int bottom_field;   /* true if bottom field */
805
    int lossless;
806
    int rgb;
807
    int rct;            /* standard rct */  
808
    int pegasus_rct;    /* pegasus reversible colorspace transform */  
809
    int bits;           /* bits per component */
810

    
811
    int width, height;
812
    int mb_width, mb_height;
813
    int nb_components;
814
    int component_id[MAX_COMPONENTS];
815
    int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
816
    int v_count[MAX_COMPONENTS];
817
    int comp_index[MAX_COMPONENTS];
818
    int dc_index[MAX_COMPONENTS];
819
    int ac_index[MAX_COMPONENTS];
820
    int nb_blocks[MAX_COMPONENTS];
821
    int h_scount[MAX_COMPONENTS];
822
    int v_scount[MAX_COMPONENTS];
823
    int h_max, v_max; /* maximum h and v counts */
824
    int quant_index[4];   /* quant table index for each component */
825
    int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
826
    AVFrame picture; /* picture structure */
827
    int linesize[MAX_COMPONENTS];                   ///< linesize << interlaced
828
    uint8_t *qscale_table;
829
    DCTELEM block[64] __align8;
830
    ScanTable scantable;
831
    void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
832

    
833
    int restart_interval;
834
    int restart_count;
835

    
836
    int buggy_avid;
837
    int interlace_polarity;
838
} MJpegDecodeContext;
839

    
840
static int mjpeg_decode_dht(MJpegDecodeContext *s);
841

    
842
static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table, 
843
                      int nb_codes)
844
{
845
    uint8_t huff_size[256];
846
    uint16_t huff_code[256];
847

    
848
    memset(huff_size, 0, sizeof(huff_size));
849
    build_huffman_codes(huff_size, huff_code, bits_table, val_table);
850
    
851
    return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
852
}
853

    
854
static int mjpeg_decode_init(AVCodecContext *avctx)
855
{
856
    MJpegDecodeContext *s = avctx->priv_data;
857
    MpegEncContext s2;
858

    
859
    s->avctx = avctx;
860

    
861
    /* ugly way to get the idct & scantable FIXME */
862
    memset(&s2, 0, sizeof(MpegEncContext));
863
    s2.avctx= avctx;
864
//    s2->out_format = FMT_MJPEG;
865
    dsputil_init(&s2.dsp, avctx);
866
    DCT_common_init(&s2);
867

    
868
    s->scantable= s2.intra_scantable;
869
    s->idct_put= s2.dsp.idct_put;
870

    
871
    s->mpeg_enc_ctx_allocated = 0;
872
    s->buffer_size = 102400; /* smaller buffer should be enough,
873
                                but photojpg files could ahive bigger sizes */
874
    s->buffer = av_malloc(s->buffer_size);
875
    if (!s->buffer)
876
        return -1;
877
    s->start_code = -1;
878
    s->first_picture = 1;
879
    s->org_height = avctx->height;
880
    
881
    build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
882
    build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
883
    build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
884
    build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
885

    
886
    if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
887
    {
888
        av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
889
        init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
890
        mjpeg_decode_dht(s);
891
        /* should check for error - but dunno */
892
    }
893

    
894
    return 0;
895
}
896

    
897
/* quantize tables */
898
static int mjpeg_decode_dqt(MJpegDecodeContext *s)
899
{
900
    int len, index, i, j;
901
    
902
    len = get_bits(&s->gb, 16) - 2;
903

    
904
    while (len >= 65) {
905
        /* only 8 bit precision handled */
906
        if (get_bits(&s->gb, 4) != 0)
907
        {
908
            dprintf("dqt: 16bit precision\n");
909
            return -1;
910
        }
911
        index = get_bits(&s->gb, 4);
912
        if (index >= 4)
913
            return -1;
914
        dprintf("index=%d\n", index);
915
        /* read quant table */
916
        for(i=0;i<64;i++) {
917
            j = s->scantable.permutated[i];
918
            s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
919
        }
920

    
921
        //XXX FIXME finetune, and perhaps add dc too
922
        s->qscale[index]= FFMAX(
923
            s->quant_matrixes[index][s->scantable.permutated[1]],
924
            s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
925
        dprintf("qscale[%d]: %d\n", index, s->qscale[index]);
926
        len -= 65;
927
    }
928
    
929
    return 0;
930
}
931

    
932
/* decode huffman tables and build VLC decoders */
933
static int mjpeg_decode_dht(MJpegDecodeContext *s)
934
{
935
    int len, index, i, class, n, v, code_max;
936
    uint8_t bits_table[17];
937
    uint8_t val_table[256];
938
    
939
    len = get_bits(&s->gb, 16) - 2;
940

    
941
    while (len > 0) {
942
        if (len < 17)
943
            return -1;
944
        class = get_bits(&s->gb, 4);
945
        if (class >= 2)
946
            return -1;
947
        index = get_bits(&s->gb, 4);
948
        if (index >= 4)
949
            return -1;
950
        n = 0;
951
        for(i=1;i<=16;i++) {
952
            bits_table[i] = get_bits(&s->gb, 8);
953
            n += bits_table[i];
954
        }
955
        len -= 17;
956
        if (len < n || n > 256)
957
            return -1;
958

    
959
        code_max = 0;
960
        for(i=0;i<n;i++) {
961
            v = get_bits(&s->gb, 8);
962
            if (v > code_max)
963
                code_max = v;
964
            val_table[i] = v;
965
        }
966
        len -= n;
967

    
968
        /* build VLC and flush previous vlc if present */
969
        free_vlc(&s->vlcs[class][index]);
970
        dprintf("class=%d index=%d nb_codes=%d\n",
971
               class, index, code_max + 1);
972
        if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1) < 0){
973
            return -1;
974
        }
975
    }
976
    return 0;
977
}
978

    
979
static int mjpeg_decode_sof(MJpegDecodeContext *s)
980
{
981
    int len, nb_components, i, width, height;
982

    
983
    /* XXX: verify len field validity */
984
    len = get_bits(&s->gb, 16);
985
    s->bits= get_bits(&s->gb, 8);
986
    
987
    if(s->pegasus_rct) s->bits=9;  
988
    if(s->bits==9 && !s->pegasus_rct) s->rct=1;    //FIXME ugly
989

    
990
    if (s->bits != 8 && !s->lossless){
991
        av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
992
        return -1;
993
    }
994
    height = get_bits(&s->gb, 16);
995
    width = get_bits(&s->gb, 16);
996
    dprintf("sof0: picture: %dx%d\n", width, height);
997

    
998
    nb_components = get_bits(&s->gb, 8);
999
    if (nb_components <= 0 ||
1000
        nb_components > MAX_COMPONENTS)
1001
        return -1;
1002
    s->nb_components = nb_components;
1003
    s->h_max = 1;
1004
    s->v_max = 1;
1005
    for(i=0;i<nb_components;i++) {
1006
        /* component id */
1007
        s->component_id[i] = get_bits(&s->gb, 8) - 1;
1008
        s->h_count[i] = get_bits(&s->gb, 4);
1009
        s->v_count[i] = get_bits(&s->gb, 4);
1010
        /* compute hmax and vmax (only used in interleaved case) */
1011
        if (s->h_count[i] > s->h_max)
1012
            s->h_max = s->h_count[i];
1013
        if (s->v_count[i] > s->v_max)
1014
            s->v_max = s->v_count[i];
1015
        s->quant_index[i] = get_bits(&s->gb, 8);
1016
        if (s->quant_index[i] >= 4)
1017
            return -1;
1018
        dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1019
            s->v_count[i], s->component_id[i], s->quant_index[i]);
1020
    }
1021
    
1022
    if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1023

    
1024
    /* if different size, realloc/alloc picture */
1025
    /* XXX: also check h_count and v_count */
1026
    if (width != s->width || height != s->height) {
1027
        av_freep(&s->qscale_table);
1028
            
1029
        s->width = width;
1030
        s->height = height;
1031
        s->avctx->width = s->width;
1032
        s->avctx->height = s->height;
1033

    
1034
        /* test interlaced mode */
1035
        if (s->first_picture &&
1036
            s->org_height != 0 &&
1037
            s->height < ((s->org_height * 3) / 4)) {
1038
            s->interlaced = 1;
1039
//            s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1040
            s->bottom_field = 0;
1041
            s->avctx->height *= 2;
1042
        }
1043

    
1044
        s->qscale_table= av_mallocz((s->width+15)/16);
1045

    
1046
        s->first_picture = 0;
1047
    }
1048
    
1049
    if(s->interlaced && s->bottom_field)
1050
        return 0;
1051
 
1052
    /* XXX: not complete test ! */
1053
    switch((s->h_count[0] << 4) | s->v_count[0]) {
1054
    case 0x11:
1055
        if(s->rgb){
1056
            s->avctx->pix_fmt = PIX_FMT_RGBA32;
1057
        }else if(s->nb_components==3)
1058
            s->avctx->pix_fmt = PIX_FMT_YUV444P;
1059
        else
1060
            s->avctx->pix_fmt = PIX_FMT_GRAY8;
1061
        break;
1062
    case 0x21:
1063
        s->avctx->pix_fmt = PIX_FMT_YUV422P;
1064
        break;
1065
    default:
1066
    case 0x22:
1067
        s->avctx->pix_fmt = PIX_FMT_YUV420P;
1068
        break;
1069
    }
1070

    
1071
    if(s->picture.data[0])
1072
        s->avctx->release_buffer(s->avctx, &s->picture);
1073

    
1074
    s->picture.reference= 0;
1075
    if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1076
        av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1077
        return -1;
1078
    }
1079
    s->picture.pict_type= I_TYPE;
1080
    s->picture.key_frame= 1;
1081
    
1082
    for(i=0; i<3; i++){
1083
        s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1084
    }
1085

    
1086
//    printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1087
    
1088
    if (len != (8+(3*nb_components)))
1089
    {
1090
        dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1091
    }
1092
    
1093
    return 0;
1094
}
1095

    
1096
static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1097
{
1098
    int code;
1099
    code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1100
    if (code < 0)
1101
    {
1102
        dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1103
                &s->vlcs[0][dc_index]);
1104
        return 0xffff;
1105
    }
1106

    
1107
    if(code)
1108
        return get_xbits(&s->gb, code);
1109
    else
1110
        return 0;
1111
}
1112

    
1113
/* decode block and dequantize */
1114
static int decode_block(MJpegDecodeContext *s, DCTELEM *block, 
1115
                        int component, int dc_index, int ac_index, int quant_index)
1116
{
1117
    int code, i, j, level, val;
1118
    VLC *ac_vlc;
1119
    int16_t *quant_matrix;
1120

    
1121
    /* DC coef */
1122
    val = mjpeg_decode_dc(s, dc_index);
1123
    if (val == 0xffff) {
1124
        dprintf("error dc\n");
1125
        return -1;
1126
    }
1127
    quant_matrix = s->quant_matrixes[quant_index];
1128
    val = val * quant_matrix[0] + s->last_dc[component];
1129
    s->last_dc[component] = val;
1130
    block[0] = val;
1131
    /* AC coefs */
1132
    ac_vlc = &s->vlcs[1][ac_index];
1133
    i = 1;
1134
    for(;;) {
1135
        code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
1136

    
1137
        if (code < 0) {
1138
            dprintf("error ac\n");
1139
            return -1;
1140
        }
1141
        /* EOB */
1142
        if (code == 0)
1143
            break;
1144
        if (code == 0xf0) {
1145
            i += 16;
1146
        } else {
1147
            level = get_xbits(&s->gb, code & 0xf);
1148
            i += code >> 4;
1149
            if (i >= 64) {
1150
                dprintf("error count: %d\n", i);
1151
                return -1;
1152
            }
1153
            j = s->scantable.permutated[i];
1154
            block[j] = level * quant_matrix[j];
1155
            i++;
1156
            if (i >= 64)
1157
                break;
1158
        }
1159
    }
1160
    return 0;
1161
}
1162

    
1163
static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1164
    int i, mb_x, mb_y;
1165
    uint16_t buffer[2048][4];
1166
    int left[3], top[3], topleft[3];
1167
    const int linesize= s->linesize[0];
1168
    const int mask= (1<<s->bits)-1;
1169
    
1170
    for(i=0; i<3; i++){
1171
        buffer[0][i]= 1 << (s->bits + point_transform - 1);
1172
    }
1173
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1174
        const int modified_predictor= mb_y ? predictor : 1;
1175
        uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1176

    
1177
        if (s->interlaced && s->bottom_field)
1178
            ptr += linesize >> 1;
1179

    
1180
        for(i=0; i<3; i++){
1181
            top[i]= left[i]= topleft[i]= buffer[0][i];
1182
        }
1183
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1184
            if (s->restart_interval && !s->restart_count)
1185
                s->restart_count = s->restart_interval;
1186

    
1187
            for(i=0;i<3;i++) {
1188
                int pred;
1189

    
1190
                topleft[i]= top[i];
1191
                top[i]= buffer[mb_x][i];
1192

    
1193
                PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1194
                
1195
                left[i]= 
1196
                buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1197
            }
1198

    
1199
            if (s->restart_interval && !--s->restart_count) {
1200
                align_get_bits(&s->gb);
1201
                skip_bits(&s->gb, 16); /* skip RSTn */
1202
            }
1203
        }
1204

    
1205
        if(s->rct){
1206
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1207
                ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1208
                ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1209
                ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1210
            }
1211
        }else if(s->pegasus_rct){
1212
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1213
                ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1214
                ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1215
                ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1216
            }
1217
        }else{
1218
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1219
                ptr[4*mb_x+0] = buffer[mb_x][0];
1220
                ptr[4*mb_x+1] = buffer[mb_x][1];
1221
                ptr[4*mb_x+2] = buffer[mb_x][2];
1222
            }
1223
        }
1224
    }
1225
    return 0;
1226
}
1227

    
1228
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1229
    int i, mb_x, mb_y;
1230
    const int nb_components=3;
1231

    
1232
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1233
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1234
            if (s->restart_interval && !s->restart_count)
1235
                s->restart_count = s->restart_interval;
1236

    
1237
            if(mb_x==0 || mb_y==0 || s->interlaced){
1238
                for(i=0;i<nb_components;i++) {
1239
                    uint8_t *ptr;
1240
                    int n, h, v, x, y, c, j, linesize;
1241
                    n = s->nb_blocks[i];
1242
                    c = s->comp_index[i];
1243
                    h = s->h_scount[i];
1244
                    v = s->v_scount[i];
1245
                    x = 0;
1246
                    y = 0;
1247
                    linesize= s->linesize[c];
1248
                    
1249
                    for(j=0; j<n; j++) {
1250
                        int pred;
1251

    
1252
                        ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1253
                        if(y==0 && mb_y==0){
1254
                            if(x==0 && mb_x==0){
1255
                                pred= 128 << point_transform;
1256
                            }else{
1257
                                pred= ptr[-1];
1258
                            }
1259
                        }else{
1260
                            if(x==0 && mb_x==0){
1261
                                pred= ptr[-linesize];
1262
                            }else{
1263
                                PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1264
                            }
1265
                        }
1266
                        
1267
                        if (s->interlaced && s->bottom_field)
1268
                            ptr += linesize >> 1;
1269
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1270

    
1271
                        if (++x == h) {
1272
                            x = 0;
1273
                            y++;
1274
                        }
1275
                    }
1276
                }
1277
            }else{
1278
                for(i=0;i<nb_components;i++) {
1279
                    uint8_t *ptr;
1280
                    int n, h, v, x, y, c, j, linesize;
1281
                    n = s->nb_blocks[i];
1282
                    c = s->comp_index[i];
1283
                    h = s->h_scount[i];
1284
                    v = s->v_scount[i];
1285
                    x = 0;
1286
                    y = 0;
1287
                    linesize= s->linesize[c];
1288
                    
1289
                    for(j=0; j<n; j++) {
1290
                        int pred;
1291

    
1292
                        ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1293
                        PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1294
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1295
                        if (++x == h) {
1296
                            x = 0;
1297
                            y++;
1298
                        }
1299
                    }
1300
                }
1301
            }
1302
            if (s->restart_interval && !--s->restart_count) {
1303
                align_get_bits(&s->gb);
1304
                skip_bits(&s->gb, 16); /* skip RSTn */
1305
            }
1306
        }
1307
    }
1308
    return 0;
1309
}
1310

    
1311
static int mjpeg_decode_scan(MJpegDecodeContext *s){
1312
    int i, mb_x, mb_y;
1313
    const int nb_components=3;
1314

    
1315
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1316
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1317
            if (s->restart_interval && !s->restart_count)
1318
                s->restart_count = s->restart_interval;
1319

    
1320
            for(i=0;i<nb_components;i++) {
1321
                uint8_t *ptr;
1322
                int n, h, v, x, y, c, j;
1323
                n = s->nb_blocks[i];
1324
                c = s->comp_index[i];
1325
                h = s->h_scount[i];
1326
                v = s->v_scount[i];
1327
                x = 0;
1328
                y = 0;
1329
                for(j=0;j<n;j++) {
1330
                    memset(s->block, 0, sizeof(s->block));
1331
                    if (decode_block(s, s->block, i, 
1332
                                     s->dc_index[i], s->ac_index[i], 
1333
                                     s->quant_index[c]) < 0) {
1334
                        dprintf("error y=%d x=%d\n", mb_y, mb_x);
1335
                        return -1;
1336
                    }
1337
//                    dprintf("mb: %d %d processed\n", mb_y, mb_x);
1338
                    ptr = s->picture.data[c] + 
1339
                        (s->linesize[c] * (v * mb_y + y) * 8) + 
1340
                        (h * mb_x + x) * 8;
1341
                    if (s->interlaced && s->bottom_field)
1342
                        ptr += s->linesize[c] >> 1;
1343
//av_log(NULL, AV_LOG_DEBUG, "%d %d %d %d %d %d %d %d \n", mb_x, mb_y, x, y, c, s->bottom_field, (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1344
                    s->idct_put(ptr, s->linesize[c], s->block);
1345
                    if (++x == h) {
1346
                        x = 0;
1347
                        y++;
1348
                    }
1349
                }
1350
            }
1351
            /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1352
            if (s->restart_interval && (s->restart_interval < 1350) &&
1353
                !--s->restart_count) {
1354
                align_get_bits(&s->gb);
1355
                skip_bits(&s->gb, 16); /* skip RSTn */
1356
                for (i=0; i<nb_components; i++) /* reset dc */
1357
                    s->last_dc[i] = 1024;
1358
            }
1359
        }
1360
    }
1361
    return 0;
1362
}
1363

    
1364
static int mjpeg_decode_sos(MJpegDecodeContext *s)
1365
{
1366
    int len, nb_components, i, h, v, predictor, point_transform;
1367
    int vmax, hmax, index, id;
1368
    const int block_size= s->lossless ? 1 : 8;
1369

    
1370
    /* XXX: verify len field validity */
1371
    len = get_bits(&s->gb, 16);
1372
    nb_components = get_bits(&s->gb, 8);
1373
    if (len != 6+2*nb_components)
1374
    {
1375
        dprintf("decode_sos: invalid len (%d)\n", len);
1376
        return -1;
1377
    }
1378
    /* XXX: only interleaved scan accepted */
1379
    if (nb_components != s->nb_components)
1380
    {
1381
        dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1382
        return -1;
1383
    }
1384
    vmax = 0;
1385
    hmax = 0;
1386
    for(i=0;i<nb_components;i++) {
1387
        id = get_bits(&s->gb, 8) - 1;
1388
        dprintf("component: %d\n", id);
1389
        /* find component index */
1390
        for(index=0;index<s->nb_components;index++)
1391
            if (id == s->component_id[index])
1392
                break;
1393
        if (index == s->nb_components)
1394
        {
1395
            dprintf("decode_sos: index(%d) out of components\n", index);
1396
            return -1;
1397
        }
1398

    
1399
        s->comp_index[i] = index;
1400

    
1401
        s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1402
        s->h_scount[i] = s->h_count[index];
1403
        s->v_scount[i] = s->v_count[index];
1404

    
1405
        s->dc_index[i] = get_bits(&s->gb, 4);
1406
        s->ac_index[i] = get_bits(&s->gb, 4);
1407

    
1408
        if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1409
            s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1410
            goto out_of_range;
1411
#if 0 //buggy
1412
        switch(s->start_code)
1413
        {
1414
            case SOF0:
1415
                if (dc_index[i] > 1 || ac_index[i] > 1)
1416
                    goto out_of_range;
1417
                break;
1418
            case SOF1:
1419
            case SOF2:
1420
                if (dc_index[i] > 3 || ac_index[i] > 3)
1421
                    goto out_of_range;
1422
                break;
1423
            case SOF3:
1424
                if (dc_index[i] > 3 || ac_index[i] != 0)
1425
                    goto out_of_range;
1426
                break;        
1427
        }
1428
#endif
1429
    }
1430

    
1431
    predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */
1432
    skip_bits(&s->gb, 8); /* Se */
1433
    skip_bits(&s->gb, 4); /* Ah */
1434
    point_transform= get_bits(&s->gb, 4); /* Al */
1435

    
1436
    for(i=0;i<nb_components;i++) 
1437
        s->last_dc[i] = 1024;
1438

    
1439
    if (nb_components > 1) {
1440
        /* interleaved stream */
1441
        s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1442
        s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1443
    } else {
1444
        h = s->h_max / s->h_scount[s->comp_index[0]];
1445
        v = s->v_max / s->v_scount[s->comp_index[0]];
1446
        s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1447
        s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1448
        s->nb_blocks[0] = 1;
1449
        s->h_scount[0] = 1;
1450
        s->v_scount[0] = 1;
1451
    }
1452

    
1453
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1454
        av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform);
1455
    
1456
    if(s->lossless){
1457
            if(s->rgb){
1458
                if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1459
                    return -1;
1460
            }else{
1461
                if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1462
                    return -1;
1463
            }
1464
    }else{
1465
        if(mjpeg_decode_scan(s) < 0)
1466
            return -1;
1467
    }
1468
    emms_c();
1469
    return 0;
1470
 out_of_range:
1471
    dprintf("decode_sos: ac/dc index out of range\n");
1472
    return -1;
1473
}
1474

    
1475
static int mjpeg_decode_dri(MJpegDecodeContext *s)
1476
{
1477
    if (get_bits(&s->gb, 16) != 4)
1478
        return -1;
1479
    s->restart_interval = get_bits(&s->gb, 16);
1480
    dprintf("restart interval: %d\n", s->restart_interval);
1481

    
1482
    return 0;
1483
}
1484

    
1485
static int mjpeg_decode_app(MJpegDecodeContext *s)
1486
{
1487
    int len, id;
1488

    
1489
    /* XXX: verify len field validity */
1490
    len = get_bits(&s->gb, 16);
1491
    if (len < 5)
1492
        return -1;
1493

    
1494
    id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1495
    id = be2me_32(id);
1496
    len -= 6;
1497

    
1498
    if(s->avctx->debug & FF_DEBUG_STARTCODE){
1499
        av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id); 
1500
    }
1501
    
1502
    /* buggy AVID, it puts EOI only at every 10th frame */
1503
    /* also this fourcc is used by non-avid files too, it holds some
1504
       informations, but it's always present in AVID creates files */
1505
    if (id == ff_get_fourcc("AVI1"))
1506
    {
1507
        /* structure:
1508
            4bytes        AVI1
1509
            1bytes        polarity
1510
            1bytes        always zero
1511
            4bytes        field_size
1512
            4bytes        field_size_less_padding
1513
        */
1514
            s->buggy_avid = 1;
1515
//        if (s->first_picture)
1516
//            printf("mjpeg: workarounding buggy AVID\n");
1517
        s->interlace_polarity = get_bits(&s->gb, 8);
1518
#if 0
1519
        skip_bits(&s->gb, 8);
1520
        skip_bits(&s->gb, 32);
1521
        skip_bits(&s->gb, 32);
1522
        len -= 10;
1523
#endif
1524
//        if (s->interlace_polarity)
1525
//            printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1526
        goto out;
1527
    }
1528
    
1529
//    len -= 2;
1530
    
1531
    if (id == ff_get_fourcc("JFIF"))
1532
    {
1533
        int t_w, t_h, v1, v2;
1534
        skip_bits(&s->gb, 8); /* the trailing zero-byte */
1535
        v1= get_bits(&s->gb, 8);
1536
        v2= get_bits(&s->gb, 8);
1537
        skip_bits(&s->gb, 8);
1538

    
1539
        s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1540
        s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1541

    
1542
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1543
            av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1544
                v1, v2,
1545
                s->avctx->sample_aspect_ratio.num,
1546
                s->avctx->sample_aspect_ratio.den
1547
            );
1548

    
1549
        t_w = get_bits(&s->gb, 8);
1550
        t_h = get_bits(&s->gb, 8);
1551
        if (t_w && t_h)
1552
        {
1553
            /* skip thumbnail */
1554
            if (len-10-(t_w*t_h*3) > 0)
1555
                len -= t_w*t_h*3;
1556
        }
1557
        len -= 10;
1558
        goto out;
1559
    }
1560
    
1561
    if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1562
    {
1563
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1564
            av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1565
        skip_bits(&s->gb, 16); /* version */
1566
        skip_bits(&s->gb, 16); /* flags0 */
1567
        skip_bits(&s->gb, 16); /* flags1 */
1568
        skip_bits(&s->gb, 8); /* transform */
1569
        len -= 7;
1570
        goto out;
1571
    }
1572

    
1573
    if (id == ff_get_fourcc("LJIF")){
1574
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1575
            av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1576
        skip_bits(&s->gb, 16); /* version ? */
1577
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1578
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1579
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1580
        switch( get_bits(&s->gb, 8)){
1581
        case 1:
1582
            s->rgb= 1;
1583
            s->pegasus_rct=0;
1584
            break;
1585
        case 2:
1586
            s->rgb= 1;
1587
            s->pegasus_rct=1;
1588
            break;
1589
        default:
1590
            av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1591
        }
1592
        len -= 9;
1593
        goto out;
1594
    }
1595
    
1596
    /* Apple MJPEG-A */
1597
    if ((s->start_code == APP1) && (len > (0x28 - 8)))
1598
    {
1599
        id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1600
        id = be2me_32(id);
1601
        len -= 4;
1602
        if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1603
        {
1604
#if 0
1605
            skip_bits(&s->gb, 32); /* field size */
1606
            skip_bits(&s->gb, 32); /* pad field size */
1607
            skip_bits(&s->gb, 32); /* next off */
1608
            skip_bits(&s->gb, 32); /* quant off */
1609
            skip_bits(&s->gb, 32); /* huff off */
1610
            skip_bits(&s->gb, 32); /* image off */
1611
            skip_bits(&s->gb, 32); /* scan off */
1612
            skip_bits(&s->gb, 32); /* data off */
1613
#endif
1614
            if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1615
                av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1616
        }
1617
    }
1618

    
1619
out:
1620
    /* slow but needed for extreme adobe jpegs */
1621
    if (len < 0)
1622
        av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1623
    while(--len > 0)
1624
        skip_bits(&s->gb, 8);
1625

    
1626
    return 0;
1627
}
1628

    
1629
static int mjpeg_decode_com(MJpegDecodeContext *s)
1630
{
1631
    /* XXX: verify len field validity */
1632
    int len = get_bits(&s->gb, 16);
1633
    if (len >= 2 && len < 32768) {
1634
        /* XXX: any better upper bound */
1635
        uint8_t *cbuf = av_malloc(len - 1);
1636
        if (cbuf) {
1637
            int i;
1638
            for (i = 0; i < len - 2; i++)
1639
                cbuf[i] = get_bits(&s->gb, 8);
1640
            if (i > 0 && cbuf[i-1] == '\n')
1641
                cbuf[i-1] = 0;
1642
            else
1643
                cbuf[i] = 0;
1644

    
1645
            if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1646
                av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1647

    
1648
            /* buggy avid, it puts EOI only at every 10th frame */
1649
            if (!strcmp(cbuf, "AVID"))
1650
            {
1651
                s->buggy_avid = 1;
1652
                //        if (s->first_picture)
1653
                //            printf("mjpeg: workarounding buggy AVID\n");
1654
            }
1655

    
1656
            av_free(cbuf);
1657
        }
1658
    }
1659

    
1660
    return 0;
1661
}
1662

    
1663
#if 0
1664
static int valid_marker_list[] =
1665
{
1666
        /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1667
/* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1668
/* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1669
/* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1670
/* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1671
/* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1672
/* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1673
/* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1674
/* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1675
/* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1676
/* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1677
/* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1678
/* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1679
/* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1680
/* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1681
/* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1682
/* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1683
}
1684
#endif
1685

    
1686
/* return the 8 bit start code value and update the search
1687
   state. Return -1 if no start code found */
1688
static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1689
{
1690
    uint8_t *buf_ptr;
1691
    unsigned int v, v2;
1692
    int val;
1693
#ifdef DEBUG
1694
    int skipped=0;
1695
#endif
1696

    
1697
    buf_ptr = *pbuf_ptr;
1698
    while (buf_ptr < buf_end) {
1699
        v = *buf_ptr++;
1700
        v2 = *buf_ptr;
1701
        if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1702
            val = *buf_ptr++;
1703
            goto found;
1704
        }
1705
#ifdef DEBUG
1706
        skipped++;
1707
#endif
1708
    }
1709
    val = -1;
1710
found:
1711
#ifdef DEBUG
1712
    dprintf("find_marker skipped %d bytes\n", skipped);
1713
#endif
1714
    *pbuf_ptr = buf_ptr;
1715
    return val;
1716
}
1717

    
1718
static int mjpeg_decode_frame(AVCodecContext *avctx, 
1719
                              void *data, int *data_size,
1720
                              uint8_t *buf, int buf_size)
1721
{
1722
    MJpegDecodeContext *s = avctx->priv_data;
1723
    uint8_t *buf_end, *buf_ptr;
1724
    int start_code;
1725
    AVFrame *picture = data;
1726

    
1727
    /* no supplementary picture */
1728
    if (buf_size == 0)
1729
        return 0;
1730

    
1731
    buf_ptr = buf;
1732
    buf_end = buf + buf_size;
1733
    while (buf_ptr < buf_end) {
1734
        /* find start next marker */
1735
        start_code = find_marker(&buf_ptr, buf_end);
1736
        {
1737
            /* EOF */
1738
            if (start_code < 0) {
1739
                goto the_end;
1740
            } else {
1741
                dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1742
                
1743
                if ((buf_end - buf_ptr) > s->buffer_size)
1744
                {
1745
                    av_free(s->buffer);
1746
                    s->buffer_size = buf_end-buf_ptr;
1747
                    s->buffer = av_malloc(s->buffer_size);
1748
                    dprintf("buffer too small, expanding to %d bytes\n",
1749
                        s->buffer_size);
1750
                }
1751
                
1752
                /* unescape buffer of SOS */
1753
                if (start_code == SOS)
1754
                {
1755
                    uint8_t *src = buf_ptr;
1756
                    uint8_t *dst = s->buffer;
1757

    
1758
                    while (src<buf_end)
1759
                    {
1760
                        uint8_t x = *(src++);
1761

    
1762
                        *(dst++) = x;
1763
                        if (x == 0xff)
1764
                        {
1765
                            while(*src == 0xff) src++;
1766

    
1767
                            x = *(src++);
1768
                            if (x >= 0xd0 && x <= 0xd7)
1769
                                *(dst++) = x;
1770
                            else if (x)
1771
                                break;
1772
                        }
1773
                    }
1774
                    init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1775
                    
1776
                    dprintf("escaping removed %d bytes\n",
1777
                        (buf_end - buf_ptr) - (dst - s->buffer));
1778
                }
1779
                else
1780
                    init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1781
                
1782
                s->start_code = start_code;
1783
                if(s->avctx->debug & FF_DEBUG_STARTCODE){
1784
                    av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
1785
                }
1786

    
1787
                /* process markers */
1788
                if (start_code >= 0xd0 && start_code <= 0xd7) {
1789
                    dprintf("restart marker: %d\n", start_code&0x0f);
1790
                    /* APP fields */
1791
                } else if (start_code >= APP0 && start_code <= APP15) {
1792
                    mjpeg_decode_app(s);
1793
                    /* Comment */
1794
                } else if (start_code == COM){
1795
                    mjpeg_decode_com(s);
1796
                }
1797

    
1798
                switch(start_code) {
1799
                case SOI:
1800
                    s->restart_interval = 0;
1801
                    /* nothing to do on SOI */
1802
                    break;
1803
                case DQT:
1804
                    mjpeg_decode_dqt(s);
1805
                    break;
1806
                case DHT:
1807
                    if(mjpeg_decode_dht(s) < 0){
1808
                        av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n");
1809
                        return -1;
1810
                    }
1811
                    break;
1812
                case SOF0:
1813
                    s->lossless=0;
1814
                    if (mjpeg_decode_sof(s) < 0) 
1815
                        return -1;
1816
                    break;
1817
                case SOF3:
1818
                    s->lossless=1;
1819
                    if (mjpeg_decode_sof(s) < 0) 
1820
                        return -1;
1821
                    break;
1822
                case EOI:
1823
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval) 
1824
                        break;
1825
eoi_parser:
1826
                    {
1827
                        if (s->interlaced) {
1828
                            s->bottom_field ^= 1;
1829
                            /* if not bottom field, do not output image yet */
1830
                            if (s->bottom_field)
1831
                                goto not_the_end;
1832
                        }
1833
                        *picture = s->picture;
1834
                        *data_size = sizeof(AVFrame);
1835

    
1836
                        if(!s->lossless){
1837
                            picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 
1838
                            picture->qstride= 0;
1839
                            picture->qscale_table= s->qscale_table;
1840
                            memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1841
                            if(avctx->debug & FF_DEBUG_QP)
1842
                                av_log(s->avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
1843
                            picture->quality*= FF_QP2LAMBDA;
1844
                        }
1845
                        
1846
                        goto the_end;
1847
                    }
1848
                    break;
1849
                case SOS:
1850
                    mjpeg_decode_sos(s);
1851
                    /* buggy avid puts EOI every 10-20th frame */
1852
                    /* if restart period is over process EOI */
1853
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1854
                        goto eoi_parser;
1855
                    break;
1856
                case DRI:
1857
                    mjpeg_decode_dri(s);
1858
                    break;
1859
                case SOF1:
1860
                case SOF2:
1861
                case SOF5:
1862
                case SOF6:
1863
                case SOF7:
1864
                case SOF9:
1865
                case SOF10:
1866
                case SOF11:
1867
                case SOF13:
1868
                case SOF14:
1869
                case SOF15:
1870
                case JPG:
1871
                    av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
1872
                    break;
1873
//                default:
1874
//                    printf("mjpeg: unsupported marker (%x)\n", start_code);
1875
//                    break;
1876
                }
1877

    
1878
not_the_end:
1879
                /* eof process start code */
1880
                buf_ptr += (get_bits_count(&s->gb)+7)/8;
1881
                dprintf("marker parser used %d bytes (%d bits)\n",
1882
                    (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1883
            }
1884
        }
1885
    }
1886
the_end:
1887
    dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1888
//    return buf_end - buf_ptr;
1889
    return buf_ptr - buf;
1890
}
1891

    
1892
static int mjpegb_decode_frame(AVCodecContext *avctx, 
1893
                              void *data, int *data_size,
1894
                              uint8_t *buf, int buf_size)
1895
{
1896
    MJpegDecodeContext *s = avctx->priv_data;
1897
    uint8_t *buf_end, *buf_ptr;
1898
    AVFrame *picture = data;
1899
    GetBitContext hgb; /* for the header */
1900
    uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
1901
    uint32_t field_size;
1902

    
1903
    /* no supplementary picture */
1904
    if (buf_size == 0)
1905
        return 0;
1906

    
1907
    buf_ptr = buf;
1908
    buf_end = buf + buf_size;
1909
    
1910
read_header:
1911
    /* reset on every SOI */
1912
    s->restart_interval = 0;
1913

    
1914
    init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
1915

    
1916
    skip_bits(&hgb, 32); /* reserved zeros */
1917
    
1918
    if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
1919
    {
1920
        dprintf("not mjpeg-b (bad fourcc)\n");
1921
        return 0;
1922
    }
1923

    
1924
    field_size = get_bits_long(&hgb, 32); /* field size */
1925
    dprintf("field size: 0x%x\n", field_size);
1926
    skip_bits(&hgb, 32); /* padded field size */
1927
    second_field_offs = get_bits_long(&hgb, 32);
1928
    dprintf("second field offs: 0x%x\n", second_field_offs);
1929
    if (second_field_offs)
1930
        s->interlaced = 1;
1931

    
1932
    dqt_offs = get_bits_long(&hgb, 32);
1933
    dprintf("dqt offs: 0x%x\n", dqt_offs);
1934
    if (dqt_offs)
1935
    {
1936
        init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
1937
        s->start_code = DQT;
1938
        mjpeg_decode_dqt(s);
1939
    }
1940
    
1941
    dht_offs = get_bits_long(&hgb, 32);
1942
    dprintf("dht offs: 0x%x\n", dht_offs);
1943
    if (dht_offs)
1944
    {
1945
        init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
1946
        s->start_code = DHT;
1947
        mjpeg_decode_dht(s);
1948
    }
1949

    
1950
    sof_offs = get_bits_long(&hgb, 32);
1951
    dprintf("sof offs: 0x%x\n", sof_offs);
1952
    if (sof_offs)
1953
    {
1954
        init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
1955
        s->start_code = SOF0;
1956
        if (mjpeg_decode_sof(s) < 0)
1957
            return -1;
1958
    }
1959

    
1960
    sos_offs = get_bits_long(&hgb, 32);
1961
    dprintf("sos offs: 0x%x\n", sos_offs);
1962
    if (sos_offs)
1963
    {
1964
//        init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
1965
        init_get_bits(&s->gb, buf+sos_offs, field_size*8);
1966
        s->start_code = SOS;
1967
        mjpeg_decode_sos(s);
1968
    }
1969

    
1970
    skip_bits(&hgb, 32); /* start of data offset */
1971

    
1972
    if (s->interlaced) {
1973
        s->bottom_field ^= 1;
1974
        /* if not bottom field, do not output image yet */
1975
        if (s->bottom_field && second_field_offs)
1976
        {
1977
            buf_ptr = buf + second_field_offs;
1978
            second_field_offs = 0;
1979
            goto read_header;
1980
            }
1981
    }
1982

    
1983
    //XXX FIXME factorize, this looks very similar to the EOI code
1984

    
1985
    *picture= s->picture;
1986
    *data_size = sizeof(AVFrame);
1987
    
1988
    if(!s->lossless){
1989
        picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 
1990
        picture->qstride= 0;
1991
        picture->qscale_table= s->qscale_table;
1992
        memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1993
        if(avctx->debug & FF_DEBUG_QP)
1994
            av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
1995
        picture->quality*= FF_QP2LAMBDA;
1996
    }
1997

    
1998
    return buf_ptr - buf;
1999
}
2000

    
2001
#include "sp5x.h"
2002

    
2003
static int sp5x_decode_frame(AVCodecContext *avctx, 
2004
                              void *data, int *data_size,
2005
                              uint8_t *buf, int buf_size)
2006
{
2007
#if 0
2008
    MJpegDecodeContext *s = avctx->priv_data;
2009
#endif
2010
    const int qscale = 5;
2011
    uint8_t *buf_ptr, *buf_end, *recoded;
2012
    int i = 0, j = 0;
2013

    
2014
    /* no supplementary picture */
2015
    if (buf_size == 0)
2016
        return 0;
2017

    
2018
    if (!avctx->width || !avctx->height)
2019
        return -1;
2020

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

    
2024
#if 1
2025
    recoded = av_mallocz(buf_size + 1024);
2026
    if (!recoded)
2027
        return -1;
2028

    
2029
    /* SOI */
2030
    recoded[j++] = 0xFF;
2031
    recoded[j++] = 0xD8;
2032

    
2033
    memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2034
    memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2035
    memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2036
    j += sizeof(sp5x_data_dqt);
2037

    
2038
    memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2039
    j += sizeof(sp5x_data_dht);
2040

    
2041
    memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2042
    recoded[j+5] = (avctx->height >> 8) & 0xFF;
2043
    recoded[j+6] = avctx->height & 0xFF;
2044
    recoded[j+7] = (avctx->width >> 8) & 0xFF;
2045
    recoded[j+8] = avctx->width & 0xFF;
2046
    j += sizeof(sp5x_data_sof);
2047

    
2048
    memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2049
    j += sizeof(sp5x_data_sos);
2050

    
2051
    for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2052
    {
2053
        recoded[j++] = buf[i];
2054
        if (buf[i] == 0xff)
2055
            recoded[j++] = 0;
2056
    }
2057

    
2058
    /* EOI */
2059
    recoded[j++] = 0xFF;
2060
    recoded[j++] = 0xD9;
2061

    
2062
    i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2063

    
2064
    av_free(recoded);
2065

    
2066
#else
2067
    /* SOF */
2068
    s->bits = 8;
2069
    s->width = avctx->width;
2070
    s->height = avctx->height;
2071
    s->nb_components = 3;
2072
    s->component_id[0] = 0;
2073
    s->h_count[0] = 2;
2074
    s->v_count[0] = 2;
2075
    s->quant_index[0] = 0;
2076
    s->component_id[1] = 1;
2077
    s->h_count[1] = 1;
2078
    s->v_count[1] = 1;
2079
    s->quant_index[1] = 1;
2080
    s->component_id[2] = 2;
2081
    s->h_count[2] = 1;
2082
    s->v_count[2] = 1;
2083
    s->quant_index[2] = 1;
2084
    s->h_max = 2;
2085
    s->v_max = 2;
2086
    
2087
    s->qscale_table = av_mallocz((s->width+15)/16);
2088
    avctx->pix_fmt = PIX_FMT_YUV420P;
2089
    s->interlaced = 0;
2090
    
2091
    s->picture.reference = 0;
2092
    if (avctx->get_buffer(avctx, &s->picture) < 0)
2093
    {
2094
        fprintf(stderr, "get_buffer() failed\n");
2095
        return -1;
2096
    }
2097

    
2098
    s->picture.pict_type = I_TYPE;
2099
    s->picture.key_frame = 1;
2100

    
2101
    for (i = 0; i < 3; i++)
2102
        s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2103

    
2104
    /* DQT */
2105
    for (i = 0; i < 64; i++)
2106
    {
2107
        j = s->scantable.permutated[i];
2108
        s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2109
    }
2110
    s->qscale[0] = FFMAX(
2111
        s->quant_matrixes[0][s->scantable.permutated[1]],
2112
        s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2113

    
2114
    for (i = 0; i < 64; i++)
2115
    {
2116
        j = s->scantable.permutated[i];
2117
        s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2118
    }
2119
    s->qscale[1] = FFMAX(
2120
        s->quant_matrixes[1][s->scantable.permutated[1]],
2121
        s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2122

    
2123
    /* DHT */
2124

    
2125
    /* SOS */
2126
    s->comp_index[0] = 0;
2127
    s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2128
    s->h_scount[0] = s->h_count[0];
2129
    s->v_scount[0] = s->v_count[0];
2130
    s->dc_index[0] = 0;
2131
    s->ac_index[0] = 0;
2132

    
2133
    s->comp_index[1] = 1;
2134
    s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2135
    s->h_scount[1] = s->h_count[1];
2136
    s->v_scount[1] = s->v_count[1];
2137
    s->dc_index[1] = 1;
2138
    s->ac_index[1] = 1;
2139

    
2140
    s->comp_index[2] = 2;
2141
    s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2142
    s->h_scount[2] = s->h_count[2];
2143
    s->v_scount[2] = s->v_count[2];
2144
    s->dc_index[2] = 1;
2145
    s->ac_index[2] = 1;
2146
    
2147
    for (i = 0; i < 3; i++)
2148
        s->last_dc[i] = 1024;
2149

    
2150
    s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2151
    s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2152

    
2153
    init_get_bits(&s->gb, buf+14, (buf_size-14)*8);
2154
    
2155
    return mjpeg_decode_scan(s);
2156
#endif
2157

    
2158
    return i;
2159
}
2160

    
2161
static int mjpeg_decode_end(AVCodecContext *avctx)
2162
{
2163
    MJpegDecodeContext *s = avctx->priv_data;
2164
    int i, j;
2165

    
2166
    av_free(s->buffer);
2167
    av_free(s->qscale_table);
2168
    
2169
    for(i=0;i<2;i++) {
2170
        for(j=0;j<4;j++)
2171
            free_vlc(&s->vlcs[i][j]);
2172
    }
2173
    return 0;
2174
}
2175

    
2176
AVCodec mjpeg_decoder = {
2177
    "mjpeg",
2178
    CODEC_TYPE_VIDEO,
2179
    CODEC_ID_MJPEG,
2180
    sizeof(MJpegDecodeContext),
2181
    mjpeg_decode_init,
2182
    NULL,
2183
    mjpeg_decode_end,
2184
    mjpeg_decode_frame,
2185
    CODEC_CAP_DR1,
2186
    NULL
2187
};
2188

    
2189
AVCodec mjpegb_decoder = {
2190
    "mjpegb",
2191
    CODEC_TYPE_VIDEO,
2192
    CODEC_ID_MJPEGB,
2193
    sizeof(MJpegDecodeContext),
2194
    mjpeg_decode_init,
2195
    NULL,
2196
    mjpeg_decode_end,
2197
    mjpegb_decode_frame,
2198
    CODEC_CAP_DR1,
2199
    NULL
2200
};
2201

    
2202
AVCodec sp5x_decoder = {
2203
    "sp5x",
2204
    CODEC_TYPE_VIDEO,
2205
    CODEC_ID_SP5X,
2206
    sizeof(MJpegDecodeContext),
2207
    mjpeg_decode_init,
2208
    NULL,
2209
    mjpeg_decode_end,
2210
    sp5x_decode_frame,
2211
    CODEC_CAP_DR1,
2212
    NULL
2213
};
2214

    
2215
#ifdef CONFIG_ENCODERS
2216
AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2217
    "ljpeg",
2218
    CODEC_TYPE_VIDEO,
2219
    CODEC_ID_LJPEG,
2220
    sizeof(MpegEncContext),
2221
    MPV_encode_init,
2222
    encode_picture_lossless,
2223
    MPV_encode_end,
2224
};
2225
#endif