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 "codec_internal.h" 33#include "get_bits.h" 34#include "libavutil/imgutils.h" 35#include "indeo4data.h" 36#include "ivi.h" 37#include "ivi_dsp.h" 38 39#define IVI4_PIC_SIZE_ESC 7 40 41 42static 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 */ 77static int decode_plane_subdivision(GetBitContext *gb) 78{ 79 int i; 80 81 switch (get_bits(gb, 2)) { 82 case 3: 83 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 94static 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 */ 106static int decode_pic_hdr(IVI45DecContext *ctx, AVCodecContext *avctx) 107{ 108 int pic_size_indx, i, p; 109 IVIPicConfig pic_conf; 110 111 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 ctx->prev_frame_type = ctx->frame_type; 117 ctx->frame_type = get_bits(&ctx->gb, 3); 118 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 if (ctx->frame_type == IVI4_FRAMETYPE_BIDIR) 124 ctx->has_b_frames = 1; 125 126 ctx->has_transp = get_bits1(&ctx->gb); 127 128 /* unknown bit: Mac decoder ignores this bit, XANIM returns error */ 129 if (get_bits1(&ctx->gb)) { 130 av_log(avctx, AV_LOG_ERROR, "Sync bit is set!\n"); 131 return AVERROR_INVALIDDATA; 132 } 133 134 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 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 if (get_bits1(&ctx->gb)) { 146 skip_bits_long(&ctx->gb, 32); 147 ff_dlog(avctx, "Password-protected clip!\n"); 148 } 149 150 pic_size_indx = get_bits(&ctx->gb, 3); 151 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 pic_conf.pic_height = ivi4_common_pic_sizes[pic_size_indx * 2 + 1]; 156 pic_conf.pic_width = ivi4_common_pic_sizes[pic_size_indx * 2 ]; 157 } 158 159 /* Decode tile dimensions. */ 160 ctx->uses_tiling = get_bits1(&ctx->gb); 161 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 pic_conf.tile_height = pic_conf.pic_height; 166 pic_conf.tile_width = pic_conf.pic_width; 167 } 168 169 /* Decode chroma subsampling. We support only 4:4 aka YVU9. */ 170 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 pic_conf.chroma_height = (pic_conf.pic_height + 3) >> 2; 175 pic_conf.chroma_width = (pic_conf.pic_width + 3) >> 2; 176 177 /* decode subdivision of the planes */ 178 pic_conf.luma_bands = decode_plane_subdivision(&ctx->gb); 179 pic_conf.chroma_bands = 0; 180 if (pic_conf.luma_bands) 181 pic_conf.chroma_bands = decode_plane_subdivision(&ctx->gb); 182 183 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 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; 194 } 195 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(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 ctx->pic_conf = pic_conf; 205 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; 211 } 212 } 213 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); 219 } 220 } 221 222 ctx->frame_num = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 20) : 0; 223 224 /* skip decTimeEst field if present */ 225 if (get_bits1(&ctx->gb)) 226 skip_bits(&ctx->gb, 8); 227 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; 232 233 ctx->rvmap_sel = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 3) : 8; 234 235 ctx->in_imf = get_bits1(&ctx->gb); 236 ctx->in_q = get_bits1(&ctx->gb); 237 238 ctx->pic_glob_quant = get_bits(&ctx->gb, 5); 239 240 /* TODO: ignore this parameter if unused */ 241 ctx->unknown1 = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 3) : 0; 242 243 ctx->checksum = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 16) : 0; 244 245 /* skip picture header extension if any */ 246 while (get_bits1(&ctx->gb)) { 247 ff_dlog(avctx, "Pic hdr extension encountered!\n"); 248 if (get_bits_left(&ctx->gb) < 10) 249 return AVERROR_INVALIDDATA; 250 skip_bits(&ctx->gb, 8); 251 } 252 253 if (get_bits1(&ctx->gb)) { 254 av_log(avctx, AV_LOG_ERROR, "Bad blocks bits encountered!\n"); 255 } 256 257 align_get_bits(&ctx->gb); 258 259 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 */ 271static 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 IVIBandDesc temp_band, *band = &temp_band; 278 memcpy(&temp_band, arg_band, sizeof(temp_band)); 279 280 plane = get_bits(&ctx->gb, 2); 281 band_num = get_bits(&ctx->gb, 4); 282 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 band->is_empty = get_bits1(&ctx->gb); 288 if (!band->is_empty) { 289 int old_blk_size = band->blk_size; 290 /* skip header size 291 * If header size is not given, header size is 4 bytes. */ 292 if (get_bits1(&ctx->gb)) 293 skip_bits(&ctx->gb, 16); 294 295 band->is_halfpel = get_bits(&ctx->gb, 2); 296 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 if (!band->is_halfpel) 302 ctx->uses_fullpel = 1; 303 304 band->checksum_present = get_bits1(&ctx->gb); 305 if (band->checksum_present) 306 band->checksum = get_bits(&ctx->gb, 16); 307 308 indx = get_bits(&ctx->gb, 2); 309 if (indx == 3) { 310 av_log(avctx, AV_LOG_ERROR, "Invalid block size!\n"); 311 return AVERROR_INVALIDDATA; 312 } 313 band->mb_size = 16 >> indx; 314 band->blk_size = 8 >> (indx >> 1); 315 316 band->inherit_mv = get_bits1(&ctx->gb); 317 band->inherit_qdelta = get_bits1(&ctx->gb); 318 319 band->glob_quant = get_bits(&ctx->gb, 5); 320 321 if (!get_bits1(&ctx->gb) || ctx->frame_type == IVI4_FRAMETYPE_INTRA) { 322 transform_id = get_bits(&ctx->gb, 5); 323 if (transform_id >= FF_ARRAY_ELEMS(transforms) || 324 !transforms[transform_id].inv_trans) { 325 avpriv_request_sample(avctx, "Transform %d", transform_id); 326 return AVERROR_PATCHWELCOME; 327 } 328 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 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 if ((transform_id >= 0 && transform_id <= 2) || transform_id == 10) 339 ctx->uses_haar = 1; 340 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; 344 345 if (transform_id < 10) 346 band->transform_size = 8; 347 else 348 band->transform_size = 4; 349 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; 353 } 354 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; 359 } 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; 364 } 365 } else if (band->blk_size != 8) { 366 av_log(avctx, AV_LOG_ERROR, "mismatching scan table!\n"); 367 return AVERROR_INVALIDDATA; 368 } 369 370 band->scan = scan_index_to_tab[scan_indx]; 371 band->scan_size = band->blk_size; 372 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; 377 } 378 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 band->quant_mat = quant_mat; 384 } else { 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 " 388 "inherited\n"); 389 return AVERROR_INVALIDDATA; 390 } 391 } 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"); 394 band->quant_mat = 0; 395 return AVERROR_INVALIDDATA; 396 } 397 if (band->scan_size != band->blk_size) { 398 av_log(avctx, AV_LOG_ERROR, "mismatching scan table!\n"); 399 return AVERROR_INVALIDDATA; 400 } 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; 404 } 405 406 /* decode block huffman codebook */ 407 if (!get_bits1(&ctx->gb)) 408 arg_band->blk_vlc.tab = ctx->blk_vlc.tab; 409 else 410 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 band->rvmap_sel = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 3) : 8; 416 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", 423 band->num_corr); 424 return AVERROR_INVALIDDATA; 425 } 426 427 /* read correction pairs */ 428 for (i = 0; i < band->num_corr * 2; i++) 429 band->corr[i] = get_bits(&ctx->gb, 8); 430 } 431 } 432 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]; 436 } else { 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]; 439 } 440 441 /* Indeo 4 doesn't use scale tables */ 442 band->intra_scale = NULL; 443 band->inter_scale = NULL; 444 445 align_get_bits(&ctx->gb); 446 447 if (!band->scan) { 448 av_log(avctx, AV_LOG_ERROR, "band->scan not set\n"); 449 return AVERROR_INVALIDDATA; 450 } 451 452 band->blk_vlc = arg_band->blk_vlc; 453 memcpy(arg_band, band, sizeof(*arg_band)); 454 455 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 */ 469static 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 int row_offset = band->mb_size * band->pitch; 476 477 mb = tile->mbs; 478 ref_mb = tile->ref_mbs; 479 offs = tile->ypos * band->pitch + tile->xpos; 480 481 blks_per_mb = band->mb_size != band->blk_size ? 4 : 1; 482 mb_type_bits = ctx->frame_type == IVI4_FRAMETYPE_BIDIR ? 2 : 1; 483 484 /* scale factor for motion vectors */ 485 mv_scale = (ctx->planes[0].bands[0].mb_size >> 3) - (band->mb_size >> 3); 486 mv_x = mv_y = 0; 487 488 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 for (y = tile->ypos; y < tile->ypos + tile->height; y += band->mb_size) { 494 mb_offset = offs; 495 496 for (x = tile->xpos; x < tile->xpos + tile->width; x += band->mb_size) { 497 mb->xpos = x; 498 mb->ypos = y; 499 mb->buf_offs = mb_offset; 500 mb->b_mv_x = 501 mb->b_mv_y = 0; 502 503 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 if (get_bits1(&ctx->gb)) { 509 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 mb->type = 1; /* empty macroblocks are always INTER */ 514 mb->cbp = 0; /* all blocks are empty */ 515 516 mb->q_delta = 0; 517 if (!band->plane && !band->band_num && ctx->in_q) { 518 mb->q_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table, 519 IVI_VLC_BITS, 1); 520 mb->q_delta = IVI_TOSIGNED(mb->q_delta); 521 } 522 523 mb->mv_x = mb->mv_y = 0; /* no motion vector coded */ 524 if (band->inherit_mv && ref_mb) { 525 /* motion vector inheritance */ 526 if (mv_scale) { 527 mb->mv_x = ivi_scale_mv(ref_mb->mv_x, mv_scale); 528 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 if (band->inherit_mv) { 536 /* copy mb_type from corresponding reference mb */ 537 if (!ref_mb) { 538 av_log(avctx, AV_LOG_ERROR, "ref_mb unavailable\n"); 539 return AVERROR_INVALIDDATA; 540 } 541 mb->type = ref_mb->type; 542 } else if (ctx->frame_type == IVI4_FRAMETYPE_INTRA || 543 ctx->frame_type == IVI4_FRAMETYPE_INTRA1) { 544 mb->type = 0; /* mb_type is always INTRA for intra-frames */ 545 } else { 546 mb->type = get_bits(&ctx->gb, mb_type_bits); 547 } 548 549 mb->cbp = get_bits(&ctx->gb, blks_per_mb); 550 551 mb->q_delta = 0; 552 if (band->inherit_qdelta) { 553 if (ref_mb) mb->q_delta = ref_mb->q_delta; 554 } else if (mb->cbp || (!band->plane && !band->band_num && 555 ctx->in_q)) { 556 mb->q_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table, 557 IVI_VLC_BITS, 1); 558 mb->q_delta = IVI_TOSIGNED(mb->q_delta); 559 } 560 561 if (!mb->type) { 562 mb->mv_x = mb->mv_y = 0; /* there is no motion vector in intra-macroblocks */ 563 } else { 564 if (band->inherit_mv) { 565 if (ref_mb) 566 /* motion vector inheritance */ 567 if (mv_scale) { 568 mb->mv_x = ivi_scale_mv(ref_mb->mv_x, mv_scale); 569 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 mv_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table, 577 IVI_VLC_BITS, 1); 578 mv_y += IVI_TOSIGNED(mv_delta); 579 mv_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table, 580 IVI_VLC_BITS, 1); 581 mv_x += IVI_TOSIGNED(mv_delta); 582 mb->mv_x = mv_x; 583 mb->mv_y = mv_y; 584 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 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 s= band->is_halfpel; 607 if (mb->type) 608 if ( x + (mb->mv_x >>s) + (y+ (mb->mv_y >>s))*band->pitch < 0 || 609 x + ((mb->mv_x+s)>>s) + band->mb_size - 1 610 + (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 mb++; 616 if (ref_mb) 617 ref_mb++; 618 mb_offset += band->mb_size; 619 } 620 621 offs += row_offset; 622 } 623 624 align_get_bits(&ctx->gb); 625 626 return 0; 627} 628 629 630/** 631 * Rearrange decoding and reference buffers. 632 * 633 * @param[in,out] ctx pointer to the decoder context 634 */ 635static void switch_buffers(IVI45DecContext *ctx) 636{ 637 int is_prev_ref = 0, is_ref = 0; 638 639 switch (ctx->prev_frame_type) { 640 case IVI4_FRAMETYPE_INTRA: 641 case IVI4_FRAMETYPE_INTRA1: 642 case IVI4_FRAMETYPE_INTER: 643 is_prev_ref = 1; 644 break; 645 } 646 647 switch (ctx->frame_type) { 648 case IVI4_FRAMETYPE_INTRA: 649 case IVI4_FRAMETYPE_INTRA1: 650 case IVI4_FRAMETYPE_INTER: 651 is_ref = 1; 652 break; 653 } 654 655 if (is_prev_ref && is_ref) { 656 FFSWAP(int, ctx->dst_buf, ctx->ref_buf); 657 } else if (is_prev_ref) { 658 FFSWAP(int, ctx->ref_buf, ctx->b_ref_buf); 659 FFSWAP(int, ctx->dst_buf, ctx->ref_buf); 660 } 661} 662 663 664static int is_nonnull_frame(IVI45DecContext *ctx) 665{ 666 return ctx->frame_type < IVI4_FRAMETYPE_NULL_FIRST; 667} 668 669 670static av_cold int decode_init(AVCodecContext *avctx) 671{ 672 IVI45DecContext *ctx = avctx->priv_data; 673 674 ff_ivi_init_static_vlc(); 675 676 /* copy rvmap tables in our context so we can apply changes to them */ 677 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 ctx->pic_conf.pic_width = 0; 682 ctx->pic_conf.pic_height = 0; 683 684 avctx->pix_fmt = AV_PIX_FMT_YUV410P; 685 686 ctx->decode_pic_hdr = decode_pic_hdr; 687 ctx->decode_band_hdr = decode_band_hdr; 688 ctx->decode_mb_info = decode_mb_info; 689 ctx->switch_buffers = switch_buffers; 690 ctx->is_nonnull_frame = is_nonnull_frame; 691 692 ctx->is_indeo4 = 1; 693 ctx->show_indeo4_info = 1; 694 695 ctx->dst_buf = 0; 696 ctx->ref_buf = 1; 697 ctx->b_ref_buf = 3; /* buffer 2 is used for scalability mode */ 698 ctx->p_frame = av_frame_alloc(); 699 if (!ctx->p_frame) 700 return AVERROR(ENOMEM); 701 702 return 0; 703} 704 705 706const FFCodec ff_indeo4_decoder = { 707 .p.name = "indeo4", 708 .p.long_name = NULL_IF_CONFIG_SMALL("Intel Indeo Video Interactive 4"), 709 .p.type = AVMEDIA_TYPE_VIDEO, 710 .p.id = AV_CODEC_ID_INDEO4, 711 .priv_data_size = sizeof(IVI45DecContext), 712 .init = decode_init, 713 .close = ff_ivi_decode_close, 714 FF_CODEC_DECODE_CB(ff_ivi_decode_frame), 715 .p.capabilities = AV_CODEC_CAP_DR1, 716 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, 717}; 718