Mercurial > libavcodec.hg
annotate mjpegdec.c @ 12043:f9a0bd0888a4 libavcodec
mpegaudio: call ff_mpegaudiodec_init_mmx() only from float decoder
The mmx code is floating-point only, and this function does not know
from which decoder it is called. Without this change, the integer
decoder only "works" because the size of the context struct is smaller
in this case, and the mmx init function writes the function pointer
outside the allocated context.
author | mru |
---|---|
date | Thu, 01 Jul 2010 23:21:17 +0000 |
parents | 7dd2a45249a9 |
children | c35d7bc64882 |
rev | line source |
---|---|
5020 | 1 /* |
2 * MJPEG decoder | |
8629
04423b2f6e0b
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
8612
diff
changeset
|
3 * Copyright (c) 2000, 2001 Fabrice Bellard |
5020 | 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 /** | |
11644
7dd2a45249a9
Remove explicit filename from Doxygen @file commands.
diego
parents:
11560
diff
changeset
|
29 * @file |
5020 | 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, |
7136 | 67 ff_mjpeg_val_dc, 12, 0, 0); |
5068
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, |
7136 | 69 ff_mjpeg_val_dc, 12, 0, 0); |
5068
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 |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6448
diff
changeset
|
76 av_cold 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; | |
9626
bd3e11b60ccd
Add a chroma_sample_location field to define positioning of chroma samples
conrad
parents:
9459
diff
changeset
|
88 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER; |
5020 | 89 |
5068
93e369c55c31
fix mjpeg decoding with broken huffman table headers
ods15
parents:
5044
diff
changeset
|
90 build_basic_mjpeg_vlc(s); |
5020 | 91 |
92 if (avctx->flags & CODEC_FLAG_EXTERN_HUFF) | |
93 { | |
94 av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n"); | |
95 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
|
96 if (ff_mjpeg_decode_dht(s)) { |
93e369c55c31
fix mjpeg decoding with broken huffman table headers
ods15
parents:
5044
diff
changeset
|
97 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
|
98 build_basic_mjpeg_vlc(s); |
93e369c55c31
fix mjpeg decoding with broken huffman table headers
ods15
parents:
5044
diff
changeset
|
99 } |
5020 | 100 } |
101 if (avctx->extradata_size > 9 && | |
102 AV_RL32(avctx->extradata + 4) == MKTAG('f','i','e','l')) { | |
103 if (avctx->extradata[9] == 6) { /* quicktime icefloe 019 */ | |
104 s->interlace_polarity = 1; /* bottom field first */ | |
105 av_log(avctx, AV_LOG_DEBUG, "mjpeg bottom field first\n"); | |
106 } | |
107 } | |
10438
710e226783f0
Flip (M)JPEG frames encoded by Intel JPEG library.
cehoyos
parents:
10412
diff
changeset
|
108 if (avctx->codec->id == CODEC_ID_AMV) |
710e226783f0
Flip (M)JPEG frames encoded by Intel JPEG library.
cehoyos
parents:
10412
diff
changeset
|
109 s->flipped = 1; |
5020 | 110 |
111 return 0; | |
112 } | |
113 | |
114 | |
115 /* quantize tables */ | |
5044 | 116 int ff_mjpeg_decode_dqt(MJpegDecodeContext *s) |
5020 | 117 { |
118 int len, index, i, j; | |
119 | |
120 len = get_bits(&s->gb, 16) - 2; | |
121 | |
122 while (len >= 65) { | |
123 /* only 8 bit precision handled */ | |
124 if (get_bits(&s->gb, 4) != 0) | |
125 { | |
126 av_log(s->avctx, AV_LOG_ERROR, "dqt: 16bit precision\n"); | |
127 return -1; | |
128 } | |
129 index = get_bits(&s->gb, 4); | |
130 if (index >= 4) | |
131 return -1; | |
132 av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index); | |
133 /* read quant table */ | |
134 for(i=0;i<64;i++) { | |
135 j = s->scantable.permutated[i]; | |
136 s->quant_matrixes[index][j] = get_bits(&s->gb, 8); | |
137 } | |
138 | |
139 //XXX FIXME finetune, and perhaps add dc too | |
140 s->qscale[index]= FFMAX( | |
141 s->quant_matrixes[index][s->scantable.permutated[1]], | |
142 s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1; | |
143 av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n", index, s->qscale[index]); | |
144 len -= 65; | |
145 } | |
146 | |
147 return 0; | |
148 } | |
149 | |
150 /* decode huffman tables and build VLC decoders */ | |
5044 | 151 int ff_mjpeg_decode_dht(MJpegDecodeContext *s) |
5020 | 152 { |
153 int len, index, i, class, n, v, code_max; | |
154 uint8_t bits_table[17]; | |
155 uint8_t val_table[256]; | |
156 | |
157 len = get_bits(&s->gb, 16) - 2; | |
158 | |
159 while (len > 0) { | |
160 if (len < 17) | |
161 return -1; | |
162 class = get_bits(&s->gb, 4); | |
163 if (class >= 2) | |
164 return -1; | |
165 index = get_bits(&s->gb, 4); | |
166 if (index >= 4) | |
167 return -1; | |
168 n = 0; | |
169 for(i=1;i<=16;i++) { | |
170 bits_table[i] = get_bits(&s->gb, 8); | |
171 n += bits_table[i]; | |
172 } | |
173 len -= 17; | |
174 if (len < n || n > 256) | |
175 return -1; | |
176 | |
177 code_max = 0; | |
178 for(i=0;i<n;i++) { | |
179 v = get_bits(&s->gb, 8); | |
180 if (v > code_max) | |
181 code_max = v; | |
182 val_table[i] = v; | |
183 } | |
184 len -= n; | |
185 | |
186 /* build VLC and flush previous vlc if present */ | |
187 free_vlc(&s->vlcs[class][index]); | |
188 av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n", | |
189 class, index, code_max + 1); | |
190 if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0, class > 0) < 0){ | |
191 return -1; | |
192 } | |
193 } | |
194 return 0; | |
195 } | |
196 | |
5044 | 197 int ff_mjpeg_decode_sof(MJpegDecodeContext *s) |
5020 | 198 { |
199 int len, nb_components, i, width, height, pix_fmt_id; | |
200 | |
201 /* XXX: verify len field validity */ | |
202 len = get_bits(&s->gb, 16); | |
203 s->bits= get_bits(&s->gb, 8); | |
204 | |
205 if(s->pegasus_rct) s->bits=9; | |
206 if(s->bits==9 && !s->pegasus_rct) s->rct=1; //FIXME ugly | |
207 | |
208 if (s->bits != 8 && !s->lossless){ | |
209 av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n"); | |
210 return -1; | |
211 } | |
212 | |
213 height = get_bits(&s->gb, 16); | |
214 width = get_bits(&s->gb, 16); | |
215 | |
216 //HACK for odd_height.mov | |
217 if(s->interlaced && s->width == width && s->height == height + 1) | |
218 height= s->height; | |
219 | |
220 av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height); | |
221 if(avcodec_check_dimensions(s->avctx, width, height)) | |
222 return -1; | |
223 | |
224 nb_components = get_bits(&s->gb, 8); | |
225 if (nb_components <= 0 || | |
226 nb_components > MAX_COMPONENTS) | |
227 return -1; | |
228 if (s->ls && !(s->bits <= 8 || nb_components == 1)){ | |
229 av_log(s->avctx, AV_LOG_ERROR, "only <= 8 bits/component or 16-bit gray accepted for JPEG-LS\n"); | |
230 return -1; | |
231 } | |
232 s->nb_components = nb_components; | |
233 s->h_max = 1; | |
234 s->v_max = 1; | |
235 for(i=0;i<nb_components;i++) { | |
236 /* component id */ | |
237 s->component_id[i] = get_bits(&s->gb, 8) - 1; | |
238 s->h_count[i] = get_bits(&s->gb, 4); | |
239 s->v_count[i] = get_bits(&s->gb, 4); | |
240 /* compute hmax and vmax (only used in interleaved case) */ | |
241 if (s->h_count[i] > s->h_max) | |
242 s->h_max = s->h_count[i]; | |
243 if (s->v_count[i] > s->v_max) | |
244 s->v_max = s->v_count[i]; | |
245 s->quant_index[i] = get_bits(&s->gb, 8); | |
246 if (s->quant_index[i] >= 4) | |
247 return -1; | |
248 av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n", i, s->h_count[i], | |
249 s->v_count[i], s->component_id[i], s->quant_index[i]); | |
250 } | |
251 | |
252 if(s->ls && (s->h_max > 1 || s->v_max > 1)) { | |
253 av_log(s->avctx, AV_LOG_ERROR, "Subsampling in JPEG-LS is not supported.\n"); | |
254 return -1; | |
255 } | |
256 | |
257 if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1; | |
258 | |
259 /* if different size, realloc/alloc picture */ | |
260 /* XXX: also check h_count and v_count */ | |
261 if (width != s->width || height != s->height) { | |
262 av_freep(&s->qscale_table); | |
263 | |
264 s->width = width; | |
265 s->height = height; | |
266 s->interlaced = 0; | |
267 | |
268 /* test interlaced mode */ | |
269 if (s->first_picture && | |
270 s->org_height != 0 && | |
271 s->height < ((s->org_height * 3) / 4)) { | |
272 s->interlaced = 1; | |
273 s->bottom_field = s->interlace_polarity; | |
274 s->picture.interlaced_frame = 1; | |
275 s->picture.top_field_first = !s->interlace_polarity; | |
276 height *= 2; | |
277 } | |
278 | |
279 avcodec_set_dimensions(s->avctx, width, height); | |
280 | |
281 s->qscale_table= av_mallocz((s->width+15)/16); | |
282 | |
283 s->first_picture = 0; | |
284 } | |
285 | |
286 if(s->interlaced && (s->bottom_field == !s->interlace_polarity)) | |
287 return 0; | |
288 | |
289 /* XXX: not complete test ! */ | |
7930
fae5e74eef1b
Check the 4th plane too when selecting the pixfmt.
michael
parents:
7478
diff
changeset
|
290 pix_fmt_id = (s->h_count[0] << 28) | (s->v_count[0] << 24) | |
fae5e74eef1b
Check the 4th plane too when selecting the pixfmt.
michael
parents:
7478
diff
changeset
|
291 (s->h_count[1] << 20) | (s->v_count[1] << 16) | |
fae5e74eef1b
Check the 4th plane too when selecting the pixfmt.
michael
parents:
7478
diff
changeset
|
292 (s->h_count[2] << 12) | (s->v_count[2] << 8) | |
fae5e74eef1b
Check the 4th plane too when selecting the pixfmt.
michael
parents:
7478
diff
changeset
|
293 (s->h_count[3] << 4) | s->v_count[3]; |
5020 | 294 av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id); |
10549 | 295 //NOTE we do not allocate pictures large enough for the possible padding of h/v_count being 4 |
296 if(!(pix_fmt_id & 0xD0D0D0D0)) | |
7931
fd6c05a225aa
Simplify pix_fmt_id instead of listing a subset of non-simplified ones.
michael
parents:
7930
diff
changeset
|
297 pix_fmt_id-= (pix_fmt_id & 0xF0F0F0F0)>>1; |
10549 | 298 if(!(pix_fmt_id & 0x0D0D0D0D)) |
7931
fd6c05a225aa
Simplify pix_fmt_id instead of listing a subset of non-simplified ones.
michael
parents:
7930
diff
changeset
|
299 pix_fmt_id-= (pix_fmt_id & 0x0F0F0F0F)>>1; |
fd6c05a225aa
Simplify pix_fmt_id instead of listing a subset of non-simplified ones.
michael
parents:
7930
diff
changeset
|
300 |
5020 | 301 switch(pix_fmt_id){ |
7930
fae5e74eef1b
Check the 4th plane too when selecting the pixfmt.
michael
parents:
7478
diff
changeset
|
302 case 0x11111100: |
5020 | 303 if(s->rgb){ |
10666
7127645ee791
Lossless jpeg expects and uses BGRA not RGB32 (this probably caused a problem on
michael
parents:
10549
diff
changeset
|
304 s->avctx->pix_fmt = PIX_FMT_BGRA; |
7932
7729da3e4866
Replace apparently always true condition by assert().
michael
parents:
7931
diff
changeset
|
305 }else |
5020 | 306 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P; |
7932
7729da3e4866
Replace apparently always true condition by assert().
michael
parents:
7931
diff
changeset
|
307 assert(s->nb_components==3); |
5020 | 308 break; |
7930
fae5e74eef1b
Check the 4th plane too when selecting the pixfmt.
michael
parents:
7478
diff
changeset
|
309 case 0x11000000: |
5478
41103dc22ad5
Add support for grayscale MJPEG streams sent by Axis cameras such as the
diego
parents:
5381
diff
changeset
|
310 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
|
311 break; |
7930
fae5e74eef1b
Check the 4th plane too when selecting the pixfmt.
michael
parents:
7478
diff
changeset
|
312 case 0x12111100: |
5363 | 313 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV440P : PIX_FMT_YUVJ440P; |
314 break; | |
7930
fae5e74eef1b
Check the 4th plane too when selecting the pixfmt.
michael
parents:
7478
diff
changeset
|
315 case 0x21111100: |
5020 | 316 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P; |
317 break; | |
7930
fae5e74eef1b
Check the 4th plane too when selecting the pixfmt.
michael
parents:
7478
diff
changeset
|
318 case 0x22111100: |
5020 | 319 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P; |
320 break; | |
5381
4cac2cfe2745
bail out on unknown jpeg pixel format instead of silently decoding data incorrectly
gpoirier
parents:
5363
diff
changeset
|
321 default: |
4cac2cfe2745
bail out on unknown jpeg pixel format instead of silently decoding data incorrectly
gpoirier
parents:
5363
diff
changeset
|
322 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
|
323 return -1; |
5020 | 324 } |
325 if(s->ls){ | |
326 if(s->nb_components > 1) | |
327 s->avctx->pix_fmt = PIX_FMT_RGB24; | |
328 else if(s->bits <= 8) | |
329 s->avctx->pix_fmt = PIX_FMT_GRAY8; | |
330 else | |
331 s->avctx->pix_fmt = PIX_FMT_GRAY16; | |
332 } | |
333 | |
334 if(s->picture.data[0]) | |
335 s->avctx->release_buffer(s->avctx, &s->picture); | |
336 | |
337 s->picture.reference= 0; | |
338 if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){ | |
339 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n"); | |
340 return -1; | |
341 } | |
6448
7fa807dd7958
remove #include "mpegvideo.h" where it is not needed
aurel
parents:
6222
diff
changeset
|
342 s->picture.pict_type= FF_I_TYPE; |
5020 | 343 s->picture.key_frame= 1; |
9913
b73796e93571
Add a got_picture flag to MJpegDecodeContext which indicates if its picture
reimar
parents:
9912
diff
changeset
|
344 s->got_picture = 1; |
5020 | 345 |
346 for(i=0; i<3; i++){ | |
347 s->linesize[i]= s->picture.linesize[i] << s->interlaced; | |
348 } | |
349 | |
350 // printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height); | |
351 | |
352 if (len != (8+(3*nb_components))) | |
353 { | |
354 av_log(s->avctx, AV_LOG_DEBUG, "decode_sof0: error, len(%d) mismatch\n", len); | |
355 } | |
356 | |
357 /* totally blank picture as progressive JPEG will only add details to it */ | |
358 if(s->progressive){ | |
8287 | 359 int bw = (width + s->h_max*8-1) / (s->h_max*8); |
360 int bh = (height + s->v_max*8-1) / (s->v_max*8); | |
361 for(i=0; i<s->nb_components; i++) { | |
362 int size = bw * bh * s->h_count[i] * s->v_count[i]; | |
363 av_freep(&s->blocks[i]); | |
364 av_freep(&s->last_nnz[i]); | |
365 s->blocks[i] = av_malloc(size * sizeof(**s->blocks)); | |
366 s->last_nnz[i] = av_mallocz(size * sizeof(**s->last_nnz)); | |
367 s->block_stride[i] = bw * s->h_count[i]; | |
368 } | |
369 memset(s->coefs_finished, 0, sizeof(s->coefs_finished)); | |
5020 | 370 } |
371 return 0; | |
372 } | |
373 | |
374 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index) | |
375 { | |
376 int code; | |
377 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2); | |
378 if (code < 0) | |
379 { | |
380 av_log(s->avctx, AV_LOG_WARNING, "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index, | |
381 &s->vlcs[0][dc_index]); | |
382 return 0xffff; | |
383 } | |
384 | |
385 if(code) | |
386 return get_xbits(&s->gb, code); | |
387 else | |
388 return 0; | |
389 } | |
390 | |
391 /* decode block and dequantize */ | |
392 static int decode_block(MJpegDecodeContext *s, DCTELEM *block, | |
393 int component, int dc_index, int ac_index, int16_t *quant_matrix) | |
394 { | |
395 int code, i, j, level, val; | |
396 | |
397 /* DC coef */ | |
398 val = mjpeg_decode_dc(s, dc_index); | |
399 if (val == 0xffff) { | |
400 av_log(s->avctx, AV_LOG_ERROR, "error dc\n"); | |
401 return -1; | |
402 } | |
403 val = val * quant_matrix[0] + s->last_dc[component]; | |
404 s->last_dc[component] = val; | |
405 block[0] = val; | |
406 /* AC coefs */ | |
407 i = 0; | |
408 {OPEN_READER(re, &s->gb) | |
409 for(;;) { | |
410 UPDATE_CACHE(re, &s->gb); | |
411 GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2) | |
412 | |
413 /* EOB */ | |
414 if (code == 0x10) | |
415 break; | |
416 i += ((unsigned)code) >> 4; | |
417 if(code != 0x100){ | |
418 code &= 0xf; | |
419 if(code > MIN_CACHE_BITS - 16){ | |
420 UPDATE_CACHE(re, &s->gb) | |
421 } | |
422 { | |
423 int cache=GET_CACHE(re,&s->gb); | |
424 int sign=(~cache)>>31; | |
425 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign; | |
426 } | |
427 | |
428 LAST_SKIP_BITS(re, &s->gb, code) | |
429 | |
430 if (i >= 63) { | |
431 if(i == 63){ | |
432 j = s->scantable.permutated[63]; | |
433 block[j] = level * quant_matrix[j]; | |
434 break; | |
435 } | |
436 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); | |
437 return -1; | |
438 } | |
439 j = s->scantable.permutated[i]; | |
440 block[j] = level * quant_matrix[j]; | |
441 } | |
442 } | |
443 CLOSE_READER(re, &s->gb)} | |
444 | |
445 return 0; | |
446 } | |
447 | |
8287 | 448 static int decode_dc_progressive(MJpegDecodeContext *s, DCTELEM *block, int component, |
449 int dc_index, int16_t *quant_matrix, int Al) | |
450 { | |
451 int val; | |
8288 | 452 s->dsp.clear_block(block); |
8287 | 453 val = mjpeg_decode_dc(s, dc_index); |
454 if (val == 0xffff) { | |
455 av_log(s->avctx, AV_LOG_ERROR, "error dc\n"); | |
456 return -1; | |
457 } | |
458 val = (val * quant_matrix[0] << Al) + s->last_dc[component]; | |
459 s->last_dc[component] = val; | |
460 block[0] = val; | |
461 return 0; | |
462 } | |
463 | |
5020 | 464 /* decode block and dequantize - progressive JPEG version */ |
8287 | 465 static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block, uint8_t *last_nnz, |
466 int ac_index, int16_t *quant_matrix, | |
467 int ss, int se, int Al, int *EOBRUN) | |
5020 | 468 { |
469 int code, i, j, level, val, run; | |
470 | |
471 if(*EOBRUN){ | |
472 (*EOBRUN)--; | |
473 return 0; | |
474 } | |
475 {OPEN_READER(re, &s->gb) | |
476 for(i=ss;;i++) { | |
477 UPDATE_CACHE(re, &s->gb); | |
478 GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2) | |
479 /* Progressive JPEG use AC coeffs from zero and this decoder sets offset 16 by default */ | |
480 code -= 16; | |
481 if(code & 0xF) { | |
482 i += ((unsigned) code) >> 4; | |
483 code &= 0xf; | |
484 if(code > MIN_CACHE_BITS - 16){ | |
485 UPDATE_CACHE(re, &s->gb) | |
486 } | |
487 { | |
488 int cache=GET_CACHE(re,&s->gb); | |
489 int sign=(~cache)>>31; | |
490 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign; | |
491 } | |
492 | |
493 LAST_SKIP_BITS(re, &s->gb, code) | |
494 | |
495 if (i >= se) { | |
496 if(i == se){ | |
497 j = s->scantable.permutated[se]; | |
498 block[j] = level * quant_matrix[j] << Al; | |
499 break; | |
500 } | |
501 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); | |
502 return -1; | |
503 } | |
504 j = s->scantable.permutated[i]; | |
505 block[j] = level * quant_matrix[j] << Al; | |
506 }else{ | |
507 run = ((unsigned) code) >> 4; | |
508 if(run == 0xF){// ZRL - skip 15 coefficients | |
509 i += 15; | |
510 }else{ | |
511 val = run; | |
512 run = (1 << run); | |
513 UPDATE_CACHE(re, &s->gb); | |
514 run += (GET_CACHE(re, &s->gb) >> (32 - val)) & (run - 1); | |
515 if(val) | |
516 LAST_SKIP_BITS(re, &s->gb, val); | |
517 *EOBRUN = run - 1; | |
518 break; | |
519 } | |
520 } | |
521 } | |
522 CLOSE_READER(re, &s->gb)} | |
8287 | 523 if(i > *last_nnz) |
524 *last_nnz = i; | |
525 return 0; | |
526 } | |
527 | |
528 #define REFINE_BIT(j) {\ | |
529 UPDATE_CACHE(re, &s->gb);\ | |
530 sign = block[j]>>15;\ | |
531 block[j] += SHOW_UBITS(re, &s->gb, 1) * ((quant_matrix[j]^sign)-sign) << Al;\ | |
532 LAST_SKIP_BITS(re, &s->gb, 1);\ | |
533 } | |
534 | |
535 #define ZERO_RUN \ | |
536 for(;;i++) {\ | |
537 if(i > last) {\ | |
538 i += run;\ | |
539 if(i > se) {\ | |
540 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);\ | |
541 return -1;\ | |
542 }\ | |
543 break;\ | |
544 }\ | |
545 j = s->scantable.permutated[i];\ | |
546 if(block[j])\ | |
547 REFINE_BIT(j)\ | |
548 else if(run-- == 0)\ | |
549 break;\ | |
550 } | |
551 | |
552 /* decode block and dequantize - progressive JPEG refinement pass */ | |
553 static int decode_block_refinement(MJpegDecodeContext *s, DCTELEM *block, uint8_t *last_nnz, | |
554 int ac_index, int16_t *quant_matrix, | |
555 int ss, int se, int Al, int *EOBRUN) | |
556 { | |
557 int code, i=ss, j, sign, val, run; | |
558 int last = FFMIN(se, *last_nnz); | |
559 | |
560 OPEN_READER(re, &s->gb); | |
561 if(*EOBRUN) | |
562 (*EOBRUN)--; | |
563 else { | |
564 for(;;i++) { | |
565 UPDATE_CACHE(re, &s->gb); | |
566 GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2) | |
567 /* Progressive JPEG use AC coeffs from zero and this decoder sets offset 16 by default */ | |
568 code -= 16; | |
569 if(code & 0xF) { | |
570 run = ((unsigned) code) >> 4; | |
571 UPDATE_CACHE(re, &s->gb); | |
572 val = SHOW_UBITS(re, &s->gb, 1); | |
573 LAST_SKIP_BITS(re, &s->gb, 1); | |
574 ZERO_RUN; | |
575 j = s->scantable.permutated[i]; | |
576 val--; | |
577 block[j] = ((quant_matrix[j]^val)-val) << Al; | |
578 if(i == se) { | |
579 if(i > *last_nnz) | |
580 *last_nnz = i; | |
581 CLOSE_READER(re, &s->gb) | |
582 return 0; | |
583 } | |
584 }else{ | |
585 run = ((unsigned) code) >> 4; | |
586 if(run == 0xF){ | |
587 ZERO_RUN; | |
588 }else{ | |
589 val = run; | |
590 run = (1 << run); | |
591 if(val) { | |
592 UPDATE_CACHE(re, &s->gb); | |
593 run += SHOW_UBITS(re, &s->gb, val); | |
594 LAST_SKIP_BITS(re, &s->gb, val); | |
595 } | |
596 *EOBRUN = run - 1; | |
597 break; | |
598 } | |
599 } | |
600 } | |
601 | |
602 if(i > *last_nnz) | |
603 *last_nnz = i; | |
604 } | |
605 | |
606 for(;i<=last;i++) { | |
607 j = s->scantable.permutated[i]; | |
608 if(block[j]) | |
609 REFINE_BIT(j) | |
610 } | |
611 CLOSE_READER(re, &s->gb); | |
5020 | 612 |
613 return 0; | |
614 } | |
8287 | 615 #undef REFINE_BIT |
616 #undef ZERO_RUN | |
5020 | 617 |
618 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){ | |
619 int i, mb_x, mb_y; | |
10487 | 620 uint16_t (*buffer)[4]; |
5020 | 621 int left[3], top[3], topleft[3]; |
622 const int linesize= s->linesize[0]; | |
623 const int mask= (1<<s->bits)-1; | |
624 | |
10487 | 625 av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size, (unsigned)s->mb_width * 4 * sizeof(s->ljpeg_buffer[0][0])); |
626 buffer= s->ljpeg_buffer; | |
5020 | 627 |
628 for(i=0; i<3; i++){ | |
629 buffer[0][i]= 1 << (s->bits + point_transform - 1); | |
630 } | |
631 for(mb_y = 0; mb_y < s->mb_height; mb_y++) { | |
632 const int modified_predictor= mb_y ? predictor : 1; | |
633 uint8_t *ptr = s->picture.data[0] + (linesize * mb_y); | |
634 | |
635 if (s->interlaced && s->bottom_field) | |
636 ptr += linesize >> 1; | |
637 | |
638 for(i=0; i<3; i++){ | |
639 top[i]= left[i]= topleft[i]= buffer[0][i]; | |
640 } | |
641 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { | |
642 if (s->restart_interval && !s->restart_count) | |
643 s->restart_count = s->restart_interval; | |
644 | |
645 for(i=0;i<3;i++) { | |
646 int pred; | |
647 | |
648 topleft[i]= top[i]; | |
649 top[i]= buffer[mb_x][i]; | |
650 | |
651 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor); | |
652 | |
653 left[i]= | |
654 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform)); | |
655 } | |
656 | |
657 if (s->restart_interval && !--s->restart_count) { | |
658 align_get_bits(&s->gb); | |
659 skip_bits(&s->gb, 16); /* skip RSTn */ | |
660 } | |
661 } | |
662 | |
663 if(s->rct){ | |
664 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { | |
665 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2); | |
666 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1]; | |
667 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1]; | |
668 } | |
669 }else if(s->pegasus_rct){ | |
670 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { | |
671 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2); | |
672 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1]; | |
673 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1]; | |
674 } | |
675 }else{ | |
676 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { | |
10667 | 677 ptr[4*mb_x+0] = buffer[mb_x][2]; |
5020 | 678 ptr[4*mb_x+1] = buffer[mb_x][1]; |
10667 | 679 ptr[4*mb_x+2] = buffer[mb_x][0]; |
5020 | 680 } |
681 } | |
682 } | |
683 return 0; | |
684 } | |
685 | |
686 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){ | |
687 int i, mb_x, mb_y; | |
688 const int nb_components=3; | |
689 | |
690 for(mb_y = 0; mb_y < s->mb_height; mb_y++) { | |
691 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { | |
692 if (s->restart_interval && !s->restart_count) | |
693 s->restart_count = s->restart_interval; | |
694 | |
695 if(mb_x==0 || mb_y==0 || s->interlaced){ | |
696 for(i=0;i<nb_components;i++) { | |
697 uint8_t *ptr; | |
698 int n, h, v, x, y, c, j, linesize; | |
699 n = s->nb_blocks[i]; | |
700 c = s->comp_index[i]; | |
701 h = s->h_scount[i]; | |
702 v = s->v_scount[i]; | |
703 x = 0; | |
704 y = 0; | |
705 linesize= s->linesize[c]; | |
706 | |
707 for(j=0; j<n; j++) { | |
708 int pred; | |
709 | |
710 ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap | |
711 if(y==0 && mb_y==0){ | |
712 if(x==0 && mb_x==0){ | |
713 pred= 128 << point_transform; | |
714 }else{ | |
715 pred= ptr[-1]; | |
716 } | |
717 }else{ | |
718 if(x==0 && mb_x==0){ | |
719 pred= ptr[-linesize]; | |
720 }else{ | |
721 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor); | |
722 } | |
723 } | |
724 | |
725 if (s->interlaced && s->bottom_field) | |
726 ptr += linesize >> 1; | |
727 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform); | |
728 | |
729 if (++x == h) { | |
730 x = 0; | |
731 y++; | |
732 } | |
733 } | |
734 } | |
735 }else{ | |
736 for(i=0;i<nb_components;i++) { | |
737 uint8_t *ptr; | |
738 int n, h, v, x, y, c, j, linesize; | |
739 n = s->nb_blocks[i]; | |
740 c = s->comp_index[i]; | |
741 h = s->h_scount[i]; | |
742 v = s->v_scount[i]; | |
743 x = 0; | |
744 y = 0; | |
745 linesize= s->linesize[c]; | |
746 | |
747 for(j=0; j<n; j++) { | |
748 int pred; | |
749 | |
750 ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap | |
751 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor); | |
752 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform); | |
753 if (++x == h) { | |
754 x = 0; | |
755 y++; | |
756 } | |
757 } | |
758 } | |
759 } | |
760 if (s->restart_interval && !--s->restart_count) { | |
761 align_get_bits(&s->gb); | |
762 skip_bits(&s->gb, 16); /* skip RSTn */ | |
763 } | |
764 } | |
765 } | |
766 return 0; | |
767 } | |
768 | |
8287 | 769 static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, int Al){ |
5020 | 770 int i, mb_x, mb_y; |
5734 | 771 uint8_t* data[MAX_COMPONENTS]; |
772 int linesize[MAX_COMPONENTS]; | |
5020 | 773 |
10539
8d8fcc20dd30
Disable image flipping during JPEG decoding if CODEC_FLAG_EMU_EDGE is set
reimar
parents:
10487
diff
changeset
|
774 if(s->flipped && s->avctx->flags & CODEC_FLAG_EMU_EDGE) { |
8d8fcc20dd30
Disable image flipping during JPEG decoding if CODEC_FLAG_EMU_EDGE is set
reimar
parents:
10487
diff
changeset
|
775 av_log(s->avctx, AV_LOG_ERROR, "Can not flip image with CODEC_FLAG_EMU_EDGE set!\n"); |
8d8fcc20dd30
Disable image flipping during JPEG decoding if CODEC_FLAG_EMU_EDGE is set
reimar
parents:
10487
diff
changeset
|
776 s->flipped = 0; |
8d8fcc20dd30
Disable image flipping during JPEG decoding if CODEC_FLAG_EMU_EDGE is set
reimar
parents:
10487
diff
changeset
|
777 } |
5734 | 778 for(i=0; i < nb_components; i++) { |
779 int c = s->comp_index[i]; | |
780 data[c] = s->picture.data[c]; | |
781 linesize[c]=s->linesize[c]; | |
8287 | 782 s->coefs_finished[c] |= 1; |
10438
710e226783f0
Flip (M)JPEG frames encoded by Intel JPEG library.
cehoyos
parents:
10412
diff
changeset
|
783 if(s->flipped) { |
5736 | 784 //picture should be flipped upside-down for this codec |
5818 | 785 data[c] += (linesize[c] * (s->v_scount[i] * (8 * s->mb_height -((s->height/s->v_max)&7)) - 1 )); |
5736 | 786 linesize[c] *= -1; |
787 } | |
5734 | 788 } |
789 | |
5020 | 790 for(mb_y = 0; mb_y < s->mb_height; mb_y++) { |
791 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { | |
792 if (s->restart_interval && !s->restart_count) | |
793 s->restart_count = s->restart_interval; | |
794 | |
795 for(i=0;i<nb_components;i++) { | |
796 uint8_t *ptr; | |
797 int n, h, v, x, y, c, j; | |
798 n = s->nb_blocks[i]; | |
799 c = s->comp_index[i]; | |
800 h = s->h_scount[i]; | |
801 v = s->v_scount[i]; | |
802 x = 0; | |
803 y = 0; | |
804 for(j=0;j<n;j++) { | |
5734 | 805 ptr = data[c] + |
806 (((linesize[c] * (v * mb_y + y) * 8) + | |
5020 | 807 (h * mb_x + x) * 8) >> s->avctx->lowres); |
8287 | 808 if(s->interlaced && s->bottom_field) |
5734 | 809 ptr += linesize[c] >> 1; |
8287 | 810 if(!s->progressive) { |
8288 | 811 s->dsp.clear_block(s->block); |
8287 | 812 if(decode_block(s, s->block, i, |
813 s->dc_index[i], s->ac_index[i], | |
814 s->quant_matrixes[ s->quant_index[c] ]) < 0) { | |
815 av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x); | |
816 return -1; | |
817 } | |
818 s->dsp.idct_put(ptr, linesize[c], s->block); | |
819 } else { | |
820 int block_idx = s->block_stride[c] * (v * mb_y + y) + (h * mb_x + x); | |
821 DCTELEM *block = s->blocks[c][block_idx]; | |
822 if(Ah) | |
823 block[0] += get_bits1(&s->gb) * s->quant_matrixes[ s->quant_index[c] ][0] << Al; | |
824 else if(decode_dc_progressive(s, block, i, s->dc_index[i], s->quant_matrixes[ s->quant_index[c] ], Al) < 0) { | |
825 av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x); | |
826 return -1; | |
827 } | |
828 } | |
829 // av_log(s->avctx, AV_LOG_DEBUG, "mb: %d %d processed\n", mb_y, mb_x); | |
5020 | 830 //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); |
831 if (++x == h) { | |
832 x = 0; | |
833 y++; | |
834 } | |
835 } | |
836 } | |
9706
473fbc242b43
honor restart interval in mjpeg, fix #861, SpectralFan.mov still decodes correctly
bcoudurier
parents:
9626
diff
changeset
|
837 |
473fbc242b43
honor restart interval in mjpeg, fix #861, SpectralFan.mov still decodes correctly
bcoudurier
parents:
9626
diff
changeset
|
838 if (s->restart_interval && !--s->restart_count) { |
5020 | 839 align_get_bits(&s->gb); |
840 skip_bits(&s->gb, 16); /* skip RSTn */ | |
841 for (i=0; i<nb_components; i++) /* reset dc */ | |
842 s->last_dc[i] = 1024; | |
843 } | |
844 } | |
845 } | |
846 return 0; | |
847 } | |
848 | |
8287 | 849 static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss, int se, int Ah, int Al){ |
850 int mb_x, mb_y; | |
851 int EOBRUN = 0; | |
852 int c = s->comp_index[0]; | |
853 uint8_t* data = s->picture.data[c]; | |
854 int linesize = s->linesize[c]; | |
855 int last_scan = 0; | |
856 int16_t *quant_matrix = s->quant_matrixes[ s->quant_index[c] ]; | |
857 | |
858 if(!Al) { | |
859 s->coefs_finished[c] |= (1LL<<(se+1))-(1LL<<ss); | |
860 last_scan = !~s->coefs_finished[c]; | |
861 } | |
862 | |
863 if(s->interlaced && s->bottom_field) | |
864 data += linesize >> 1; | |
865 | |
866 for(mb_y = 0; mb_y < s->mb_height; mb_y++) { | |
867 uint8_t *ptr = data + (mb_y*linesize*8 >> s->avctx->lowres); | |
868 int block_idx = mb_y * s->block_stride[c]; | |
869 DCTELEM (*block)[64] = &s->blocks[c][block_idx]; | |
870 uint8_t *last_nnz = &s->last_nnz[c][block_idx]; | |
871 for(mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) { | |
872 int ret; | |
873 if(Ah) | |
874 ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0], | |
875 quant_matrix, ss, se, Al, &EOBRUN); | |
876 else | |
877 ret = decode_block_progressive(s, *block, last_nnz, s->ac_index[0], | |
878 quant_matrix, ss, se, Al, &EOBRUN); | |
879 if(ret < 0) { | |
880 av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x); | |
881 return -1; | |
882 } | |
883 if(last_scan) { | |
884 s->dsp.idct_put(ptr, linesize, *block); | |
885 ptr += 8 >> s->avctx->lowres; | |
886 } | |
887 } | |
888 } | |
889 return 0; | |
890 } | |
891 | |
5044 | 892 int ff_mjpeg_decode_sos(MJpegDecodeContext *s) |
5020 | 893 { |
894 int len, nb_components, i, h, v, predictor, point_transform; | |
9459
84932ac233a5
Remove unused variables from ff_mjpeg_decode_sos() found by CSA.
michael
parents:
9355
diff
changeset
|
895 int index, id; |
5020 | 896 const int block_size= s->lossless ? 1 : 8; |
897 int ilv, prev_shift; | |
898 | |
899 /* XXX: verify len field validity */ | |
900 len = get_bits(&s->gb, 16); | |
901 nb_components = get_bits(&s->gb, 8); | |
11006
d99420b73262
Fix heap overflow due to lack of nb_components check.
michael
parents:
10672
diff
changeset
|
902 if (nb_components == 0 || nb_components > MAX_COMPONENTS){ |
d99420b73262
Fix heap overflow due to lack of nb_components check.
michael
parents:
10672
diff
changeset
|
903 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: nb_components (%d) unsupported\n", nb_components); |
d99420b73262
Fix heap overflow due to lack of nb_components check.
michael
parents:
10672
diff
changeset
|
904 return -1; |
d99420b73262
Fix heap overflow due to lack of nb_components check.
michael
parents:
10672
diff
changeset
|
905 } |
5020 | 906 if (len != 6+2*nb_components) |
907 { | |
908 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len); | |
909 return -1; | |
910 } | |
911 for(i=0;i<nb_components;i++) { | |
912 id = get_bits(&s->gb, 8) - 1; | |
913 av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id); | |
914 /* find component index */ | |
915 for(index=0;index<s->nb_components;index++) | |
916 if (id == s->component_id[index]) | |
917 break; | |
918 if (index == s->nb_components) | |
919 { | |
920 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: index(%d) out of components\n", index); | |
921 return -1; | |
922 } | |
11007
8d4ae55fdada
Metasoft MJPEG codec has Cb and Cr swapped, fixes issue 1611.
cehoyos
parents:
11006
diff
changeset
|
923 /* Metasoft MJPEG codec has Cb and Cr swapped */ |
8d4ae55fdada
Metasoft MJPEG codec has Cb and Cr swapped, fixes issue 1611.
cehoyos
parents:
11006
diff
changeset
|
924 if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J') |
8d4ae55fdada
Metasoft MJPEG codec has Cb and Cr swapped, fixes issue 1611.
cehoyos
parents:
11006
diff
changeset
|
925 && nb_components == 3 && s->nb_components == 3 && i) |
8d4ae55fdada
Metasoft MJPEG codec has Cb and Cr swapped, fixes issue 1611.
cehoyos
parents:
11006
diff
changeset
|
926 index = 3 - i; |
5020 | 927 |
928 s->comp_index[i] = index; | |
929 | |
930 s->nb_blocks[i] = s->h_count[index] * s->v_count[index]; | |
931 s->h_scount[i] = s->h_count[index]; | |
932 s->v_scount[i] = s->v_count[index]; | |
933 | |
934 s->dc_index[i] = get_bits(&s->gb, 4); | |
935 s->ac_index[i] = get_bits(&s->gb, 4); | |
936 | |
937 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 || | |
938 s->dc_index[i] >= 4 || s->ac_index[i] >= 4) | |
939 goto out_of_range; | |
9912
9502108caadf
mjpegdec: check that the coded dc_index and ac_index have a valid associated VLC table.
reimar
parents:
9706
diff
changeset
|
940 if (!s->vlcs[0][s->dc_index[i]].table || !s->vlcs[1][s->ac_index[i]].table) |
9502108caadf
mjpegdec: check that the coded dc_index and ac_index have a valid associated VLC table.
reimar
parents:
9706
diff
changeset
|
941 goto out_of_range; |
5020 | 942 } |
943 | |
944 predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */ | |
945 ilv= get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */ | |
946 prev_shift = get_bits(&s->gb, 4); /* Ah */ | |
947 point_transform= get_bits(&s->gb, 4); /* Al */ | |
948 | |
949 for(i=0;i<nb_components;i++) | |
950 s->last_dc[i] = 1024; | |
951 | |
952 if (nb_components > 1) { | |
953 /* interleaved stream */ | |
954 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size); | |
955 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size); | |
956 } else if(!s->ls) { /* skip this for JPEG-LS */ | |
957 h = s->h_max / s->h_scount[0]; | |
958 v = s->v_max / s->v_scount[0]; | |
959 s->mb_width = (s->width + h * block_size - 1) / (h * block_size); | |
960 s->mb_height = (s->height + v * block_size - 1) / (v * block_size); | |
961 s->nb_blocks[0] = 1; | |
962 s->h_scount[0] = 1; | |
963 s->v_scount[0] = 1; | |
964 } | |
965 | |
966 if(s->avctx->debug & FF_DEBUG_PICT_INFO) | |
11024 | 967 av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d %s\n", s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "", |
5020 | 968 predictor, point_transform, ilv, s->bits, |
969 s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : "")); | |
970 | |
971 | |
972 /* mjpeg-b can have padding bytes between sos and image data, skip them */ | |
973 for (i = s->mjpb_skiptosod; i > 0; i--) | |
974 skip_bits(&s->gb, 8); | |
975 | |
976 if(s->lossless){ | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8288
diff
changeset
|
977 if(CONFIG_JPEGLS_DECODER && s->ls){ |
5020 | 978 // for(){ |
979 // reset_ls_coding_parameters(s, 0); | |
980 | |
7478
12d42593e467
Return an error when ff_jpegls_decode_picture fails.
benoit
parents:
7136
diff
changeset
|
981 if(ff_jpegls_decode_picture(s, predictor, point_transform, ilv) < 0) |
12d42593e467
Return an error when ff_jpegls_decode_picture fails.
benoit
parents:
7136
diff
changeset
|
982 return -1; |
5020 | 983 }else{ |
984 if(s->rgb){ | |
985 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0) | |
986 return -1; | |
987 }else{ | |
988 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0) | |
989 return -1; | |
990 } | |
991 } | |
992 }else{ | |
8287 | 993 if(s->progressive && predictor) { |
994 if(mjpeg_decode_scan_progressive_ac(s, predictor, ilv, prev_shift, point_transform) < 0) | |
995 return -1; | |
996 } else { | |
997 if(mjpeg_decode_scan(s, nb_components, prev_shift, point_transform) < 0) | |
998 return -1; | |
999 } | |
5020 | 1000 } |
1001 emms_c(); | |
1002 return 0; | |
1003 out_of_range: | |
1004 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n"); | |
1005 return -1; | |
1006 } | |
1007 | |
1008 static int mjpeg_decode_dri(MJpegDecodeContext *s) | |
1009 { | |
1010 if (get_bits(&s->gb, 16) != 4) | |
1011 return -1; | |
1012 s->restart_interval = get_bits(&s->gb, 16); | |
1013 s->restart_count = 0; | |
1014 av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n", s->restart_interval); | |
1015 | |
1016 return 0; | |
1017 } | |
1018 | |
1019 static int mjpeg_decode_app(MJpegDecodeContext *s) | |
1020 { | |
1021 int len, id, i; | |
1022 | |
1023 len = get_bits(&s->gb, 16); | |
1024 if (len < 5) | |
1025 return -1; | |
1026 if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits) | |
1027 return -1; | |
1028 | |
1029 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16); | |
1030 id = be2me_32(id); | |
1031 len -= 6; | |
1032 | |
1033 if(s->avctx->debug & FF_DEBUG_STARTCODE){ | |
1034 av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id); | |
1035 } | |
1036 | |
1037 /* buggy AVID, it puts EOI only at every 10th frame */ | |
1038 /* also this fourcc is used by non-avid files too, it holds some | |
1039 informations, but it's always present in AVID creates files */ | |
8612 | 1040 if (id == AV_RL32("AVI1")) |
5020 | 1041 { |
1042 /* structure: | |
1043 4bytes AVI1 | |
1044 1bytes polarity | |
1045 1bytes always zero | |
1046 4bytes field_size | |
1047 4bytes field_size_less_padding | |
1048 */ | |
1049 s->buggy_avid = 1; | |
1050 // if (s->first_picture) | |
1051 // printf("mjpeg: workarounding buggy AVID\n"); | |
1052 i = get_bits(&s->gb, 8); | |
1053 if (i==2) s->bottom_field= 1; | |
1054 else if(i==1) s->bottom_field= 0; | |
1055 #if 0 | |
1056 skip_bits(&s->gb, 8); | |
1057 skip_bits(&s->gb, 32); | |
1058 skip_bits(&s->gb, 32); | |
1059 len -= 10; | |
1060 #endif | |
1061 // if (s->interlace_polarity) | |
1062 // printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity); | |
1063 goto out; | |
1064 } | |
1065 | |
1066 // len -= 2; | |
1067 | |
8612 | 1068 if (id == AV_RL32("JFIF")) |
5020 | 1069 { |
1070 int t_w, t_h, v1, v2; | |
1071 skip_bits(&s->gb, 8); /* the trailing zero-byte */ | |
1072 v1= get_bits(&s->gb, 8); | |
1073 v2= get_bits(&s->gb, 8); | |
1074 skip_bits(&s->gb, 8); | |
1075 | |
1076 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16); | |
1077 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16); | |
1078 | |
1079 if (s->avctx->debug & FF_DEBUG_PICT_INFO) | |
1080 av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n", | |
1081 v1, v2, | |
1082 s->avctx->sample_aspect_ratio.num, | |
1083 s->avctx->sample_aspect_ratio.den | |
1084 ); | |
1085 | |
1086 t_w = get_bits(&s->gb, 8); | |
1087 t_h = get_bits(&s->gb, 8); | |
1088 if (t_w && t_h) | |
1089 { | |
1090 /* skip thumbnail */ | |
1091 if (len-10-(t_w*t_h*3) > 0) | |
1092 len -= t_w*t_h*3; | |
1093 } | |
1094 len -= 10; | |
1095 goto out; | |
1096 } | |
1097 | |
8612 | 1098 if (id == AV_RL32("Adob") && (get_bits(&s->gb, 8) == 'e')) |
5020 | 1099 { |
1100 if (s->avctx->debug & FF_DEBUG_PICT_INFO) | |
1101 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n"); | |
1102 skip_bits(&s->gb, 16); /* version */ | |
1103 skip_bits(&s->gb, 16); /* flags0 */ | |
1104 skip_bits(&s->gb, 16); /* flags1 */ | |
1105 skip_bits(&s->gb, 8); /* transform */ | |
1106 len -= 7; | |
1107 goto out; | |
1108 } | |
1109 | |
8612 | 1110 if (id == AV_RL32("LJIF")){ |
5020 | 1111 if (s->avctx->debug & FF_DEBUG_PICT_INFO) |
1112 av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n"); | |
1113 skip_bits(&s->gb, 16); /* version ? */ | |
1114 skip_bits(&s->gb, 16); /* unknwon always 0? */ | |
1115 skip_bits(&s->gb, 16); /* unknwon always 0? */ | |
1116 skip_bits(&s->gb, 16); /* unknwon always 0? */ | |
1117 switch( get_bits(&s->gb, 8)){ | |
1118 case 1: | |
1119 s->rgb= 1; | |
1120 s->pegasus_rct=0; | |
1121 break; | |
1122 case 2: | |
1123 s->rgb= 1; | |
1124 s->pegasus_rct=1; | |
1125 break; | |
1126 default: | |
1127 av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n"); | |
1128 } | |
1129 len -= 9; | |
1130 goto out; | |
1131 } | |
1132 | |
1133 /* Apple MJPEG-A */ | |
1134 if ((s->start_code == APP1) && (len > (0x28 - 8))) | |
1135 { | |
1136 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16); | |
1137 id = be2me_32(id); | |
1138 len -= 4; | |
8612 | 1139 if (id == AV_RL32("mjpg")) /* Apple MJPEG-A */ |
5020 | 1140 { |
1141 #if 0 | |
1142 skip_bits(&s->gb, 32); /* field size */ | |
1143 skip_bits(&s->gb, 32); /* pad field size */ | |
1144 skip_bits(&s->gb, 32); /* next off */ | |
1145 skip_bits(&s->gb, 32); /* quant off */ | |
1146 skip_bits(&s->gb, 32); /* huff off */ | |
1147 skip_bits(&s->gb, 32); /* image off */ | |
1148 skip_bits(&s->gb, 32); /* scan off */ | |
1149 skip_bits(&s->gb, 32); /* data off */ | |
1150 #endif | |
1151 if (s->avctx->debug & FF_DEBUG_PICT_INFO) | |
1152 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n"); | |
1153 } | |
1154 } | |
1155 | |
1156 out: | |
1157 /* slow but needed for extreme adobe jpegs */ | |
1158 if (len < 0) | |
1159 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n"); | |
1160 while(--len > 0) | |
1161 skip_bits(&s->gb, 8); | |
1162 | |
1163 return 0; | |
1164 } | |
1165 | |
1166 static int mjpeg_decode_com(MJpegDecodeContext *s) | |
1167 { | |
1168 int len = get_bits(&s->gb, 16); | |
1169 if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) { | |
1170 char *cbuf = av_malloc(len - 1); | |
1171 if (cbuf) { | |
1172 int i; | |
1173 for (i = 0; i < len - 2; i++) | |
1174 cbuf[i] = get_bits(&s->gb, 8); | |
1175 if (i > 0 && cbuf[i-1] == '\n') | |
1176 cbuf[i-1] = 0; | |
1177 else | |
1178 cbuf[i] = 0; | |
1179 | |
1180 if(s->avctx->debug & FF_DEBUG_PICT_INFO) | |
1181 av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf); | |
1182 | |
1183 /* buggy avid, it puts EOI only at every 10th frame */ | |
1184 if (!strcmp(cbuf, "AVID")) | |
1185 { | |
1186 s->buggy_avid = 1; | |
1187 // if (s->first_picture) | |
1188 // printf("mjpeg: workarounding buggy AVID\n"); | |
1189 } | |
1190 else if(!strcmp(cbuf, "CS=ITU601")){ | |
1191 s->cs_itu601= 1; | |
1192 } | |
10672
2aab93afc826
(Partly) support Metasoft MJPEG Codec, fixes half of issue 1611.
cehoyos
parents:
10667
diff
changeset
|
1193 else if((len > 20 && !strncmp(cbuf, "Intel(R) JPEG Library", 21)) || |
2aab93afc826
(Partly) support Metasoft MJPEG Codec, fixes half of issue 1611.
cehoyos
parents:
10667
diff
changeset
|
1194 (len > 19 && !strncmp(cbuf, "Metasoft MJPEG Codec", 20))){ |
10438
710e226783f0
Flip (M)JPEG frames encoded by Intel JPEG library.
cehoyos
parents:
10412
diff
changeset
|
1195 s->flipped = 1; |
710e226783f0
Flip (M)JPEG frames encoded by Intel JPEG library.
cehoyos
parents:
10412
diff
changeset
|
1196 } |
5020 | 1197 |
1198 av_free(cbuf); | |
1199 } | |
1200 } | |
1201 | |
1202 return 0; | |
1203 } | |
1204 | |
1205 #if 0 | |
1206 static int valid_marker_list[] = | |
1207 { | |
1208 /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */ | |
1209 /* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
1210 /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
1211 /* 2 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
1212 /* 3 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
1213 /* 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
1214 /* 5 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
1215 /* 6 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
1216 /* 7 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
1217 /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
1218 /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
1219 /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
1220 /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
1221 /* c */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
1222 /* d */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
1223 /* e */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
1224 /* f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, | |
1225 } | |
1226 #endif | |
1227 | |
1228 /* return the 8 bit start code value and update the search | |
1229 state. Return -1 if no start code found */ | |
6222 | 1230 static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end) |
5020 | 1231 { |
6222 | 1232 const uint8_t *buf_ptr; |
5020 | 1233 unsigned int v, v2; |
1234 int val; | |
1235 #ifdef DEBUG | |
1236 int skipped=0; | |
1237 #endif | |
1238 | |
1239 buf_ptr = *pbuf_ptr; | |
1240 while (buf_ptr < buf_end) { | |
1241 v = *buf_ptr++; | |
1242 v2 = *buf_ptr; | |
1243 if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) { | |
1244 val = *buf_ptr++; | |
1245 goto found; | |
1246 } | |
1247 #ifdef DEBUG | |
1248 skipped++; | |
1249 #endif | |
1250 } | |
1251 val = -1; | |
1252 found: | |
9999
c78fd9154378
Change av_log() calls surrounded by '#ifdef DEBUG' into dprintf macros.
diego
parents:
9915
diff
changeset
|
1253 dprintf(NULL, "find_marker skipped %d bytes\n", skipped); |
5020 | 1254 *pbuf_ptr = buf_ptr; |
1255 return val; | |
1256 } | |
1257 | |
5041 | 1258 int ff_mjpeg_decode_frame(AVCodecContext *avctx, |
5020 | 1259 void *data, int *data_size, |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8718
diff
changeset
|
1260 AVPacket *avpkt) |
5020 | 1261 { |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8718
diff
changeset
|
1262 const uint8_t *buf = avpkt->data; |
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8718
diff
changeset
|
1263 int buf_size = avpkt->size; |
5020 | 1264 MJpegDecodeContext *s = avctx->priv_data; |
6222 | 1265 const uint8_t *buf_end, *buf_ptr; |
5020 | 1266 int start_code; |
1267 AVFrame *picture = data; | |
1268 | |
9913
b73796e93571
Add a got_picture flag to MJpegDecodeContext which indicates if its picture
reimar
parents:
9912
diff
changeset
|
1269 s->got_picture = 0; // picture from previous image can not be reused |
5020 | 1270 buf_ptr = buf; |
1271 buf_end = buf + buf_size; | |
1272 while (buf_ptr < buf_end) { | |
1273 /* find start next marker */ | |
1274 start_code = find_marker(&buf_ptr, buf_end); | |
1275 { | |
1276 /* EOF */ | |
1277 if (start_code < 0) { | |
1278 goto the_end; | |
1279 } else { | |
5153 | 1280 av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%td\n", start_code, buf_end - buf_ptr); |
5020 | 1281 |
1282 if ((buf_end - buf_ptr) > s->buffer_size) | |
1283 { | |
1284 av_free(s->buffer); | |
1285 s->buffer_size = buf_end-buf_ptr; | |
1286 s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE); | |
1287 av_log(avctx, AV_LOG_DEBUG, "buffer too small, expanding to %d bytes\n", | |
1288 s->buffer_size); | |
1289 } | |
1290 | |
1291 /* unescape buffer of SOS, use special treatment for JPEG-LS */ | |
1292 if (start_code == SOS && !s->ls) | |
1293 { | |
6222 | 1294 const uint8_t *src = buf_ptr; |
5020 | 1295 uint8_t *dst = s->buffer; |
1296 | |
1297 while (src<buf_end) | |
1298 { | |
1299 uint8_t x = *(src++); | |
1300 | |
1301 *(dst++) = x; | |
1302 if (avctx->codec_id != CODEC_ID_THP) | |
1303 { | |
1304 if (x == 0xff) { | |
1305 while (src < buf_end && x == 0xff) | |
1306 x = *(src++); | |
1307 | |
1308 if (x >= 0xd0 && x <= 0xd7) | |
1309 *(dst++) = x; | |
1310 else if (x) | |
1311 break; | |
1312 } | |
1313 } | |
1314 } | |
1315 init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8); | |
1316 | |
5153 | 1317 av_log(avctx, AV_LOG_DEBUG, "escaping removed %td bytes\n", |
5020 | 1318 (buf_end - buf_ptr) - (dst - s->buffer)); |
1319 } | |
1320 else if(start_code == SOS && s->ls){ | |
6222 | 1321 const uint8_t *src = buf_ptr; |
5020 | 1322 uint8_t *dst = s->buffer; |
1323 int bit_count = 0; | |
1324 int t = 0, b = 0; | |
1325 PutBitContext pb; | |
1326 | |
1327 s->cur_scan++; | |
1328 | |
1329 /* find marker */ | |
1330 while (src + t < buf_end){ | |
1331 uint8_t x = src[t++]; | |
1332 if (x == 0xff){ | |
1333 while((src + t < buf_end) && x == 0xff) | |
1334 x = src[t++]; | |
1335 if (x & 0x80) { | |
1336 t -= 2; | |
1337 break; | |
1338 } | |
1339 } | |
1340 } | |
1341 bit_count = t * 8; | |
1342 | |
1343 init_put_bits(&pb, dst, t); | |
1344 | |
1345 /* unescape bitstream */ | |
1346 while(b < t){ | |
1347 uint8_t x = src[b++]; | |
1348 put_bits(&pb, 8, x); | |
1349 if(x == 0xFF){ | |
1350 x = src[b++]; | |
1351 put_bits(&pb, 7, x); | |
1352 bit_count--; | |
1353 } | |
1354 } | |
1355 flush_put_bits(&pb); | |
1356 | |
1357 init_get_bits(&s->gb, dst, bit_count); | |
1358 } | |
1359 else | |
1360 init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8); | |
1361 | |
1362 s->start_code = start_code; | |
1363 if(s->avctx->debug & FF_DEBUG_STARTCODE){ | |
1364 av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code); | |
1365 } | |
1366 | |
1367 /* process markers */ | |
1368 if (start_code >= 0xd0 && start_code <= 0xd7) { | |
1369 av_log(avctx, AV_LOG_DEBUG, "restart marker: %d\n", start_code&0x0f); | |
1370 /* APP fields */ | |
1371 } else if (start_code >= APP0 && start_code <= APP15) { | |
1372 mjpeg_decode_app(s); | |
1373 /* Comment */ | |
1374 } else if (start_code == COM){ | |
1375 mjpeg_decode_com(s); | |
1376 } | |
1377 | |
1378 switch(start_code) { | |
1379 case SOI: | |
1380 s->restart_interval = 0; | |
1381 | |
1382 s->restart_count = 0; | |
1383 /* nothing to do on SOI */ | |
1384 break; | |
1385 case DQT: | |
5044 | 1386 ff_mjpeg_decode_dqt(s); |
5020 | 1387 break; |
1388 case DHT: | |
5044 | 1389 if(ff_mjpeg_decode_dht(s) < 0){ |
5020 | 1390 av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n"); |
1391 return -1; | |
1392 } | |
1393 break; | |
1394 case SOF0: | |
10336
a554d7e29e99
lavc MJPEG decoder is capable of decoding some extended sequential
kostya
parents:
9999
diff
changeset
|
1395 case SOF1: |
5020 | 1396 s->lossless=0; |
1397 s->ls=0; | |
1398 s->progressive=0; | |
5044 | 1399 if (ff_mjpeg_decode_sof(s) < 0) |
5020 | 1400 return -1; |
1401 break; | |
1402 case SOF2: | |
1403 s->lossless=0; | |
1404 s->ls=0; | |
1405 s->progressive=1; | |
5044 | 1406 if (ff_mjpeg_decode_sof(s) < 0) |
5020 | 1407 return -1; |
1408 break; | |
1409 case SOF3: | |
1410 s->lossless=1; | |
1411 s->ls=0; | |
1412 s->progressive=0; | |
5044 | 1413 if (ff_mjpeg_decode_sof(s) < 0) |
5020 | 1414 return -1; |
1415 break; | |
1416 case SOF48: | |
1417 s->lossless=1; | |
1418 s->ls=1; | |
1419 s->progressive=0; | |
5044 | 1420 if (ff_mjpeg_decode_sof(s) < 0) |
5020 | 1421 return -1; |
1422 break; | |
1423 case LSE: | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8288
diff
changeset
|
1424 if (!CONFIG_JPEGLS_DECODER || ff_jpegls_decode_lse(s) < 0) |
5020 | 1425 return -1; |
1426 break; | |
1427 case EOI: | |
1428 s->cur_scan = 0; | |
1429 if ((s->buggy_avid && !s->interlaced) || s->restart_interval) | |
1430 break; | |
1431 eoi_parser: | |
9913
b73796e93571
Add a got_picture flag to MJpegDecodeContext which indicates if its picture
reimar
parents:
9912
diff
changeset
|
1432 if (!s->got_picture) { |
b73796e93571
Add a got_picture flag to MJpegDecodeContext which indicates if its picture
reimar
parents:
9912
diff
changeset
|
1433 av_log(avctx, AV_LOG_WARNING, "Found EOI before any SOF, ignoring\n"); |
b73796e93571
Add a got_picture flag to MJpegDecodeContext which indicates if its picture
reimar
parents:
9912
diff
changeset
|
1434 break; |
b73796e93571
Add a got_picture flag to MJpegDecodeContext which indicates if its picture
reimar
parents:
9912
diff
changeset
|
1435 } |
5020 | 1436 { |
1437 if (s->interlaced) { | |
1438 s->bottom_field ^= 1; | |
1439 /* if not bottom field, do not output image yet */ | |
1440 if (s->bottom_field == !s->interlace_polarity) | |
1441 goto not_the_end; | |
1442 } | |
1443 *picture = s->picture; | |
1444 *data_size = sizeof(AVFrame); | |
1445 | |
1446 if(!s->lossless){ | |
6655
22cca5d3173a
Implement FFMAX3(a,b,c) - maximum over three arguments.
voroshil
parents:
6517
diff
changeset
|
1447 picture->quality= FFMAX3(s->qscale[0], s->qscale[1], s->qscale[2]); |
5020 | 1448 picture->qstride= 0; |
1449 picture->qscale_table= s->qscale_table; | |
1450 memset(picture->qscale_table, picture->quality, (s->width+15)/16); | |
1451 if(avctx->debug & FF_DEBUG_QP) | |
1452 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality); | |
1453 picture->quality*= FF_QP2LAMBDA; | |
1454 } | |
1455 | |
1456 goto the_end; | |
1457 } | |
1458 break; | |
1459 case SOS: | |
9913
b73796e93571
Add a got_picture flag to MJpegDecodeContext which indicates if its picture
reimar
parents:
9912
diff
changeset
|
1460 if (!s->got_picture) { |
b73796e93571
Add a got_picture flag to MJpegDecodeContext which indicates if its picture
reimar
parents:
9912
diff
changeset
|
1461 av_log(avctx, AV_LOG_WARNING, "Can not process SOS before SOF, skipping\n"); |
b73796e93571
Add a got_picture flag to MJpegDecodeContext which indicates if its picture
reimar
parents:
9912
diff
changeset
|
1462 break; |
b73796e93571
Add a got_picture flag to MJpegDecodeContext which indicates if its picture
reimar
parents:
9912
diff
changeset
|
1463 } |
5044 | 1464 ff_mjpeg_decode_sos(s); |
5020 | 1465 /* buggy avid puts EOI every 10-20th frame */ |
1466 /* if restart period is over process EOI */ | |
1467 if ((s->buggy_avid && !s->interlaced) || s->restart_interval) | |
1468 goto eoi_parser; | |
1469 break; | |
1470 case DRI: | |
1471 mjpeg_decode_dri(s); | |
1472 break; | |
1473 case SOF5: | |
1474 case SOF6: | |
1475 case SOF7: | |
1476 case SOF9: | |
1477 case SOF10: | |
1478 case SOF11: | |
1479 case SOF13: | |
1480 case SOF14: | |
1481 case SOF15: | |
1482 case JPG: | |
1483 av_log(avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code); | |
1484 break; | |
1485 // default: | |
1486 // printf("mjpeg: unsupported marker (%x)\n", start_code); | |
1487 // break; | |
1488 } | |
1489 | |
1490 not_the_end: | |
1491 /* eof process start code */ | |
1492 buf_ptr += (get_bits_count(&s->gb)+7)/8; | |
1493 av_log(avctx, AV_LOG_DEBUG, "marker parser used %d bytes (%d bits)\n", | |
1494 (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb)); | |
1495 } | |
1496 } | |
1497 } | |
9915
f1707434e40b
If the end of the input buffer is reached while decoding MJPEG and at least
reimar
parents:
9914
diff
changeset
|
1498 if (s->got_picture) { |
f1707434e40b
If the end of the input buffer is reached while decoding MJPEG and at least
reimar
parents:
9914
diff
changeset
|
1499 av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n"); |
f1707434e40b
If the end of the input buffer is reached while decoding MJPEG and at least
reimar
parents:
9914
diff
changeset
|
1500 goto eoi_parser; |
f1707434e40b
If the end of the input buffer is reached while decoding MJPEG and at least
reimar
parents:
9914
diff
changeset
|
1501 } |
9914
e1aaf6216769
Make the MJPEG decoder return -1 when no image was decoded so that decode
reimar
parents:
9913
diff
changeset
|
1502 av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n"); |
e1aaf6216769
Make the MJPEG decoder return -1 when no image was decoded so that decode
reimar
parents:
9913
diff
changeset
|
1503 return -1; |
5020 | 1504 the_end: |
5153 | 1505 av_log(avctx, AV_LOG_DEBUG, "mjpeg decode frame unused %td bytes\n", buf_end - buf_ptr); |
5020 | 1506 // return buf_end - buf_ptr; |
1507 return buf_ptr - buf; | |
1508 } | |
1509 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6448
diff
changeset
|
1510 av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx) |
5020 | 1511 { |
1512 MJpegDecodeContext *s = avctx->priv_data; | |
1513 int i, j; | |
1514 | |
10412 | 1515 if (s->picture.data[0]) |
1516 avctx->release_buffer(avctx, &s->picture); | |
1517 | |
5020 | 1518 av_free(s->buffer); |
1519 av_free(s->qscale_table); | |
10487 | 1520 av_freep(&s->ljpeg_buffer); |
1521 s->ljpeg_buffer_size=0; | |
5020 | 1522 |
1523 for(i=0;i<2;i++) { | |
1524 for(j=0;j<4;j++) | |
1525 free_vlc(&s->vlcs[i][j]); | |
1526 } | |
8287 | 1527 for(i=0; i<MAX_COMPONENTS; i++) { |
1528 av_freep(&s->blocks[i]); | |
1529 av_freep(&s->last_nnz[i]); | |
1530 } | |
5020 | 1531 return 0; |
1532 } | |
1533 | |
1534 AVCodec mjpeg_decoder = { | |
1535 "mjpeg", | |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
11024
diff
changeset
|
1536 AVMEDIA_TYPE_VIDEO, |
5020 | 1537 CODEC_ID_MJPEG, |
1538 sizeof(MJpegDecodeContext), | |
5041 | 1539 ff_mjpeg_decode_init, |
5020 | 1540 NULL, |
5041 | 1541 ff_mjpeg_decode_end, |
1542 ff_mjpeg_decode_frame, | |
5020 | 1543 CODEC_CAP_DR1, |
6710 | 1544 NULL, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6710
diff
changeset
|
1545 .long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"), |
5020 | 1546 }; |
1547 | |
1548 AVCodec thp_decoder = { | |
1549 "thp", | |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
11024
diff
changeset
|
1550 AVMEDIA_TYPE_VIDEO, |
5020 | 1551 CODEC_ID_THP, |
1552 sizeof(MJpegDecodeContext), | |
5041 | 1553 ff_mjpeg_decode_init, |
5020 | 1554 NULL, |
5041 | 1555 ff_mjpeg_decode_end, |
1556 ff_mjpeg_decode_frame, | |
5020 | 1557 CODEC_CAP_DR1, |
6710 | 1558 NULL, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6710
diff
changeset
|
1559 .long_name = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"), |
5020 | 1560 }; |