Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mjpeg.c @ c53d2d90

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