2 * Indeo Video Interactive v4 compatible decoder
3 * Copyright (c) 2009-2011 Maxim Poliakovski
5 * This file is part of FFmpeg.
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.
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.
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
24 * Indeo Video Interactive version 4 decoder
26 * Indeo 4 data is usually transported within .avi or .mov files.
27 * Known FOURCCs: 'IV41'
30 #define BITSTREAM_READER_LE
34 #include "ivi_common.h"
35 #include "indeo4data.h"
37 #define IVI4_PIC_SIZE_ESC 7
41 InvTransformPtr
*inv_trans
;
42 DCTransformPtr
*dc_trans
;
45 { ff_ivi_inverse_haar_8x8
, ff_ivi_dc_haar_2d
, 1 },
46 { ff_ivi_row_haar8
, ff_ivi_dc_haar_2d
, 0 },
47 { ff_ivi_col_haar8
, ff_ivi_dc_haar_2d
, 0 },
48 { ff_ivi_put_pixels_8x8
, ff_ivi_put_dc_pixel_8x8
, 1 },
49 { ff_ivi_inverse_slant_8x8
, ff_ivi_dc_slant_2d
, 1 },
50 { ff_ivi_row_slant8
, ff_ivi_dc_row_slant
, 1 },
51 { ff_ivi_col_slant8
, ff_ivi_dc_col_slant
, 1 },
52 { NULL
, NULL
, 0 }, /* inverse DCT 8x8 */
53 { NULL
, NULL
, 0 }, /* inverse DCT 8x1 */
54 { NULL
, NULL
, 0 }, /* inverse DCT 1x8 */
55 { ff_ivi_inverse_haar_4x4
, ff_ivi_dc_haar_2d
, 1 },
56 { ff_ivi_inverse_slant_4x4
, ff_ivi_dc_slant_2d
, 1 },
57 { NULL
, NULL
, 0 }, /* no transform 4x4 */
58 { ff_ivi_row_haar4
, ff_ivi_dc_haar_2d
, 0 },
59 { ff_ivi_col_haar4
, ff_ivi_dc_haar_2d
, 0 },
60 { ff_ivi_row_slant4
, ff_ivi_dc_row_slant
, 0 },
61 { ff_ivi_col_slant4
, ff_ivi_dc_col_slant
, 0 },
62 { NULL
, NULL
, 0 }, /* inverse DCT 4x4 */
66 * Decode subdivision of a plane.
67 * This is a simplified version that checks for two supported subdivisions:
68 * - 1 wavelet band per plane, size factor 1:1, code pattern: 3
69 * - 4 wavelet bands per plane, size factor 1:4, code pattern: 2,3,3,3,3
70 * Anything else is either unsupported or corrupt.
72 * @param[in,out] gb the GetBit context
73 * @return number of wavelet bands or 0 on error
75 static int decode_plane_subdivision(GetBitContext
*gb
)
79 switch (get_bits(gb
, 2)) {
83 for (i
= 0; i
< 4; i
++)
84 if (get_bits(gb
, 2) != 3)
92 static inline int scale_tile_size(int def_size
, int size_factor
)
94 return size_factor
== 15 ? def_size
: (size_factor
+ 1) << 5;
98 * Decode Indeo 4 picture header.
100 * @param[in,out] ctx pointer to the decoder context
101 * @param[in] avctx pointer to the AVCodecContext
102 * @return result code: 0 = OK, negative number = error
104 static int decode_pic_hdr(IVI45DecContext
*ctx
, AVCodecContext
*avctx
)
106 int pic_size_indx
, i
, p
;
107 IVIPicConfig pic_conf
;
109 if (get_bits(&ctx
->gb
, 18) != 0x3FFF8) {
110 av_log(avctx
, AV_LOG_ERROR
, "Invalid picture start code!\n");
111 return AVERROR_INVALIDDATA
;
114 ctx
->prev_frame_type
= ctx
->frame_type
;
115 ctx
->frame_type
= get_bits(&ctx
->gb
, 3);
116 if (ctx
->frame_type
== 7) {
117 av_log(avctx
, AV_LOG_ERROR
, "Invalid frame type: %d\n", ctx
->frame_type
);
118 return AVERROR_INVALIDDATA
;
121 #if IVI4_STREAM_ANALYSER
122 if (ctx
->frame_type
== IVI4_FRAMETYPE_BIDIR
)
123 ctx
->has_b_frames
= 1;
126 ctx
->transp_status
= get_bits1(&ctx
->gb
);
127 #if IVI4_STREAM_ANALYSER
128 if (ctx
->transp_status
) {
133 /* unknown bit: Mac decoder ignores this bit, XANIM returns error */
134 if (get_bits1(&ctx
->gb
)) {
135 av_log(avctx
, AV_LOG_ERROR
, "Sync bit is set!\n");
136 return AVERROR_INVALIDDATA
;
139 ctx
->data_size
= get_bits1(&ctx
->gb
) ? get_bits(&ctx
->gb
, 24) : 0;
141 /* null frames don't contain anything else so we just return */
142 if (ctx
->frame_type
>= IVI4_FRAMETYPE_NULL_FIRST
) {
143 av_dlog(avctx
, "Null frame encountered!\n");
147 /* Check key lock status. If enabled - ignore lock word. */
148 /* Usually we have to prompt the user for the password, but */
149 /* we don't do that because Indeo 4 videos can be decoded anyway */
150 if (get_bits1(&ctx
->gb
)) {
151 skip_bits_long(&ctx
->gb
, 32);
152 av_dlog(avctx
, "Password-protected clip!\n");
155 pic_size_indx
= get_bits(&ctx
->gb
, 3);
156 if (pic_size_indx
== IVI4_PIC_SIZE_ESC
) {
157 pic_conf
.pic_height
= get_bits(&ctx
->gb
, 16);
158 pic_conf
.pic_width
= get_bits(&ctx
->gb
, 16);
160 pic_conf
.pic_height
= ivi4_common_pic_sizes
[pic_size_indx
* 2 + 1];
161 pic_conf
.pic_width
= ivi4_common_pic_sizes
[pic_size_indx
* 2 ];
164 /* Decode tile dimensions. */
165 if (get_bits1(&ctx
->gb
)) {
166 pic_conf
.tile_height
= scale_tile_size(pic_conf
.pic_height
, get_bits(&ctx
->gb
, 4));
167 pic_conf
.tile_width
= scale_tile_size(pic_conf
.pic_width
, get_bits(&ctx
->gb
, 4));
168 #if IVI4_STREAM_ANALYSER
169 ctx
->uses_tiling
= 1;
172 pic_conf
.tile_height
= pic_conf
.pic_height
;
173 pic_conf
.tile_width
= pic_conf
.pic_width
;
176 /* Decode chroma subsampling. We support only 4:4 aka YVU9. */
177 if (get_bits(&ctx
->gb
, 2)) {
178 av_log(avctx
, AV_LOG_ERROR
, "Only YVU9 picture format is supported!\n");
179 return AVERROR_INVALIDDATA
;
181 pic_conf
.chroma_height
= (pic_conf
.pic_height
+ 3) >> 2;
182 pic_conf
.chroma_width
= (pic_conf
.pic_width
+ 3) >> 2;
184 /* decode subdivision of the planes */
185 pic_conf
.luma_bands
= decode_plane_subdivision(&ctx
->gb
);
186 pic_conf
.chroma_bands
= 0;
187 if (pic_conf
.luma_bands
)
188 pic_conf
.chroma_bands
= decode_plane_subdivision(&ctx
->gb
);
189 ctx
->is_scalable
= pic_conf
.luma_bands
!= 1 || pic_conf
.chroma_bands
!= 1;
190 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
;
196 /* check if picture layout was changed and reallocate buffers */
197 if (ivi_pic_config_cmp(&pic_conf
, &ctx
->pic_conf
)) {
198 if (ff_ivi_init_planes(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
);
204 ctx
->pic_conf
= pic_conf
;
206 /* set default macroblock/block dimensions */
207 for (p
= 0; p
<= 2; p
++) {
208 for (i
= 0; i
< (!p
? pic_conf
.luma_bands
: pic_conf
.chroma_bands
); i
++) {
209 ctx
->planes
[p
].bands
[i
].mb_size
= !p
? (!ctx
->is_scalable
? 16 : 8) : 4;
210 ctx
->planes
[p
].bands
[i
].blk_size
= !p
? 8 : 4;
214 if (ff_ivi_init_tiles(ctx
->planes
, ctx
->pic_conf
.tile_width
,
215 ctx
->pic_conf
.tile_height
)) {
216 av_log(avctx
, AV_LOG_ERROR
,
217 "Couldn't reallocate internal structures!\n");
218 return AVERROR(ENOMEM
);
222 ctx
->frame_num
= get_bits1(&ctx
->gb
) ? get_bits(&ctx
->gb
, 20) : 0;
224 /* skip decTimeEst field if present */
225 if (get_bits1(&ctx
->gb
))
226 skip_bits(&ctx
->gb
, 8);
228 /* decode macroblock and block huffman codebooks */
229 if (ff_ivi_dec_huff_desc(&ctx
->gb
, get_bits1(&ctx
->gb
), IVI_MB_HUFF
, &ctx
->mb_vlc
, avctx
) ||
230 ff_ivi_dec_huff_desc(&ctx
->gb
, get_bits1(&ctx
->gb
), IVI_BLK_HUFF
, &ctx
->blk_vlc
, avctx
))
231 return AVERROR_INVALIDDATA
;
233 ctx
->rvmap_sel
= get_bits1(&ctx
->gb
) ? get_bits(&ctx
->gb
, 3) : 8;
235 ctx
->in_imf
= get_bits1(&ctx
->gb
);
236 ctx
->in_q
= get_bits1(&ctx
->gb
);
238 ctx
->pic_glob_quant
= get_bits(&ctx
->gb
, 5);
240 /* TODO: ignore this parameter if unused */
241 ctx
->unknown1
= get_bits1(&ctx
->gb
) ? get_bits(&ctx
->gb
, 3) : 0;
243 ctx
->checksum
= get_bits1(&ctx
->gb
) ? get_bits(&ctx
->gb
, 16) : 0;
245 /* skip picture header extension if any */
246 while (get_bits1(&ctx
->gb
)) {
247 av_dlog(avctx
, "Pic hdr extension encountered!\n");
248 skip_bits(&ctx
->gb
, 8);
251 if (get_bits1(&ctx
->gb
)) {
252 av_log(avctx
, AV_LOG_ERROR
, "Bad blocks bits encountered!\n");
255 align_get_bits(&ctx
->gb
);
262 * Decode Indeo 4 band header.
264 * @param[in,out] ctx pointer to the decoder context
265 * @param[in,out] band pointer to the band descriptor
266 * @param[in] avctx pointer to the AVCodecContext
267 * @return result code: 0 = OK, negative number = error
269 static int decode_band_hdr(IVI45DecContext
*ctx
, IVIBandDesc
*band
,
270 AVCodecContext
*avctx
)
272 int plane
, band_num
, indx
, transform_id
, scan_indx
;
276 plane
= get_bits(&ctx
->gb
, 2);
277 band_num
= get_bits(&ctx
->gb
, 4);
278 if (band
->plane
!= plane
|| band
->band_num
!= band_num
) {
279 av_log(avctx
, AV_LOG_ERROR
, "Invalid band header sequence!\n");
280 return AVERROR_INVALIDDATA
;
283 band
->is_empty
= get_bits1(&ctx
->gb
);
284 if (!band
->is_empty
) {
285 int old_blk_size
= band
->blk_size
;
287 * If header size is not given, header size is 4 bytes. */
288 if (get_bits1(&ctx
->gb
))
289 skip_bits(&ctx
->gb
, 16);
291 band
->is_halfpel
= get_bits(&ctx
->gb
, 2);
292 if (band
->is_halfpel
>= 2) {
293 av_log(avctx
, AV_LOG_ERROR
, "Invalid/unsupported mv resolution: %d!\n",
295 return AVERROR_INVALIDDATA
;
297 #if IVI4_STREAM_ANALYSER
298 if (!band
->is_halfpel
)
299 ctx
->uses_fullpel
= 1;
302 band
->checksum_present
= get_bits1(&ctx
->gb
);
303 if (band
->checksum_present
)
304 band
->checksum
= get_bits(&ctx
->gb
, 16);
306 indx
= get_bits(&ctx
->gb
, 2);
308 av_log(avctx
, AV_LOG_ERROR
, "Invalid block size!\n");
309 return AVERROR_INVALIDDATA
;
311 band
->mb_size
= 16 >> indx
;
312 band
->blk_size
= 8 >> (indx
>> 1);
314 band
->inherit_mv
= get_bits1(&ctx
->gb
);
315 band
->inherit_qdelta
= get_bits1(&ctx
->gb
);
317 band
->glob_quant
= get_bits(&ctx
->gb
, 5);
319 if (!get_bits1(&ctx
->gb
) || ctx
->frame_type
== IVI4_FRAMETYPE_INTRA
) {
320 transform_id
= get_bits(&ctx
->gb
, 5);
321 if (transform_id
>= FF_ARRAY_ELEMS(transforms
) ||
322 !transforms
[transform_id
].inv_trans
) {
323 avpriv_request_sample(avctx
, "Transform %d", transform_id
);
324 return AVERROR_PATCHWELCOME
;
326 if ((transform_id
>= 7 && transform_id
<= 9) ||
327 transform_id
== 17) {
328 avpriv_request_sample(avctx
, "DCT transform");
329 return AVERROR_PATCHWELCOME
;
332 if (transform_id
< 10 && band
->blk_size
< 8) {
333 av_log(avctx
, AV_LOG_ERROR
, "wrong transform size!\n");
334 return AVERROR_INVALIDDATA
;
336 #if IVI4_STREAM_ANALYSER
337 if ((transform_id
>= 0 && transform_id
<= 2) || transform_id
== 10)
341 band
->inv_transform
= transforms
[transform_id
].inv_trans
;
342 band
->dc_transform
= transforms
[transform_id
].dc_trans
;
343 band
->is_2d_trans
= transforms
[transform_id
].is_2d_trans
;
345 if (transform_id
< 10)
346 band
->transform_size
= 8;
348 band
->transform_size
= 4;
350 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
;
355 scan_indx
= get_bits(&ctx
->gb
, 4);
356 if (scan_indx
== 15) {
357 av_log(avctx
, AV_LOG_ERROR
, "Custom scan pattern encountered!\n");
358 return AVERROR_INVALIDDATA
;
360 if (scan_indx
> 4 && scan_indx
< 10) {
361 if (band
->blk_size
!= 4) {
362 av_log(avctx
, AV_LOG_ERROR
, "mismatching scan table!\n");
363 return AVERROR_INVALIDDATA
;
365 } else if (band
->blk_size
!= 8) {
366 av_log(avctx
, AV_LOG_ERROR
, "mismatching scan table!\n");
367 return AVERROR_INVALIDDATA
;
370 band
->scan
= scan_index_to_tab
[scan_indx
];
371 band
->scan_size
= band
->blk_size
;
373 quant_mat
= get_bits(&ctx
->gb
, 5);
374 if (quant_mat
== 31) {
375 av_log(avctx
, AV_LOG_ERROR
, "Custom quant matrix encountered!\n");
376 return AVERROR_INVALIDDATA
;
378 if (quant_mat
>= FF_ARRAY_ELEMS(quant_index_to_tab
)) {
379 avpriv_request_sample(avctx
, "Quantization matrix %d",
381 return AVERROR_INVALIDDATA
;
383 band
->quant_mat
= quant_mat
;
385 if (old_blk_size
!= band
->blk_size
) {
386 av_log(avctx
, AV_LOG_ERROR
,
387 "The band block size does not match the configuration "
389 return AVERROR_INVALIDDATA
;
392 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");
395 return AVERROR_INVALIDDATA
;
397 if (band
->scan_size
!= band
->blk_size
) {
398 av_log(avctx
, AV_LOG_ERROR
, "mismatching scan table!\n");
399 return AVERROR_INVALIDDATA
;
401 if (band
->transform_size
== 8 && band
->blk_size
< 8) {
402 av_log(avctx
, AV_LOG_ERROR
, "mismatching transform_size!\n");
403 return AVERROR_INVALIDDATA
;
406 /* decode block huffman codebook */
407 if (!get_bits1(&ctx
->gb
))
408 band
->blk_vlc
.tab
= ctx
->blk_vlc
.tab
;
410 if (ff_ivi_dec_huff_desc(&ctx
->gb
, 1, IVI_BLK_HUFF
,
411 &band
->blk_vlc
, avctx
))
412 return AVERROR_INVALIDDATA
;
414 /* select appropriate rvmap table for this band */
415 band
->rvmap_sel
= get_bits1(&ctx
->gb
) ? get_bits(&ctx
->gb
, 3) : 8;
417 /* decode rvmap probability corrections if any */
418 band
->num_corr
= 0; /* there is no corrections */
419 if (get_bits1(&ctx
->gb
)) {
420 band
->num_corr
= get_bits(&ctx
->gb
, 8); /* get number of correction pairs */
421 if (band
->num_corr
> 61) {
422 av_log(avctx
, AV_LOG_ERROR
, "Too many corrections: %d\n",
424 return AVERROR_INVALIDDATA
;
427 /* read correction pairs */
428 for (i
= 0; i
< band
->num_corr
* 2; i
++)
429 band
->corr
[i
] = get_bits(&ctx
->gb
, 8);
433 if (band
->blk_size
== 8) {
434 band
->intra_base
= &ivi4_quant_8x8_intra
[quant_index_to_tab
[band
->quant_mat
]][0];
435 band
->inter_base
= &ivi4_quant_8x8_inter
[quant_index_to_tab
[band
->quant_mat
]][0];
437 band
->intra_base
= &ivi4_quant_4x4_intra
[quant_index_to_tab
[band
->quant_mat
]][0];
438 band
->inter_base
= &ivi4_quant_4x4_inter
[quant_index_to_tab
[band
->quant_mat
]][0];
441 /* Indeo 4 doesn't use scale tables */
442 band
->intra_scale
= NULL
;
443 band
->inter_scale
= NULL
;
445 align_get_bits(&ctx
->gb
);
448 av_log(avctx
, AV_LOG_ERROR
, "band->scan not set\n");
449 return AVERROR_INVALIDDATA
;
457 * Decode information (block type, cbp, quant delta, motion vector)
458 * for all macroblocks in the current tile.
460 * @param[in,out] ctx pointer to the decoder context
461 * @param[in,out] band pointer to the band descriptor
462 * @param[in,out] tile pointer to the tile descriptor
463 * @param[in] avctx pointer to the AVCodecContext
464 * @return result code: 0 = OK, negative number = error
466 static int decode_mb_info(IVI45DecContext
*ctx
, IVIBandDesc
*band
,
467 IVITile
*tile
, AVCodecContext
*avctx
)
469 int x
, y
, mv_x
, mv_y
, mv_delta
, offs
, mb_offset
, blks_per_mb
,
470 mv_scale
, mb_type_bits
, s
;
471 IVIMbInfo
*mb
, *ref_mb
;
472 int row_offset
= band
->mb_size
* band
->pitch
;
475 ref_mb
= tile
->ref_mbs
;
476 offs
= tile
->ypos
* band
->pitch
+ tile
->xpos
;
478 blks_per_mb
= band
->mb_size
!= band
->blk_size
? 4 : 1;
479 mb_type_bits
= ctx
->frame_type
== IVI4_FRAMETYPE_BIDIR
? 2 : 1;
481 /* scale factor for motion vectors */
482 mv_scale
= (ctx
->planes
[0].bands
[0].mb_size
>> 3) - (band
->mb_size
>> 3);
485 if (((tile
->width
+ band
->mb_size
-1)/band
->mb_size
) * ((tile
->height
+ band
->mb_size
-1)/band
->mb_size
) != tile
->num_MBs
) {
486 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 for (y
= tile
->ypos
; y
< tile
->ypos
+ tile
->height
; y
+= band
->mb_size
) {
493 for (x
= tile
->xpos
; x
< tile
->xpos
+ tile
->width
; x
+= band
->mb_size
) {
496 mb
->buf_offs
= mb_offset
;
500 if (get_bits1(&ctx
->gb
)) {
501 if (ctx
->frame_type
== IVI4_FRAMETYPE_INTRA
) {
502 av_log(avctx
, AV_LOG_ERROR
, "Empty macroblock in an INTRA picture!\n");
503 return AVERROR_INVALIDDATA
;
505 mb
->type
= 1; /* empty macroblocks are always INTER */
506 mb
->cbp
= 0; /* all blocks are empty */
509 if (!band
->plane
&& !band
->band_num
&& ctx
->in_q
) {
510 mb
->q_delta
= get_vlc2(&ctx
->gb
, ctx
->mb_vlc
.tab
->table
,
512 mb
->q_delta
= IVI_TOSIGNED(mb
->q_delta
);
515 mb
->mv_x
= mb
->mv_y
= 0; /* no motion vector coded */
516 if (band
->inherit_mv
&& ref_mb
) {
517 /* motion vector inheritance */
519 mb
->mv_x
= ivi_scale_mv(ref_mb
->mv_x
, mv_scale
);
520 mb
->mv_y
= ivi_scale_mv(ref_mb
->mv_y
, mv_scale
);
522 mb
->mv_x
= ref_mb
->mv_x
;
523 mb
->mv_y
= ref_mb
->mv_y
;
527 if (band
->inherit_mv
) {
528 /* copy mb_type from corresponding reference mb */
530 av_log(avctx
, AV_LOG_ERROR
, "ref_mb unavailable\n");
531 return AVERROR_INVALIDDATA
;
533 mb
->type
= ref_mb
->type
;
534 } else if (ctx
->frame_type
== IVI4_FRAMETYPE_INTRA
||
535 ctx
->frame_type
== IVI4_FRAMETYPE_INTRA1
) {
536 mb
->type
= 0; /* mb_type is always INTRA for intra-frames */
538 mb
->type
= get_bits(&ctx
->gb
, mb_type_bits
);
541 mb
->cbp
= get_bits(&ctx
->gb
, blks_per_mb
);
544 if (band
->inherit_qdelta
) {
545 if (ref_mb
) mb
->q_delta
= ref_mb
->q_delta
;
546 } else if (mb
->cbp
|| (!band
->plane
&& !band
->band_num
&&
548 mb
->q_delta
= get_vlc2(&ctx
->gb
, ctx
->mb_vlc
.tab
->table
,
550 mb
->q_delta
= IVI_TOSIGNED(mb
->q_delta
);
554 mb
->mv_x
= mb
->mv_y
= 0; /* there is no motion vector in intra-macroblocks */
556 if (band
->inherit_mv
) {
558 /* motion vector inheritance */
560 mb
->mv_x
= ivi_scale_mv(ref_mb
->mv_x
, mv_scale
);
561 mb
->mv_y
= ivi_scale_mv(ref_mb
->mv_y
, mv_scale
);
563 mb
->mv_x
= ref_mb
->mv_x
;
564 mb
->mv_y
= ref_mb
->mv_y
;
567 /* decode motion vector deltas */
568 mv_delta
= get_vlc2(&ctx
->gb
, ctx
->mb_vlc
.tab
->table
,
570 mv_y
+= IVI_TOSIGNED(mv_delta
);
571 mv_delta
= get_vlc2(&ctx
->gb
, ctx
->mb_vlc
.tab
->table
,
573 mv_x
+= IVI_TOSIGNED(mv_delta
);
577 mv_delta
= get_vlc2(&ctx
->gb
,
578 ctx
->mb_vlc
.tab
->table
,
580 mv_y
+= IVI_TOSIGNED(mv_delta
);
581 mv_delta
= get_vlc2(&ctx
->gb
,
582 ctx
->mb_vlc
.tab
->table
,
584 mv_x
+= IVI_TOSIGNED(mv_delta
);
590 mb
->b_mv_x
= -mb
->mv_x
;
591 mb
->b_mv_y
= -mb
->mv_y
;
600 if ( x
+ (mb
->mv_x
>>s
) + (y
+ (mb
->mv_y
>>s
))*band
->pitch
< 0 ||
601 x
+ ((mb
->mv_x
+s
)>>s
) + band
->mb_size
- 1
602 + (y
+band
->mb_size
- 1 +((mb
->mv_y
+s
)>>s
))*band
->pitch
> band
->bufsize
-1) {
603 av_log(avctx
, AV_LOG_ERROR
, "motion vector %d %d outside reference\n", x
*s
+ mb
->mv_x
, y
*s
+ mb
->mv_y
);
604 return AVERROR_INVALIDDATA
;
610 mb_offset
+= band
->mb_size
;
616 align_get_bits(&ctx
->gb
);
623 * Rearrange decoding and reference buffers.
625 * @param[in,out] ctx pointer to the decoder context
627 static void switch_buffers(IVI45DecContext
*ctx
)
629 int is_prev_ref
= 0, is_ref
= 0;
631 switch (ctx
->prev_frame_type
) {
632 case IVI4_FRAMETYPE_INTRA
:
633 case IVI4_FRAMETYPE_INTRA1
:
634 case IVI4_FRAMETYPE_INTER
:
639 switch (ctx
->frame_type
) {
640 case IVI4_FRAMETYPE_INTRA
:
641 case IVI4_FRAMETYPE_INTRA1
:
642 case IVI4_FRAMETYPE_INTER
:
647 if (is_prev_ref
&& is_ref
) {
648 FFSWAP(int, ctx
->dst_buf
, ctx
->ref_buf
);
649 } else if (is_prev_ref
) {
650 FFSWAP(int, ctx
->ref_buf
, ctx
->b_ref_buf
);
651 FFSWAP(int, ctx
->dst_buf
, ctx
->ref_buf
);
656 static int is_nonnull_frame(IVI45DecContext
*ctx
)
658 return ctx
->frame_type
< IVI4_FRAMETYPE_NULL_FIRST
;
662 static av_cold
int decode_init(AVCodecContext
*avctx
)
664 IVI45DecContext
*ctx
= avctx
->priv_data
;
666 ff_ivi_init_static_vlc();
668 /* copy rvmap tables in our context so we can apply changes to them */
669 memcpy(ctx
->rvmap_tabs
, ff_ivi_rvmap_tabs
, sizeof(ff_ivi_rvmap_tabs
));
671 /* Force allocation of the internal buffers */
672 /* during picture header decoding. */
673 ctx
->pic_conf
.pic_width
= 0;
674 ctx
->pic_conf
.pic_height
= 0;
676 avctx
->pix_fmt
= AV_PIX_FMT_YUV410P
;
678 ctx
->decode_pic_hdr
= decode_pic_hdr
;
679 ctx
->decode_band_hdr
= decode_band_hdr
;
680 ctx
->decode_mb_info
= decode_mb_info
;
681 ctx
->switch_buffers
= switch_buffers
;
682 ctx
->is_nonnull_frame
= is_nonnull_frame
;
688 ctx
->b_ref_buf
= 3; /* buffer 2 is used for scalability mode */
689 ctx
->p_frame
= av_frame_alloc();
691 return AVERROR(ENOMEM
);
697 AVCodec ff_indeo4_decoder
= {
699 .long_name
= NULL_IF_CONFIG_SMALL("Intel Indeo Video Interactive 4"),
700 .type
= AVMEDIA_TYPE_VIDEO
,
701 .id
= AV_CODEC_ID_INDEO4
,
702 .priv_data_size
= sizeof(IVI45DecContext
),
704 .close
= ff_ivi_decode_close
,
705 .decode
= ff_ivi_decode_frame
,
706 .capabilities
= CODEC_CAP_DR1
,