Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mjpeg.c @ d4c5d2ad

History | View | Annotate | Download (66 KB)

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