| GCC Code Coverage Report | |||||||||||||||||||||
|
|||||||||||||||||||||
| Line | Branch | Exec | Source |
1 |
/* |
||
2 |
* Indeo Video Interactive v4 compatible decoder |
||
3 |
* Copyright (c) 2009-2011 Maxim Poliakovski |
||
4 |
* |
||
5 |
* This file is part of FFmpeg. |
||
6 |
* |
||
7 |
* FFmpeg is free software; you can redistribute it and/or |
||
8 |
* modify it under the terms of the GNU Lesser General Public |
||
9 |
* License as published by the Free Software Foundation; either |
||
10 |
* version 2.1 of the License, or (at your option) any later version. |
||
11 |
* |
||
12 |
* FFmpeg is distributed in the hope that it will be useful, |
||
13 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
14 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||
15 |
* Lesser General Public License for more details. |
||
16 |
* |
||
17 |
* You should have received a copy of the GNU Lesser General Public |
||
18 |
* License along with FFmpeg; if not, write to the Free Software |
||
19 |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||
20 |
*/ |
||
21 |
|||
22 |
/** |
||
23 |
* @file |
||
24 |
* Indeo Video Interactive version 4 decoder |
||
25 |
* |
||
26 |
* Indeo 4 data is usually transported within .avi or .mov files. |
||
27 |
* Known FOURCCs: 'IV41' |
||
28 |
*/ |
||
29 |
|||
30 |
#define BITSTREAM_READER_LE |
||
31 |
#include "avcodec.h" |
||
32 |
#include "get_bits.h" |
||
33 |
#include "libavutil/imgutils.h" |
||
34 |
#include "indeo4data.h" |
||
35 |
#include "internal.h" |
||
36 |
#include "ivi.h" |
||
37 |
#include "ivi_dsp.h" |
||
38 |
|||
39 |
#define IVI4_PIC_SIZE_ESC 7 |
||
40 |
|||
41 |
|||
42 |
static const struct { |
||
43 |
InvTransformPtr *inv_trans; |
||
44 |
DCTransformPtr *dc_trans; |
||
45 |
int is_2d_trans; |
||
46 |
} transforms[18] = { |
||
47 |
{ ff_ivi_inverse_haar_8x8, ff_ivi_dc_haar_2d, 1 }, |
||
48 |
{ ff_ivi_row_haar8, ff_ivi_dc_haar_2d, 0 }, |
||
49 |
{ ff_ivi_col_haar8, ff_ivi_dc_haar_2d, 0 }, |
||
50 |
{ ff_ivi_put_pixels_8x8, ff_ivi_put_dc_pixel_8x8, 1 }, |
||
51 |
{ ff_ivi_inverse_slant_8x8, ff_ivi_dc_slant_2d, 1 }, |
||
52 |
{ ff_ivi_row_slant8, ff_ivi_dc_row_slant, 1 }, |
||
53 |
{ ff_ivi_col_slant8, ff_ivi_dc_col_slant, 1 }, |
||
54 |
{ NULL, NULL, 0 }, /* inverse DCT 8x8 */ |
||
55 |
{ NULL, NULL, 0 }, /* inverse DCT 8x1 */ |
||
56 |
{ NULL, NULL, 0 }, /* inverse DCT 1x8 */ |
||
57 |
{ ff_ivi_inverse_haar_4x4, ff_ivi_dc_haar_2d, 1 }, |
||
58 |
{ ff_ivi_inverse_slant_4x4, ff_ivi_dc_slant_2d, 1 }, |
||
59 |
{ NULL, NULL, 0 }, /* no transform 4x4 */ |
||
60 |
{ ff_ivi_row_haar4, ff_ivi_dc_haar_2d, 0 }, |
||
61 |
{ ff_ivi_col_haar4, ff_ivi_dc_haar_2d, 0 }, |
||
62 |
{ ff_ivi_row_slant4, ff_ivi_dc_row_slant, 0 }, |
||
63 |
{ ff_ivi_col_slant4, ff_ivi_dc_col_slant, 0 }, |
||
64 |
{ NULL, NULL, 0 }, /* inverse DCT 4x4 */ |
||
65 |
}; |
||
66 |
|||
67 |
/** |
||
68 |
* Decode subdivision of a plane. |
||
69 |
* This is a simplified version that checks for two supported subdivisions: |
||
70 |
* - 1 wavelet band per plane, size factor 1:1, code pattern: 3 |
||
71 |
* - 4 wavelet bands per plane, size factor 1:4, code pattern: 2,3,3,3,3 |
||
72 |
* Anything else is either unsupported or corrupt. |
||
73 |
* |
||
74 |
* @param[in,out] gb the GetBit context |
||
75 |
* @return number of wavelet bands or 0 on error |
||
76 |
*/ |
||
77 |
202 |
static int decode_plane_subdivision(GetBitContext *gb) |
|
78 |
{ |
||
79 |
int i; |
||
80 |
|||
81 |
✓✗✗ | 202 |
switch (get_bits(gb, 2)) { |
82 |
202 |
case 3: |
|
83 |
202 |
return 1; |
|
84 |
case 2: |
||
85 |
for (i = 0; i < 4; i++) |
||
86 |
if (get_bits(gb, 2) != 3) |
||
87 |
return 0; |
||
88 |
return 4; |
||
89 |
default: |
||
90 |
return 0; |
||
91 |
} |
||
92 |
} |
||
93 |
|||
94 |
static inline int scale_tile_size(int def_size, int size_factor) |
||
95 |
{ |
||
96 |
return size_factor == 15 ? def_size : (size_factor + 1) << 5; |
||
97 |
} |
||
98 |
|||
99 |
/** |
||
100 |
* Decode Indeo 4 picture header. |
||
101 |
* |
||
102 |
* @param[in,out] ctx pointer to the decoder context |
||
103 |
* @param[in] avctx pointer to the AVCodecContext |
||
104 |
* @return result code: 0 = OK, negative number = error |
||
105 |
*/ |
||
106 |
101 |
static int decode_pic_hdr(IVI45DecContext *ctx, AVCodecContext *avctx) |
|
107 |
{ |
||
108 |
int pic_size_indx, i, p; |
||
109 |
IVIPicConfig pic_conf; |
||
110 |
|||
111 |
✗✓ | 101 |
if (get_bits(&ctx->gb, 18) != 0x3FFF8) { |
112 |
av_log(avctx, AV_LOG_ERROR, "Invalid picture start code!\n"); |
||
113 |
return AVERROR_INVALIDDATA; |
||
114 |
} |
||
115 |
|||
116 |
101 |
ctx->prev_frame_type = ctx->frame_type; |
|
117 |
101 |
ctx->frame_type = get_bits(&ctx->gb, 3); |
|
118 |
✗✓ | 101 |
if (ctx->frame_type == 7) { |
119 |
av_log(avctx, AV_LOG_ERROR, "Invalid frame type: %d\n", ctx->frame_type); |
||
120 |
return AVERROR_INVALIDDATA; |
||
121 |
} |
||
122 |
|||
123 |
✗✓ | 101 |
if (ctx->frame_type == IVI4_FRAMETYPE_BIDIR) |
124 |
ctx->has_b_frames = 1; |
||
125 |
|||
126 |
101 |
ctx->has_transp = get_bits1(&ctx->gb); |
|
127 |
|||
128 |
/* unknown bit: Mac decoder ignores this bit, XANIM returns error */ |
||
129 |
✗✓ | 101 |
if (get_bits1(&ctx->gb)) { |
130 |
av_log(avctx, AV_LOG_ERROR, "Sync bit is set!\n"); |
||
131 |
return AVERROR_INVALIDDATA; |
||
132 |
} |
||
133 |
|||
134 |
✓✗ | 101 |
ctx->data_size = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 24) : 0; |
135 |
|||
136 |
/* null frames don't contain anything else so we just return */ |
||
137 |
✗✓ | 101 |
if (ctx->frame_type >= IVI4_FRAMETYPE_NULL_FIRST) { |
138 |
ff_dlog(avctx, "Null frame encountered!\n"); |
||
139 |
return 0; |
||
140 |
} |
||
141 |
|||
142 |
/* Check key lock status. If enabled - ignore lock word. */ |
||
143 |
/* Usually we have to prompt the user for the password, but */ |
||
144 |
/* we don't do that because Indeo 4 videos can be decoded anyway */ |
||
145 |
✗✓ | 101 |
if (get_bits1(&ctx->gb)) { |
146 |
skip_bits_long(&ctx->gb, 32); |
||
147 |
ff_dlog(avctx, "Password-protected clip!\n"); |
||
148 |
} |
||
149 |
|||
150 |
101 |
pic_size_indx = get_bits(&ctx->gb, 3); |
|
151 |
✗✓ | 101 |
if (pic_size_indx == IVI4_PIC_SIZE_ESC) { |
152 |
pic_conf.pic_height = get_bits(&ctx->gb, 16); |
||
153 |
pic_conf.pic_width = get_bits(&ctx->gb, 16); |
||
154 |
} else { |
||
155 |
101 |
pic_conf.pic_height = ivi4_common_pic_sizes[pic_size_indx * 2 + 1]; |
|
156 |
101 |
pic_conf.pic_width = ivi4_common_pic_sizes[pic_size_indx * 2 ]; |
|
157 |
} |
||
158 |
|||
159 |
/* Decode tile dimensions. */ |
||
160 |
101 |
ctx->uses_tiling = get_bits1(&ctx->gb); |
|
161 |
✗✓ | 101 |
if (ctx->uses_tiling) { |
162 |
pic_conf.tile_height = scale_tile_size(pic_conf.pic_height, get_bits(&ctx->gb, 4)); |
||
163 |
pic_conf.tile_width = scale_tile_size(pic_conf.pic_width, get_bits(&ctx->gb, 4)); |
||
164 |
} else { |
||
165 |
101 |
pic_conf.tile_height = pic_conf.pic_height; |
|
166 |
101 |
pic_conf.tile_width = pic_conf.pic_width; |
|
167 |
} |
||
168 |
|||
169 |
/* Decode chroma subsampling. We support only 4:4 aka YVU9. */ |
||
170 |
✗✓ | 101 |
if (get_bits(&ctx->gb, 2)) { |
171 |
av_log(avctx, AV_LOG_ERROR, "Only YVU9 picture format is supported!\n"); |
||
172 |
return AVERROR_INVALIDDATA; |
||
173 |
} |
||
174 |
101 |
pic_conf.chroma_height = (pic_conf.pic_height + 3) >> 2; |
|
175 |
101 |
pic_conf.chroma_width = (pic_conf.pic_width + 3) >> 2; |
|
176 |
|||
177 |
/* decode subdivision of the planes */ |
||
178 |
101 |
pic_conf.luma_bands = decode_plane_subdivision(&ctx->gb); |
|
179 |
101 |
pic_conf.chroma_bands = 0; |
|
180 |
✓✗ | 101 |
if (pic_conf.luma_bands) |
181 |
101 |
pic_conf.chroma_bands = decode_plane_subdivision(&ctx->gb); |
|
182 |
|||
183 |
✗✓ | 101 |
if (av_image_check_size2(pic_conf.pic_width, pic_conf.pic_height, avctx->max_pixels, AV_PIX_FMT_YUV410P, 0, avctx) < 0) { |
184 |
av_log(avctx, AV_LOG_ERROR, "picture dimensions %d %d cannot be decoded\n", |
||
185 |
pic_conf.pic_width, pic_conf.pic_height); |
||
186 |
return AVERROR_INVALIDDATA; |
||
187 |
} |
||
188 |
|||
189 |
✓✗✗✓ |
101 |
ctx->is_scalable = pic_conf.luma_bands != 1 || pic_conf.chroma_bands != 1; |
190 |
✗✓✗✗ ✗✗ |
101 |
if (ctx->is_scalable && (pic_conf.luma_bands != 4 || pic_conf.chroma_bands != 1)) { |
191 |
av_log(avctx, AV_LOG_ERROR, "Scalability: unsupported subdivision! Luma bands: %d, chroma bands: %d\n", |
||
192 |
pic_conf.luma_bands, pic_conf.chroma_bands); |
||
193 |
return AVERROR_INVALIDDATA; |
||
194 |
} |
||
195 |
|||
196 |
/* check if picture layout was changed and reallocate buffers */ |
||
197 |
✓✓ | 101 |
if (ivi_pic_config_cmp(&pic_conf, &ctx->pic_conf)) { |
198 |
✗✓ | 1 |
if (ff_ivi_init_planes(avctx, ctx->planes, &pic_conf, 1)) { |
199 |
av_log(avctx, AV_LOG_ERROR, "Couldn't reallocate color planes!\n"); |
||
200 |
ctx->pic_conf.luma_bands = 0; |
||
201 |
return AVERROR(ENOMEM); |
||
202 |
} |
||
203 |
|||
204 |
1 |
ctx->pic_conf = pic_conf; |
|
205 |
|||
206 |
/* set default macroblock/block dimensions */ |
||
207 |
✓✓ | 4 |
for (p = 0; p <= 2; p++) { |
208 |
✓✓✓✓ |
6 |
for (i = 0; i < (!p ? pic_conf.luma_bands : pic_conf.chroma_bands); i++) { |
209 |
✓✓✓✗ |
3 |
ctx->planes[p].bands[i].mb_size = !p ? (!ctx->is_scalable ? 16 : 8) : 4; |
210 |
✓✓ | 3 |
ctx->planes[p].bands[i].blk_size = !p ? 8 : 4; |
211 |
} |
||
212 |
} |
||
213 |
|||
214 |
✗✓ | 1 |
if (ff_ivi_init_tiles(ctx->planes, ctx->pic_conf.tile_width, |
215 |
1 |
ctx->pic_conf.tile_height)) { |
|
216 |
av_log(avctx, AV_LOG_ERROR, |
||
217 |
"Couldn't reallocate internal structures!\n"); |
||
218 |
return AVERROR(ENOMEM); |
||
219 |
} |
||
220 |
} |
||
221 |
|||
222 |
✓✗ | 101 |
ctx->frame_num = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 20) : 0; |
223 |
|||
224 |
/* skip decTimeEst field if present */ |
||
225 |
✗✓ | 101 |
if (get_bits1(&ctx->gb)) |
226 |
skip_bits(&ctx->gb, 8); |
||
227 |
|||
228 |
/* decode macroblock and block huffman codebooks */ |
||
229 |
✓✗✗✓ |
202 |
if (ff_ivi_dec_huff_desc(&ctx->gb, get_bits1(&ctx->gb), IVI_MB_HUFF, &ctx->mb_vlc, avctx) || |
230 |
101 |
ff_ivi_dec_huff_desc(&ctx->gb, get_bits1(&ctx->gb), IVI_BLK_HUFF, &ctx->blk_vlc, avctx)) |
|
231 |
return AVERROR_INVALIDDATA; |
||
232 |
|||
233 |
✗✓ | 101 |
ctx->rvmap_sel = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 3) : 8; |
234 |
|||
235 |
101 |
ctx->in_imf = get_bits1(&ctx->gb); |
|
236 |
101 |
ctx->in_q = get_bits1(&ctx->gb); |
|
237 |
|||
238 |
101 |
ctx->pic_glob_quant = get_bits(&ctx->gb, 5); |
|
239 |
|||
240 |
/* TODO: ignore this parameter if unused */ |
||
241 |
✓✗ | 101 |
ctx->unknown1 = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 3) : 0; |
242 |
|||
243 |
✓✗ | 101 |
ctx->checksum = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 16) : 0; |
244 |
|||
245 |
/* skip picture header extension if any */ |
||
246 |
✓✓ | 202 |
while (get_bits1(&ctx->gb)) { |
247 |
ff_dlog(avctx, "Pic hdr extension encountered!\n"); |
||
248 |
✗✓ | 101 |
if (get_bits_left(&ctx->gb) < 10) |
249 |
return AVERROR_INVALIDDATA; |
||
250 |
101 |
skip_bits(&ctx->gb, 8); |
|
251 |
} |
||
252 |
|||
253 |
✗✓ | 101 |
if (get_bits1(&ctx->gb)) { |
254 |
av_log(avctx, AV_LOG_ERROR, "Bad blocks bits encountered!\n"); |
||
255 |
} |
||
256 |
|||
257 |
101 |
align_get_bits(&ctx->gb); |
|
258 |
|||
259 |
101 |
return 0; |
|
260 |
} |
||
261 |
|||
262 |
|||
263 |
/** |
||
264 |
* Decode Indeo 4 band header. |
||
265 |
* |
||
266 |
* @param[in,out] ctx pointer to the decoder context |
||
267 |
* @param[in,out] band pointer to the band descriptor |
||
268 |
* @param[in] avctx pointer to the AVCodecContext |
||
269 |
* @return result code: 0 = OK, negative number = error |
||
270 |
*/ |
||
271 |
301 |
static int decode_band_hdr(IVI45DecContext *ctx, IVIBandDesc *arg_band, |
|
272 |
AVCodecContext *avctx) |
||
273 |
{ |
||
274 |
int plane, band_num, indx, transform_id, scan_indx; |
||
275 |
int i; |
||
276 |
int quant_mat; |
||
277 |
301 |
IVIBandDesc temp_band, *band = &temp_band; |
|
278 |
301 |
memcpy(&temp_band, arg_band, sizeof(temp_band)); |
|
279 |
|||
280 |
301 |
plane = get_bits(&ctx->gb, 2); |
|
281 |
301 |
band_num = get_bits(&ctx->gb, 4); |
|
282 |
✓✗✗✓ |
301 |
if (band->plane != plane || band->band_num != band_num) { |
283 |
av_log(avctx, AV_LOG_ERROR, "Invalid band header sequence!\n"); |
||
284 |
return AVERROR_INVALIDDATA; |
||
285 |
} |
||
286 |
|||
287 |
301 |
band->is_empty = get_bits1(&ctx->gb); |
|
288 |
✓✗ | 301 |
if (!band->is_empty) { |
289 |
301 |
int old_blk_size = band->blk_size; |
|
290 |
/* skip header size |
||
291 |
* If header size is not given, header size is 4 bytes. */ |
||
292 |
✓✗ | 301 |
if (get_bits1(&ctx->gb)) |
293 |
301 |
skip_bits(&ctx->gb, 16); |
|
294 |
|||
295 |
301 |
band->is_halfpel = get_bits(&ctx->gb, 2); |
|
296 |
✗✓ | 301 |
if (band->is_halfpel >= 2) { |
297 |
av_log(avctx, AV_LOG_ERROR, "Invalid/unsupported mv resolution: %d!\n", |
||
298 |
band->is_halfpel); |
||
299 |
return AVERROR_INVALIDDATA; |
||
300 |
} |
||
301 |
✗✓ | 301 |
if (!band->is_halfpel) |
302 |
ctx->uses_fullpel = 1; |
||
303 |
|||
304 |
301 |
band->checksum_present = get_bits1(&ctx->gb); |
|
305 |
✓✗ | 301 |
if (band->checksum_present) |
306 |
301 |
band->checksum = get_bits(&ctx->gb, 16); |
|
307 |
|||
308 |
301 |
indx = get_bits(&ctx->gb, 2); |
|
309 |
✗✓ | 301 |
if (indx == 3) { |
310 |
av_log(avctx, AV_LOG_ERROR, "Invalid block size!\n"); |
||
311 |
return AVERROR_INVALIDDATA; |
||
312 |
} |
||
313 |
301 |
band->mb_size = 16 >> indx; |
|
314 |
301 |
band->blk_size = 8 >> (indx >> 1); |
|
315 |
|||
316 |
301 |
band->inherit_mv = get_bits1(&ctx->gb); |
|
317 |
301 |
band->inherit_qdelta = get_bits1(&ctx->gb); |
|
318 |
|||
319 |
301 |
band->glob_quant = get_bits(&ctx->gb, 5); |
|
320 |
|||
321 |
✓✓✗✓ |
301 |
if (!get_bits1(&ctx->gb) || ctx->frame_type == IVI4_FRAMETYPE_INTRA) { |
322 |
21 |
transform_id = get_bits(&ctx->gb, 5); |
|
323 |
✓✗ | 21 |
if (transform_id >= FF_ARRAY_ELEMS(transforms) || |
324 |
✗✓ | 21 |
!transforms[transform_id].inv_trans) { |
325 |
avpriv_request_sample(avctx, "Transform %d", transform_id); |
||
326 |
return AVERROR_PATCHWELCOME; |
||
327 |
} |
||
328 |
✓✓✓✗ ✗✓ |
21 |
if ((transform_id >= 7 && transform_id <= 9) || |
329 |
transform_id == 17) { |
||
330 |
avpriv_request_sample(avctx, "DCT transform"); |
||
331 |
return AVERROR_PATCHWELCOME; |
||
332 |
} |
||
333 |
|||
334 |
✓✓✗✓ |
21 |
if (transform_id < 10 && band->blk_size < 8) { |
335 |
av_log(avctx, AV_LOG_ERROR, "wrong transform size!\n"); |
||
336 |
return AVERROR_INVALIDDATA; |
||
337 |
} |
||
338 |
✓✗✓✗ ✗✓ |
21 |
if ((transform_id >= 0 && transform_id <= 2) || transform_id == 10) |
339 |
ctx->uses_haar = 1; |
||
340 |
|||
341 |
21 |
band->inv_transform = transforms[transform_id].inv_trans; |
|
342 |
21 |
band->dc_transform = transforms[transform_id].dc_trans; |
|
343 |
21 |
band->is_2d_trans = transforms[transform_id].is_2d_trans; |
|
344 |
|||
345 |
✓✓ | 21 |
if (transform_id < 10) |
346 |
7 |
band->transform_size = 8; |
|
347 |
else |
||
348 |
14 |
band->transform_size = 4; |
|
349 |
|||
350 |
✗✓ | 21 |
if (band->blk_size != band->transform_size) { |
351 |
av_log(avctx, AV_LOG_ERROR, "transform and block size mismatch (%d != %d)\n", band->transform_size, band->blk_size); |
||
352 |
return AVERROR_INVALIDDATA; |
||
353 |
} |
||
354 |
|||
355 |
21 |
scan_indx = get_bits(&ctx->gb, 4); |
|
356 |
✗✓ | 21 |
if (scan_indx == 15) { |
357 |
av_log(avctx, AV_LOG_ERROR, "Custom scan pattern encountered!\n"); |
||
358 |
return AVERROR_INVALIDDATA; |
||
359 |
} |
||
360 |
✓✓✓✗ |
21 |
if (scan_indx > 4 && scan_indx < 10) { |
361 |
✗✓ | 14 |
if (band->blk_size != 4) { |
362 |
av_log(avctx, AV_LOG_ERROR, "mismatching scan table!\n"); |
||
363 |
return AVERROR_INVALIDDATA; |
||
364 |
} |
||
365 |
✗✓ | 7 |
} else if (band->blk_size != 8) { |
366 |
av_log(avctx, AV_LOG_ERROR, "mismatching scan table!\n"); |
||
367 |
return AVERROR_INVALIDDATA; |
||
368 |
} |
||
369 |
|||
370 |
21 |
band->scan = scan_index_to_tab[scan_indx]; |
|
371 |
21 |
band->scan_size = band->blk_size; |
|
372 |
|||
373 |
21 |
quant_mat = get_bits(&ctx->gb, 5); |
|
374 |
✗✓ | 21 |
if (quant_mat == 31) { |
375 |
av_log(avctx, AV_LOG_ERROR, "Custom quant matrix encountered!\n"); |
||
376 |
return AVERROR_INVALIDDATA; |
||
377 |
} |
||
378 |
✗✓ | 21 |
if (quant_mat >= FF_ARRAY_ELEMS(quant_index_to_tab)) { |
379 |
avpriv_request_sample(avctx, "Quantization matrix %d", |
||
380 |
quant_mat); |
||
381 |
return AVERROR_INVALIDDATA; |
||
382 |
} |
||
383 |
21 |
band->quant_mat = quant_mat; |
|
384 |
} else { |
||
385 |
✗✓ | 280 |
if (old_blk_size != band->blk_size) { |
386 |
av_log(avctx, AV_LOG_ERROR, |
||
387 |
"The band block size does not match the configuration " |
||
388 |
"inherited\n"); |
||
389 |
return AVERROR_INVALIDDATA; |
||
390 |
} |
||
391 |
} |
||
392 |
✓✓✗✓ |
301 |
if (quant_index_to_tab[band->quant_mat] > 4 && band->blk_size == 4) { |
393 |
av_log(avctx, AV_LOG_ERROR, "Invalid quant matrix for 4x4 block encountered!\n"); |
||
394 |
band->quant_mat = 0; |
||
395 |
return AVERROR_INVALIDDATA; |
||
396 |
} |
||
397 |
✗✓ | 301 |
if (band->scan_size != band->blk_size) { |
398 |
av_log(avctx, AV_LOG_ERROR, "mismatching scan table!\n"); |
||
399 |
return AVERROR_INVALIDDATA; |
||
400 |
} |
||
401 |
✓✓✗✓ |
301 |
if (band->transform_size == 8 && band->blk_size < 8) { |
402 |
av_log(avctx, AV_LOG_ERROR, "mismatching transform_size!\n"); |
||
403 |
return AVERROR_INVALIDDATA; |
||
404 |
} |
||
405 |
|||
406 |
/* decode block huffman codebook */ |
||
407 |
✗✓ | 301 |
if (!get_bits1(&ctx->gb)) |
408 |
arg_band->blk_vlc.tab = ctx->blk_vlc.tab; |
||
409 |
else |
||
410 |
✗✓ | 301 |
if (ff_ivi_dec_huff_desc(&ctx->gb, 1, IVI_BLK_HUFF, |
411 |
&arg_band->blk_vlc, avctx)) |
||
412 |
return AVERROR_INVALIDDATA; |
||
413 |
|||
414 |
/* select appropriate rvmap table for this band */ |
||
415 |
✓✗ | 301 |
band->rvmap_sel = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 3) : 8; |
416 |
|||
417 |
/* decode rvmap probability corrections if any */ |
||
418 |
301 |
band->num_corr = 0; /* there is no corrections */ |
|
419 |
✓✓ | 301 |
if (get_bits1(&ctx->gb)) { |
420 |
253 |
band->num_corr = get_bits(&ctx->gb, 8); /* get number of correction pairs */ |
|
421 |
✗✓ | 253 |
if (band->num_corr > 61) { |
422 |
av_log(avctx, AV_LOG_ERROR, "Too many corrections: %d\n", |
||
423 |
band->num_corr); |
||
424 |
return AVERROR_INVALIDDATA; |
||
425 |
} |
||
426 |
|||
427 |
/* read correction pairs */ |
||
428 |
✓✓ | 4087 |
for (i = 0; i < band->num_corr * 2; i++) |
429 |
3834 |
band->corr[i] = get_bits(&ctx->gb, 8); |
|
430 |
} |
||
431 |
} |
||
432 |
|||
433 |
✓✓ | 301 |
if (band->blk_size == 8) { |
434 |
101 |
band->intra_base = &ivi4_quant_8x8_intra[quant_index_to_tab[band->quant_mat]][0]; |
|
435 |
101 |
band->inter_base = &ivi4_quant_8x8_inter[quant_index_to_tab[band->quant_mat]][0]; |
|
436 |
} else { |
||
437 |
200 |
band->intra_base = &ivi4_quant_4x4_intra[quant_index_to_tab[band->quant_mat]][0]; |
|
438 |
200 |
band->inter_base = &ivi4_quant_4x4_inter[quant_index_to_tab[band->quant_mat]][0]; |
|
439 |
} |
||
440 |
|||
441 |
/* Indeo 4 doesn't use scale tables */ |
||
442 |
301 |
band->intra_scale = NULL; |
|
443 |
301 |
band->inter_scale = NULL; |
|
444 |
|||
445 |
301 |
align_get_bits(&ctx->gb); |
|
446 |
|||
447 |
✗✓ | 301 |
if (!band->scan) { |
448 |
av_log(avctx, AV_LOG_ERROR, "band->scan not set\n"); |
||
449 |
return AVERROR_INVALIDDATA; |
||
450 |
} |
||
451 |
|||
452 |
301 |
band->blk_vlc = arg_band->blk_vlc; |
|
453 |
301 |
memcpy(arg_band, band, sizeof(*arg_band)); |
|
454 |
|||
455 |
301 |
return 0; |
|
456 |
} |
||
457 |
|||
458 |
|||
459 |
/** |
||
460 |
* Decode information (block type, cbp, quant delta, motion vector) |
||
461 |
* for all macroblocks in the current tile. |
||
462 |
* |
||
463 |
* @param[in,out] ctx pointer to the decoder context |
||
464 |
* @param[in,out] band pointer to the band descriptor |
||
465 |
* @param[in,out] tile pointer to the tile descriptor |
||
466 |
* @param[in] avctx pointer to the AVCodecContext |
||
467 |
* @return result code: 0 = OK, negative number = error |
||
468 |
*/ |
||
469 |
301 |
static int decode_mb_info(IVI45DecContext *ctx, IVIBandDesc *band, |
|
470 |
IVITile *tile, AVCodecContext *avctx) |
||
471 |
{ |
||
472 |
int x, y, mv_x, mv_y, mv_delta, offs, mb_offset, blks_per_mb, |
||
473 |
mv_scale, mb_type_bits, s; |
||
474 |
IVIMbInfo *mb, *ref_mb; |
||
475 |
301 |
int row_offset = band->mb_size * band->pitch; |
|
476 |
|||
477 |
301 |
mb = tile->mbs; |
|
478 |
301 |
ref_mb = tile->ref_mbs; |
|
479 |
301 |
offs = tile->ypos * band->pitch + tile->xpos; |
|
480 |
|||
481 |
✓✓ | 301 |
blks_per_mb = band->mb_size != band->blk_size ? 4 : 1; |
482 |
✗✓ | 301 |
mb_type_bits = ctx->frame_type == IVI4_FRAMETYPE_BIDIR ? 2 : 1; |
483 |
|||
484 |
/* scale factor for motion vectors */ |
||
485 |
301 |
mv_scale = (ctx->planes[0].bands[0].mb_size >> 3) - (band->mb_size >> 3); |
|
486 |
301 |
mv_x = mv_y = 0; |
|
487 |
|||
488 |
✗✓ | 301 |
if (((tile->width + band->mb_size-1)/band->mb_size) * ((tile->height + band->mb_size-1)/band->mb_size) != tile->num_MBs) { |
489 |
av_log(avctx, AV_LOG_ERROR, "num_MBs mismatch %d %d %d %d\n", tile->width, tile->height, band->mb_size, tile->num_MBs); |
||
490 |
return -1; |
||
491 |
} |
||
492 |
|||
493 |
✓✓ | 4816 |
for (y = tile->ypos; y < tile->ypos + tile->height; y += band->mb_size) { |
494 |
4515 |
mb_offset = offs; |
|
495 |
|||
496 |
✓✓ | 94815 |
for (x = tile->xpos; x < tile->xpos + tile->width; x += band->mb_size) { |
497 |
90300 |
mb->xpos = x; |
|
498 |
90300 |
mb->ypos = y; |
|
499 |
90300 |
mb->buf_offs = mb_offset; |
|
500 |
90300 |
mb->b_mv_x = |
|
501 |
90300 |
mb->b_mv_y = 0; |
|
502 |
|||
503 |
✗✓ | 90300 |
if (get_bits_left(&ctx->gb) < 1) { |
504 |
av_log(avctx, AV_LOG_ERROR, "Insufficient input for mb info\n"); |
||
505 |
return AVERROR_INVALIDDATA; |
||
506 |
} |
||
507 |
|||
508 |
✓✓ | 90300 |
if (get_bits1(&ctx->gb)) { |
509 |
✗✓ | 2014 |
if (ctx->frame_type == IVI4_FRAMETYPE_INTRA) { |
510 |
av_log(avctx, AV_LOG_ERROR, "Empty macroblock in an INTRA picture!\n"); |
||
511 |
return AVERROR_INVALIDDATA; |
||
512 |
} |
||
513 |
2014 |
mb->type = 1; /* empty macroblocks are always INTER */ |
|
514 |
2014 |
mb->cbp = 0; /* all blocks are empty */ |
|
515 |
|||
516 |
2014 |
mb->q_delta = 0; |
|
517 |
✓✓✓✗ ✓✗ |
2014 |
if (!band->plane && !band->band_num && ctx->in_q) { |
518 |
56 |
mb->q_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table, |
|
519 |
IVI_VLC_BITS, 1); |
||
520 |
56 |
mb->q_delta = IVI_TOSIGNED(mb->q_delta); |
|
521 |
} |
||
522 |
|||
523 |
2014 |
mb->mv_x = mb->mv_y = 0; /* no motion vector coded */ |
|
524 |
✓✓✓✗ |
2014 |
if (band->inherit_mv && ref_mb) { |
525 |
/* motion vector inheritance */ |
||
526 |
✓✗ | 1958 |
if (mv_scale) { |
527 |
1958 |
mb->mv_x = ivi_scale_mv(ref_mb->mv_x, mv_scale); |
|
528 |
1958 |
mb->mv_y = ivi_scale_mv(ref_mb->mv_y, mv_scale); |
|
529 |
} else { |
||
530 |
mb->mv_x = ref_mb->mv_x; |
||
531 |
mb->mv_y = ref_mb->mv_y; |
||
532 |
} |
||
533 |
} |
||
534 |
} else { |
||
535 |
✓✓ | 88286 |
if (band->inherit_mv) { |
536 |
/* copy mb_type from corresponding reference mb */ |
||
537 |
✗✓ | 58042 |
if (!ref_mb) { |
538 |
av_log(avctx, AV_LOG_ERROR, "ref_mb unavailable\n"); |
||
539 |
return AVERROR_INVALIDDATA; |
||
540 |
} |
||
541 |
58042 |
mb->type = ref_mb->type; |
|
542 |
✓✓ | 30244 |
} else if (ctx->frame_type == IVI4_FRAMETYPE_INTRA || |
543 |
✗✓ | 28144 |
ctx->frame_type == IVI4_FRAMETYPE_INTRA1) { |
544 |
2100 |
mb->type = 0; /* mb_type is always INTRA for intra-frames */ |
|
545 |
} else { |
||
546 |
28144 |
mb->type = get_bits(&ctx->gb, mb_type_bits); |
|
547 |
} |
||
548 |
|||
549 |
88286 |
mb->cbp = get_bits(&ctx->gb, blks_per_mb); |
|
550 |
|||
551 |
88286 |
mb->q_delta = 0; |
|
552 |
✓✓ | 88286 |
if (band->inherit_qdelta) { |
553 |
✓✗ | 58042 |
if (ref_mb) mb->q_delta = ref_mb->q_delta; |
554 |
✓✓✓✗ ✓✗ |
30244 |
} else if (mb->cbp || (!band->plane && !band->band_num && |
555 |
✓✗ | 967 |
ctx->in_q)) { |
556 |
30244 |
mb->q_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table, |
|
557 |
IVI_VLC_BITS, 1); |
||
558 |
30244 |
mb->q_delta = IVI_TOSIGNED(mb->q_delta); |
|
559 |
} |
||
560 |
|||
561 |
✓✓ | 88286 |
if (!mb->type) { |
562 |
77874 |
mb->mv_x = mb->mv_y = 0; /* there is no motion vector in intra-macroblocks */ |
|
563 |
} else { |
||
564 |
✓✓ | 10412 |
if (band->inherit_mv) { |
565 |
✓✗ | 6274 |
if (ref_mb) |
566 |
/* motion vector inheritance */ |
||
567 |
✓✗ | 6274 |
if (mv_scale) { |
568 |
6274 |
mb->mv_x = ivi_scale_mv(ref_mb->mv_x, mv_scale); |
|
569 |
6274 |
mb->mv_y = ivi_scale_mv(ref_mb->mv_y, mv_scale); |
|
570 |
} else { |
||
571 |
mb->mv_x = ref_mb->mv_x; |
||
572 |
mb->mv_y = ref_mb->mv_y; |
||
573 |
} |
||
574 |
} else { |
||
575 |
/* decode motion vector deltas */ |
||
576 |
4138 |
mv_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table, |
|
577 |
IVI_VLC_BITS, 1); |
||
578 |
4138 |
mv_y += IVI_TOSIGNED(mv_delta); |
|
579 |
4138 |
mv_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table, |
|
580 |
IVI_VLC_BITS, 1); |
||
581 |
4138 |
mv_x += IVI_TOSIGNED(mv_delta); |
|
582 |
4138 |
mb->mv_x = mv_x; |
|
583 |
4138 |
mb->mv_y = mv_y; |
|
584 |
✗✓ | 4138 |
if (mb->type == 3) { |
585 |
mv_delta = get_vlc2(&ctx->gb, |
||
586 |
ctx->mb_vlc.tab->table, |
||
587 |
IVI_VLC_BITS, 1); |
||
588 |
mv_y += IVI_TOSIGNED(mv_delta); |
||
589 |
mv_delta = get_vlc2(&ctx->gb, |
||
590 |
ctx->mb_vlc.tab->table, |
||
591 |
IVI_VLC_BITS, 1); |
||
592 |
mv_x += IVI_TOSIGNED(mv_delta); |
||
593 |
mb->b_mv_x = -mv_x; |
||
594 |
mb->b_mv_y = -mv_y; |
||
595 |
} |
||
596 |
} |
||
597 |
✗✓ | 10412 |
if (mb->type == 2) { |
598 |
mb->b_mv_x = -mb->mv_x; |
||
599 |
mb->b_mv_y = -mb->mv_y; |
||
600 |
mb->mv_x = 0; |
||
601 |
mb->mv_y = 0; |
||
602 |
} |
||
603 |
} |
||
604 |
} |
||
605 |
|||
606 |
90300 |
s= band->is_halfpel; |
|
607 |
✓✓ | 90300 |
if (mb->type) |
608 |
✓✗ | 12426 |
if ( x + (mb->mv_x >>s) + (y+ (mb->mv_y >>s))*band->pitch < 0 || |
609 |
12426 |
x + ((mb->mv_x+s)>>s) + band->mb_size - 1 |
|
610 |
✗✓ | 12426 |
+ (y+band->mb_size - 1 +((mb->mv_y+s)>>s))*band->pitch > band->bufsize -1) { |
611 |
av_log(avctx, AV_LOG_ERROR, "motion vector %d %d outside reference\n", x*s + mb->mv_x, y*s + mb->mv_y); |
||
612 |
return AVERROR_INVALIDDATA; |
||
613 |
} |
||
614 |
|||
615 |
90300 |
mb++; |
|
616 |
✓✓ | 90300 |
if (ref_mb) |
617 |
60000 |
ref_mb++; |
|
618 |
90300 |
mb_offset += band->mb_size; |
|
619 |
} |
||
620 |
|||
621 |
4515 |
offs += row_offset; |
|
622 |
} |
||
623 |
|||
624 |
301 |
align_get_bits(&ctx->gb); |
|
625 |
|||
626 |
301 |
return 0; |
|
627 |
} |
||
628 |
|||
629 |
|||
630 |
/** |
||
631 |
* Rearrange decoding and reference buffers. |
||
632 |
* |
||
633 |
* @param[in,out] ctx pointer to the decoder context |
||
634 |
*/ |
||
635 |
101 |
static void switch_buffers(IVI45DecContext *ctx) |
|
636 |
{ |
||
637 |
101 |
int is_prev_ref = 0, is_ref = 0; |
|
638 |
|||
639 |
✓✓ | 101 |
switch (ctx->prev_frame_type) { |
640 |
54 |
case IVI4_FRAMETYPE_INTRA: |
|
641 |
case IVI4_FRAMETYPE_INTRA1: |
||
642 |
case IVI4_FRAMETYPE_INTER: |
||
643 |
54 |
is_prev_ref = 1; |
|
644 |
54 |
break; |
|
645 |
} |
||
646 |
|||
647 |
✓✓ | 101 |
switch (ctx->frame_type) { |
648 |
54 |
case IVI4_FRAMETYPE_INTRA: |
|
649 |
case IVI4_FRAMETYPE_INTRA1: |
||
650 |
case IVI4_FRAMETYPE_INTER: |
||
651 |
54 |
is_ref = 1; |
|
652 |
54 |
break; |
|
653 |
} |
||
654 |
|||
655 |
✓✓✓✓ |
101 |
if (is_prev_ref && is_ref) { |
656 |
7 |
FFSWAP(int, ctx->dst_buf, ctx->ref_buf); |
|
657 |
✓✓ | 94 |
} else if (is_prev_ref) { |
658 |
47 |
FFSWAP(int, ctx->ref_buf, ctx->b_ref_buf); |
|
659 |
47 |
FFSWAP(int, ctx->dst_buf, ctx->ref_buf); |
|
660 |
} |
||
661 |
101 |
} |
|
662 |
|||
663 |
|||
664 |
201 |
static int is_nonnull_frame(IVI45DecContext *ctx) |
|
665 |
{ |
||
666 |
201 |
return ctx->frame_type < IVI4_FRAMETYPE_NULL_FIRST; |
|
667 |
} |
||
668 |
|||
669 |
|||
670 |
2 |
static av_cold int decode_init(AVCodecContext *avctx) |
|
671 |
{ |
||
672 |
2 |
IVI45DecContext *ctx = avctx->priv_data; |
|
673 |
|||
674 |
2 |
ff_ivi_init_static_vlc(); |
|
675 |
|||
676 |
/* copy rvmap tables in our context so we can apply changes to them */ |
||
677 |
2 |
memcpy(ctx->rvmap_tabs, ff_ivi_rvmap_tabs, sizeof(ff_ivi_rvmap_tabs)); |
|
678 |
|||
679 |
/* Force allocation of the internal buffers */ |
||
680 |
/* during picture header decoding. */ |
||
681 |
2 |
ctx->pic_conf.pic_width = 0; |
|
682 |
2 |
ctx->pic_conf.pic_height = 0; |
|
683 |
|||
684 |
2 |
avctx->pix_fmt = AV_PIX_FMT_YUV410P; |
|
685 |
|||
686 |
2 |
ctx->decode_pic_hdr = decode_pic_hdr; |
|
687 |
2 |
ctx->decode_band_hdr = decode_band_hdr; |
|
688 |
2 |
ctx->decode_mb_info = decode_mb_info; |
|
689 |
2 |
ctx->switch_buffers = switch_buffers; |
|
690 |
2 |
ctx->is_nonnull_frame = is_nonnull_frame; |
|
691 |
|||
692 |
2 |
ctx->is_indeo4 = 1; |
|
693 |
2 |
ctx->show_indeo4_info = 1; |
|
694 |
|||
695 |
2 |
ctx->dst_buf = 0; |
|
696 |
2 |
ctx->ref_buf = 1; |
|
697 |
2 |
ctx->b_ref_buf = 3; /* buffer 2 is used for scalability mode */ |
|
698 |
2 |
ctx->p_frame = av_frame_alloc(); |
|
699 |
✗✓ | 2 |
if (!ctx->p_frame) |
700 |
return AVERROR(ENOMEM); |
||
701 |
|||
702 |
2 |
return 0; |
|
703 |
} |
||
704 |
|||
705 |
|||
706 |
AVCodec ff_indeo4_decoder = { |
||
707 |
.name = "indeo4", |
||
708 |
.long_name = NULL_IF_CONFIG_SMALL("Intel Indeo Video Interactive 4"), |
||
709 |
.type = AVMEDIA_TYPE_VIDEO, |
||
710 |
.id = AV_CODEC_ID_INDEO4, |
||
711 |
.priv_data_size = sizeof(IVI45DecContext), |
||
712 |
.init = decode_init, |
||
713 |
.close = ff_ivi_decode_close, |
||
714 |
.decode = ff_ivi_decode_frame, |
||
715 |
.capabilities = AV_CODEC_CAP_DR1, |
||
716 |
.caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, |
||
717 |
}; |
| Generated by: GCOVR (Version 4.2) |