Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mjpeg.c @ 9515c0c1

History | View | Annotate | Download (65.8 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
    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);
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= get_bit_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 mjpeg_picture_trailer(MpegEncContext *s)
535
{
536
    int pad= (-get_bit_count(&s->pb))&7;
537
    
538
    put_bits(&s->pb, pad,0xFF>>(8-pad));
539
    flush_put_bits(&s->pb);
540

    
541
    assert((s->header_bits&7)==0);
542
    
543
    escape_FF(s, s->header_bits>>3);
544

    
545
    put_marker(&s->pb, EOI);
546
}
547

    
548
static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
549
                                   uint8_t *huff_size, uint16_t *huff_code)
550
{
551
    int mant, nbits;
552

    
553
    if (val == 0) {
554
        put_bits(&s->pb, huff_size[0], huff_code[0]);
555
    } else {
556
        mant = val;
557
        if (val < 0) {
558
            val = -val;
559
            mant--;
560
        }
561
        
562
        nbits= av_log2_16bit(val) + 1;
563
            
564
        put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
565
        
566
        put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
567
    }
568
}
569

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

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

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

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

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

    
646
    init_put_bits(&s->pb, buf, buf_size);
647

    
648
    *p = *pict;
649
    p->pict_type= FF_I_TYPE;
650
    p->key_frame= 1;
651
    
652
    mjpeg_picture_header(s);
653

    
654
    s->header_bits= get_bit_count(&s->pb);
655

    
656
    if(avctx->pix_fmt == PIX_FMT_RGBA32){
657
        int x, y, i;
658
        const int linesize= p->linesize[0];
659
        uint16_t buffer[2048][4];
660
        int left[3], top[3], topleft[3];
661

    
662
        for(i=0; i<3; i++){
663
            buffer[0][i]= 1 << (9 - 1);
664
        }
665

    
666
        for(y = 0; y < height; y++) {
667
            const int modified_predictor= y ? predictor : 1;
668
            uint8_t *ptr = p->data[0] + (linesize * y);
669

    
670
            for(i=0; i<3; i++){
671
                top[i]= left[i]= topleft[i]= buffer[0][i];
672
            }
673
            for(x = 0; x < width; x++) {
674
                buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
675
                buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
676
                buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
677

    
678
                for(i=0;i<3;i++) {
679
                    int pred, diff;
680

    
681
                    PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
682
                        
683
                    topleft[i]= top[i];
684
                    top[i]= buffer[x+1][i];
685
                    
686
                    left[i]= buffer[x][i];
687

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

    
712
                        for(y=0; y<v; y++){
713
                            for(x=0; x<h; x++){
714
                                int pred;
715

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

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

    
754
                                if(i==0)
755
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
756
                                else
757
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
758
                            }
759
                        }
760
                    }
761
                }
762
            }
763
        }
764
    }
765

    
766
    emms_c();
767
    
768
    mjpeg_picture_trailer(s);
769
    s->picture_number++;
770

    
771
    flush_put_bits(&s->pb);
772
    return pbBufPtr(&s->pb) - s->pb.buf;
773
//    return (get_bit_count(&f->pb)+7)/8;
774
}
775

    
776
#endif //CONFIG_ENCODERS
777

    
778
/******************************************/
779
/* decoding */
780

    
781
#define MAX_COMPONENTS 4
782

    
783
typedef struct MJpegDecodeContext {
784
    AVCodecContext *avctx;
785
    GetBitContext gb;
786
    int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
787

    
788
    int start_code; /* current start code */
789
    int buffer_size;
790
    uint8_t *buffer;
791

    
792
    int16_t quant_matrixes[4][64];
793
    VLC vlcs[2][4];
794
    int qscale[4];      ///< quantizer scale calculated from quant_matrixes
795

    
796
    int org_width, org_height;  /* size given at codec init */
797
    int first_picture;    /* true if decoding first picture */
798
    int interlaced;     /* true if interlaced */
799
    int bottom_field;   /* true if bottom field */
800
    int lossless;
801
    int rgb;
802
    int rct;            /* standard rct */  
803
    int pegasus_rct;    /* pegasus reversible colorspace transform */  
804
    int bits;           /* bits per component */
805

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

    
828
    int restart_interval;
829
    int restart_count;
830

    
831
    int buggy_avid;
832
    int interlace_polarity;
833
} MJpegDecodeContext;
834

    
835
static int mjpeg_decode_dht(MJpegDecodeContext *s);
836

    
837
static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table, 
838
                      int nb_codes)
839
{
840
    uint8_t huff_size[256];
841
    uint16_t huff_code[256];
842

    
843
    memset(huff_size, 0, sizeof(huff_size));
844
    build_huffman_codes(huff_size, huff_code, bits_table, val_table);
845
    
846
    return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
847
}
848

    
849
static int mjpeg_decode_init(AVCodecContext *avctx)
850
{
851
    MJpegDecodeContext *s = avctx->priv_data;
852
    MpegEncContext s2;
853

    
854
    s->avctx = avctx;
855

    
856
    /* ugly way to get the idct & scantable FIXME */
857
    memset(&s2, 0, sizeof(MpegEncContext));
858
    s2.flags= avctx->flags;
859
    s2.avctx= avctx;
860
//    s2->out_format = FMT_MJPEG;
861
    s2.width = 8;
862
    s2.height = 8;
863
    if (MPV_common_init(&s2) < 0)
864
       return -1;
865
    s->scantable= s2.intra_scantable;
866
    s->idct_put= s2.dsp.idct_put;
867
    MPV_common_end(&s2);
868

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

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

    
893
    return 0;
894
}
895

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

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

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

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

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

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

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

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

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

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

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

    
1023
    /* if different size, realloc/alloc picture */
1024
    /* XXX: also check h_count and v_count */
1025
    if (width != s->width || height != s->height) {
1026
        av_freep(&s->qscale_table);
1027
            
1028
        s->width = width;
1029
        s->height = height;
1030
        /* test interlaced mode */
1031
        if (s->first_picture &&
1032
            s->org_height != 0 &&
1033
            s->height < ((s->org_height * 3) / 4)) {
1034
            s->interlaced = 1;
1035
//            s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1036
            s->bottom_field = 0;
1037
        }
1038

    
1039
        s->qscale_table= av_mallocz((s->width+15)/16);
1040

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

    
1064
    if(s->picture.data[0])
1065
        s->avctx->release_buffer(s->avctx, &s->picture);
1066

    
1067
    s->picture.reference= 0;
1068
    if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1069
        av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1070
        return -1;
1071
    }
1072
    s->picture.pict_type= I_TYPE;
1073
    s->picture.key_frame= 1;
1074
    
1075
    for(i=0; i<3; i++){
1076
        s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1077
    }
1078

    
1079
//    printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1080
    
1081
    if (len != (8+(3*nb_components)))
1082
    {
1083
        dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1084
    }
1085
    
1086
    return 0;
1087
}
1088

    
1089
static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1090
{
1091
    int code;
1092
    code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1093
    if (code < 0)
1094
    {
1095
        dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1096
                &s->vlcs[0][dc_index]);
1097
        return 0xffff;
1098
    }
1099

    
1100
    if(code)
1101
        return get_xbits(&s->gb, code);
1102
    else
1103
        return 0;
1104
}
1105

    
1106
/* decode block and dequantize */
1107
static int decode_block(MJpegDecodeContext *s, DCTELEM *block, 
1108
                        int component, int dc_index, int ac_index, int quant_index)
1109
{
1110
    int code, i, j, level, val;
1111
    VLC *ac_vlc;
1112
    int16_t *quant_matrix;
1113

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

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

    
1156
static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1157
    int i, mb_x, mb_y;
1158
    uint16_t buffer[2048][4];
1159
    int left[3], top[3], topleft[3];
1160
    const int linesize= s->linesize[0];
1161
    const int mask= (1<<s->bits)-1;
1162
    
1163
    for(i=0; i<3; i++){
1164
        buffer[0][i]= 1 << (s->bits + point_transform - 1);
1165
    }
1166
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1167
        const int modified_predictor= mb_y ? predictor : 1;
1168
        uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1169

    
1170
        if (s->interlaced && s->bottom_field)
1171
            ptr += linesize >> 1;
1172

    
1173
        for(i=0; i<3; i++){
1174
            top[i]= left[i]= topleft[i]= buffer[0][i];
1175
        }
1176
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1177
            if (s->restart_interval && !s->restart_count)
1178
                s->restart_count = s->restart_interval;
1179

    
1180
            for(i=0;i<3;i++) {
1181
                int pred;
1182

    
1183
                topleft[i]= top[i];
1184
                top[i]= buffer[mb_x][i];
1185

    
1186
                PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1187
                
1188
                left[i]= 
1189
                buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1190
            }
1191

    
1192
            if (s->restart_interval && !--s->restart_count) {
1193
                align_get_bits(&s->gb);
1194
                skip_bits(&s->gb, 16); /* skip RSTn */
1195
            }
1196
        }
1197

    
1198
        if(s->rct){
1199
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1200
                ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1201
                ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1202
                ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1203
            }
1204
        }else if(s->pegasus_rct){
1205
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1206
                ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1207
                ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1208
                ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1209
            }
1210
        }else{
1211
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1212
                ptr[4*mb_x+0] = buffer[mb_x][0];
1213
                ptr[4*mb_x+1] = buffer[mb_x][1];
1214
                ptr[4*mb_x+2] = buffer[mb_x][2];
1215
            }
1216
        }
1217
    }
1218
    return 0;
1219
}
1220

    
1221
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1222
    int i, mb_x, mb_y;
1223
    const int nb_components=3;
1224

    
1225
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1226
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1227
            if (s->restart_interval && !s->restart_count)
1228
                s->restart_count = s->restart_interval;
1229

    
1230
            if(mb_x==0 || mb_y==0 || s->interlaced){
1231
                for(i=0;i<nb_components;i++) {
1232
                    uint8_t *ptr;
1233
                    int n, h, v, x, y, c, j, linesize;
1234
                    n = s->nb_blocks[i];
1235
                    c = s->comp_index[i];
1236
                    h = s->h_scount[i];
1237
                    v = s->v_scount[i];
1238
                    x = 0;
1239
                    y = 0;
1240
                    linesize= s->linesize[c];
1241
                    
1242
                    for(j=0; j<n; j++) {
1243
                        int pred;
1244

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

    
1264
                        if (++x == h) {
1265
                            x = 0;
1266
                            y++;
1267
                        }
1268
                    }
1269
                }
1270
            }else{
1271
                for(i=0;i<nb_components;i++) {
1272
                    uint8_t *ptr;
1273
                    int n, h, v, x, y, c, j, linesize;
1274
                    n = s->nb_blocks[i];
1275
                    c = s->comp_index[i];
1276
                    h = s->h_scount[i];
1277
                    v = s->v_scount[i];
1278
                    x = 0;
1279
                    y = 0;
1280
                    linesize= s->linesize[c];
1281
                    
1282
                    for(j=0; j<n; j++) {
1283
                        int pred;
1284

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

    
1304
static int mjpeg_decode_scan(MJpegDecodeContext *s){
1305
    int i, mb_x, mb_y;
1306
    const int nb_components=3;
1307

    
1308
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1309
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1310
            if (s->restart_interval && !s->restart_count)
1311
                s->restart_count = s->restart_interval;
1312

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

    
1357
static int mjpeg_decode_sos(MJpegDecodeContext *s)
1358
{
1359
    int len, nb_components, i, h, v, predictor, point_transform;
1360
    int vmax, hmax, index, id;
1361
    const int block_size= s->lossless ? 1 : 8;
1362

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

    
1392
        s->comp_index[i] = index;
1393

    
1394
        s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1395
        s->h_scount[i] = s->h_count[index];
1396
        s->v_scount[i] = s->v_count[index];
1397

    
1398
        s->dc_index[i] = get_bits(&s->gb, 4);
1399
        s->ac_index[i] = get_bits(&s->gb, 4);
1400

    
1401
        if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1402
            s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1403
            goto out_of_range;
1404
#if 0 //buggy
1405
        switch(s->start_code)
1406
        {
1407
            case SOF0:
1408
                if (dc_index[i] > 1 || ac_index[i] > 1)
1409
                    goto out_of_range;
1410
                break;
1411
            case SOF1:
1412
            case SOF2:
1413
                if (dc_index[i] > 3 || ac_index[i] > 3)
1414
                    goto out_of_range;
1415
                break;
1416
            case SOF3:
1417
                if (dc_index[i] > 3 || ac_index[i] != 0)
1418
                    goto out_of_range;
1419
                break;        
1420
        }
1421
#endif
1422
    }
1423

    
1424
    predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */
1425
    skip_bits(&s->gb, 8); /* Se */
1426
    skip_bits(&s->gb, 4); /* Ah */
1427
    point_transform= get_bits(&s->gb, 4); /* Al */
1428

    
1429
    for(i=0;i<nb_components;i++) 
1430
        s->last_dc[i] = 1024;
1431

    
1432
    if (nb_components > 1) {
1433
        /* interleaved stream */
1434
        s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1435
        s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1436
    } else {
1437
        h = s->h_max / s->h_scount[s->comp_index[0]];
1438
        v = s->v_max / s->v_scount[s->comp_index[0]];
1439
        s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1440
        s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1441
        s->nb_blocks[0] = 1;
1442
        s->h_scount[0] = 1;
1443
        s->v_scount[0] = 1;
1444
    }
1445

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

    
1468
static int mjpeg_decode_dri(MJpegDecodeContext *s)
1469
{
1470
    if (get_bits(&s->gb, 16) != 4)
1471
        return -1;
1472
    s->restart_interval = get_bits(&s->gb, 16);
1473
    dprintf("restart interval: %d\n", s->restart_interval);
1474

    
1475
    return 0;
1476
}
1477

    
1478
static int mjpeg_decode_app(MJpegDecodeContext *s)
1479
{
1480
    int len, id;
1481

    
1482
    /* XXX: verify len field validity */
1483
    len = get_bits(&s->gb, 16);
1484
    if (len < 5)
1485
        return -1;
1486

    
1487
    id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1488
    id = be2me_32(id);
1489
    len -= 6;
1490

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

    
1532
        s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1533
        s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1534

    
1535
        t_w = get_bits(&s->gb, 8);
1536
        t_h = get_bits(&s->gb, 8);
1537
        if (t_w && t_h)
1538
        {
1539
            /* skip thumbnail */
1540
            if (len-10-(t_w*t_h*3) > 0)
1541
                len -= t_w*t_h*3;
1542
        }
1543
        len -= 10;
1544
        goto out;
1545
    }
1546
    
1547
    if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1548
    {
1549
        av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1550
        skip_bits(&s->gb, 16); /* version */
1551
        skip_bits(&s->gb, 16); /* flags0 */
1552
        skip_bits(&s->gb, 16); /* flags1 */
1553
        skip_bits(&s->gb, 8); /* transform */
1554
        len -= 7;
1555
        goto out;
1556
    }
1557

    
1558
    if (id == ff_get_fourcc("LJIF")){
1559
        av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1560
        skip_bits(&s->gb, 16); /* version ? */
1561
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1562
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1563
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1564
        switch( get_bits(&s->gb, 8)){
1565
        case 1:
1566
            s->rgb= 1;
1567
            s->pegasus_rct=0;
1568
            break;
1569
        case 2:
1570
            s->rgb= 1;
1571
            s->pegasus_rct=1;
1572
            break;
1573
        default:
1574
            av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1575
        }
1576
        len -= 9;
1577
        goto out;
1578
    }
1579
    
1580
    /* Apple MJPEG-A */
1581
    if ((s->start_code == APP1) && (len > (0x28 - 8)))
1582
    {
1583
        id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1584
        id = be2me_32(id);
1585
        len -= 4;
1586
        if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1587
        {
1588
#if 0
1589
            skip_bits(&s->gb, 32); /* field size */
1590
            skip_bits(&s->gb, 32); /* pad field size */
1591
            skip_bits(&s->gb, 32); /* next off */
1592
            skip_bits(&s->gb, 32); /* quant off */
1593
            skip_bits(&s->gb, 32); /* huff off */
1594
            skip_bits(&s->gb, 32); /* image off */
1595
            skip_bits(&s->gb, 32); /* scan off */
1596
            skip_bits(&s->gb, 32); /* data off */
1597
#endif
1598
            if (s->first_picture)
1599
                av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1600
        }
1601
    }
1602

    
1603
out:
1604
    /* slow but needed for extreme adobe jpegs */
1605
    if (len < 0)
1606
        av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1607
    while(--len > 0)
1608
        skip_bits(&s->gb, 8);
1609

    
1610
    return 0;
1611
}
1612

    
1613
static int mjpeg_decode_com(MJpegDecodeContext *s)
1614
{
1615
    /* XXX: verify len field validity */
1616
    int len = get_bits(&s->gb, 16);
1617
    if (len >= 2 && len < 32768) {
1618
        /* XXX: any better upper bound */
1619
        uint8_t *cbuf = av_malloc(len - 1);
1620
        if (cbuf) {
1621
            int i;
1622
            for (i = 0; i < len - 2; i++)
1623
                cbuf[i] = get_bits(&s->gb, 8);
1624
            if (i > 0 && cbuf[i-1] == '\n')
1625
                cbuf[i-1] = 0;
1626
            else
1627
                cbuf[i] = 0;
1628

    
1629
            av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1630

    
1631
            /* buggy avid, it puts EOI only at every 10th frame */
1632
            if (!strcmp(cbuf, "AVID"))
1633
            {
1634
                s->buggy_avid = 1;
1635
                //        if (s->first_picture)
1636
                //            printf("mjpeg: workarounding buggy AVID\n");
1637
            }
1638

    
1639
            av_free(cbuf);
1640
        }
1641
    }
1642

    
1643
    return 0;
1644
}
1645

    
1646
#if 0
1647
static int valid_marker_list[] =
1648
{
1649
        /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1650
/* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1651
/* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1652
/* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1653
/* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1654
/* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1655
/* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1656
/* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1657
/* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1658
/* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1659
/* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1660
/* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1661
/* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1662
/* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1663
/* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1664
/* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1665
/* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1666
}
1667
#endif
1668

    
1669
/* return the 8 bit start code value and update the search
1670
   state. Return -1 if no start code found */
1671
static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1672
{
1673
    uint8_t *buf_ptr;
1674
    unsigned int v, v2;
1675
    int val;
1676
#ifdef DEBUG
1677
    int skipped=0;
1678
#endif
1679

    
1680
    buf_ptr = *pbuf_ptr;
1681
    while (buf_ptr < buf_end) {
1682
        v = *buf_ptr++;
1683
        v2 = *buf_ptr;
1684
        if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1685
            val = *buf_ptr++;
1686
            goto found;
1687
        }
1688
#ifdef DEBUG
1689
        skipped++;
1690
#endif
1691
    }
1692
    val = -1;
1693
found:
1694
#ifdef DEBUG
1695
    dprintf("find_marker skipped %d bytes\n", skipped);
1696
#endif
1697
    *pbuf_ptr = buf_ptr;
1698
    return val;
1699
}
1700

    
1701
static int mjpeg_decode_frame(AVCodecContext *avctx, 
1702
                              void *data, int *data_size,
1703
                              uint8_t *buf, int buf_size)
1704
{
1705
    MJpegDecodeContext *s = avctx->priv_data;
1706
    uint8_t *buf_end, *buf_ptr;
1707
    int start_code;
1708
    AVFrame *picture = data;
1709

    
1710
    *data_size = 0;
1711

    
1712
    /* no supplementary picture */
1713
    if (buf_size == 0)
1714
        return 0;
1715

    
1716
    buf_ptr = buf;
1717
    buf_end = buf + buf_size;
1718
    while (buf_ptr < buf_end) {
1719
        /* find start next marker */
1720
        start_code = find_marker(&buf_ptr, buf_end);
1721
        {
1722
            /* EOF */
1723
            if (start_code < 0) {
1724
                goto the_end;
1725
            } else {
1726
                dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1727
                
1728
                if ((buf_end - buf_ptr) > s->buffer_size)
1729
                {
1730
                    av_free(s->buffer);
1731
                    s->buffer_size = buf_end-buf_ptr;
1732
                    s->buffer = av_malloc(s->buffer_size);
1733
                    dprintf("buffer too small, expanding to %d bytes\n",
1734
                        s->buffer_size);
1735
                }
1736
                
1737
                /* unescape buffer of SOS */
1738
                if (start_code == SOS)
1739
                {
1740
                    uint8_t *src = buf_ptr;
1741
                    uint8_t *dst = s->buffer;
1742

    
1743
                    while (src<buf_end)
1744
                    {
1745
                        uint8_t x = *(src++);
1746

    
1747
                        *(dst++) = x;
1748
                        if (x == 0xff)
1749
                        {
1750
                            while(*src == 0xff) src++;
1751

    
1752
                            x = *(src++);
1753
                            if (x >= 0xd0 && x <= 0xd7)
1754
                                *(dst++) = x;
1755
                            else if (x)
1756
                                break;
1757
                        }
1758
                    }
1759
                    init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1760
                    
1761
                    dprintf("escaping removed %d bytes\n",
1762
                        (buf_end - buf_ptr) - (dst - s->buffer));
1763
                }
1764
                else
1765
                    init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1766
                
1767
                s->start_code = start_code;
1768
                if(s->avctx->debug & FF_DEBUG_STARTCODE){
1769
                    av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
1770
                }
1771

    
1772
                /* process markers */
1773
                if (start_code >= 0xd0 && start_code <= 0xd7) {
1774
                    dprintf("restart marker: %d\n", start_code&0x0f);
1775
                } else if (s->first_picture) {
1776
                    /* APP fields */
1777
                    if (start_code >= 0xe0 && start_code <= 0xef)
1778
                        mjpeg_decode_app(s);
1779
                    /* Comment */
1780
                    else if (start_code == COM)
1781
                        mjpeg_decode_com(s);
1782
                }
1783

    
1784
                switch(start_code) {
1785
                case SOI:
1786
                    s->restart_interval = 0;
1787
                    /* nothing to do on SOI */
1788
                    break;
1789
                case DQT:
1790
                    mjpeg_decode_dqt(s);
1791
                    break;
1792
                case DHT:
1793
                    if(mjpeg_decode_dht(s) < 0){
1794
                        av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n");
1795
                        return -1;
1796
                    }
1797
                    break;
1798
                case SOF0:
1799
                    s->lossless=0;
1800
                    if (mjpeg_decode_sof(s) < 0) 
1801
                        return -1;
1802
                    break;
1803
                case SOF3:
1804
                    s->lossless=1;
1805
                    if (mjpeg_decode_sof(s) < 0) 
1806
                        return -1;
1807
                    break;
1808
                case EOI:
1809
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval) 
1810
                        break;
1811
eoi_parser:
1812
                    {
1813
                        if (s->interlaced) {
1814
                            s->bottom_field ^= 1;
1815
                            /* if not bottom field, do not output image yet */
1816
                            if (s->bottom_field)
1817
                                goto not_the_end;
1818
                        }
1819
                        *picture = s->picture;
1820
                        *data_size = sizeof(AVFrame);
1821
                        avctx->height = s->height;
1822
                        if (s->interlaced)
1823
                            avctx->height *= 2;
1824
                        avctx->width = s->width;
1825

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

    
1868
not_the_end:
1869
                /* eof process start code */
1870
                buf_ptr += (get_bits_count(&s->gb)+7)/8;
1871
                dprintf("marker parser used %d bytes (%d bits)\n",
1872
                    (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1873
            }
1874
        }
1875
    }
1876
the_end:
1877
    dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1878
//    return buf_end - buf_ptr;
1879
    return buf_ptr - buf;
1880
}
1881

    
1882
static int mjpegb_decode_frame(AVCodecContext *avctx, 
1883
                              void *data, int *data_size,
1884
                              uint8_t *buf, int buf_size)
1885
{
1886
    MJpegDecodeContext *s = avctx->priv_data;
1887
    uint8_t *buf_end, *buf_ptr;
1888
    AVFrame *picture = data;
1889
    GetBitContext hgb; /* for the header */
1890
    uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
1891
    uint32_t field_size;
1892

    
1893
    *data_size = 0;
1894

    
1895
    /* no supplementary picture */
1896
    if (buf_size == 0)
1897
        return 0;
1898

    
1899
    buf_ptr = buf;
1900
    buf_end = buf + buf_size;
1901
    
1902
read_header:
1903
    /* reset on every SOI */
1904
    s->restart_interval = 0;
1905

    
1906
    init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
1907

    
1908
    skip_bits(&hgb, 32); /* reserved zeros */
1909
    
1910
    if (get_bits(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
1911
    {
1912
        dprintf("not mjpeg-b (bad fourcc)\n");
1913
        return 0;
1914
    }
1915

    
1916
    field_size = get_bits(&hgb, 32); /* field size */
1917
    dprintf("field size: 0x%x\n", field_size);
1918
    skip_bits(&hgb, 32); /* padded field size */
1919
    second_field_offs = get_bits(&hgb, 32);
1920
    dprintf("second field offs: 0x%x\n", second_field_offs);
1921
    if (second_field_offs)
1922
        s->interlaced = 1;
1923

    
1924
    dqt_offs = get_bits(&hgb, 32);
1925
    dprintf("dqt offs: 0x%x\n", dqt_offs);
1926
    if (dqt_offs)
1927
    {
1928
        init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
1929
        s->start_code = DQT;
1930
        mjpeg_decode_dqt(s);
1931
    }
1932
    
1933
    dht_offs = get_bits(&hgb, 32);
1934
    dprintf("dht offs: 0x%x\n", dht_offs);
1935
    if (dht_offs)
1936
    {
1937
        init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
1938
        s->start_code = DHT;
1939
        mjpeg_decode_dht(s);
1940
    }
1941

    
1942
    sof_offs = get_bits(&hgb, 32);
1943
    dprintf("sof offs: 0x%x\n", sof_offs);
1944
    if (sof_offs)
1945
    {
1946
        init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
1947
        s->start_code = SOF0;
1948
        if (mjpeg_decode_sof(s) < 0)
1949
            return -1;
1950
    }
1951

    
1952
    sos_offs = get_bits(&hgb, 32);
1953
    dprintf("sos offs: 0x%x\n", sos_offs);
1954
    if (sos_offs)
1955
    {
1956
//        init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
1957
        init_get_bits(&s->gb, buf+sos_offs, field_size*8);
1958
        s->start_code = SOS;
1959
        mjpeg_decode_sos(s);
1960
    }
1961

    
1962
    skip_bits(&hgb, 32); /* start of data offset */
1963

    
1964
    if (s->interlaced) {
1965
        s->bottom_field ^= 1;
1966
        /* if not bottom field, do not output image yet */
1967
        if (s->bottom_field && second_field_offs)
1968
        {
1969
            buf_ptr = buf + second_field_offs;
1970
            second_field_offs = 0;
1971
            goto read_header;
1972
            }
1973
    }
1974

    
1975
    //XXX FIXME factorize, this looks very similar to the EOI code
1976

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

    
1994
    return buf_ptr - buf;
1995
}
1996

    
1997
#include "sp5x.h"
1998

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

    
2010
    *data_size = 0;
2011

    
2012
    /* no supplementary picture */
2013
    if (buf_size == 0)
2014
        return 0;
2015

    
2016
    if (!avctx->width || !avctx->height)
2017
        return -1;
2018

    
2019
    buf_ptr = buf;
2020
    buf_end = buf + buf_size;
2021

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

    
2027
    /* SOI */
2028
    recoded[j++] = 0xFF;
2029
    recoded[j++] = 0xD8;
2030

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

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

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

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

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

    
2056
    /* EOI */
2057
    recoded[j++] = 0xFF;
2058
    recoded[j++] = 0xD9;
2059

    
2060
    i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2061

    
2062
    av_free(recoded);
2063

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

    
2096
    s->picture.pict_type = I_TYPE;
2097
    s->picture.key_frame = 1;
2098

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

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

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

    
2121
    /* DHT */
2122

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

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

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

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

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

    
2156
    return i;
2157
}
2158

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

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

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

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

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

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