Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mjpeg.c @ 5509bffa

History | View | Annotate | Download (72.9 KB)

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