Mercurial > libavcodec.hg
annotate mjpegdec.c @ 5818:e0a872dd3ea1 libavcodec
Fix MJPEG decoder for AMV files.
Since decoding is doing from the end and aligned by 16
previous code worked correctly only when picture height was dividable by 16,
otherwise it provides garbage in top lines and truncates bottom.
New code adjusts data[] pointers taking in account alignment issue.
author | voroshil |
---|---|
date | Sat, 13 Oct 2007 17:38:58 +0000 |
parents | 810067f2c33d |
children | 01e909d2a435 |
rev | line source |
---|---|
5020 | 1 /* |
2 * MJPEG decoder | |
3 * Copyright (c) 2000, 2001 Fabrice Bellard. | |
4 * Copyright (c) 2003 Alex Beregszaszi | |
5 * Copyright (c) 2003-2004 Michael Niedermayer | |
6 * | |
5214 | 7 * Support for external huffman table, various fixes (AVID workaround), |
8 * aspecting, new decode_frame mechanism and apple mjpeg-b support | |
9 * by Alex Beregszaszi | |
10 * | |
5020 | 11 * This file is part of FFmpeg. |
12 * | |
13 * FFmpeg is free software; you can redistribute it and/or | |
14 * modify it under the terms of the GNU Lesser General Public | |
15 * License as published by the Free Software Foundation; either | |
16 * version 2.1 of the License, or (at your option) any later version. | |
17 * | |
18 * FFmpeg is distributed in the hope that it will be useful, | |
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
21 * Lesser General Public License for more details. | |
22 * | |
23 * You should have received a copy of the GNU Lesser General Public | |
24 * License along with FFmpeg; if not, write to the Free Software | |
25 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
26 */ | |
27 | |
28 /** | |
29 * @file mjpegdec.c | |
30 * MJPEG decoder. | |
31 */ | |
32 | |
33 //#define DEBUG | |
34 #include <assert.h> | |
35 | |
36 #include "avcodec.h" | |
37 #include "dsputil.h" | |
38 #include "mjpeg.h" | |
5041 | 39 #include "mjpegdec.h" |
5020 | 40 #include "jpeglsdec.h" |
41 | |
42 | |
43 static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table, | |
44 int nb_codes, int use_static, int is_ac) | |
45 { | |
46 uint8_t huff_size[256+16]; | |
47 uint16_t huff_code[256+16]; | |
48 | |
49 assert(nb_codes <= 256); | |
50 | |
51 memset(huff_size, 0, sizeof(huff_size)); | |
5021 | 52 ff_mjpeg_build_huffman_codes(huff_size, huff_code, bits_table, val_table); |
5020 | 53 |
54 if(is_ac){ | |
55 memmove(huff_size+16, huff_size, sizeof(uint8_t)*nb_codes); | |
56 memmove(huff_code+16, huff_code, sizeof(uint16_t)*nb_codes); | |
57 memset(huff_size, 0, sizeof(uint8_t)*16); | |
58 memset(huff_code, 0, sizeof(uint16_t)*16); | |
59 nb_codes += 16; | |
60 } | |
61 | |
62 return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2, use_static); | |
63 } | |
64 | |
5068
93e369c55c31
fix mjpeg decoding with broken huffman table headers
ods15
parents:
5044
diff
changeset
|
65 static void build_basic_mjpeg_vlc(MJpegDecodeContext * s) { |
93e369c55c31
fix mjpeg decoding with broken huffman table headers
ods15
parents:
5044
diff
changeset
|
66 build_vlc(&s->vlcs[0][0], ff_mjpeg_bits_dc_luminance, |
93e369c55c31
fix mjpeg decoding with broken huffman table headers
ods15
parents:
5044
diff
changeset
|
67 ff_mjpeg_val_dc_luminance, 12, 0, 0); |
93e369c55c31
fix mjpeg decoding with broken huffman table headers
ods15
parents:
5044
diff
changeset
|
68 build_vlc(&s->vlcs[0][1], ff_mjpeg_bits_dc_chrominance, |
93e369c55c31
fix mjpeg decoding with broken huffman table headers
ods15
parents:
5044
diff
changeset
|
69 ff_mjpeg_val_dc_chrominance, 12, 0, 0); |
93e369c55c31
fix mjpeg decoding with broken huffman table headers
ods15
parents:
5044
diff
changeset
|
70 build_vlc(&s->vlcs[1][0], ff_mjpeg_bits_ac_luminance, |
93e369c55c31
fix mjpeg decoding with broken huffman table headers
ods15
parents:
5044
diff
changeset
|
71 ff_mjpeg_val_ac_luminance, 251, 0, 1); |
93e369c55c31
fix mjpeg decoding with broken huffman table headers
ods15
parents:
5044
diff
changeset
|
72 build_vlc(&s->vlcs[1][1], ff_mjpeg_bits_ac_chrominance, |
93e369c55c31
fix mjpeg decoding with broken huffman table headers
ods15
parents:
5044
diff
changeset
|
73 ff_mjpeg_val_ac_chrominance, 251, 0, 1); |
93e369c55c31
fix mjpeg decoding with broken huffman table headers
ods15
parents:
5044
diff
changeset
|
74 } |
93e369c55c31
fix mjpeg decoding with broken huffman table headers
ods15
parents:
5044
diff
changeset
|
75 |
5041 | 76 int ff_mjpeg_decode_init(AVCodecContext *avctx) |
5020 | 77 { |
78 MJpegDecodeContext *s = avctx->priv_data; | |
79 | |
80 s->avctx = avctx; | |
81 dsputil_init(&s->dsp, avctx); | |
82 ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct); | |
83 s->buffer_size = 0; | |
84 s->buffer = NULL; | |
85 s->start_code = -1; | |
86 s->first_picture = 1; | |
87 s->org_height = avctx->coded_height; | |
88 | |
5068
93e369c55c31
fix mjpeg decoding with broken huffman table headers
ods15
parents:
5044
diff
changeset
|
89 build_basic_mjpeg_vlc(s); |
5020 | 90 |
91 if (avctx->flags & CODEC_FLAG_EXTERN_HUFF) | |
92 { | |
93 av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n"); | |
94 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8); | |
5068
93e369c55c31
fix mjpeg decoding with broken huffman table headers
ods15
parents:
5044
diff
changeset
|
95 if (ff_mjpeg_decode_dht(s)) { |
93e369c55c31
fix mjpeg decoding with broken huffman table headers
ods15
parents:
5044
diff
changeset
|
96 av_log(avctx, AV_LOG_ERROR, "mjpeg: error using external huffman table, switching back to internal\n"); |
93e369c55c31
fix mjpeg decoding with broken huffman table headers
ods15
parents:
5044
diff
changeset
|
97 build_basic_mjpeg_vlc(s); |
93e369c55c31
fix mjpeg decoding with broken huffman table headers
ods15
parents:
5044
diff
changeset
|
98 } |
5020 | 99 } |
100 if (avctx->extradata_size > 9 && | |
101 AV_RL32(avctx->extradata + 4) == MKTAG('f','i','e','l')) { | |
102 if (avctx->extradata[9] == 6) { /* quicktime icefloe 019 */ | |
103 s->interlace_polarity = 1; /* bottom field first */ | |
104 av_log(avctx, AV_LOG_DEBUG, "mjpeg bottom field first\n"); | |
105 } | |
106 } | |
107 | |
108 return 0; | |
109 } | |
110 | |
111 | |
112 /* quantize tables */ | |
5044 | 113 int ff_mjpeg_decode_dqt(MJpegDecodeContext *s) |
5020 | 114 { |
115 int len, index, i, j; | |
116 | |
117 len = get_bits(&s->gb, 16) - 2; | |
118 | |
119 while (len >= 65) { | |
120 /* only 8 bit precision handled */ | |
121 if (get_bits(&s->gb, 4) != 0) | |
122 { | |
123 av_log(s->avctx, AV_LOG_ERROR, "dqt: 16bit precision\n"); | |
124 return -1; | |
125 } | |
126 index = get_bits(&s->gb, 4); | |
127 if (index >= 4) | |
128 return -1; | |
129 av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index); | |
130 /* read quant table */ | |
131 for(i=0;i<64;i++) { | |
132 j = s->scantable.permutated[i]; | |
133 s->quant_matrixes[index][j] = get_bits(&s->gb, 8); | |
134 } | |
135 | |
136 //XXX FIXME finetune, and perhaps add dc too | |
137 s->qscale[index]= FFMAX( | |
138 s->quant_matrixes[index][s->scantable.permutated[1]], | |
139 s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1; | |
140 av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n", index, s->qscale[index]); | |
141 len -= 65; | |
142 } | |
143 | |
144 return 0; | |
145 } | |
146 | |
147 /* decode huffman tables and build VLC decoders */ | |
5044 | 148 int ff_mjpeg_decode_dht(MJpegDecodeContext *s) |
5020 | 149 { |
150 int len, index, i, class, n, v, code_max; | |
151 uint8_t bits_table[17]; | |
152 uint8_t val_table[256]; | |
153 | |
154 len = get_bits(&s->gb, 16) - 2; | |
155 | |
156 while (len > 0) { | |
157 if (len < 17) | |
158 return -1; | |
159 class = get_bits(&s->gb, 4); | |
160 if (class >= 2) | |
161 return -1; | |
162 index = get_bits(&s->gb, 4); | |
163 if (index >= 4) | |
164 return -1; | |
165 n = 0; | |
166 for(i=1;i<=16;i++) { | |
167 bits_table[i] = get_bits(&s->gb, 8); | |
168 n += bits_table[i]; | |
169 } | |
170 len -= 17; | |
171 if (len < n || n > 256) | |
172 return -1; | |
173 | |
174 code_max = 0; | |
175 for(i=0;i<n;i++) { | |
176 v = get_bits(&s->gb, 8); | |
177 if (v > code_max) | |
178 code_max = v; | |
179 val_table[i] = v; | |
180 } | |
181 len -= n; | |
182 | |
183 /* build VLC and flush previous vlc if present */ | |
184 free_vlc(&s->vlcs[class][index]); | |
185 av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n", | |
186 class, index, code_max + 1); | |
187 if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0, class > 0) < 0){ | |
188 return -1; | |
189 } | |
190 } | |
191 return 0; | |
192 } | |
193 | |
5044 | 194 int ff_mjpeg_decode_sof(MJpegDecodeContext *s) |
5020 | 195 { |
196 int len, nb_components, i, width, height, pix_fmt_id; | |
197 | |
198 /* XXX: verify len field validity */ | |
199 len = get_bits(&s->gb, 16); | |
200 s->bits= get_bits(&s->gb, 8); | |
201 | |
202 if(s->pegasus_rct) s->bits=9; | |
203 if(s->bits==9 && !s->pegasus_rct) s->rct=1; //FIXME ugly | |
204 | |
205 if (s->bits != 8 && !s->lossless){ | |
206 av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n"); | |
207 return -1; | |
208 } | |
209 | |
210 height = get_bits(&s->gb, 16); | |
211 width = get_bits(&s->gb, 16); | |
212 | |
213 //HACK for odd_height.mov | |
214 if(s->interlaced && s->width == width && s->height == height + 1) | |
215 height= s->height; | |
216 | |
217 av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height); | |
218 if(avcodec_check_dimensions(s->avctx, width, height)) | |
219 return -1; | |
220 | |
221 nb_components = get_bits(&s->gb, 8); | |
222 if (nb_components <= 0 || | |
223 nb_components > MAX_COMPONENTS) | |
224 return -1; | |
225 if (s->ls && !(s->bits <= 8 || nb_components == 1)){ | |
226 av_log(s->avctx, AV_LOG_ERROR, "only <= 8 bits/component or 16-bit gray accepted for JPEG-LS\n"); | |
227 return -1; | |
228 } | |
229 s->nb_components = nb_components; | |
230 s->h_max = 1; | |
231 s->v_max = 1; | |
232 for(i=0;i<nb_components;i++) { | |
233 /* component id */ | |
234 s->component_id[i] = get_bits(&s->gb, 8) - 1; | |
235 s->h_count[i] = get_bits(&s->gb, 4); | |
236 s->v_count[i] = get_bits(&s->gb, 4); | |
237 /* compute hmax and vmax (only used in interleaved case) */ | |
238 if (s->h_count[i] > s->h_max) | |
239 s->h_max = s->h_count[i]; | |
240 if (s->v_count[i] > s->v_max) | |
241 s->v_max = s->v_count[i]; | |
242 s->quant_index[i] = get_bits(&s->gb, 8); | |
243 if (s->quant_index[i] >= 4) | |
244 return -1; | |
245 av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n", i, s->h_count[i], | |
246 s->v_count[i], s->component_id[i], s->quant_index[i]); | |
247 } | |
248 | |
249 if(s->ls && (s->h_max > 1 || s->v_max > 1)) { | |
250 av_log(s->avctx, AV_LOG_ERROR, "Subsampling in JPEG-LS is not supported.\n"); | |
251 return -1; | |
252 } | |
253 | |
254 if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1; | |
255 | |
256 /* if different size, realloc/alloc picture */ | |
257 /* XXX: also check h_count and v_count */ | |
258 if (width != s->width || height != s->height) { | |
259 av_freep(&s->qscale_table); | |
260 | |
261 s->width = width; | |
262 s->height = height; | |
263 s->interlaced = 0; | |
264 | |
265 /* test interlaced mode */ | |
266 if (s->first_picture && | |
267 s->org_height != 0 && | |
268 s->height < ((s->org_height * 3) / 4)) { | |
269 s->interlaced = 1; | |
270 s->bottom_field = s->interlace_polarity; | |
271 s->picture.interlaced_frame = 1; | |
272 s->picture.top_field_first = !s->interlace_polarity; | |
273 height *= 2; | |
274 } | |
275 | |
276 avcodec_set_dimensions(s->avctx, width, height); | |
277 | |
278 s->qscale_table= av_mallocz((s->width+15)/16); | |
279 | |
280 s->first_picture = 0; | |
281 } | |
282 | |
283 if(s->interlaced && (s->bottom_field == !s->interlace_polarity)) | |
284 return 0; | |
285 | |
286 /* XXX: not complete test ! */ | |
287 pix_fmt_id = (s->h_count[0] << 20) | (s->v_count[0] << 16) | | |
288 (s->h_count[1] << 12) | (s->v_count[1] << 8) | | |
289 (s->h_count[2] << 4) | s->v_count[2]; | |
290 av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id); | |
291 switch(pix_fmt_id){ | |
292 case 0x222222: | |
293 case 0x111111: | |
294 if(s->rgb){ | |
295 s->avctx->pix_fmt = PIX_FMT_RGB32; | |
296 }else if(s->nb_components==3) | |
297 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P; | |
298 else | |
299 s->avctx->pix_fmt = PIX_FMT_GRAY8; | |
300 break; | |
5478
41103dc22ad5
Add support for grayscale MJPEG streams sent by Axis cameras such as the
diego
parents:
5381
diff
changeset
|
301 case 0x110000: |
41103dc22ad5
Add support for grayscale MJPEG streams sent by Axis cameras such as the
diego
parents:
5381
diff
changeset
|
302 s->avctx->pix_fmt = PIX_FMT_GRAY8; |
41103dc22ad5
Add support for grayscale MJPEG streams sent by Axis cameras such as the
diego
parents:
5381
diff
changeset
|
303 break; |
5363 | 304 case 0x121111: |
305 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV440P : PIX_FMT_YUVJ440P; | |
306 break; | |
5020 | 307 case 0x211111: |
308 case 0x221212: | |
309 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P; | |
310 break; | |
311 case 0x221111: | |
312 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P; | |
313 break; | |
5381
4cac2cfe2745
bail out on unknown jpeg pixel format instead of silently decoding data incorrectly
gpoirier
parents:
5363
diff
changeset
|
314 default: |
4cac2cfe2745
bail out on unknown jpeg pixel format instead of silently decoding data incorrectly
gpoirier
parents:
5363
diff
changeset
|
315 av_log(s->avctx, AV_LOG_ERROR, "Unhandled pixel format 0x%x\n", pix_fmt_id); |
4cac2cfe2745
bail out on unknown jpeg pixel format instead of silently decoding data incorrectly
gpoirier
parents:
5363
diff
changeset
|
316 return -1; |
5020 | 317 } |
318 if(s->ls){ | |
319 if(s->nb_components > 1) | |
320 s->avctx->pix_fmt = PIX_FMT_RGB24; | |
321 else if(s->bits <= 8) | |
322 s->avctx->pix_fmt = PIX_FMT_GRAY8; | |
323 else | |
324 s->avctx->pix_fmt = PIX_FMT_GRAY16; | |
325 } | |
326 | |
327 if(s->picture.data[0]) | |
328 s->avctx->release_buffer(s->avctx, &s->picture); | |
329 | |
330 s->picture.reference= 0; | |
331 if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){ | |
332 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n"); | |
333 return -1; | |
334 } | |
335 s->picture.pict_type= I_TYPE; | |
336 s->picture.key_frame= 1; | |
337 | |
338 for(i=0; i<3; i++){ | |
339 s->linesize[i]= s->picture.linesize[i] << s->interlaced; | |
340 } | |
341 | |
342 // printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height); | |
343 | |
344 if (len != (8+(3*nb_components))) | |
345 { | |
346 av_log(s->avctx, AV_LOG_DEBUG, "decode_sof0: error, len(%d) mismatch\n", len); | |
347 } | |
348 | |
349 /* totally blank picture as progressive JPEG will only add details to it */ | |
350 if(s->progressive){ | |
351 memset(s->picture.data[0], 0, s->picture.linesize[0] * s->height); | |
352 memset(s->picture.data[1], 0, s->picture.linesize[1] * s->height >> (s->v_max - s->v_count[1])); | |
353 memset(s->picture.data[2], 0, s->picture.linesize[2] * s->height >> (s->v_max - s->v_count[2])); | |
354 } | |
355 return 0; | |
356 } | |
357 | |
358 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index) | |
359 { | |
360 int code; | |
361 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2); | |
362 if (code < 0) | |
363 { | |
364 av_log(s->avctx, AV_LOG_WARNING, "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index, | |
365 &s->vlcs[0][dc_index]); | |
366 return 0xffff; | |
367 } | |
368 | |
369 if(code) | |
370 return get_xbits(&s->gb, code); | |
371 else | |
372 return 0; | |
373 } | |
374 | |
375 /* decode block and dequantize */ | |
376 static int decode_block(MJpegDecodeContext *s, DCTELEM *block, | |
377 int component, int dc_index, int ac_index, int16_t *quant_matrix) | |
378 { | |
379 int code, i, j, level, val; | |
380 | |
381 /* DC coef */ | |
382 val = mjpeg_decode_dc(s, dc_index); | |
383 if (val == 0xffff) { | |
384 av_log(s->avctx, AV_LOG_ERROR, "error dc\n"); | |
385 return -1; | |
386 } | |
387 val = val * quant_matrix[0] + s->last_dc[component]; | |
388 s->last_dc[component] = val; | |
389 block[0] = val; | |
390 /* AC coefs */ | |
391 i = 0; | |
392 {OPEN_READER(re, &s->gb) | |
393 for(;;) { | |
394 UPDATE_CACHE(re, &s->gb); | |
395 GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2) | |
396 | |
397 /* EOB */ | |
398 if (code == 0x10) | |
399 break; | |
400 i += ((unsigned)code) >> 4; | |
401 if(code != 0x100){ | |
402 code &= 0xf; | |
403 if(code > MIN_CACHE_BITS - 16){ | |
404 UPDATE_CACHE(re, &s->gb) | |
405 } | |
406 { | |
407 int cache=GET_CACHE(re,&s->gb); | |
408 int sign=(~cache)>>31; | |
409 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign; | |
410 } | |
411 | |
412 LAST_SKIP_BITS(re, &s->gb, code) | |
413 | |
414 if (i >= 63) { | |
415 if(i == 63){ | |
416 j = s->scantable.permutated[63]; | |
417 block[j] = level * quant_matrix[j]; | |
418 break; | |
419 } | |
420 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); | |
421 return -1; | |
422 } | |
423 j = s->scantable.permutated[i]; | |
424 block[j] = level * quant_matrix[j]; | |
425 } | |
426 } | |
427 CLOSE_READER(re, &s->gb)} | |
428 | |
429 return 0; | |
430 } | |
431 | |
432 /* decode block and dequantize - progressive JPEG version */ | |
433 static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block, | |
434 int component, int dc_index, int ac_index, int16_t *quant_matrix, | |
435 int ss, int se, int Ah, int Al, int *EOBRUN) | |
436 { | |
437 int code, i, j, level, val, run; | |
438 | |
439 /* DC coef */ | |
440 if(!ss){ | |
441 val = mjpeg_decode_dc(s, dc_index); | |
442 if (val == 0xffff) { | |
443 av_log(s->avctx, AV_LOG_ERROR, "error dc\n"); | |
444 return -1; | |
445 } | |
446 val = (val * quant_matrix[0] << Al) + s->last_dc[component]; | |
447 }else | |
448 val = 0; | |
449 s->last_dc[component] = val; | |
450 block[0] = val; | |
451 if(!se) return 0; | |
452 /* AC coefs */ | |
453 if(*EOBRUN){ | |
454 (*EOBRUN)--; | |
455 return 0; | |
456 } | |
457 {OPEN_READER(re, &s->gb) | |
458 for(i=ss;;i++) { | |
459 UPDATE_CACHE(re, &s->gb); | |
460 GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2) | |
461 /* Progressive JPEG use AC coeffs from zero and this decoder sets offset 16 by default */ | |
462 code -= 16; | |
463 if(code & 0xF) { | |
464 i += ((unsigned) code) >> 4; | |
465 code &= 0xf; | |
466 if(code > MIN_CACHE_BITS - 16){ | |
467 UPDATE_CACHE(re, &s->gb) | |
468 } | |
469 { | |
470 int cache=GET_CACHE(re,&s->gb); | |
471 int sign=(~cache)>>31; | |
472 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign; | |
473 } | |
474 | |
475 LAST_SKIP_BITS(re, &s->gb, code) | |
476 | |
477 if (i >= se) { | |
478 if(i == se){ | |
479 j = s->scantable.permutated[se]; | |
480 block[j] = level * quant_matrix[j] << Al; | |
481 break; | |
482 } | |
483 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); | |
484 return -1; | |
485 } | |
486 j = s->scantable.permutated[i]; | |
487 block[j] = level * quant_matrix[j] << Al; | |
488 }else{ | |
489 run = ((unsigned) code) >> 4; | |
490 if(run == 0xF){// ZRL - skip 15 coefficients | |
491 i += 15; | |
492 }else{ | |
493 val = run; | |
494 run = (1 << run); | |
495 UPDATE_CACHE(re, &s->gb); | |
496 run += (GET_CACHE(re, &s->gb) >> (32 - val)) & (run - 1); | |
497 if(val) | |
498 LAST_SKIP_BITS(re, &s->gb, val); | |
499 *EOBRUN = run - 1; | |
500 break; | |
501 } | |
502 } | |
503 } | |
504 CLOSE_READER(re, &s->gb)} | |
505 | |
506 return 0; | |
507 } | |
508 | |
509 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){ | |
510 int i, mb_x, mb_y; | |
511 uint16_t buffer[32768][4]; | |
512 int left[3], top[3], topleft[3]; | |
513 const int linesize= s->linesize[0]; | |
514 const int mask= (1<<s->bits)-1; | |
515 | |
516 if((unsigned)s->mb_width > 32768) //dynamic alloc | |
517 return -1; | |
518 | |
519 for(i=0; i<3; i++){ | |
520 buffer[0][i]= 1 << (s->bits + point_transform - 1); | |
521 } | |
522 for(mb_y = 0; mb_y < s->mb_height; mb_y++) { | |
523 const int modified_predictor= mb_y ? predictor : 1; | |
524 uint8_t *ptr = s->picture.data[0] + (linesize * mb_y); | |
525 | |
526 if (s->interlaced && s->bottom_field) | |
527 ptr += linesize >> 1; | |
528 | |
529 for(i=0; i<3; i++){ | |
530 top[i]= left[i]= topleft[i]= buffer[0][i]; | |
531 } | |
532 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { | |
533 if (s->restart_interval && !s->restart_count) | |
534 s->restart_count = s->restart_interval; | |
535 | |
536 for(i=0;i<3;i++) { | |
537 int pred; | |
538 | |
539 topleft[i]= top[i]; | |
540 top[i]= buffer[mb_x][i]; | |
541 | |
542 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor); | |
543 | |
544 left[i]= | |
545 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform)); | |
546 } | |
547 | |
548 if (s->restart_interval && !--s->restart_count) { | |
549 align_get_bits(&s->gb); | |
550 skip_bits(&s->gb, 16); /* skip RSTn */ | |
551 } | |
552 } | |
553 | |
554 if(s->rct){ | |
555 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { | |
556 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2); | |
557 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1]; | |
558 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1]; | |
559 } | |
560 }else if(s->pegasus_rct){ | |
561 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { | |
562 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2); | |
563 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1]; | |
564 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1]; | |
565 } | |
566 }else{ | |
567 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { | |
568 ptr[4*mb_x+0] = buffer[mb_x][0]; | |
569 ptr[4*mb_x+1] = buffer[mb_x][1]; | |
570 ptr[4*mb_x+2] = buffer[mb_x][2]; | |
571 } | |
572 } | |
573 } | |
574 return 0; | |
575 } | |
576 | |
577 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){ | |
578 int i, mb_x, mb_y; | |
579 const int nb_components=3; | |
580 | |
581 for(mb_y = 0; mb_y < s->mb_height; mb_y++) { | |
582 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { | |
583 if (s->restart_interval && !s->restart_count) | |
584 s->restart_count = s->restart_interval; | |
585 | |
586 if(mb_x==0 || mb_y==0 || s->interlaced){ | |
587 for(i=0;i<nb_components;i++) { | |
588 uint8_t *ptr; | |
589 int n, h, v, x, y, c, j, linesize; | |
590 n = s->nb_blocks[i]; | |
591 c = s->comp_index[i]; | |
592 h = s->h_scount[i]; | |
593 v = s->v_scount[i]; | |
594 x = 0; | |
595 y = 0; | |
596 linesize= s->linesize[c]; | |
597 | |
598 for(j=0; j<n; j++) { | |
599 int pred; | |
600 | |
601 ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap | |
602 if(y==0 && mb_y==0){ | |
603 if(x==0 && mb_x==0){ | |
604 pred= 128 << point_transform; | |
605 }else{ | |
606 pred= ptr[-1]; | |
607 } | |
608 }else{ | |
609 if(x==0 && mb_x==0){ | |
610 pred= ptr[-linesize]; | |
611 }else{ | |
612 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor); | |
613 } | |
614 } | |
615 | |
616 if (s->interlaced && s->bottom_field) | |
617 ptr += linesize >> 1; | |
618 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform); | |
619 | |
620 if (++x == h) { | |
621 x = 0; | |
622 y++; | |
623 } | |
624 } | |
625 } | |
626 }else{ | |
627 for(i=0;i<nb_components;i++) { | |
628 uint8_t *ptr; | |
629 int n, h, v, x, y, c, j, linesize; | |
630 n = s->nb_blocks[i]; | |
631 c = s->comp_index[i]; | |
632 h = s->h_scount[i]; | |
633 v = s->v_scount[i]; | |
634 x = 0; | |
635 y = 0; | |
636 linesize= s->linesize[c]; | |
637 | |
638 for(j=0; j<n; j++) { | |
639 int pred; | |
640 | |
641 ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap | |
642 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor); | |
643 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform); | |
644 if (++x == h) { | |
645 x = 0; | |
646 y++; | |
647 } | |
648 } | |
649 } | |
650 } | |
651 if (s->restart_interval && !--s->restart_count) { | |
652 align_get_bits(&s->gb); | |
653 skip_bits(&s->gb, 16); /* skip RSTn */ | |
654 } | |
655 } | |
656 } | |
657 return 0; | |
658 } | |
659 | |
660 static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int ss, int se, int Ah, int Al){ | |
661 int i, mb_x, mb_y; | |
662 int EOBRUN = 0; | |
5734 | 663 uint8_t* data[MAX_COMPONENTS]; |
664 int linesize[MAX_COMPONENTS]; | |
5020 | 665 |
666 if(Ah) return 0; /* TODO decode refinement planes too */ | |
5734 | 667 |
668 for(i=0; i < nb_components; i++) { | |
669 int c = s->comp_index[i]; | |
670 data[c] = s->picture.data[c]; | |
671 linesize[c]=s->linesize[c]; | |
5736 | 672 if(s->avctx->codec->id==CODEC_ID_AMV) { |
673 //picture should be flipped upside-down for this codec | |
5818 | 674 assert(!(s->avctx->flags & CODEC_FLAG_EMU_EDGE)); |
675 data[c] += (linesize[c] * (s->v_scount[i] * (8 * s->mb_height -((s->height/s->v_max)&7)) - 1 )); | |
5736 | 676 linesize[c] *= -1; |
677 } | |
5734 | 678 } |
679 | |
5020 | 680 for(mb_y = 0; mb_y < s->mb_height; mb_y++) { |
681 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { | |
682 if (s->restart_interval && !s->restart_count) | |
683 s->restart_count = s->restart_interval; | |
684 | |
685 for(i=0;i<nb_components;i++) { | |
686 uint8_t *ptr; | |
687 int n, h, v, x, y, c, j; | |
688 n = s->nb_blocks[i]; | |
689 c = s->comp_index[i]; | |
690 h = s->h_scount[i]; | |
691 v = s->v_scount[i]; | |
692 x = 0; | |
693 y = 0; | |
694 for(j=0;j<n;j++) { | |
695 memset(s->block, 0, sizeof(s->block)); | |
696 if (!s->progressive && decode_block(s, s->block, i, | |
697 s->dc_index[i], s->ac_index[i], | |
698 s->quant_matrixes[ s->quant_index[c] ]) < 0) { | |
699 av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x); | |
700 return -1; | |
701 } | |
702 if (s->progressive && decode_block_progressive(s, s->block, i, | |
703 s->dc_index[i], s->ac_index[i], | |
704 s->quant_matrixes[ s->quant_index[c] ], ss, se, Ah, Al, &EOBRUN) < 0) { | |
705 av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x); | |
706 return -1; | |
707 } | |
708 // av_log(s->avctx, AV_LOG_DEBUG, "mb: %d %d processed\n", mb_y, mb_x); | |
5734 | 709 ptr = data[c] + |
710 (((linesize[c] * (v * mb_y + y) * 8) + | |
5020 | 711 (h * mb_x + x) * 8) >> s->avctx->lowres); |
712 if (s->interlaced && s->bottom_field) | |
5734 | 713 ptr += linesize[c] >> 1; |
5020 | 714 //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); |
715 if(!s->progressive) | |
5734 | 716 s->dsp.idct_put(ptr, linesize[c], s->block); |
5020 | 717 else |
5734 | 718 s->dsp.idct_add(ptr, linesize[c], s->block); |
5020 | 719 if (++x == h) { |
720 x = 0; | |
721 y++; | |
722 } | |
723 } | |
724 } | |
725 /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */ | |
726 if (s->restart_interval && (s->restart_interval < 1350) && | |
727 !--s->restart_count) { | |
728 align_get_bits(&s->gb); | |
729 skip_bits(&s->gb, 16); /* skip RSTn */ | |
730 for (i=0; i<nb_components; i++) /* reset dc */ | |
731 s->last_dc[i] = 1024; | |
732 } | |
733 } | |
734 } | |
735 return 0; | |
736 } | |
737 | |
5044 | 738 int ff_mjpeg_decode_sos(MJpegDecodeContext *s) |
5020 | 739 { |
740 int len, nb_components, i, h, v, predictor, point_transform; | |
741 int vmax, hmax, index, id; | |
742 const int block_size= s->lossless ? 1 : 8; | |
743 int ilv, prev_shift; | |
744 | |
745 /* XXX: verify len field validity */ | |
746 len = get_bits(&s->gb, 16); | |
747 nb_components = get_bits(&s->gb, 8); | |
748 if (len != 6+2*nb_components) | |
749 { | |
750 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len); | |
751 return -1; | |
752 } | |
753 vmax = 0; | |
754 hmax = 0; | |
755 for(i=0;i<nb_components;i++) { | |
756 id = get_bits(&s->gb, 8) - 1; | |
757 av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id); | |
758 /* find component index */ | |
759 for(index=0;index<s->nb_components;index++) | |
760 if (id == s->component_id[index]) | |
761 break; | |
762 if (index == s->nb_components) | |
763 { | |
764 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: index(%d) out of components\n", index); | |
765 return -1; | |
766 } | |
767 | |
768 s->comp_index[i] = index; | |
769 | |
770 s->nb_blocks[i] = s->h_count[index] * s->v_count[index]; | |
771 s->h_scount[i] = s->h_count[index]; | |
772 s->v_scount[i] = s->v_count[index]; | |
773 | |
774 s->dc_index[i] = get_bits(&s->gb, 4); | |
775 s->ac_index[i] = get_bits(&s->gb, 4); | |
776 | |
777 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 || | |
778 s->dc_index[i] >= 4 || s->ac_index[i] >= 4) | |
779 goto out_of_range; | |
780 #if 0 //buggy | |
781 switch(s->start_code) | |
782 { | |
783 case SOF0: | |
784 if (dc_index[i] > 1 || ac_index[i] > 1) | |
785 goto out_of_range; | |
786 break; | |
787 case SOF1: | |
788 case SOF2: | |
789 if (dc_index[i] > 3 || ac_index[i] > 3) | |
790 goto out_of_range; | |
791 break; | |
792 case SOF3: | |
793 if (dc_index[i] > 3 || ac_index[i] != 0) | |
794 goto out_of_range; | |
795 break; | |
796 } | |
797 #endif | |
798 } | |
799 | |
800 predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */ | |
801 ilv= get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */ | |
802 prev_shift = get_bits(&s->gb, 4); /* Ah */ | |
803 point_transform= get_bits(&s->gb, 4); /* Al */ | |
804 | |
805 for(i=0;i<nb_components;i++) | |
806 s->last_dc[i] = 1024; | |
807 | |
808 if (nb_components > 1) { | |
809 /* interleaved stream */ | |
810 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size); | |
811 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size); | |
812 } else if(!s->ls) { /* skip this for JPEG-LS */ | |
813 h = s->h_max / s->h_scount[0]; | |
814 v = s->v_max / s->v_scount[0]; | |
815 s->mb_width = (s->width + h * block_size - 1) / (h * block_size); | |
816 s->mb_height = (s->height + v * block_size - 1) / (v * block_size); | |
817 s->nb_blocks[0] = 1; | |
818 s->h_scount[0] = 1; | |
819 s->v_scount[0] = 1; | |
820 } | |
821 | |
822 if(s->avctx->debug & FF_DEBUG_PICT_INFO) | |
823 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" : "", | |
824 predictor, point_transform, ilv, s->bits, | |
825 s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : "")); | |
826 | |
827 | |
828 /* mjpeg-b can have padding bytes between sos and image data, skip them */ | |
829 for (i = s->mjpb_skiptosod; i > 0; i--) | |
830 skip_bits(&s->gb, 8); | |
831 | |
832 if(s->lossless){ | |
5041 | 833 if(ENABLE_JPEGLS_DECODER && s->ls){ |
5020 | 834 // for(){ |
835 // reset_ls_coding_parameters(s, 0); | |
836 | |
837 ff_jpegls_decode_picture(s, predictor, point_transform, ilv); | |
838 }else{ | |
839 if(s->rgb){ | |
840 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0) | |
841 return -1; | |
842 }else{ | |
843 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0) | |
844 return -1; | |
845 } | |
846 } | |
847 }else{ | |
848 if(mjpeg_decode_scan(s, nb_components, predictor, ilv, prev_shift, point_transform) < 0) | |
849 return -1; | |
850 } | |
851 emms_c(); | |
852 return 0; | |
853 out_of_range: | |
854 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n"); | |
855 return -1; | |
856 } | |
857 | |
858 static int mjpeg_decode_dri(MJpegDecodeContext *s) | |
859 { | |
860 if (get_bits(&s->gb, 16) != 4) | |
861 return -1; | |
862 s->restart_interval = get_bits(&s->gb, 16); | |
863 s->restart_count = 0; | |
864 av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n", s->restart_interval); | |
865 | |
866 return 0; | |
867 } | |
868 | |
869 static int mjpeg_decode_app(MJpegDecodeContext *s) | |
870 { | |
871 int len, id, i; | |
872 | |
873 len = get_bits(&s->gb, 16); | |
874 if (len < 5) | |
875 return -1; | |
876 if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits) | |
877 return -1; | |
878 | |
879 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16); | |
880 id = be2me_32(id); | |
881 len -= 6; | |
882 | |
883 if(s->avctx->debug & FF_DEBUG_STARTCODE){ | |
884 av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id); | |
885 } | |
886 | |
887 /* buggy AVID, it puts EOI only at every 10th frame */ | |
888 /* also this fourcc is used by non-avid files too, it holds some | |
889 informations, but it's always present in AVID creates files */ | |
890 if (id == ff_get_fourcc("AVI1")) | |
891 { | |
892 /* structure: | |
893 4bytes AVI1 | |
894 1bytes polarity | |
895 1bytes always zero | |
896 4bytes field_size | |
897 4bytes field_size_less_padding | |
898 */ | |
899 s->buggy_avid = 1; | |
900 // if (s->first_picture) | |
901 // printf("mjpeg: workarounding buggy AVID\n"); | |
902 i = get_bits(&s->gb, 8); | |
903 if (i==2) s->bottom_field= 1; | |
904 else if(i==1) s->bottom_field= 0; | |
905 #if 0 | |
906 skip_bits(&s->gb, 8); | |
907 skip_bits(&s->gb, 32); | |
908 skip_bits(&s->gb, 32); | |
909 len -= 10; | |
910 #endif | |
911 // if (s->interlace_polarity) | |
912 // printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity); | |
913 goto out; | |
914 } | |
915 | |
916 // len -= 2; | |
917 | |
918 if (id == ff_get_fourcc("JFIF")) | |
919 { | |
920 int t_w, t_h, v1, v2; | |
921 skip_bits(&s->gb, 8); /* the trailing zero-byte */ | |
922 v1= get_bits(&s->gb, 8); | |
923 v2= get_bits(&s->gb, 8); | |
924 skip_bits(&s->gb, 8); | |
925 | |
926 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16); | |
927 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16); | |
928 | |
929 if (s->avctx->debug & FF_DEBUG_PICT_INFO) | |
930 av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n", | |
931 v1, v2, | |
932 s->avctx->sample_aspect_ratio.num, | |
933 s->avctx->sample_aspect_ratio.den | |
934 ); | |
935 | |
936 t_w = get_bits(&s->gb, 8); | |
937 t_h = get_bits(&s->gb, 8); | |
938 if (t_w && t_h) | |
939 { | |
940 /* skip thumbnail */ | |
941 if (len-10-(t_w*t_h*3) > 0) | |
942 len -= t_w*t_h*3; | |
943 } | |
944 len -= 10; | |
945 goto out; | |
946 } | |
947 | |
948 if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e')) | |
949 { | |
950 if (s->avctx->debug & FF_DEBUG_PICT_INFO) | |
951 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n"); | |
952 skip_bits(&s->gb, 16); /* version */ | |
953 skip_bits(&s->gb, 16); /* flags0 */ | |
954 skip_bits(&s->gb, 16); /* flags1 */ | |
955 skip_bits(&s->gb, 8); /* transform */ | |
956 len -= 7; | |
957 goto out; | |
958 } | |
959 | |
960 if (id == ff_get_fourcc("LJIF")){ | |
961 if (s->avctx->debug & FF_DEBUG_PICT_INFO) | |
962 av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n"); | |
963 skip_bits(&s->gb, 16); /* version ? */ | |
964 skip_bits(&s->gb, 16); /* unknwon always 0? */ | |
965 skip_bits(&s->gb, 16); /* unknwon always 0? */ | |
966 skip_bits(&s->gb, 16); /* unknwon always 0? */ | |
967 switch( get_bits(&s->gb, 8)){ | |
968 case 1: | |
969 s->rgb= 1; | |
970 s->pegasus_rct=0; | |
971 break; | |
972 case 2: | |
973 s->rgb= 1; | |
974 s->pegasus_rct=1; | |
975 break; | |
976 default: | |
977 av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n"); | |
978 } | |
979 len -= 9; | |
980 goto out; | |
981 } | |
982 | |
983 /* Apple MJPEG-A */ | |
984 if ((s->start_code == APP1) && (len > (0x28 - 8))) | |
985 { | |
986 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16); | |
987 id = be2me_32(id); | |
988 len -= 4; | |
989 if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */ | |
990 { | |
991 #if 0 | |
992 skip_bits(&s->gb, 32); /* field size */ | |
993 skip_bits(&s->gb, 32); /* pad field size */ | |
994 skip_bits(&s->gb, 32); /* next off */ | |
995 skip_bits(&s->gb, 32); /* quant off */ | |
996 skip_bits(&s->gb, 32); /* huff off */ | |
997 skip_bits(&s->gb, 32); /* image off */ | |
998 skip_bits(&s->gb, 32); /* scan off */ | |
999 skip_bits(&s->gb, 32); /* data off */ | |
1000 #endif | |
1001 if (s->avctx->debug & FF_DEBUG_PICT_INFO) | |
1002 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n"); | |
1003 } | |
1004 } | |
1005 | |
1006 out: | |
1007 /* slow but needed for extreme adobe jpegs */ | |
1008 if (len < 0) | |
1009 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n"); | |
1010 while(--len > 0) | |
1011 skip_bits(&s->gb, 8); | |
1012 | |
1013 return 0; | |
1014 } | |
1015 | |
1016 static int mjpeg_decode_com(MJpegDecodeContext *s) | |
1017 { | |
1018 int len = get_bits(&s->gb, 16); | |
1019 if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) { | |
1020 char *cbuf = av_malloc(len - 1); | |
1021 if (cbuf) { | |
1022 int i; | |
1023 for (i = 0; i < len - 2; i++) | |
1024 cbuf[i] = get_bits(&s->gb, 8); | |
1025 if (i > 0 && cbuf[i-1] == '\n') | |
1026 cbuf[i-1] = 0; | |
1027 else | |
1028 cbuf[i] = 0; | |
1029 | |
1030 if(s->avctx->debug & FF_DEBUG_PICT_INFO) | |
1031 av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf); | |
1032 | |
1033 /* buggy avid, it puts EOI only at every 10th frame */ | |
1034 if (!strcmp(cbuf, "AVID")) | |
1035 { | |
1036 s->buggy_avid = 1; | |
1037 // if (s->first_picture) | |
1038 // printf("mjpeg: workarounding buggy AVID\n"); | |
1039 } | |
1040 else if(!strcmp(cbuf, "CS=ITU601")){ | |
1041 s->cs_itu601= 1; | |
1042 } | |
1043 | |
1044 av_free(cbuf); | |
1045 } | |
1046 } | |
1047 | |
1048 return 0; | |
1049 } | |
1050 | |
1051 #if 0 | |
1052 static int valid_marker_list[] = | |
1053 { | |
1054 /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */ | |
1055 /* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
1056 /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
1057 /* 2 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
1058 /* 3 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
1059 /* 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
1060 /* 5 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
1061 /* 6 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
1062 /* 7 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
1063 /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
1064 /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
1065 /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
1066 /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
1067 /* c */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
1068 /* d */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
1069 /* e */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
1070 /* f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, | |
1071 } | |
1072 #endif | |
1073 | |
1074 /* return the 8 bit start code value and update the search | |
1075 state. Return -1 if no start code found */ | |
1076 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end) | |
1077 { | |
1078 uint8_t *buf_ptr; | |
1079 unsigned int v, v2; | |
1080 int val; | |
1081 #ifdef DEBUG | |
1082 int skipped=0; | |
1083 #endif | |
1084 | |
1085 buf_ptr = *pbuf_ptr; | |
1086 while (buf_ptr < buf_end) { | |
1087 v = *buf_ptr++; | |
1088 v2 = *buf_ptr; | |
1089 if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) { | |
1090 val = *buf_ptr++; | |
1091 goto found; | |
1092 } | |
1093 #ifdef DEBUG | |
1094 skipped++; | |
1095 #endif | |
1096 } | |
1097 val = -1; | |
1098 found: | |
1099 #ifdef DEBUG | |
1100 av_log(NULL, AV_LOG_VERBOSE, "find_marker skipped %d bytes\n", skipped); | |
1101 #endif | |
1102 *pbuf_ptr = buf_ptr; | |
1103 return val; | |
1104 } | |
1105 | |
5041 | 1106 int ff_mjpeg_decode_frame(AVCodecContext *avctx, |
5020 | 1107 void *data, int *data_size, |
1108 uint8_t *buf, int buf_size) | |
1109 { | |
1110 MJpegDecodeContext *s = avctx->priv_data; | |
1111 uint8_t *buf_end, *buf_ptr; | |
1112 int start_code; | |
1113 AVFrame *picture = data; | |
1114 | |
1115 buf_ptr = buf; | |
1116 buf_end = buf + buf_size; | |
1117 while (buf_ptr < buf_end) { | |
1118 /* find start next marker */ | |
1119 start_code = find_marker(&buf_ptr, buf_end); | |
1120 { | |
1121 /* EOF */ | |
1122 if (start_code < 0) { | |
1123 goto the_end; | |
1124 } else { | |
5153 | 1125 av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%td\n", start_code, buf_end - buf_ptr); |
5020 | 1126 |
1127 if ((buf_end - buf_ptr) > s->buffer_size) | |
1128 { | |
1129 av_free(s->buffer); | |
1130 s->buffer_size = buf_end-buf_ptr; | |
1131 s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE); | |
1132 av_log(avctx, AV_LOG_DEBUG, "buffer too small, expanding to %d bytes\n", | |
1133 s->buffer_size); | |
1134 } | |
1135 | |
1136 /* unescape buffer of SOS, use special treatment for JPEG-LS */ | |
1137 if (start_code == SOS && !s->ls) | |
1138 { | |
1139 uint8_t *src = buf_ptr; | |
1140 uint8_t *dst = s->buffer; | |
1141 | |
1142 while (src<buf_end) | |
1143 { | |
1144 uint8_t x = *(src++); | |
1145 | |
1146 *(dst++) = x; | |
1147 if (avctx->codec_id != CODEC_ID_THP) | |
1148 { | |
1149 if (x == 0xff) { | |
1150 while (src < buf_end && x == 0xff) | |
1151 x = *(src++); | |
1152 | |
1153 if (x >= 0xd0 && x <= 0xd7) | |
1154 *(dst++) = x; | |
1155 else if (x) | |
1156 break; | |
1157 } | |
1158 } | |
1159 } | |
1160 init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8); | |
1161 | |
5153 | 1162 av_log(avctx, AV_LOG_DEBUG, "escaping removed %td bytes\n", |
5020 | 1163 (buf_end - buf_ptr) - (dst - s->buffer)); |
1164 } | |
1165 else if(start_code == SOS && s->ls){ | |
1166 uint8_t *src = buf_ptr; | |
1167 uint8_t *dst = s->buffer; | |
1168 int bit_count = 0; | |
1169 int t = 0, b = 0; | |
1170 PutBitContext pb; | |
1171 | |
1172 s->cur_scan++; | |
1173 | |
1174 /* find marker */ | |
1175 while (src + t < buf_end){ | |
1176 uint8_t x = src[t++]; | |
1177 if (x == 0xff){ | |
1178 while((src + t < buf_end) && x == 0xff) | |
1179 x = src[t++]; | |
1180 if (x & 0x80) { | |
1181 t -= 2; | |
1182 break; | |
1183 } | |
1184 } | |
1185 } | |
1186 bit_count = t * 8; | |
1187 | |
1188 init_put_bits(&pb, dst, t); | |
1189 | |
1190 /* unescape bitstream */ | |
1191 while(b < t){ | |
1192 uint8_t x = src[b++]; | |
1193 put_bits(&pb, 8, x); | |
1194 if(x == 0xFF){ | |
1195 x = src[b++]; | |
1196 put_bits(&pb, 7, x); | |
1197 bit_count--; | |
1198 } | |
1199 } | |
1200 flush_put_bits(&pb); | |
1201 | |
1202 init_get_bits(&s->gb, dst, bit_count); | |
1203 } | |
1204 else | |
1205 init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8); | |
1206 | |
1207 s->start_code = start_code; | |
1208 if(s->avctx->debug & FF_DEBUG_STARTCODE){ | |
1209 av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code); | |
1210 } | |
1211 | |
1212 /* process markers */ | |
1213 if (start_code >= 0xd0 && start_code <= 0xd7) { | |
1214 av_log(avctx, AV_LOG_DEBUG, "restart marker: %d\n", start_code&0x0f); | |
1215 /* APP fields */ | |
1216 } else if (start_code >= APP0 && start_code <= APP15) { | |
1217 mjpeg_decode_app(s); | |
1218 /* Comment */ | |
1219 } else if (start_code == COM){ | |
1220 mjpeg_decode_com(s); | |
1221 } | |
1222 | |
1223 switch(start_code) { | |
1224 case SOI: | |
1225 s->restart_interval = 0; | |
1226 | |
1227 s->restart_count = 0; | |
1228 /* nothing to do on SOI */ | |
1229 break; | |
1230 case DQT: | |
5044 | 1231 ff_mjpeg_decode_dqt(s); |
5020 | 1232 break; |
1233 case DHT: | |
5044 | 1234 if(ff_mjpeg_decode_dht(s) < 0){ |
5020 | 1235 av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n"); |
1236 return -1; | |
1237 } | |
1238 break; | |
1239 case SOF0: | |
1240 s->lossless=0; | |
1241 s->ls=0; | |
1242 s->progressive=0; | |
5044 | 1243 if (ff_mjpeg_decode_sof(s) < 0) |
5020 | 1244 return -1; |
1245 break; | |
1246 case SOF2: | |
1247 s->lossless=0; | |
1248 s->ls=0; | |
1249 s->progressive=1; | |
5044 | 1250 if (ff_mjpeg_decode_sof(s) < 0) |
5020 | 1251 return -1; |
1252 break; | |
1253 case SOF3: | |
1254 s->lossless=1; | |
1255 s->ls=0; | |
1256 s->progressive=0; | |
5044 | 1257 if (ff_mjpeg_decode_sof(s) < 0) |
5020 | 1258 return -1; |
1259 break; | |
1260 case SOF48: | |
1261 s->lossless=1; | |
1262 s->ls=1; | |
1263 s->progressive=0; | |
5044 | 1264 if (ff_mjpeg_decode_sof(s) < 0) |
5020 | 1265 return -1; |
1266 break; | |
1267 case LSE: | |
5041 | 1268 if (!ENABLE_JPEGLS_DECODER || ff_jpegls_decode_lse(s) < 0) |
5020 | 1269 return -1; |
1270 break; | |
1271 case EOI: | |
1272 s->cur_scan = 0; | |
1273 if ((s->buggy_avid && !s->interlaced) || s->restart_interval) | |
1274 break; | |
1275 eoi_parser: | |
1276 { | |
1277 if (s->interlaced) { | |
1278 s->bottom_field ^= 1; | |
1279 /* if not bottom field, do not output image yet */ | |
1280 if (s->bottom_field == !s->interlace_polarity) | |
1281 goto not_the_end; | |
1282 } | |
1283 *picture = s->picture; | |
1284 *data_size = sizeof(AVFrame); | |
1285 | |
1286 if(!s->lossless){ | |
1287 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); | |
1288 picture->qstride= 0; | |
1289 picture->qscale_table= s->qscale_table; | |
1290 memset(picture->qscale_table, picture->quality, (s->width+15)/16); | |
1291 if(avctx->debug & FF_DEBUG_QP) | |
1292 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality); | |
1293 picture->quality*= FF_QP2LAMBDA; | |
1294 } | |
1295 | |
1296 goto the_end; | |
1297 } | |
1298 break; | |
1299 case SOS: | |
5044 | 1300 ff_mjpeg_decode_sos(s); |
5020 | 1301 /* buggy avid puts EOI every 10-20th frame */ |
1302 /* if restart period is over process EOI */ | |
1303 if ((s->buggy_avid && !s->interlaced) || s->restart_interval) | |
1304 goto eoi_parser; | |
1305 break; | |
1306 case DRI: | |
1307 mjpeg_decode_dri(s); | |
1308 break; | |
1309 case SOF1: | |
1310 case SOF5: | |
1311 case SOF6: | |
1312 case SOF7: | |
1313 case SOF9: | |
1314 case SOF10: | |
1315 case SOF11: | |
1316 case SOF13: | |
1317 case SOF14: | |
1318 case SOF15: | |
1319 case JPG: | |
1320 av_log(avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code); | |
1321 break; | |
1322 // default: | |
1323 // printf("mjpeg: unsupported marker (%x)\n", start_code); | |
1324 // break; | |
1325 } | |
1326 | |
1327 not_the_end: | |
1328 /* eof process start code */ | |
1329 buf_ptr += (get_bits_count(&s->gb)+7)/8; | |
1330 av_log(avctx, AV_LOG_DEBUG, "marker parser used %d bytes (%d bits)\n", | |
1331 (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb)); | |
1332 } | |
1333 } | |
1334 } | |
1335 the_end: | |
5153 | 1336 av_log(avctx, AV_LOG_DEBUG, "mjpeg decode frame unused %td bytes\n", buf_end - buf_ptr); |
5020 | 1337 // return buf_end - buf_ptr; |
1338 return buf_ptr - buf; | |
1339 } | |
1340 | |
5041 | 1341 int ff_mjpeg_decode_end(AVCodecContext *avctx) |
5020 | 1342 { |
1343 MJpegDecodeContext *s = avctx->priv_data; | |
1344 int i, j; | |
1345 | |
1346 av_free(s->buffer); | |
1347 av_free(s->qscale_table); | |
1348 | |
1349 for(i=0;i<2;i++) { | |
1350 for(j=0;j<4;j++) | |
1351 free_vlc(&s->vlcs[i][j]); | |
1352 } | |
1353 return 0; | |
1354 } | |
1355 | |
1356 AVCodec mjpeg_decoder = { | |
1357 "mjpeg", | |
1358 CODEC_TYPE_VIDEO, | |
1359 CODEC_ID_MJPEG, | |
1360 sizeof(MJpegDecodeContext), | |
5041 | 1361 ff_mjpeg_decode_init, |
5020 | 1362 NULL, |
5041 | 1363 ff_mjpeg_decode_end, |
1364 ff_mjpeg_decode_frame, | |
5020 | 1365 CODEC_CAP_DR1, |
1366 NULL | |
1367 }; | |
1368 | |
1369 AVCodec thp_decoder = { | |
1370 "thp", | |
1371 CODEC_TYPE_VIDEO, | |
1372 CODEC_ID_THP, | |
1373 sizeof(MJpegDecodeContext), | |
5041 | 1374 ff_mjpeg_decode_init, |
5020 | 1375 NULL, |
5041 | 1376 ff_mjpeg_decode_end, |
1377 ff_mjpeg_decode_frame, | |
5020 | 1378 CODEC_CAP_DR1, |
1379 NULL | |
1380 }; |