Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mjpeg.c @ da9c9637

History | View | Annotate | Download (66.1 KB)

1 10b7b472 Fabrice Bellard
/*
2
 * MJPEG encoder and decoder
3 3093185e Fabrice Bellard
 * Copyright (c) 2000, 2001 Fabrice Bellard.
4 02da1f0d Alex Beregszaszi
 * Copyright (c) 2003 Alex Beregszaszi
5
 * Copyright (c) 2003-2004 Michael Niedermayer
6 10b7b472 Fabrice Bellard
 *
7 3093185e Fabrice Bellard
 * This library is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2 of the License, or (at your option) any later version.
11 10b7b472 Fabrice Bellard
 *
12 3093185e Fabrice Bellard
 * This library is distributed in the hope that it will be useful,
13 10b7b472 Fabrice Bellard
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 3093185e Fabrice Bellard
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16 10b7b472 Fabrice Bellard
 *
17 3093185e Fabrice Bellard
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with this library; if not, write to the Free Software
19
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20 e84c31dc Arpi
 *
21 85bf478e Alex Beregszaszi
 * Support for external huffman table, various fixes (AVID workaround),
22 b135d9fb Alex Beregszaszi
 * aspecting, new decode_frame mechanism and apple mjpeg-b support
23 85bf478e Alex Beregszaszi
 *                                  by Alex Beregszaszi <alex@naxine.org>
24 10b7b472 Fabrice Bellard
 */
25 983e3246 Michael Niedermayer
26
/**
27
 * @file mjpeg.c
28
 * MJPEG encoder and decoder.
29
 */
30
 
31 97d4469a Alex Beregszaszi
//#define DEBUG
32 e4d2b1f3 Michael Niedermayer
#include <assert.h>
33
34 10b7b472 Fabrice Bellard
#include "avcodec.h"
35
#include "dsputil.h"
36
#include "mpegvideo.h"
37
38 109362cb Alex Beregszaszi
/* use two quantizer tables (one for luminance and one for chrominance) */
39 723106b2 Alex Beregszaszi
/* not yet working */
40
#undef TWOMATRIXES
41
42 10b7b472 Fabrice Bellard
typedef struct MJpegContext {
43 b1e6b355 Michael Niedermayer
    uint8_t huff_size_dc_luminance[12]; //FIXME use array [3] instead of lumi / chrom, for easier addressing 
44 0c1a9eda Zdenek Kabelac
    uint16_t huff_code_dc_luminance[12];
45
    uint8_t huff_size_dc_chrominance[12];
46
    uint16_t huff_code_dc_chrominance[12];
47
48
    uint8_t huff_size_ac_luminance[256];
49
    uint16_t huff_code_ac_luminance[256];
50
    uint8_t huff_size_ac_chrominance[256];
51
    uint16_t huff_code_ac_chrominance[256];
52 10b7b472 Fabrice Bellard
} MJpegContext;
53
54 e84c31dc Arpi
/* JPEG marker codes */
55
typedef enum {
56
    /* start of frame */
57
    SOF0  = 0xc0,        /* baseline */
58
    SOF1  = 0xc1,        /* extended sequential, huffman */
59
    SOF2  = 0xc2,        /* progressive, huffman */
60
    SOF3  = 0xc3,        /* lossless, huffman */
61
62
    SOF5  = 0xc5,        /* differential sequential, huffman */
63
    SOF6  = 0xc6,        /* differential progressive, huffman */
64
    SOF7  = 0xc7,        /* differential lossless, huffman */
65
    JPG   = 0xc8,        /* reserved for JPEG extension */
66
    SOF9  = 0xc9,        /* extended sequential, arithmetic */
67
    SOF10 = 0xca,        /* progressive, arithmetic */
68
    SOF11 = 0xcb,        /* lossless, arithmetic */
69
70
    SOF13 = 0xcd,        /* differential sequential, arithmetic */
71
    SOF14 = 0xce,        /* differential progressive, arithmetic */
72
    SOF15 = 0xcf,        /* differential lossless, arithmetic */
73
74
    DHT   = 0xc4,        /* define huffman tables */
75
76
    DAC   = 0xcc,        /* define arithmetic-coding conditioning */
77
78
    /* restart with modulo 8 count "m" */
79
    RST0  = 0xd0,
80
    RST1  = 0xd1,
81
    RST2  = 0xd2,
82
    RST3  = 0xd3,
83
    RST4  = 0xd4,
84
    RST5  = 0xd5,
85
    RST6  = 0xd6,
86
    RST7  = 0xd7,
87
88
    SOI   = 0xd8,        /* start of image */
89
    EOI   = 0xd9,        /* end of image */
90
    SOS   = 0xda,        /* start of scan */
91
    DQT   = 0xdb,        /* define quantization tables */
92
    DNL   = 0xdc,        /* define number of lines */
93
    DRI   = 0xdd,        /* define restart interval */
94
    DHP   = 0xde,        /* define hierarchical progression */
95
    EXP   = 0xdf,        /* expand reference components */
96
97
    APP0  = 0xe0,
98
    APP1  = 0xe1,
99
    APP2  = 0xe2,
100
    APP3  = 0xe3,
101
    APP4  = 0xe4,
102
    APP5  = 0xe5,
103
    APP6  = 0xe6,
104
    APP7  = 0xe7,
105
    APP8  = 0xe8,
106
    APP9  = 0xe9,
107
    APP10 = 0xea,
108
    APP11 = 0xeb,
109
    APP12 = 0xec,
110
    APP13 = 0xed,
111
    APP14 = 0xee,
112
    APP15 = 0xef,
113
114
    JPG0  = 0xf0,
115
    JPG1  = 0xf1,
116
    JPG2  = 0xf2,
117
    JPG3  = 0xf3,
118
    JPG4  = 0xf4,
119
    JPG5  = 0xf5,
120
    JPG6  = 0xf6,
121
    JPG7  = 0xf7,
122
    JPG8  = 0xf8,
123
    JPG9  = 0xf9,
124
    JPG10 = 0xfa,
125
    JPG11 = 0xfb,
126
    JPG12 = 0xfc,
127
    JPG13 = 0xfd,
128
129
    COM   = 0xfe,        /* comment */
130
131
    TEM   = 0x01,        /* temporary private use for arithmetic coding */
132
133
    /* 0x02 -> 0xbf reserved */
134
} JPEG_MARKER;
135 10b7b472 Fabrice Bellard
136
#if 0
137
/* These are the sample quantization tables given in JPEG spec section K.1.
138
 * The spec says that the values given produce "good" quality, and
139
 * when divided by 2, "very good" quality.
140
 */
141
static const unsigned char std_luminance_quant_tbl[64] = {
142
    16,  11,  10,  16,  24,  40,  51,  61,
143
    12,  12,  14,  19,  26,  58,  60,  55,
144
    14,  13,  16,  24,  40,  57,  69,  56,
145
    14,  17,  22,  29,  51,  87,  80,  62,
146
    18,  22,  37,  56,  68, 109, 103,  77,
147
    24,  35,  55,  64,  81, 104, 113,  92,
148
    49,  64,  78,  87, 103, 121, 120, 101,
149
    72,  92,  95,  98, 112, 100, 103,  99
150
};
151
static const unsigned char std_chrominance_quant_tbl[64] = {
152
    17,  18,  24,  47,  99,  99,  99,  99,
153
    18,  21,  26,  66,  99,  99,  99,  99,
154
    24,  26,  56,  99,  99,  99,  99,  99,
155
    47,  66,  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
    99,  99,  99,  99,  99,  99,  99,  99,
159
    99,  99,  99,  99,  99,  99,  99,  99
160
};
161
#endif
162
163
/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
164
/* IMPORTANT: these are only valid for 8-bit data precision! */
165 0c1a9eda Zdenek Kabelac
static const uint8_t bits_dc_luminance[17] =
166 10b7b472 Fabrice Bellard
{ /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
167 0c1a9eda Zdenek Kabelac
static const uint8_t val_dc_luminance[] =
168 10b7b472 Fabrice Bellard
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
169
170 0c1a9eda Zdenek Kabelac
static const uint8_t bits_dc_chrominance[17] =
171 10b7b472 Fabrice Bellard
{ /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
172 0c1a9eda Zdenek Kabelac
static const uint8_t val_dc_chrominance[] =
173 10b7b472 Fabrice Bellard
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
174
175 0c1a9eda Zdenek Kabelac
static const uint8_t bits_ac_luminance[17] =
176 10b7b472 Fabrice Bellard
{ /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
177 0c1a9eda Zdenek Kabelac
static const uint8_t val_ac_luminance[] =
178 10b7b472 Fabrice Bellard
{ 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
179
  0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
180
  0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
181
  0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
182
  0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
183
  0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
184
  0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
185
  0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
186
  0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
187
  0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
188
  0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
189
  0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
190
  0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
191
  0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
192
  0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
193
  0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
194
  0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
195
  0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
196
  0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
197
  0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
198
  0xf9, 0xfa 
199
};
200
201 0c1a9eda Zdenek Kabelac
static const uint8_t bits_ac_chrominance[17] =
202 10b7b472 Fabrice Bellard
{ /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
203
204 0c1a9eda Zdenek Kabelac
static const uint8_t val_ac_chrominance[] =
205 10b7b472 Fabrice Bellard
{ 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
206
  0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
207
  0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
208
  0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
209
  0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
210
  0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
211
  0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
212
  0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
213
  0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
214
  0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
215
  0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
216
  0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
217
  0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
218
  0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
219
  0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
220
  0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
221
  0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
222
  0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
223
  0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
224
  0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
225
  0xf9, 0xfa 
226
};
227
228
/* isn't this function nicer than the one in the libjpeg ? */
229 0c1a9eda Zdenek Kabelac
static void build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code,
230
                                const uint8_t *bits_table, const uint8_t *val_table)
231 10b7b472 Fabrice Bellard
{
232
    int i, j, k,nb, code, sym;
233
234
    code = 0;
235
    k = 0;
236
    for(i=1;i<=16;i++) {
237
        nb = bits_table[i];
238
        for(j=0;j<nb;j++) {
239
            sym = val_table[k++];
240
            huff_size[sym] = i;
241
            huff_code[sym] = code;
242
            code++;
243
        }
244
        code <<= 1;
245
    }
246
}
247
248 764ef400 Mike Melanson
#ifdef CONFIG_ENCODERS
249 10b7b472 Fabrice Bellard
int mjpeg_init(MpegEncContext *s)
250
{
251
    MJpegContext *m;
252
    
253 6000abfa Fabrice Bellard
    m = av_malloc(sizeof(MJpegContext));
254 10b7b472 Fabrice Bellard
    if (!m)
255
        return -1;
256 d7e9533a Michael Niedermayer
    
257
    s->min_qcoeff=-1023;
258
    s->max_qcoeff= 1023;
259 10b7b472 Fabrice Bellard
260
    /* build all the huffman tables */
261
    build_huffman_codes(m->huff_size_dc_luminance,
262
                        m->huff_code_dc_luminance,
263
                        bits_dc_luminance,
264
                        val_dc_luminance);
265
    build_huffman_codes(m->huff_size_dc_chrominance,
266
                        m->huff_code_dc_chrominance,
267
                        bits_dc_chrominance,
268
                        val_dc_chrominance);
269
    build_huffman_codes(m->huff_size_ac_luminance,
270
                        m->huff_code_ac_luminance,
271
                        bits_ac_luminance,
272
                        val_ac_luminance);
273
    build_huffman_codes(m->huff_size_ac_chrominance,
274
                        m->huff_code_ac_chrominance,
275
                        bits_ac_chrominance,
276
                        val_ac_chrominance);
277
    
278
    s->mjpeg_ctx = m;
279
    return 0;
280
}
281
282
void mjpeg_close(MpegEncContext *s)
283
{
284 6000abfa Fabrice Bellard
    av_free(s->mjpeg_ctx);
285 10b7b472 Fabrice Bellard
}
286 764ef400 Mike Melanson
#endif //CONFIG_ENCODERS
287 10b7b472 Fabrice Bellard
288 63efe9a7 Michael Niedermayer
#define PREDICT(ret, topleft, top, left, predictor)\
289
    switch(predictor){\
290
        case 1: ret= left; break;\
291
        case 2: ret= top; break;\
292
        case 3: ret= topleft; break;\
293
        case 4: ret= left   +   top - topleft; break;\
294
        case 5: ret= left   + ((top - topleft)>>1); break;\
295
        case 6: ret= top + ((left   - topleft)>>1); break;\
296 b1609412 Fabrice Bellard
        default:\
297 63efe9a7 Michael Niedermayer
        case 7: ret= (left + top)>>1; break;\
298 e4d2b1f3 Michael Niedermayer
    }
299
300 2a250222 Michael Niedermayer
#ifdef CONFIG_ENCODERS
301 10b7b472 Fabrice Bellard
static inline void put_marker(PutBitContext *p, int code)
302
{
303
    put_bits(p, 8, 0xff);
304
    put_bits(p, 8, code);
305
}
306
307
/* table_class: 0 = DC coef, 1 = AC coefs */
308
static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
309 0c1a9eda Zdenek Kabelac
                             const uint8_t *bits_table, const uint8_t *value_table)
310 10b7b472 Fabrice Bellard
{
311
    PutBitContext *p = &s->pb;
312
    int n, i;
313
314
    put_bits(p, 4, table_class);
315
    put_bits(p, 4, table_id);
316
317
    n = 0;
318
    for(i=1;i<=16;i++) {
319
        n += bits_table[i];
320
        put_bits(p, 8, bits_table[i]);
321
    }
322
323
    for(i=0;i<n;i++)
324
        put_bits(p, 8, value_table[i]);
325
326
    return n + 17;
327
}
328
329
static void jpeg_table_header(MpegEncContext *s)
330
{
331
    PutBitContext *p = &s->pb;
332 47476fa9 Fabrice Bellard
    int i, j, size;
333 0c1a9eda Zdenek Kabelac
    uint8_t *ptr;
334 10b7b472 Fabrice Bellard
335
    /* quant matrixes */
336
    put_marker(p, DQT);
337 723106b2 Alex Beregszaszi
#ifdef TWOMATRIXES
338
    put_bits(p, 16, 2 + 2 * (1 + 64));
339
#else
340 10b7b472 Fabrice Bellard
    put_bits(p, 16, 2 + 1 * (1 + 64));
341 723106b2 Alex Beregszaszi
#endif
342 10b7b472 Fabrice Bellard
    put_bits(p, 4, 0); /* 8 bit precision */
343
    put_bits(p, 4, 0); /* table 0 */
344
    for(i=0;i<64;i++) {
345 2ad1516a Michael Niedermayer
        j = s->intra_scantable.permutated[i];
346 47476fa9 Fabrice Bellard
        put_bits(p, 8, s->intra_matrix[j]);
347 10b7b472 Fabrice Bellard
    }
348 723106b2 Alex Beregszaszi
#ifdef TWOMATRIXES
349 10b7b472 Fabrice Bellard
    put_bits(p, 4, 0); /* 8 bit precision */
350
    put_bits(p, 4, 1); /* table 1 */
351
    for(i=0;i<64;i++) {
352 2ad1516a Michael Niedermayer
        j = s->intra_scantable.permutated[i];
353 47476fa9 Fabrice Bellard
        put_bits(p, 8, s->chroma_intra_matrix[j]);
354 10b7b472 Fabrice Bellard
    }
355
#endif
356
357
    /* huffman table */
358
    put_marker(p, DHT);
359
    flush_put_bits(p);
360 17592475 Michael Niedermayer
    ptr = pbBufPtr(p);
361 10b7b472 Fabrice Bellard
    put_bits(p, 16, 0); /* patched later */
362
    size = 2;
363
    size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
364
    size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
365
    
366
    size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
367
    size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
368
    ptr[0] = size >> 8;
369
    ptr[1] = size;
370
}
371
372 723106b2 Alex Beregszaszi
static void jpeg_put_comments(MpegEncContext *s)
373
{
374
    PutBitContext *p = &s->pb;
375
    int size;
376 0c1a9eda Zdenek Kabelac
    uint8_t *ptr;
377 723106b2 Alex Beregszaszi
378 b1e6b355 Michael Niedermayer
    if (s->aspect_ratio_info /* && !lossless */)
379 85bf478e Alex Beregszaszi
    {
380 723106b2 Alex Beregszaszi
    /* JFIF header */
381
    put_marker(p, APP0);
382
    put_bits(p, 16, 16);
383 99683a30 Michael Niedermayer
    put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */
384 85bf478e Alex Beregszaszi
    put_bits(p, 16, 0x0201); /* v 1.02 */
385 723106b2 Alex Beregszaszi
    put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
386 5ff85f1d Michael Niedermayer
    put_bits(p, 16, s->avctx->sample_aspect_ratio.num);
387
    put_bits(p, 16, s->avctx->sample_aspect_ratio.den);
388 723106b2 Alex Beregszaszi
    put_bits(p, 8, 0); /* thumbnail width */
389
    put_bits(p, 8, 0); /* thumbnail height */
390 85bf478e Alex Beregszaszi
    }
391 723106b2 Alex Beregszaszi
392
    /* comment */
393 b0368839 Michael Niedermayer
    if(!(s->flags & CODEC_FLAG_BITEXACT)){
394 5596c60c Michael Niedermayer
        put_marker(p, COM);
395
        flush_put_bits(p);
396
        ptr = pbBufPtr(p);
397
        put_bits(p, 16, 0); /* patched later */
398 99683a30 Michael Niedermayer
        put_string(p, LIBAVCODEC_IDENT, 1);
399 ce2749d2 Alex Beregszaszi
        size = strlen(LIBAVCODEC_IDENT)+3;
400 5596c60c Michael Niedermayer
        ptr[0] = size >> 8;
401
        ptr[1] = size;
402
    }
403 723106b2 Alex Beregszaszi
}
404
405 10b7b472 Fabrice Bellard
void mjpeg_picture_header(MpegEncContext *s)
406
{
407 b1e6b355 Michael Niedermayer
    const int lossless= s->avctx->codec_id == CODEC_ID_LJPEG;
408
409 10b7b472 Fabrice Bellard
    put_marker(&s->pb, SOI);
410
411 a69b930c Alex Beregszaszi
    if (!s->mjpeg_data_only_frames)
412
    {
413 723106b2 Alex Beregszaszi
    jpeg_put_comments(s);    
414
415 80e103d0 Arpi
    if (s->mjpeg_write_tables) jpeg_table_header(s);
416 10b7b472 Fabrice Bellard
417 b1e6b355 Michael Niedermayer
    put_marker(&s->pb, lossless ? SOF3 : SOF0);
418 10b7b472 Fabrice Bellard
419
    put_bits(&s->pb, 16, 17);
420 b1e6b355 Michael Niedermayer
    if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32)
421
        put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
422
    else
423
        put_bits(&s->pb, 8, 8); /* 8 bits/component */
424 10b7b472 Fabrice Bellard
    put_bits(&s->pb, 16, s->height);
425
    put_bits(&s->pb, 16, s->width);
426
    put_bits(&s->pb, 8, 3); /* 3 components */
427
    
428
    /* Y component */
429
    put_bits(&s->pb, 8, 1); /* component number */
430 80e103d0 Arpi
    put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
431
    put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
432 10b7b472 Fabrice Bellard
    put_bits(&s->pb, 8, 0); /* select matrix */
433
    
434
    /* Cb component */
435
    put_bits(&s->pb, 8, 2); /* component number */
436 80e103d0 Arpi
    put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
437
    put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
438 723106b2 Alex Beregszaszi
#ifdef TWOMATRIXES
439 b1e6b355 Michael Niedermayer
    put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
440 723106b2 Alex Beregszaszi
#else
441 10b7b472 Fabrice Bellard
    put_bits(&s->pb, 8, 0); /* select matrix */
442 723106b2 Alex Beregszaszi
#endif
443 10b7b472 Fabrice Bellard
444
    /* Cr component */
445
    put_bits(&s->pb, 8, 3); /* component number */
446 80e103d0 Arpi
    put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
447
    put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
448 723106b2 Alex Beregszaszi
#ifdef TWOMATRIXES
449 b1e6b355 Michael Niedermayer
    put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
450 723106b2 Alex Beregszaszi
#else
451 10b7b472 Fabrice Bellard
    put_bits(&s->pb, 8, 0); /* select matrix */
452 723106b2 Alex Beregszaszi
#endif
453 a69b930c Alex Beregszaszi
    }
454 10b7b472 Fabrice Bellard
455
    /* scan header */
456
    put_marker(&s->pb, SOS);
457
    put_bits(&s->pb, 16, 12); /* length */
458
    put_bits(&s->pb, 8, 3); /* 3 components */
459
    
460
    /* Y component */
461
    put_bits(&s->pb, 8, 1); /* index */
462
    put_bits(&s->pb, 4, 0); /* DC huffman table index */
463
    put_bits(&s->pb, 4, 0); /* AC huffman table index */
464
    
465
    /* Cb component */
466
    put_bits(&s->pb, 8, 2); /* index */
467
    put_bits(&s->pb, 4, 1); /* DC huffman table index */
468 b1e6b355 Michael Niedermayer
    put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
469 10b7b472 Fabrice Bellard
    
470
    /* Cr component */
471
    put_bits(&s->pb, 8, 3); /* index */
472
    put_bits(&s->pb, 4, 1); /* DC huffman table index */
473 b1e6b355 Michael Niedermayer
    put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
474 10b7b472 Fabrice Bellard
475 b1e6b355 Michael Niedermayer
    put_bits(&s->pb, 8, lossless ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
476
    put_bits(&s->pb, 8, lossless ? 0 : 63); /* Se (not used) */
477 723106b2 Alex Beregszaszi
    put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
478 10b7b472 Fabrice Bellard
}
479
480 218baf10 Michael Niedermayer
static void escape_FF(MpegEncContext *s, int start)
481 81ada1ce Michael Niedermayer
{
482 fe455f33 Alex Beregszaszi
    int size= put_bits_count(&s->pb) - start*8;
483 81ada1ce Michael Niedermayer
    int i, ff_count;
484 218baf10 Michael Niedermayer
    uint8_t *buf= s->pb.buf + start;
485 3db320ea Falk H├╝ffner
    int align= (-(size_t)(buf))&3;
486 81ada1ce Michael Niedermayer
    
487
    assert((size&7) == 0);
488
    size >>= 3;
489
    
490
    ff_count=0;
491
    for(i=0; i<size && i<align; i++){
492
        if(buf[i]==0xFF) ff_count++;
493
    }
494
    for(; i<size-15; i+=16){
495
        int acc, v;
496
497
        v= *(uint32_t*)(&buf[i]);
498
        acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
499
        v= *(uint32_t*)(&buf[i+4]);
500
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
501
        v= *(uint32_t*)(&buf[i+8]);
502
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
503
        v= *(uint32_t*)(&buf[i+12]);
504
        acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
505
506
        acc>>=4;
507
        acc+= (acc>>16);
508
        acc+= (acc>>8);
509
        ff_count+= acc&0xFF;
510
    }
511
    for(; i<size; i++){
512
        if(buf[i]==0xFF) ff_count++;
513
    }
514
515
    if(ff_count==0) return;
516
    
517
    /* skip put bits */
518
    for(i=0; i<ff_count-3; i+=4)
519
        put_bits(&s->pb, 32, 0);
520
    put_bits(&s->pb, (ff_count-i)*8, 0);
521
    flush_put_bits(&s->pb); 
522
523
    for(i=size-1; ff_count; i--){
524
        int v= buf[i];
525
526
        if(v==0xFF){
527
//printf("%d %d\n", i, ff_count);
528
            buf[i+ff_count]= 0;
529
            ff_count--;
530
        }
531
532
        buf[i+ff_count]= v;
533
    }
534
}
535
536 9c3d33d6 Michael Niedermayer
void ff_mjpeg_stuffing(PutBitContext * pbc)
537
{
538
    int length;
539
    length= (-put_bits_count(pbc))&7;
540
    if(length) put_bits(pbc, length, (1<<length)-1);
541
}
542
543 10b7b472 Fabrice Bellard
void mjpeg_picture_trailer(MpegEncContext *s)
544
{
545 9c3d33d6 Michael Niedermayer
    ff_mjpeg_stuffing(&s->pb);
546 81ada1ce Michael Niedermayer
    flush_put_bits(&s->pb);
547
548 218baf10 Michael Niedermayer
    assert((s->header_bits&7)==0);
549
    
550
    escape_FF(s, s->header_bits>>3);
551 81ada1ce Michael Niedermayer
552 10b7b472 Fabrice Bellard
    put_marker(&s->pb, EOI);
553
}
554
555 cd4af68a Zdenek Kabelac
static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
556 0c1a9eda Zdenek Kabelac
                                   uint8_t *huff_size, uint16_t *huff_code)
557 10b7b472 Fabrice Bellard
{
558
    int mant, nbits;
559
560
    if (val == 0) {
561 81ada1ce Michael Niedermayer
        put_bits(&s->pb, huff_size[0], huff_code[0]);
562 10b7b472 Fabrice Bellard
    } else {
563
        mant = val;
564
        if (val < 0) {
565
            val = -val;
566
            mant--;
567
        }
568
        
569 2a250222 Michael Niedermayer
        nbits= av_log2_16bit(val) + 1;
570 10b7b472 Fabrice Bellard
            
571 81ada1ce Michael Niedermayer
        put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
572 10b7b472 Fabrice Bellard
        
573 81ada1ce Michael Niedermayer
        put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
574 10b7b472 Fabrice Bellard
    }
575
}
576
577
static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
578
{
579
    int mant, nbits, code, i, j;
580
    int component, dc, run, last_index, val;
581
    MJpegContext *m = s->mjpeg_ctx;
582 0c1a9eda Zdenek Kabelac
    uint8_t *huff_size_ac;
583
    uint16_t *huff_code_ac;
584 10b7b472 Fabrice Bellard
    
585
    /* DC coef */
586
    component = (n <= 3 ? 0 : n - 4 + 1);
587
    dc = block[0]; /* overflow is impossible */
588
    val = dc - s->last_dc[component];
589
    if (n < 4) {
590 cd4af68a Zdenek Kabelac
        mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
591 10b7b472 Fabrice Bellard
        huff_size_ac = m->huff_size_ac_luminance;
592
        huff_code_ac = m->huff_code_ac_luminance;
593
    } else {
594 cd4af68a Zdenek Kabelac
        mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
595 10b7b472 Fabrice Bellard
        huff_size_ac = m->huff_size_ac_chrominance;
596
        huff_code_ac = m->huff_code_ac_chrominance;
597
    }
598
    s->last_dc[component] = dc;
599
    
600
    /* AC coefs */
601
    
602
    run = 0;
603
    last_index = s->block_last_index[n];
604
    for(i=1;i<=last_index;i++) {
605 2ad1516a Michael Niedermayer
        j = s->intra_scantable.permutated[i];
606 10b7b472 Fabrice Bellard
        val = block[j];
607
        if (val == 0) {
608
            run++;
609
        } else {
610
            while (run >= 16) {
611 81ada1ce Michael Niedermayer
                put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
612 10b7b472 Fabrice Bellard
                run -= 16;
613
            }
614
            mant = val;
615
            if (val < 0) {
616
                val = -val;
617
                mant--;
618
            }
619
            
620 9fe690c8 Michael Niedermayer
            nbits= av_log2(val) + 1;
621 10b7b472 Fabrice Bellard
            code = (run << 4) | nbits;
622
623 81ada1ce Michael Niedermayer
            put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
624 10b7b472 Fabrice Bellard
        
625 81ada1ce Michael Niedermayer
            put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
626 10b7b472 Fabrice Bellard
            run = 0;
627
        }
628
    }
629
630
    /* output EOB only if not already 64 values */
631
    if (last_index < 63 || run != 0)
632 81ada1ce Michael Niedermayer
        put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
633 10b7b472 Fabrice Bellard
}
634
635
void mjpeg_encode_mb(MpegEncContext *s, 
636
                     DCTELEM block[6][64])
637
{
638
    int i;
639
    for(i=0;i<6;i++) {
640
        encode_block(s, block[i], i);
641
    }
642
}
643
644 b1e6b355 Michael Niedermayer
static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
645
    MpegEncContext * const s = avctx->priv_data;
646
    MJpegContext * const m = s->mjpeg_ctx;
647
    AVFrame *pict = data;
648
    const int width= s->width;
649
    const int height= s->height;
650
    AVFrame * const p= (AVFrame*)&s->current_picture;
651
    const int predictor= avctx->prediction_method+1;
652
653 ed7debda Alex Beregszaszi
    init_put_bits(&s->pb, buf, buf_size);
654 b1e6b355 Michael Niedermayer
655
    *p = *pict;
656
    p->pict_type= FF_I_TYPE;
657
    p->key_frame= 1;
658
    
659
    mjpeg_picture_header(s);
660
661 fe455f33 Alex Beregszaszi
    s->header_bits= put_bits_count(&s->pb);
662 b1e6b355 Michael Niedermayer
663
    if(avctx->pix_fmt == PIX_FMT_RGBA32){
664
        int x, y, i;
665
        const int linesize= p->linesize[0];
666
        uint16_t buffer[2048][4];
667
        int left[3], top[3], topleft[3];
668
669
        for(i=0; i<3; i++){
670
            buffer[0][i]= 1 << (9 - 1);
671
        }
672
673
        for(y = 0; y < height; y++) {
674 68a48891 Michael Niedermayer
            const int modified_predictor= y ? predictor : 1;
675 b1e6b355 Michael Niedermayer
            uint8_t *ptr = p->data[0] + (linesize * y);
676
677
            for(i=0; i<3; i++){
678
                top[i]= left[i]= topleft[i]= buffer[0][i];
679
            }
680
            for(x = 0; x < width; x++) {
681
                buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
682
                buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
683
                buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
684
685
                for(i=0;i<3;i++) {
686
                    int pred, diff;
687
688
                    PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
689
                        
690
                    topleft[i]= top[i];
691
                    top[i]= buffer[x+1][i];
692
                    
693
                    left[i]= buffer[x][i];
694
695
                    diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
696
                    
697
                    if(i==0)
698
                        mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
699
                    else
700
                        mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
701
                }
702
            }
703
        }
704
    }else{
705
        int mb_x, mb_y, i;
706
        const int mb_width  = (width  + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
707
        const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
708
        
709
        for(mb_y = 0; mb_y < mb_height; mb_y++) {
710
            for(mb_x = 0; mb_x < mb_width; mb_x++) {
711
                if(mb_x==0 || mb_y==0){
712
                    for(i=0;i<3;i++) {
713
                        uint8_t *ptr;
714
                        int x, y, h, v, linesize;
715
                        h = s->mjpeg_hsample[i];
716
                        v = s->mjpeg_vsample[i];
717
                        linesize= p->linesize[i];
718
719
                        for(y=0; y<v; y++){
720
                            for(x=0; x<h; x++){
721
                                int pred;
722
723
                                ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
724
                                if(y==0 && mb_y==0){
725
                                    if(x==0 && mb_x==0){
726
                                        pred= 128;
727
                                    }else{
728
                                        pred= ptr[-1];
729
                                    }
730
                                }else{
731
                                    if(x==0 && mb_x==0){
732
                                        pred= ptr[-linesize];
733
                                    }else{
734
                                        PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
735
                                    }
736
                                }
737
                                
738
                                if(i==0)
739
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
740
                                else
741
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
742
                            }
743
                        }
744
                    }
745
                }else{
746
                    for(i=0;i<3;i++) {
747
                        uint8_t *ptr;
748
                        int x, y, h, v, linesize;
749
                        h = s->mjpeg_hsample[i];
750
                        v = s->mjpeg_vsample[i];
751
                        linesize= p->linesize[i];
752
                             
753
                        for(y=0; y<v; y++){
754
                            for(x=0; x<h; x++){
755
                                int pred;
756
757
                                ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
758
//printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr); 
759
                                PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
760
761
                                if(i==0)
762
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
763
                                else
764
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
765
                            }
766
                        }
767
                    }
768
                }
769
            }
770
        }
771
    }
772
773
    emms_c();
774
    
775
    mjpeg_picture_trailer(s);
776
    s->picture_number++;
777
778
    flush_put_bits(&s->pb);
779
    return pbBufPtr(&s->pb) - s->pb.buf;
780 fe455f33 Alex Beregszaszi
//    return (put_bits_count(&f->pb)+7)/8;
781 b1e6b355 Michael Niedermayer
}
782
783 2a250222 Michael Niedermayer
#endif //CONFIG_ENCODERS
784 b1e6b355 Michael Niedermayer
785 10b7b472 Fabrice Bellard
/******************************************/
786
/* decoding */
787
788
#define MAX_COMPONENTS 4
789
790
typedef struct MJpegDecodeContext {
791 723106b2 Alex Beregszaszi
    AVCodecContext *avctx;
792 10b7b472 Fabrice Bellard
    GetBitContext gb;
793 109362cb Alex Beregszaszi
    int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
794
795 10b7b472 Fabrice Bellard
    int start_code; /* current start code */
796
    int buffer_size;
797 0c1a9eda Zdenek Kabelac
    uint8_t *buffer;
798 109362cb Alex Beregszaszi
799 0c1a9eda Zdenek Kabelac
    int16_t quant_matrixes[4][64];
800 10b7b472 Fabrice Bellard
    VLC vlcs[2][4];
801 ec0eeaa2 Michael Niedermayer
    int qscale[4];      ///< quantizer scale calculated from quant_matrixes
802 991ae7b6 Fabrice Bellard
803 5814beaa Michael Niedermayer
    int org_height;  /* size given at codec init */
804 991ae7b6 Fabrice Bellard
    int first_picture;    /* true if decoding first picture */
805
    int interlaced;     /* true if interlaced */
806
    int bottom_field;   /* true if bottom field */
807 e4d2b1f3 Michael Niedermayer
    int lossless;
808
    int rgb;
809 b1e6b355 Michael Niedermayer
    int rct;            /* standard rct */  
810
    int pegasus_rct;    /* pegasus reversible colorspace transform */  
811 63efe9a7 Michael Niedermayer
    int bits;           /* bits per component */
812 991ae7b6 Fabrice Bellard
813 10b7b472 Fabrice Bellard
    int width, height;
814 7e9e2b55 Michael Niedermayer
    int mb_width, mb_height;
815 e2388404 Fabrice Bellard
    int nb_components;
816
    int component_id[MAX_COMPONENTS];
817 10b7b472 Fabrice Bellard
    int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
818
    int v_count[MAX_COMPONENTS];
819 7e9e2b55 Michael Niedermayer
    int comp_index[MAX_COMPONENTS];
820
    int dc_index[MAX_COMPONENTS];
821
    int ac_index[MAX_COMPONENTS];
822
    int nb_blocks[MAX_COMPONENTS];
823
    int h_scount[MAX_COMPONENTS];
824
    int v_scount[MAX_COMPONENTS];
825 10b7b472 Fabrice Bellard
    int h_max, v_max; /* maximum h and v counts */
826
    int quant_index[4];   /* quant table index for each component */
827
    int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
828 688cbabe Michael Niedermayer
    AVFrame picture; /* picture structure */
829
    int linesize[MAX_COMPONENTS];                   ///< linesize << interlaced
830 ec0eeaa2 Michael Niedermayer
    uint8_t *qscale_table;
831 10b7b472 Fabrice Bellard
    DCTELEM block[64] __align8;
832 145956de Alex Beregszaszi
    ScanTable scantable;
833 0c1a9eda Zdenek Kabelac
    void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
834 af289048 Alex Beregszaszi
835 723106b2 Alex Beregszaszi
    int restart_interval;
836
    int restart_count;
837 145956de Alex Beregszaszi
838
    int buggy_avid;
839 f3a34447 Alex Beregszaszi
    int interlace_polarity;
840 10b7b472 Fabrice Bellard
} MJpegDecodeContext;
841
842 109362cb Alex Beregszaszi
static int mjpeg_decode_dht(MJpegDecodeContext *s);
843 564ef23d Juanjo
844 0273ceeb Michael Niedermayer
static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table, 
845 bbc0d0c1 Fabrice Bellard
                      int nb_codes)
846
{
847 0c1a9eda Zdenek Kabelac
    uint8_t huff_size[256];
848
    uint16_t huff_code[256];
849 bbc0d0c1 Fabrice Bellard
850
    memset(huff_size, 0, sizeof(huff_size));
851
    build_huffman_codes(huff_size, huff_code, bits_table, val_table);
852
    
853 0273ceeb Michael Niedermayer
    return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
854 bbc0d0c1 Fabrice Bellard
}
855
856 10b7b472 Fabrice Bellard
static int mjpeg_decode_init(AVCodecContext *avctx)
857
{
858
    MJpegDecodeContext *s = avctx->priv_data;
859 2ad1516a Michael Niedermayer
    MpegEncContext s2;
860 10b7b472 Fabrice Bellard
861 723106b2 Alex Beregszaszi
    s->avctx = avctx;
862
863 b0368839 Michael Niedermayer
    /* ugly way to get the idct & scantable FIXME */
864 2ad1516a Michael Niedermayer
    memset(&s2, 0, sizeof(MpegEncContext));
865
    s2.avctx= avctx;
866
//    s2->out_format = FMT_MJPEG;
867 3edcacde Michael Niedermayer
    dsputil_init(&s2.dsp, avctx);
868
    DCT_common_init(&s2);
869
870 2ad1516a Michael Niedermayer
    s->scantable= s2.intra_scantable;
871 b0368839 Michael Niedermayer
    s->idct_put= s2.dsp.idct_put;
872 2ad1516a Michael Niedermayer
873 10b7b472 Fabrice Bellard
    s->mpeg_enc_ctx_allocated = 0;
874 f3a34447 Alex Beregszaszi
    s->buffer_size = 102400; /* smaller buffer should be enough,
875
                                but photojpg files could ahive bigger sizes */
876 109362cb Alex Beregszaszi
    s->buffer = av_malloc(s->buffer_size);
877 a46a7052 Alex Beregszaszi
    if (!s->buffer)
878
        return -1;
879 10b7b472 Fabrice Bellard
    s->start_code = -1;
880 991ae7b6 Fabrice Bellard
    s->first_picture = 1;
881
    s->org_height = avctx->height;
882 2ad1516a Michael Niedermayer
    
883 bbc0d0c1 Fabrice Bellard
    build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
884
    build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
885
    build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
886
    build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
887 109362cb Alex Beregszaszi
888 e84c31dc Arpi
    if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
889
    {
890 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
891 68f593b4 Michael Niedermayer
        init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
892 109362cb Alex Beregszaszi
        mjpeg_decode_dht(s);
893 e84c31dc Arpi
        /* should check for error - but dunno */
894
    }
895 109362cb Alex Beregszaszi
896 10b7b472 Fabrice Bellard
    return 0;
897
}
898
899
/* quantize tables */
900 109362cb Alex Beregszaszi
static int mjpeg_decode_dqt(MJpegDecodeContext *s)
901 10b7b472 Fabrice Bellard
{
902 47476fa9 Fabrice Bellard
    int len, index, i, j;
903 723106b2 Alex Beregszaszi
    
904
    len = get_bits(&s->gb, 16) - 2;
905 10b7b472 Fabrice Bellard
906
    while (len >= 65) {
907
        /* only 8 bit precision handled */
908
        if (get_bits(&s->gb, 4) != 0)
909 e84c31dc Arpi
        {
910
            dprintf("dqt: 16bit precision\n");
911 10b7b472 Fabrice Bellard
            return -1;
912 e84c31dc Arpi
        }
913 10b7b472 Fabrice Bellard
        index = get_bits(&s->gb, 4);
914
        if (index >= 4)
915
            return -1;
916
        dprintf("index=%d\n", index);
917
        /* read quant table */
918 47476fa9 Fabrice Bellard
        for(i=0;i<64;i++) {
919 2ad1516a Michael Niedermayer
            j = s->scantable.permutated[i];
920 723106b2 Alex Beregszaszi
            s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
921 47476fa9 Fabrice Bellard
        }
922 ec0eeaa2 Michael Niedermayer
923
        //XXX FIXME finetune, and perhaps add dc too
924
        s->qscale[index]= FFMAX(
925
            s->quant_matrixes[index][s->scantable.permutated[1]],
926
            s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
927 5e83dec4 Alex Beregszaszi
        dprintf("qscale[%d]: %d\n", index, s->qscale[index]);
928 10b7b472 Fabrice Bellard
        len -= 65;
929
    }
930 723106b2 Alex Beregszaszi
    
931 10b7b472 Fabrice Bellard
    return 0;
932
}
933
934
/* decode huffman tables and build VLC decoders */
935 109362cb Alex Beregszaszi
static int mjpeg_decode_dht(MJpegDecodeContext *s)
936 10b7b472 Fabrice Bellard
{
937
    int len, index, i, class, n, v, code_max;
938 0c1a9eda Zdenek Kabelac
    uint8_t bits_table[17];
939
    uint8_t val_table[256];
940 10b7b472 Fabrice Bellard
    
941 109362cb Alex Beregszaszi
    len = get_bits(&s->gb, 16) - 2;
942 10b7b472 Fabrice Bellard
943
    while (len > 0) {
944
        if (len < 17)
945
            return -1;
946
        class = get_bits(&s->gb, 4);
947
        if (class >= 2)
948
            return -1;
949
        index = get_bits(&s->gb, 4);
950
        if (index >= 4)
951
            return -1;
952
        n = 0;
953
        for(i=1;i<=16;i++) {
954
            bits_table[i] = get_bits(&s->gb, 8);
955
            n += bits_table[i];
956
        }
957
        len -= 17;
958
        if (len < n || n > 256)
959
            return -1;
960
961
        code_max = 0;
962
        for(i=0;i<n;i++) {
963
            v = get_bits(&s->gb, 8);
964
            if (v > code_max)
965
                code_max = v;
966
            val_table[i] = v;
967
        }
968
        len -= n;
969
970
        /* build VLC and flush previous vlc if present */
971
        free_vlc(&s->vlcs[class][index]);
972
        dprintf("class=%d index=%d nb_codes=%d\n",
973
               class, index, code_max + 1);
974 0273ceeb Michael Niedermayer
        if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1) < 0){
975
            return -1;
976
        }
977 10b7b472 Fabrice Bellard
    }
978
    return 0;
979
}
980
981 e4d2b1f3 Michael Niedermayer
static int mjpeg_decode_sof(MJpegDecodeContext *s)
982 10b7b472 Fabrice Bellard
{
983 e2388404 Fabrice Bellard
    int len, nb_components, i, width, height;
984 10b7b472 Fabrice Bellard
985
    /* XXX: verify len field validity */
986
    len = get_bits(&s->gb, 16);
987 63efe9a7 Michael Niedermayer
    s->bits= get_bits(&s->gb, 8);
988 b1e6b355 Michael Niedermayer
    
989
    if(s->pegasus_rct) s->bits=9;  
990
    if(s->bits==9 && !s->pegasus_rct) s->rct=1;    //FIXME ugly
991 63efe9a7 Michael Niedermayer
992
    if (s->bits != 8 && !s->lossless){
993 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
994 10b7b472 Fabrice Bellard
        return -1;
995 e4d2b1f3 Michael Niedermayer
    }
996 10b7b472 Fabrice Bellard
    height = get_bits(&s->gb, 16);
997
    width = get_bits(&s->gb, 16);
998 723106b2 Alex Beregszaszi
    dprintf("sof0: picture: %dx%d\n", width, height);
999 10b7b472 Fabrice Bellard
1000
    nb_components = get_bits(&s->gb, 8);
1001
    if (nb_components <= 0 ||
1002
        nb_components > MAX_COMPONENTS)
1003
        return -1;
1004 e2388404 Fabrice Bellard
    s->nb_components = nb_components;
1005 10b7b472 Fabrice Bellard
    s->h_max = 1;
1006
    s->v_max = 1;
1007
    for(i=0;i<nb_components;i++) {
1008
        /* component id */
1009 e2388404 Fabrice Bellard
        s->component_id[i] = get_bits(&s->gb, 8) - 1;
1010 10b7b472 Fabrice Bellard
        s->h_count[i] = get_bits(&s->gb, 4);
1011
        s->v_count[i] = get_bits(&s->gb, 4);
1012
        /* compute hmax and vmax (only used in interleaved case) */
1013
        if (s->h_count[i] > s->h_max)
1014
            s->h_max = s->h_count[i];
1015
        if (s->v_count[i] > s->v_max)
1016
            s->v_max = s->v_count[i];
1017
        s->quant_index[i] = get_bits(&s->gb, 8);
1018
        if (s->quant_index[i] >= 4)
1019
            return -1;
1020 723106b2 Alex Beregszaszi
        dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1021
            s->v_count[i], s->component_id[i], s->quant_index[i]);
1022 10b7b472 Fabrice Bellard
    }
1023 63efe9a7 Michael Niedermayer
    
1024
    if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1025 10b7b472 Fabrice Bellard
1026
    /* if different size, realloc/alloc picture */
1027
    /* XXX: also check h_count and v_count */
1028
    if (width != s->width || height != s->height) {
1029 ec0eeaa2 Michael Niedermayer
        av_freep(&s->qscale_table);
1030
            
1031 10b7b472 Fabrice Bellard
        s->width = width;
1032
        s->height = height;
1033 5814beaa Michael Niedermayer
        s->avctx->width = s->width;
1034
        s->avctx->height = s->height;
1035
1036 991ae7b6 Fabrice Bellard
        /* test interlaced mode */
1037
        if (s->first_picture &&
1038
            s->org_height != 0 &&
1039
            s->height < ((s->org_height * 3) / 4)) {
1040
            s->interlaced = 1;
1041 f3a34447 Alex Beregszaszi
//            s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1042 5814beaa Michael Niedermayer
            s->bottom_field = 0;
1043
            s->avctx->height *= 2;
1044 991ae7b6 Fabrice Bellard
        }
1045
1046 ec0eeaa2 Michael Niedermayer
        s->qscale_table= av_mallocz((s->width+15)/16);
1047
1048 991ae7b6 Fabrice Bellard
        s->first_picture = 0;
1049 10b7b472 Fabrice Bellard
    }
1050 688cbabe Michael Niedermayer
    
1051
    if(s->interlaced && s->bottom_field)
1052
        return 0;
1053
 
1054
    /* XXX: not complete test ! */
1055
    switch((s->h_count[0] << 4) | s->v_count[0]) {
1056
    case 0x11:
1057
        if(s->rgb){
1058
            s->avctx->pix_fmt = PIX_FMT_RGBA32;
1059 909678c7 Michael Niedermayer
        }else if(s->nb_components==3)
1060 688cbabe Michael Niedermayer
            s->avctx->pix_fmt = PIX_FMT_YUV444P;
1061 909678c7 Michael Niedermayer
        else
1062
            s->avctx->pix_fmt = PIX_FMT_GRAY8;
1063 688cbabe Michael Niedermayer
        break;
1064
    case 0x21:
1065
        s->avctx->pix_fmt = PIX_FMT_YUV422P;
1066
        break;
1067
    default:
1068
    case 0x22:
1069
        s->avctx->pix_fmt = PIX_FMT_YUV420P;
1070
        break;
1071
    }
1072
1073
    if(s->picture.data[0])
1074
        s->avctx->release_buffer(s->avctx, &s->picture);
1075
1076
    s->picture.reference= 0;
1077
    if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1078 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1079 688cbabe Michael Niedermayer
        return -1;
1080
    }
1081
    s->picture.pict_type= I_TYPE;
1082
    s->picture.key_frame= 1;
1083
    
1084
    for(i=0; i<3; i++){
1085
        s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1086
    }
1087 e84c31dc Arpi
1088 688cbabe Michael Niedermayer
//    printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1089
    
1090 af289048 Alex Beregszaszi
    if (len != (8+(3*nb_components)))
1091
    {
1092 e84c31dc Arpi
        dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1093 af289048 Alex Beregszaszi
    }
1094 991ae7b6 Fabrice Bellard
    
1095 10b7b472 Fabrice Bellard
    return 0;
1096
}
1097
1098 cd4af68a Zdenek Kabelac
static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1099 10b7b472 Fabrice Bellard
{
1100 9fe690c8 Michael Niedermayer
    int code;
1101 1c0a593a Michael Niedermayer
    code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1102 10b7b472 Fabrice Bellard
    if (code < 0)
1103 e84c31dc Arpi
    {
1104 cd4af68a Zdenek Kabelac
        dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1105 3093185e Fabrice Bellard
                &s->vlcs[0][dc_index]);
1106 10b7b472 Fabrice Bellard
        return 0xffff;
1107 e84c31dc Arpi
    }
1108 9fe690c8 Michael Niedermayer
1109
    if(code)
1110
        return get_xbits(&s->gb, code);
1111
    else
1112
        return 0;
1113 10b7b472 Fabrice Bellard
}
1114
1115
/* decode block and dequantize */
1116
static int decode_block(MJpegDecodeContext *s, DCTELEM *block, 
1117
                        int component, int dc_index, int ac_index, int quant_index)
1118
{
1119 9fe690c8 Michael Niedermayer
    int code, i, j, level, val;
1120 10b7b472 Fabrice Bellard
    VLC *ac_vlc;
1121 0c1a9eda Zdenek Kabelac
    int16_t *quant_matrix;
1122 10b7b472 Fabrice Bellard
1123
    /* DC coef */
1124 cd4af68a Zdenek Kabelac
    val = mjpeg_decode_dc(s, dc_index);
1125 10b7b472 Fabrice Bellard
    if (val == 0xffff) {
1126
        dprintf("error dc\n");
1127
        return -1;
1128
    }
1129 e84c31dc Arpi
    quant_matrix = s->quant_matrixes[quant_index];
1130 10b7b472 Fabrice Bellard
    val = val * quant_matrix[0] + s->last_dc[component];
1131
    s->last_dc[component] = val;
1132
    block[0] = val;
1133
    /* AC coefs */
1134
    ac_vlc = &s->vlcs[1][ac_index];
1135
    i = 1;
1136
    for(;;) {
1137 1c0a593a Michael Niedermayer
        code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
1138 6d50b2e6 Michael Niedermayer
1139 10b7b472 Fabrice Bellard
        if (code < 0) {
1140
            dprintf("error ac\n");
1141
            return -1;
1142
        }
1143
        /* EOB */
1144
        if (code == 0)
1145
            break;
1146
        if (code == 0xf0) {
1147
            i += 16;
1148
        } else {
1149 9fe690c8 Michael Niedermayer
            level = get_xbits(&s->gb, code & 0xf);
1150
            i += code >> 4;
1151 10b7b472 Fabrice Bellard
            if (i >= 64) {
1152
                dprintf("error count: %d\n", i);
1153
                return -1;
1154
            }
1155 2ad1516a Michael Niedermayer
            j = s->scantable.permutated[i];
1156 10b7b472 Fabrice Bellard
            block[j] = level * quant_matrix[j];
1157
            i++;
1158 b182e68a Fabrice Bellard
            if (i >= 64)
1159
                break;
1160 10b7b472 Fabrice Bellard
        }
1161
    }
1162
    return 0;
1163
}
1164
1165 7e9e2b55 Michael Niedermayer
static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1166
    int i, mb_x, mb_y;
1167
    uint16_t buffer[2048][4];
1168
    int left[3], top[3], topleft[3];
1169
    const int linesize= s->linesize[0];
1170
    const int mask= (1<<s->bits)-1;
1171
    
1172
    for(i=0; i<3; i++){
1173
        buffer[0][i]= 1 << (s->bits + point_transform - 1);
1174
    }
1175
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1176 68a48891 Michael Niedermayer
        const int modified_predictor= mb_y ? predictor : 1;
1177 688cbabe Michael Niedermayer
        uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1178 7e9e2b55 Michael Niedermayer
1179
        if (s->interlaced && s->bottom_field)
1180
            ptr += linesize >> 1;
1181
1182
        for(i=0; i<3; i++){
1183
            top[i]= left[i]= topleft[i]= buffer[0][i];
1184
        }
1185
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1186
            if (s->restart_interval && !s->restart_count)
1187
                s->restart_count = s->restart_interval;
1188
1189
            for(i=0;i<3;i++) {
1190
                int pred;
1191
1192
                topleft[i]= top[i];
1193
                top[i]= buffer[mb_x][i];
1194
1195
                PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1196
                
1197
                left[i]= 
1198
                buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1199
            }
1200
1201
            if (s->restart_interval && !--s->restart_count) {
1202
                align_get_bits(&s->gb);
1203
                skip_bits(&s->gb, 16); /* skip RSTn */
1204
            }
1205
        }
1206
1207
        if(s->rct){
1208
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1209
                ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1210
                ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1211
                ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1212
            }
1213
        }else if(s->pegasus_rct){
1214
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1215
                ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1216
                ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1217
                ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1218
            }
1219
        }else{
1220
            for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1221
                ptr[4*mb_x+0] = buffer[mb_x][0];
1222
                ptr[4*mb_x+1] = buffer[mb_x][1];
1223
                ptr[4*mb_x+2] = buffer[mb_x][2];
1224
            }
1225
        }
1226
    }
1227
    return 0;
1228
}
1229
1230
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1231
    int i, mb_x, mb_y;
1232
    const int nb_components=3;
1233
1234
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1235
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1236
            if (s->restart_interval && !s->restart_count)
1237
                s->restart_count = s->restart_interval;
1238
1239
            if(mb_x==0 || mb_y==0 || s->interlaced){
1240
                for(i=0;i<nb_components;i++) {
1241
                    uint8_t *ptr;
1242
                    int n, h, v, x, y, c, j, linesize;
1243
                    n = s->nb_blocks[i];
1244
                    c = s->comp_index[i];
1245
                    h = s->h_scount[i];
1246
                    v = s->v_scount[i];
1247
                    x = 0;
1248
                    y = 0;
1249
                    linesize= s->linesize[c];
1250
                    
1251
                    for(j=0; j<n; j++) {
1252
                        int pred;
1253
1254 688cbabe Michael Niedermayer
                        ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1255 7e9e2b55 Michael Niedermayer
                        if(y==0 && mb_y==0){
1256
                            if(x==0 && mb_x==0){
1257
                                pred= 128 << point_transform;
1258
                            }else{
1259
                                pred= ptr[-1];
1260
                            }
1261
                        }else{
1262
                            if(x==0 && mb_x==0){
1263
                                pred= ptr[-linesize];
1264
                            }else{
1265
                                PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1266
                            }
1267
                        }
1268
                        
1269
                        if (s->interlaced && s->bottom_field)
1270
                            ptr += linesize >> 1;
1271
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1272
1273
                        if (++x == h) {
1274
                            x = 0;
1275
                            y++;
1276
                        }
1277
                    }
1278
                }
1279
            }else{
1280
                for(i=0;i<nb_components;i++) {
1281
                    uint8_t *ptr;
1282
                    int n, h, v, x, y, c, j, linesize;
1283
                    n = s->nb_blocks[i];
1284
                    c = s->comp_index[i];
1285
                    h = s->h_scount[i];
1286
                    v = s->v_scount[i];
1287
                    x = 0;
1288
                    y = 0;
1289
                    linesize= s->linesize[c];
1290
                    
1291
                    for(j=0; j<n; j++) {
1292
                        int pred;
1293
1294 688cbabe Michael Niedermayer
                        ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1295 7e9e2b55 Michael Niedermayer
                        PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1296
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1297
                        if (++x == h) {
1298
                            x = 0;
1299
                            y++;
1300
                        }
1301
                    }
1302
                }
1303
            }
1304
            if (s->restart_interval && !--s->restart_count) {
1305
                align_get_bits(&s->gb);
1306
                skip_bits(&s->gb, 16); /* skip RSTn */
1307
            }
1308
        }
1309
    }
1310
    return 0;
1311
}
1312
1313
static int mjpeg_decode_scan(MJpegDecodeContext *s){
1314
    int i, mb_x, mb_y;
1315
    const int nb_components=3;
1316
1317
    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1318
        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1319
            if (s->restart_interval && !s->restart_count)
1320
                s->restart_count = s->restart_interval;
1321
1322
            for(i=0;i<nb_components;i++) {
1323
                uint8_t *ptr;
1324
                int n, h, v, x, y, c, j;
1325
                n = s->nb_blocks[i];
1326
                c = s->comp_index[i];
1327
                h = s->h_scount[i];
1328
                v = s->v_scount[i];
1329
                x = 0;
1330
                y = 0;
1331
                for(j=0;j<n;j++) {
1332
                    memset(s->block, 0, sizeof(s->block));
1333
                    if (decode_block(s, s->block, i, 
1334
                                     s->dc_index[i], s->ac_index[i], 
1335
                                     s->quant_index[c]) < 0) {
1336
                        dprintf("error y=%d x=%d\n", mb_y, mb_x);
1337
                        return -1;
1338
                    }
1339
//                    dprintf("mb: %d %d processed\n", mb_y, mb_x);
1340 688cbabe Michael Niedermayer
                    ptr = s->picture.data[c] + 
1341 6aeb03d8 Michael Niedermayer
                        (((s->linesize[c] * (v * mb_y + y) * 8) + 
1342
                        (h * mb_x + x) * 8) >> s->avctx->lowres);
1343 7e9e2b55 Michael Niedermayer
                    if (s->interlaced && s->bottom_field)
1344
                        ptr += s->linesize[c] >> 1;
1345 eea8c08f Michael Niedermayer
//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);
1346 7e9e2b55 Michael Niedermayer
                    s->idct_put(ptr, s->linesize[c], s->block);
1347
                    if (++x == h) {
1348
                        x = 0;
1349
                        y++;
1350
                    }
1351
                }
1352
            }
1353
            /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1354
            if (s->restart_interval && (s->restart_interval < 1350) &&
1355
                !--s->restart_count) {
1356
                align_get_bits(&s->gb);
1357
                skip_bits(&s->gb, 16); /* skip RSTn */
1358
                for (i=0; i<nb_components; i++) /* reset dc */
1359
                    s->last_dc[i] = 1024;
1360
            }
1361
        }
1362
    }
1363
    return 0;
1364
}
1365
1366 109362cb Alex Beregszaszi
static int mjpeg_decode_sos(MJpegDecodeContext *s)
1367 10b7b472 Fabrice Bellard
{
1368 b1609412 Fabrice Bellard
    int len, nb_components, i, h, v, predictor, point_transform;
1369 7e9e2b55 Michael Niedermayer
    int vmax, hmax, index, id;
1370 e4d2b1f3 Michael Niedermayer
    const int block_size= s->lossless ? 1 : 8;
1371
1372 10b7b472 Fabrice Bellard
    /* XXX: verify len field validity */
1373
    len = get_bits(&s->gb, 16);
1374
    nb_components = get_bits(&s->gb, 8);
1375 109362cb Alex Beregszaszi
    if (len != 6+2*nb_components)
1376
    {
1377
        dprintf("decode_sos: invalid len (%d)\n", len);
1378
        return -1;
1379
    }
1380 10b7b472 Fabrice Bellard
    /* XXX: only interleaved scan accepted */
1381 909678c7 Michael Niedermayer
    if (nb_components != s->nb_components)
1382 e84c31dc Arpi
    {
1383
        dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1384 10b7b472 Fabrice Bellard
        return -1;
1385 e84c31dc Arpi
    }
1386 10b7b472 Fabrice Bellard
    vmax = 0;
1387
    hmax = 0;
1388
    for(i=0;i<nb_components;i++) {
1389 e2388404 Fabrice Bellard
        id = get_bits(&s->gb, 8) - 1;
1390 723106b2 Alex Beregszaszi
        dprintf("component: %d\n", id);
1391 e2388404 Fabrice Bellard
        /* find component index */
1392
        for(index=0;index<s->nb_components;index++)
1393
            if (id == s->component_id[index])
1394
                break;
1395
        if (index == s->nb_components)
1396 e84c31dc Arpi
        {
1397 723106b2 Alex Beregszaszi
            dprintf("decode_sos: index(%d) out of components\n", index);
1398 10b7b472 Fabrice Bellard
            return -1;
1399 e84c31dc Arpi
        }
1400 e2388404 Fabrice Bellard
1401 7e9e2b55 Michael Niedermayer
        s->comp_index[i] = index;
1402 63efe9a7 Michael Niedermayer
1403 7e9e2b55 Michael Niedermayer
        s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1404
        s->h_scount[i] = s->h_count[index];
1405
        s->v_scount[i] = s->v_count[index];
1406 b182e68a Fabrice Bellard
1407 7e9e2b55 Michael Niedermayer
        s->dc_index[i] = get_bits(&s->gb, 4);
1408
        s->ac_index[i] = get_bits(&s->gb, 4);
1409 e84c31dc Arpi
1410 7e9e2b55 Michael Niedermayer
        if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1411
            s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1412 e84c31dc Arpi
            goto out_of_range;
1413 7e9e2b55 Michael Niedermayer
#if 0 //buggy
1414 e84c31dc Arpi
        switch(s->start_code)
1415
        {
1416
            case SOF0:
1417
                if (dc_index[i] > 1 || ac_index[i] > 1)
1418
                    goto out_of_range;
1419
                break;
1420
            case SOF1:
1421
            case SOF2:
1422
                if (dc_index[i] > 3 || ac_index[i] > 3)
1423
                    goto out_of_range;
1424
                break;
1425
            case SOF3:
1426
                if (dc_index[i] > 3 || ac_index[i] != 0)
1427
                    goto out_of_range;
1428
                break;        
1429
        }
1430 7e9e2b55 Michael Niedermayer
#endif
1431 10b7b472 Fabrice Bellard
    }
1432 63efe9a7 Michael Niedermayer
1433 e4d2b1f3 Michael Niedermayer
    predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */
1434 723106b2 Alex Beregszaszi
    skip_bits(&s->gb, 8); /* Se */
1435 e4d2b1f3 Michael Niedermayer
    skip_bits(&s->gb, 4); /* Ah */
1436
    point_transform= get_bits(&s->gb, 4); /* Al */
1437 10b7b472 Fabrice Bellard
1438
    for(i=0;i<nb_components;i++) 
1439
        s->last_dc[i] = 1024;
1440
1441
    if (nb_components > 1) {
1442
        /* interleaved stream */
1443 7e9e2b55 Michael Niedermayer
        s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1444
        s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1445 10b7b472 Fabrice Bellard
    } else {
1446 7e9e2b55 Michael Niedermayer
        h = s->h_max / s->h_scount[s->comp_index[0]];
1447
        v = s->v_max / s->v_scount[s->comp_index[0]];
1448
        s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1449
        s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1450
        s->nb_blocks[0] = 1;
1451
        s->h_scount[0] = 1;
1452
        s->v_scount[0] = 1;
1453 10b7b472 Fabrice Bellard
    }
1454 e4d2b1f3 Michael Niedermayer
1455 63efe9a7 Michael Niedermayer
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1456 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform);
1457 63efe9a7 Michael Niedermayer
    
1458 e4d2b1f3 Michael Niedermayer
    if(s->lossless){
1459 7e9e2b55 Michael Niedermayer
            if(s->rgb){
1460
                if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1461
                    return -1;
1462
            }else{
1463
                if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1464
                    return -1;
1465 e4d2b1f3 Michael Niedermayer
            }
1466
    }else{
1467 7e9e2b55 Michael Niedermayer
        if(mjpeg_decode_scan(s) < 0)
1468
            return -1;
1469 10b7b472 Fabrice Bellard
    }
1470 186f8ae1 Fabrice Bellard
    emms_c();
1471 7e9e2b55 Michael Niedermayer
    return 0;
1472 e84c31dc Arpi
 out_of_range:
1473
    dprintf("decode_sos: ac/dc index out of range\n");
1474
    return -1;
1475 10b7b472 Fabrice Bellard
}
1476
1477 109362cb Alex Beregszaszi
static int mjpeg_decode_dri(MJpegDecodeContext *s)
1478 723106b2 Alex Beregszaszi
{
1479
    if (get_bits(&s->gb, 16) != 4)
1480
        return -1;
1481
    s->restart_interval = get_bits(&s->gb, 16);
1482 d8592280 Zdenek Kabelac
    dprintf("restart interval: %d\n", s->restart_interval);
1483 723106b2 Alex Beregszaszi
1484
    return 0;
1485
}
1486
1487 f3a34447 Alex Beregszaszi
static int mjpeg_decode_app(MJpegDecodeContext *s)
1488 af289048 Alex Beregszaszi
{
1489
    int len, id;
1490
1491
    /* XXX: verify len field validity */
1492 723106b2 Alex Beregszaszi
    len = get_bits(&s->gb, 16);
1493 af289048 Alex Beregszaszi
    if (len < 5)
1494
        return -1;
1495 723106b2 Alex Beregszaszi
1496 f9745d55 Alex Beregszaszi
    id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1497
    id = be2me_32(id);
1498 723106b2 Alex Beregszaszi
    len -= 6;
1499
1500 63efe9a7 Michael Niedermayer
    if(s->avctx->debug & FF_DEBUG_STARTCODE){
1501 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id); 
1502 63efe9a7 Michael Niedermayer
    }
1503
    
1504 723106b2 Alex Beregszaszi
    /* buggy AVID, it puts EOI only at every 10th frame */
1505 145956de Alex Beregszaszi
    /* also this fourcc is used by non-avid files too, it holds some
1506
       informations, but it's always present in AVID creates files */
1507 f3a34447 Alex Beregszaszi
    if (id == ff_get_fourcc("AVI1"))
1508 af289048 Alex Beregszaszi
    {
1509 723106b2 Alex Beregszaszi
        /* structure:
1510
            4bytes        AVI1
1511
            1bytes        polarity
1512
            1bytes        always zero
1513
            4bytes        field_size
1514
            4bytes        field_size_less_padding
1515
        */
1516
            s->buggy_avid = 1;
1517 f3a34447 Alex Beregszaszi
//        if (s->first_picture)
1518
//            printf("mjpeg: workarounding buggy AVID\n");
1519
        s->interlace_polarity = get_bits(&s->gb, 8);
1520 723106b2 Alex Beregszaszi
#if 0
1521
        skip_bits(&s->gb, 8);
1522
        skip_bits(&s->gb, 32);
1523
        skip_bits(&s->gb, 32);
1524
        len -= 10;
1525
#endif
1526 f3a34447 Alex Beregszaszi
//        if (s->interlace_polarity)
1527
//            printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1528 723106b2 Alex Beregszaszi
        goto out;
1529 af289048 Alex Beregszaszi
    }
1530
    
1531 145956de Alex Beregszaszi
//    len -= 2;
1532 723106b2 Alex Beregszaszi
    
1533 f3a34447 Alex Beregszaszi
    if (id == ff_get_fourcc("JFIF"))
1534 723106b2 Alex Beregszaszi
    {
1535 96d8b5a6 Michael Niedermayer
        int t_w, t_h, v1, v2;
1536 723106b2 Alex Beregszaszi
        skip_bits(&s->gb, 8); /* the trailing zero-byte */
1537 96d8b5a6 Michael Niedermayer
        v1= get_bits(&s->gb, 8);
1538
        v2= get_bits(&s->gb, 8);
1539 5ff85f1d Michael Niedermayer
        skip_bits(&s->gb, 8);
1540 1e491e29 Michael Niedermayer
1541 5ff85f1d Michael Niedermayer
        s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1542
        s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1543 a46a7052 Alex Beregszaszi
1544 96d8b5a6 Michael Niedermayer
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1545
            av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1546
                v1, v2,
1547
                s->avctx->sample_aspect_ratio.num,
1548
                s->avctx->sample_aspect_ratio.den
1549
            );
1550
1551 145956de Alex Beregszaszi
        t_w = get_bits(&s->gb, 8);
1552
        t_h = get_bits(&s->gb, 8);
1553
        if (t_w && t_h)
1554
        {
1555
            /* skip thumbnail */
1556
            if (len-10-(t_w*t_h*3) > 0)
1557
                len -= t_w*t_h*3;
1558
        }
1559
        len -= 10;
1560
        goto out;
1561
    }
1562
    
1563
    if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1564
    {
1565 046bee86 Michael Niedermayer
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1566
            av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1567 145956de Alex Beregszaszi
        skip_bits(&s->gb, 16); /* version */
1568
        skip_bits(&s->gb, 16); /* flags0 */
1569
        skip_bits(&s->gb, 16); /* flags1 */
1570
        skip_bits(&s->gb, 8); /* transform */
1571
        len -= 7;
1572 723106b2 Alex Beregszaszi
        goto out;
1573
    }
1574 63efe9a7 Michael Niedermayer
1575
    if (id == ff_get_fourcc("LJIF")){
1576 046bee86 Michael Niedermayer
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1577
            av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1578 63efe9a7 Michael Niedermayer
        skip_bits(&s->gb, 16); /* version ? */
1579
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1580
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1581
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1582
        switch( get_bits(&s->gb, 8)){
1583
        case 1:
1584
            s->rgb= 1;
1585 b1e6b355 Michael Niedermayer
            s->pegasus_rct=0;
1586 63efe9a7 Michael Niedermayer
            break;
1587
        case 2:
1588
            s->rgb= 1;
1589 b1e6b355 Michael Niedermayer
            s->pegasus_rct=1;
1590 63efe9a7 Michael Niedermayer
            break;
1591
        default:
1592 9b879566 Michel Bardiaux
            av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1593 63efe9a7 Michael Niedermayer
        }
1594
        len -= 9;
1595
        goto out;
1596
    }
1597 723106b2 Alex Beregszaszi
    
1598
    /* Apple MJPEG-A */
1599 f3a34447 Alex Beregszaszi
    if ((s->start_code == APP1) && (len > (0x28 - 8)))
1600 723106b2 Alex Beregszaszi
    {
1601 f9745d55 Alex Beregszaszi
        id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1602
        id = be2me_32(id);
1603 723106b2 Alex Beregszaszi
        len -= 4;
1604 f3a34447 Alex Beregszaszi
        if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1605 723106b2 Alex Beregszaszi
        {
1606
#if 0
1607
            skip_bits(&s->gb, 32); /* field size */
1608
            skip_bits(&s->gb, 32); /* pad field size */
1609
            skip_bits(&s->gb, 32); /* next off */
1610
            skip_bits(&s->gb, 32); /* quant off */
1611
            skip_bits(&s->gb, 32); /* huff off */
1612
            skip_bits(&s->gb, 32); /* image off */
1613
            skip_bits(&s->gb, 32); /* scan off */
1614
            skip_bits(&s->gb, 32); /* data off */
1615
#endif
1616 046bee86 Michael Niedermayer
            if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1617 9b879566 Michel Bardiaux
                av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1618 723106b2 Alex Beregszaszi
        }
1619
    }
1620 af289048 Alex Beregszaszi
1621 723106b2 Alex Beregszaszi
out:
1622 145956de Alex Beregszaszi
    /* slow but needed for extreme adobe jpegs */
1623
    if (len < 0)
1624 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1625 145956de Alex Beregszaszi
    while(--len > 0)
1626
        skip_bits(&s->gb, 8);
1627
1628 af289048 Alex Beregszaszi
    return 0;
1629
}
1630
1631 109362cb Alex Beregszaszi
static int mjpeg_decode_com(MJpegDecodeContext *s)
1632 723106b2 Alex Beregszaszi
{
1633
    /* XXX: verify len field validity */
1634 eb60dddc Alex Beregszaszi
    int len = get_bits(&s->gb, 16);
1635 dce778e0 Zdenek Kabelac
    if (len >= 2 && len < 32768) {
1636
        /* XXX: any better upper bound */
1637 0c1a9eda Zdenek Kabelac
        uint8_t *cbuf = av_malloc(len - 1);
1638 dce778e0 Zdenek Kabelac
        if (cbuf) {
1639
            int i;
1640
            for (i = 0; i < len - 2; i++)
1641
                cbuf[i] = get_bits(&s->gb, 8);
1642
            if (i > 0 && cbuf[i-1] == '\n')
1643
                cbuf[i-1] = 0;
1644
            else
1645
                cbuf[i] = 0;
1646
1647 96d8b5a6 Michael Niedermayer
            if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1648
                av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1649 dce778e0 Zdenek Kabelac
1650
            /* buggy avid, it puts EOI only at every 10th frame */
1651
            if (!strcmp(cbuf, "AVID"))
1652
            {
1653
                s->buggy_avid = 1;
1654
                //        if (s->first_picture)
1655
                //            printf("mjpeg: workarounding buggy AVID\n");
1656
            }
1657 723106b2 Alex Beregszaszi
1658 dce778e0 Zdenek Kabelac
            av_free(cbuf);
1659
        }
1660 723106b2 Alex Beregszaszi
    }
1661
1662
    return 0;
1663
}
1664
1665 109362cb Alex Beregszaszi
#if 0
1666
static int valid_marker_list[] =
1667
{
1668
        /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1669
/* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1670
/* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1671
/* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1672
/* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1673
/* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1674
/* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1675
/* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1676
/* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1677
/* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1678
/* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1679
/* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1680
/* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1681
/* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1682
/* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1683
/* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1684
/* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1685
}
1686
#endif
1687
1688 10b7b472 Fabrice Bellard
/* return the 8 bit start code value and update the search
1689
   state. Return -1 if no start code found */
1690 0c1a9eda Zdenek Kabelac
static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1691 10b7b472 Fabrice Bellard
{
1692 0c1a9eda Zdenek Kabelac
    uint8_t *buf_ptr;
1693 109362cb Alex Beregszaszi
    unsigned int v, v2;
1694 10b7b472 Fabrice Bellard
    int val;
1695 109362cb Alex Beregszaszi
#ifdef DEBUG
1696
    int skipped=0;
1697
#endif
1698 10b7b472 Fabrice Bellard
1699
    buf_ptr = *pbuf_ptr;
1700 109362cb Alex Beregszaszi
    while (buf_ptr < buf_end) {
1701
        v = *buf_ptr++;
1702
        v2 = *buf_ptr;
1703 9515c0c1 Michael Niedermayer
        if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1704 109362cb Alex Beregszaszi
            val = *buf_ptr++;
1705
            goto found;
1706 10b7b472 Fabrice Bellard
        }
1707 109362cb Alex Beregszaszi
#ifdef DEBUG
1708
        skipped++;
1709
#endif
1710 10b7b472 Fabrice Bellard
    }
1711 109362cb Alex Beregszaszi
    val = -1;
1712
found:
1713
#ifdef DEBUG
1714
    dprintf("find_marker skipped %d bytes\n", skipped);
1715
#endif
1716 10b7b472 Fabrice Bellard
    *pbuf_ptr = buf_ptr;
1717
    return val;
1718
}
1719
1720
static int mjpeg_decode_frame(AVCodecContext *avctx, 
1721
                              void *data, int *data_size,
1722 0c1a9eda Zdenek Kabelac
                              uint8_t *buf, int buf_size)
1723 10b7b472 Fabrice Bellard
{
1724
    MJpegDecodeContext *s = avctx->priv_data;
1725 0c1a9eda Zdenek Kabelac
    uint8_t *buf_end, *buf_ptr;
1726 5e83dec4 Alex Beregszaszi
    int start_code;
1727 ec0eeaa2 Michael Niedermayer
    AVFrame *picture = data;
1728 10b7b472 Fabrice Bellard
1729
    /* no supplementary picture */
1730 9d02db7a Fabrice Bellard
    if (buf_size == 0)
1731 10b7b472 Fabrice Bellard
        return 0;
1732
1733
    buf_ptr = buf;
1734
    buf_end = buf + buf_size;
1735
    while (buf_ptr < buf_end) {
1736
        /* find start next marker */
1737 109362cb Alex Beregszaszi
        start_code = find_marker(&buf_ptr, buf_end);
1738
        {
1739
            /* EOF */
1740
            if (start_code < 0) {
1741
                goto the_end;
1742 af289048 Alex Beregszaszi
            } else {
1743 109362cb Alex Beregszaszi
                dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1744
                
1745
                if ((buf_end - buf_ptr) > s->buffer_size)
1746
                {
1747
                    av_free(s->buffer);
1748
                    s->buffer_size = buf_end-buf_ptr;
1749
                    s->buffer = av_malloc(s->buffer_size);
1750 f3a34447 Alex Beregszaszi
                    dprintf("buffer too small, expanding to %d bytes\n",
1751
                        s->buffer_size);
1752 109362cb Alex Beregszaszi
                }
1753
                
1754
                /* unescape buffer of SOS */
1755
                if (start_code == SOS)
1756
                {
1757 0c1a9eda Zdenek Kabelac
                    uint8_t *src = buf_ptr;
1758
                    uint8_t *dst = s->buffer;
1759 109362cb Alex Beregszaszi
1760
                    while (src<buf_end)
1761
                    {
1762 0c1a9eda Zdenek Kabelac
                        uint8_t x = *(src++);
1763 145956de Alex Beregszaszi
1764 109362cb Alex Beregszaszi
                        *(dst++) = x;
1765
                        if (x == 0xff)
1766
                        {
1767 81ada1ce Michael Niedermayer
                            while(*src == 0xff) src++;
1768
1769 109362cb Alex Beregszaszi
                            x = *(src++);
1770
                            if (x >= 0xd0 && x <= 0xd7)
1771
                                *(dst++) = x;
1772
                            else if (x)
1773
                                break;
1774
                        }
1775
                    }
1776 68f593b4 Michael Niedermayer
                    init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1777 145956de Alex Beregszaszi
                    
1778
                    dprintf("escaping removed %d bytes\n",
1779
                        (buf_end - buf_ptr) - (dst - s->buffer));
1780 109362cb Alex Beregszaszi
                }
1781
                else
1782 68f593b4 Michael Niedermayer
                    init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1783 109362cb Alex Beregszaszi
                
1784
                s->start_code = start_code;
1785 63efe9a7 Michael Niedermayer
                if(s->avctx->debug & FF_DEBUG_STARTCODE){
1786 9b879566 Michel Bardiaux
                    av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
1787 63efe9a7 Michael Niedermayer
                }
1788 109362cb Alex Beregszaszi
1789
                /* process markers */
1790
                if (start_code >= 0xd0 && start_code <= 0xd7) {
1791
                    dprintf("restart marker: %d\n", start_code&0x0f);
1792
                    /* APP fields */
1793 046bee86 Michael Niedermayer
                } else if (start_code >= APP0 && start_code <= APP15) {
1794
                    mjpeg_decode_app(s);
1795 109362cb Alex Beregszaszi
                    /* Comment */
1796 046bee86 Michael Niedermayer
                } else if (start_code == COM){
1797
                    mjpeg_decode_com(s);
1798 109362cb Alex Beregszaszi
                }
1799
1800 10b7b472 Fabrice Bellard
                switch(start_code) {
1801
                case SOI:
1802 723106b2 Alex Beregszaszi
                    s->restart_interval = 0;
1803 10b7b472 Fabrice Bellard
                    /* nothing to do on SOI */
1804
                    break;
1805
                case DQT:
1806 109362cb Alex Beregszaszi
                    mjpeg_decode_dqt(s);
1807 10b7b472 Fabrice Bellard
                    break;
1808
                case DHT:
1809 0273ceeb Michael Niedermayer
                    if(mjpeg_decode_dht(s) < 0){
1810 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n");
1811 0273ceeb Michael Niedermayer
                        return -1;
1812
                    }
1813 10b7b472 Fabrice Bellard
                    break;
1814
                case SOF0:
1815 e4d2b1f3 Michael Niedermayer
                    s->lossless=0;
1816
                    if (mjpeg_decode_sof(s) < 0) 
1817
                        return -1;
1818
                    break;
1819
                case SOF3:
1820
                    s->lossless=1;
1821
                    if (mjpeg_decode_sof(s) < 0) 
1822 17308326 Alex Beregszaszi
                        return -1;
1823 10b7b472 Fabrice Bellard
                    break;
1824 109362cb Alex Beregszaszi
                case EOI:
1825 ec0eeaa2 Michael Niedermayer
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval) 
1826
                        break;
1827 109362cb Alex Beregszaszi
eoi_parser:
1828
                    {
1829 991ae7b6 Fabrice Bellard
                        if (s->interlaced) {
1830
                            s->bottom_field ^= 1;
1831
                            /* if not bottom field, do not output image yet */
1832
                            if (s->bottom_field)
1833 d85c5979 Arpi
                                goto not_the_end;
1834 991ae7b6 Fabrice Bellard
                        }
1835 688cbabe Michael Niedermayer
                        *picture = s->picture;
1836 ec0eeaa2 Michael Niedermayer
                        *data_size = sizeof(AVFrame);
1837
1838
                        if(!s->lossless){
1839
                            picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 
1840
                            picture->qstride= 0;
1841
                            picture->qscale_table= s->qscale_table;
1842
                            memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1843
                            if(avctx->debug & FF_DEBUG_QP)
1844 9b879566 Michel Bardiaux
                                av_log(s->avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
1845 158c7f05 Michael Niedermayer
                            picture->quality*= FF_QP2LAMBDA;
1846 ec0eeaa2 Michael Niedermayer
                        }
1847
                        
1848 10b7b472 Fabrice Bellard
                        goto the_end;
1849
                    }
1850 109362cb Alex Beregszaszi
                    break;
1851
                case SOS:
1852
                    mjpeg_decode_sos(s);
1853
                    /* buggy avid puts EOI every 10-20th frame */
1854
                    /* if restart period is over process EOI */
1855
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1856
                        goto eoi_parser;
1857 10b7b472 Fabrice Bellard
                    break;
1858 723106b2 Alex Beregszaszi
                case DRI:
1859 109362cb Alex Beregszaszi
                    mjpeg_decode_dri(s);
1860 af289048 Alex Beregszaszi
                    break;
1861
                case SOF1:
1862
                case SOF2:
1863
                case SOF5:
1864
                case SOF6:
1865
                case SOF7:
1866
                case SOF9:
1867
                case SOF10:
1868
                case SOF11:
1869
                case SOF13:
1870
                case SOF14:
1871
                case SOF15:
1872
                case JPG:
1873 9b879566 Michel Bardiaux
                    av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
1874 109362cb Alex Beregszaszi
                    break;
1875
//                default:
1876
//                    printf("mjpeg: unsupported marker (%x)\n", start_code);
1877
//                    break;
1878 10b7b472 Fabrice Bellard
                }
1879 109362cb Alex Beregszaszi
1880
not_the_end:
1881
                /* eof process start code */
1882
                buf_ptr += (get_bits_count(&s->gb)+7)/8;
1883
                dprintf("marker parser used %d bytes (%d bits)\n",
1884
                    (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1885 10b7b472 Fabrice Bellard
            }
1886
        }
1887
    }
1888 109362cb Alex Beregszaszi
the_end:
1889
    dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1890
//    return buf_end - buf_ptr;
1891 10b7b472 Fabrice Bellard
    return buf_ptr - buf;
1892
}
1893
1894 b135d9fb Alex Beregszaszi
static int mjpegb_decode_frame(AVCodecContext *avctx, 
1895
                              void *data, int *data_size,
1896 0c1a9eda Zdenek Kabelac
                              uint8_t *buf, int buf_size)
1897 b135d9fb Alex Beregszaszi
{
1898
    MJpegDecodeContext *s = avctx->priv_data;
1899 0c1a9eda Zdenek Kabelac
    uint8_t *buf_end, *buf_ptr;
1900 ec0eeaa2 Michael Niedermayer
    AVFrame *picture = data;
1901 b135d9fb Alex Beregszaszi
    GetBitContext hgb; /* for the header */
1902
    uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
1903
    uint32_t field_size;
1904
1905
    /* no supplementary picture */
1906
    if (buf_size == 0)
1907
        return 0;
1908
1909
    buf_ptr = buf;
1910
    buf_end = buf + buf_size;
1911
    
1912
read_header:
1913
    /* reset on every SOI */
1914
    s->restart_interval = 0;
1915
1916 68f593b4 Michael Niedermayer
    init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
1917 b135d9fb Alex Beregszaszi
1918
    skip_bits(&hgb, 32); /* reserved zeros */
1919
    
1920 8a515d2d Michael Niedermayer
    if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
1921 b135d9fb Alex Beregszaszi
    {
1922
        dprintf("not mjpeg-b (bad fourcc)\n");
1923
        return 0;
1924
    }
1925
1926 8a515d2d Michael Niedermayer
    field_size = get_bits_long(&hgb, 32); /* field size */
1927 b135d9fb Alex Beregszaszi
    dprintf("field size: 0x%x\n", field_size);
1928
    skip_bits(&hgb, 32); /* padded field size */
1929 8a515d2d Michael Niedermayer
    second_field_offs = get_bits_long(&hgb, 32);
1930 b135d9fb Alex Beregszaszi
    dprintf("second field offs: 0x%x\n", second_field_offs);
1931
    if (second_field_offs)
1932
        s->interlaced = 1;
1933
1934 8a515d2d Michael Niedermayer
    dqt_offs = get_bits_long(&hgb, 32);
1935 b135d9fb Alex Beregszaszi
    dprintf("dqt offs: 0x%x\n", dqt_offs);
1936
    if (dqt_offs)
1937
    {
1938 68f593b4 Michael Niedermayer
        init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
1939 b135d9fb Alex Beregszaszi
        s->start_code = DQT;
1940
        mjpeg_decode_dqt(s);
1941
    }
1942
    
1943 8a515d2d Michael Niedermayer
    dht_offs = get_bits_long(&hgb, 32);
1944 b135d9fb Alex Beregszaszi
    dprintf("dht offs: 0x%x\n", dht_offs);
1945
    if (dht_offs)
1946
    {
1947 68f593b4 Michael Niedermayer
        init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
1948 b135d9fb Alex Beregszaszi
        s->start_code = DHT;
1949
        mjpeg_decode_dht(s);
1950
    }
1951
1952 8a515d2d Michael Niedermayer
    sof_offs = get_bits_long(&hgb, 32);
1953 b135d9fb Alex Beregszaszi
    dprintf("sof offs: 0x%x\n", sof_offs);
1954
    if (sof_offs)
1955
    {
1956 68f593b4 Michael Niedermayer
        init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
1957 b135d9fb Alex Beregszaszi
        s->start_code = SOF0;
1958 e4d2b1f3 Michael Niedermayer
        if (mjpeg_decode_sof(s) < 0)
1959 17308326 Alex Beregszaszi
            return -1;
1960 b135d9fb Alex Beregszaszi
    }
1961
1962 8a515d2d Michael Niedermayer
    sos_offs = get_bits_long(&hgb, 32);
1963 b135d9fb Alex Beregszaszi
    dprintf("sos offs: 0x%x\n", sos_offs);
1964
    if (sos_offs)
1965
    {
1966 68f593b4 Michael Niedermayer
//        init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
1967
        init_get_bits(&s->gb, buf+sos_offs, field_size*8);
1968 b135d9fb Alex Beregszaszi
        s->start_code = SOS;
1969
        mjpeg_decode_sos(s);
1970
    }
1971
1972
    skip_bits(&hgb, 32); /* start of data offset */
1973
1974
    if (s->interlaced) {
1975
        s->bottom_field ^= 1;
1976
        /* if not bottom field, do not output image yet */
1977
        if (s->bottom_field && second_field_offs)
1978
        {
1979
            buf_ptr = buf + second_field_offs;
1980
            second_field_offs = 0;
1981
            goto read_header;
1982
            }
1983
    }
1984
1985 ec0eeaa2 Michael Niedermayer
    //XXX FIXME factorize, this looks very similar to the EOI code
1986 688cbabe Michael Niedermayer
1987
    *picture= s->picture;
1988 ec0eeaa2 Michael Niedermayer
    *data_size = sizeof(AVFrame);
1989
    
1990
    if(!s->lossless){
1991
        picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 
1992
        picture->qstride= 0;
1993
        picture->qscale_table= s->qscale_table;
1994
        memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1995
        if(avctx->debug & FF_DEBUG_QP)
1996 9b879566 Michel Bardiaux
            av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
1997 158c7f05 Michael Niedermayer
        picture->quality*= FF_QP2LAMBDA;
1998 ec0eeaa2 Michael Niedermayer
    }
1999 b135d9fb Alex Beregszaszi
2000
    return buf_ptr - buf;
2001
}
2002
2003 5e83dec4 Alex Beregszaszi
#include "sp5x.h"
2004
2005
static int sp5x_decode_frame(AVCodecContext *avctx, 
2006
                              void *data, int *data_size,
2007
                              uint8_t *buf, int buf_size)
2008
{
2009
#if 0
2010
    MJpegDecodeContext *s = avctx->priv_data;
2011
#endif
2012
    const int qscale = 5;
2013
    uint8_t *buf_ptr, *buf_end, *recoded;
2014
    int i = 0, j = 0;
2015
2016
    /* no supplementary picture */
2017
    if (buf_size == 0)
2018
        return 0;
2019
2020
    if (!avctx->width || !avctx->height)
2021
        return -1;
2022
2023
    buf_ptr = buf;
2024
    buf_end = buf + buf_size;
2025
2026
#if 1
2027
    recoded = av_mallocz(buf_size + 1024);
2028
    if (!recoded)
2029
        return -1;
2030
2031
    /* SOI */
2032
    recoded[j++] = 0xFF;
2033
    recoded[j++] = 0xD8;
2034
2035
    memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2036
    memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2037
    memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2038
    j += sizeof(sp5x_data_dqt);
2039
2040
    memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2041
    j += sizeof(sp5x_data_dht);
2042
2043
    memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2044
    recoded[j+5] = (avctx->height >> 8) & 0xFF;
2045
    recoded[j+6] = avctx->height & 0xFF;
2046
    recoded[j+7] = (avctx->width >> 8) & 0xFF;
2047
    recoded[j+8] = avctx->width & 0xFF;
2048
    j += sizeof(sp5x_data_sof);
2049
2050
    memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2051
    j += sizeof(sp5x_data_sos);
2052
2053 5ff85f1d Michael Niedermayer
    for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2054 5e83dec4 Alex Beregszaszi
    {
2055
        recoded[j++] = buf[i];
2056
        if (buf[i] == 0xff)
2057
            recoded[j++] = 0;
2058
    }
2059
2060
    /* EOI */
2061
    recoded[j++] = 0xFF;
2062
    recoded[j++] = 0xD9;
2063
2064
    i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2065
2066
    av_free(recoded);
2067
2068
#else
2069
    /* SOF */
2070
    s->bits = 8;
2071
    s->width = avctx->width;
2072
    s->height = avctx->height;
2073
    s->nb_components = 3;
2074
    s->component_id[0] = 0;
2075
    s->h_count[0] = 2;
2076
    s->v_count[0] = 2;
2077
    s->quant_index[0] = 0;
2078
    s->component_id[1] = 1;
2079
    s->h_count[1] = 1;
2080
    s->v_count[1] = 1;
2081
    s->quant_index[1] = 1;
2082
    s->component_id[2] = 2;
2083
    s->h_count[2] = 1;
2084
    s->v_count[2] = 1;
2085
    s->quant_index[2] = 1;
2086
    s->h_max = 2;
2087
    s->v_max = 2;
2088
    
2089
    s->qscale_table = av_mallocz((s->width+15)/16);
2090
    avctx->pix_fmt = PIX_FMT_YUV420P;
2091
    s->interlaced = 0;
2092
    
2093
    s->picture.reference = 0;
2094
    if (avctx->get_buffer(avctx, &s->picture) < 0)
2095
    {
2096
        fprintf(stderr, "get_buffer() failed\n");
2097
        return -1;
2098
    }
2099
2100
    s->picture.pict_type = I_TYPE;
2101
    s->picture.key_frame = 1;
2102
2103
    for (i = 0; i < 3; i++)
2104
        s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2105
2106
    /* DQT */
2107
    for (i = 0; i < 64; i++)
2108
    {
2109
        j = s->scantable.permutated[i];
2110
        s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2111
    }
2112
    s->qscale[0] = FFMAX(
2113
        s->quant_matrixes[0][s->scantable.permutated[1]],
2114
        s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2115
2116
    for (i = 0; i < 64; i++)
2117
    {
2118
        j = s->scantable.permutated[i];
2119
        s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2120
    }
2121
    s->qscale[1] = FFMAX(
2122
        s->quant_matrixes[1][s->scantable.permutated[1]],
2123
        s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2124
2125
    /* DHT */
2126
2127
    /* SOS */
2128
    s->comp_index[0] = 0;
2129
    s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2130
    s->h_scount[0] = s->h_count[0];
2131
    s->v_scount[0] = s->v_count[0];
2132
    s->dc_index[0] = 0;
2133
    s->ac_index[0] = 0;
2134
2135
    s->comp_index[1] = 1;
2136
    s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2137
    s->h_scount[1] = s->h_count[1];
2138
    s->v_scount[1] = s->v_count[1];
2139
    s->dc_index[1] = 1;
2140
    s->ac_index[1] = 1;
2141
2142
    s->comp_index[2] = 2;
2143
    s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2144
    s->h_scount[2] = s->h_count[2];
2145
    s->v_scount[2] = s->v_count[2];
2146
    s->dc_index[2] = 1;
2147
    s->ac_index[2] = 1;
2148
    
2149
    for (i = 0; i < 3; i++)
2150
        s->last_dc[i] = 1024;
2151
2152
    s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2153
    s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2154
2155 369e2d50 Alex Beregszaszi
    init_get_bits(&s->gb, buf+14, (buf_size-14)*8);
2156 5e83dec4 Alex Beregszaszi
    
2157
    return mjpeg_decode_scan(s);
2158
#endif
2159
2160
    return i;
2161
}
2162 b135d9fb Alex Beregszaszi
2163 10b7b472 Fabrice Bellard
static int mjpeg_decode_end(AVCodecContext *avctx)
2164
{
2165
    MJpegDecodeContext *s = avctx->priv_data;
2166
    int i, j;
2167
2168 109362cb Alex Beregszaszi
    av_free(s->buffer);
2169 ec0eeaa2 Michael Niedermayer
    av_free(s->qscale_table);
2170 688cbabe Michael Niedermayer
    
2171 10b7b472 Fabrice Bellard
    for(i=0;i<2;i++) {
2172
        for(j=0;j<4;j++)
2173
            free_vlc(&s->vlcs[i][j]);
2174
    }
2175
    return 0;
2176
}
2177
2178
AVCodec mjpeg_decoder = {
2179
    "mjpeg",
2180
    CODEC_TYPE_VIDEO,
2181
    CODEC_ID_MJPEG,
2182
    sizeof(MJpegDecodeContext),
2183
    mjpeg_decode_init,
2184
    NULL,
2185
    mjpeg_decode_end,
2186
    mjpeg_decode_frame,
2187 688cbabe Michael Niedermayer
    CODEC_CAP_DR1,
2188 723106b2 Alex Beregszaszi
    NULL
2189 10b7b472 Fabrice Bellard
};
2190 b135d9fb Alex Beregszaszi
2191
AVCodec mjpegb_decoder = {
2192
    "mjpegb",
2193
    CODEC_TYPE_VIDEO,
2194
    CODEC_ID_MJPEGB,
2195
    sizeof(MJpegDecodeContext),
2196
    mjpeg_decode_init,
2197
    NULL,
2198
    mjpeg_decode_end,
2199
    mjpegb_decode_frame,
2200 688cbabe Michael Niedermayer
    CODEC_CAP_DR1,
2201 b135d9fb Alex Beregszaszi
    NULL
2202
};
2203 b1e6b355 Michael Niedermayer
2204 5e83dec4 Alex Beregszaszi
AVCodec sp5x_decoder = {
2205
    "sp5x",
2206
    CODEC_TYPE_VIDEO,
2207
    CODEC_ID_SP5X,
2208
    sizeof(MJpegDecodeContext),
2209
    mjpeg_decode_init,
2210
    NULL,
2211
    mjpeg_decode_end,
2212
    sp5x_decode_frame,
2213
    CODEC_CAP_DR1,
2214
    NULL
2215
};
2216
2217 2a250222 Michael Niedermayer
#ifdef CONFIG_ENCODERS
2218 b1e6b355 Michael Niedermayer
AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2219
    "ljpeg",
2220
    CODEC_TYPE_VIDEO,
2221
    CODEC_ID_LJPEG,
2222
    sizeof(MpegEncContext),
2223
    MPV_encode_init,
2224
    encode_picture_lossless,
2225
    MPV_encode_end,
2226
};
2227 2a250222 Michael Niedermayer
#endif