FFmpeg: libavcodec/indeo4.c Source File

FFmpeg

[フレーム]

libavcodec

indeo4.c

Go to the documentation of this file.

1 /*

2 * Indeo Video Interactive v4 compatible decoder

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 */

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 */

30 #define BITSTREAM_READER_LE

31 #include "avcodec.h"

32 #include "get_bits.h"

33 #include "indeo4data.h"

34 #include "internal.h"

35 #include "ivi.h"

36 #include "ivi_dsp.h"

38 #define IVI4_PIC_SIZE_ESC 7

41 static const struct {

42 InvTransformPtr *inv_trans;

43 DCTransformPtr *dc_trans;

44 int is_2d_trans;

45 } transforms[18] = {

46 { ff_ivi_inverse_haar_8x8, ff_ivi_dc_haar_2d, 1 },

47 { ff_ivi_row_haar8, ff_ivi_dc_haar_2d, 0 },

48 { ff_ivi_col_haar8, ff_ivi_dc_haar_2d, 0 },

49 { ff_ivi_put_pixels_8x8, ff_ivi_put_dc_pixel_8x8, 1 },

50 { ff_ivi_inverse_slant_8x8, ff_ivi_dc_slant_2d, 1 },

51 { ff_ivi_row_slant8, ff_ivi_dc_row_slant, 1 },

52 { ff_ivi_col_slant8, ff_ivi_dc_col_slant, 1 },

53 { NULL, NULL, 0 }, /* inverse DCT 8x8 */

54 { NULL, NULL, 0 }, /* inverse DCT 8x1 */

55 { NULL, NULL, 0 }, /* inverse DCT 1x8 */

56 { ff_ivi_inverse_haar_4x4, ff_ivi_dc_haar_2d, 1 },

57 { ff_ivi_inverse_slant_4x4, ff_ivi_dc_slant_2d, 1 },

58 { NULL, NULL, 0 }, /* no transform 4x4 */

59 { ff_ivi_row_haar4, ff_ivi_dc_haar_2d, 0 },

60 { ff_ivi_col_haar4, ff_ivi_dc_haar_2d, 0 },

61 { ff_ivi_row_slant4, ff_ivi_dc_row_slant, 0 },

62 { ff_ivi_col_slant4, ff_ivi_dc_col_slant, 0 },

63 { NULL, NULL, 0 }, /* inverse DCT 4x4 */

64 };

66 /**

67 * Decode subdivision of a plane.

68 * This is a simplified version that checks for two supported subdivisions:

69 * - 1 wavelet band per plane, size factor 1:1, code pattern: 3

70 * - 4 wavelet bands per plane, size factor 1:4, code pattern: 2,3,3,3,3

71 * Anything else is either unsupported or corrupt.

72 *

73 * @param[in,out] gb the GetBit context

74 * @return number of wavelet bands or 0 on error

75 */

76 static int decode_plane_subdivision(GetBitContext *gb)

77 {

78 int i;

80 switch (get_bits(gb, 2)) {

81 case 3:

82 return 1;

83 case 2:

84 for (i = 0; i < 4; i++)

85 if (get_bits(gb, 2) != 3)

86 return 0;

87 return 4;

88 default:

89 return 0;

90 }

91 }

93 static inline int scale_tile_size(int def_size, int size_factor)

94 {

95 return size_factor == 15 ? def_size : (size_factor + 1) << 5;

96 }

98 /**

99 * Decode Indeo 4 picture header.

100 *

101 * @param[in,out] ctx pointer to the decoder context

102 * @param[in] avctx pointer to the AVCodecContext

103 * @return result code: 0 = OK, negative number = error

104 */

105 static int decode_pic_hdr(IVI45DecContext *ctx, AVCodecContext *avctx)

106 {

107 int pic_size_indx, i, p;

108 IVIPicConfig pic_conf;

109

110 if (get_bits(&ctx->gb, 18) != 0x3FFF8) {

111 av_log(avctx, AV_LOG_ERROR, "Invalid picture start code!\n");

112 return AVERROR_INVALIDDATA;

113 }

114

115 ctx->prev_frame_type = ctx->frame_type;

116 ctx->frame_type = get_bits(&ctx->gb, 3);

117 if (ctx->frame_type == 7) {

118 av_log(avctx, AV_LOG_ERROR, "Invalid frame type: %d\n", ctx->frame_type);

119 return AVERROR_INVALIDDATA;

120 }

121

122 if (ctx->frame_type == IVI4_FRAMETYPE_BIDIR)

123 ctx->has_b_frames = 1;

124

125 ctx->has_transp = get_bits1(&ctx->gb);

126

127 /* unknown bit: Mac decoder ignores this bit, XANIM returns error */

128 if (get_bits1(&ctx->gb)) {

129 av_log(avctx, AV_LOG_ERROR, "Sync bit is set!\n");

130 return AVERROR_INVALIDDATA;

131 }

132

133 ctx->data_size = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 24) : 0;

134

135 /* null frames don't contain anything else so we just return */

136 if (ctx->frame_type >= IVI4_FRAMETYPE_NULL_FIRST) {

137 ff_dlog(avctx, "Null frame encountered!\n");

138 return 0;

139 }

140

141 /* Check key lock status. If enabled - ignore lock word. */

142 /* Usually we have to prompt the user for the password, but */

143 /* we don't do that because Indeo 4 videos can be decoded anyway */

144 if (get_bits1(&ctx->gb)) {

145 skip_bits_long(&ctx->gb, 32);

146 ff_dlog(avctx, "Password-protected clip!\n");

147 }

148

149 pic_size_indx = get_bits(&ctx->gb, 3);

150 if (pic_size_indx == IVI4_PIC_SIZE_ESC) {

151 pic_conf.pic_height = get_bits(&ctx->gb, 16);

152 pic_conf.pic_width = get_bits(&ctx->gb, 16);

153 } else {

154 pic_conf.pic_height = ivi4_common_pic_sizes[pic_size_indx * 2 + 1];

155 pic_conf.pic_width = ivi4_common_pic_sizes[pic_size_indx * 2 ];

156 }

157

158 /* Decode tile dimensions. */

159 ctx->uses_tiling = get_bits1(&ctx->gb);

160 if (ctx->uses_tiling) {

161 pic_conf.tile_height = scale_tile_size(pic_conf.pic_height, get_bits(&ctx->gb, 4));

162 pic_conf.tile_width = scale_tile_size(pic_conf.pic_width, get_bits(&ctx->gb, 4));

163 } else {

164 pic_conf.tile_height = pic_conf.pic_height;

165 pic_conf.tile_width = pic_conf.pic_width;

166 }

167

168 /* Decode chroma subsampling. We support only 4:4 aka YVU9. */

169 if (get_bits(&ctx->gb, 2)) {

170 av_log(avctx, AV_LOG_ERROR, "Only YVU9 picture format is supported!\n");

171 return AVERROR_INVALIDDATA;

172 }

173 pic_conf.chroma_height = (pic_conf.pic_height + 3) >> 2;

174 pic_conf.chroma_width = (pic_conf.pic_width + 3) >> 2;

175

176 /* decode subdivision of the planes */

177 pic_conf.luma_bands = decode_plane_subdivision(&ctx->gb);

178 pic_conf.chroma_bands = 0;

179 if (pic_conf.luma_bands)

180 pic_conf.chroma_bands = decode_plane_subdivision(&ctx->gb);

181 ctx->is_scalable = pic_conf.luma_bands != 1 || pic_conf.chroma_bands != 1;

182 if (ctx->is_scalable && (pic_conf.luma_bands != 4 || pic_conf.chroma_bands != 1)) {

183 av_log(avctx, AV_LOG_ERROR, "Scalability: unsupported subdivision! Luma bands: %d, chroma bands: %d\n",

184 pic_conf.luma_bands, pic_conf.chroma_bands);

185 return AVERROR_INVALIDDATA;

186 }

187

188 /* check if picture layout was changed and reallocate buffers */

189 if (ivi_pic_config_cmp(&pic_conf, &ctx->pic_conf)) {

190 if (ff_ivi_init_planes(ctx->planes, &pic_conf, 1)) {

191 av_log(avctx, AV_LOG_ERROR, "Couldn't reallocate color planes!\n");

192 ctx->pic_conf.luma_bands = 0;

193 return AVERROR(ENOMEM);

194 }

195

196 ctx->pic_conf = pic_conf;

197

198 /* set default macroblock/block dimensions */

199 for (p = 0; p <= 2; p++) {

200 for (i = 0; i < (!p ? pic_conf.luma_bands : pic_conf.chroma_bands); i++) {

201 ctx->planes[p].bands[i].mb_size = !p ? (!ctx->is_scalable ? 16 : 8) : 4;

202 ctx->planes[p].bands[i].blk_size = !p ? 8 : 4;

203 }

204 }

205

206 if (ff_ivi_init_tiles(ctx->planes, ctx->pic_conf.tile_width,

207 ctx->pic_conf.tile_height)) {

208 av_log(avctx, AV_LOG_ERROR,

209 "Couldn't reallocate internal structures!\n");

210 return AVERROR(ENOMEM);

211 }

212 }

213

214 ctx->frame_num = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 20) : 0;

215

216 /* skip decTimeEst field if present */

217 if (get_bits1(&ctx->gb))

218 skip_bits(&ctx->gb, 8);

219

220 /* decode macroblock and block huffman codebooks */

221 if (ff_ivi_dec_huff_desc(&ctx->gb, get_bits1(&ctx->gb), IVI_MB_HUFF, &ctx->mb_vlc, avctx) ||

222 ff_ivi_dec_huff_desc(&ctx->gb, get_bits1(&ctx->gb), IVI_BLK_HUFF, &ctx->blk_vlc, avctx))

223 return AVERROR_INVALIDDATA;

224

225 ctx->rvmap_sel = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 3) : 8;

226

227 ctx->in_imf = get_bits1(&ctx->gb);

228 ctx->in_q = get_bits1(&ctx->gb);

229

230 ctx->pic_glob_quant = get_bits(&ctx->gb, 5);

231

232 /* TODO: ignore this parameter if unused */

233 ctx->unknown1 = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 3) : 0;

234

235 ctx->checksum = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 16) : 0;

236

237 /* skip picture header extension if any */

238 while (get_bits1(&ctx->gb)) {

239 ff_dlog(avctx, "Pic hdr extension encountered!\n");

240 skip_bits(&ctx->gb, 8);

241 }

242

243 if (get_bits1(&ctx->gb)) {

244 av_log(avctx, AV_LOG_ERROR, "Bad blocks bits encountered!\n");

245 }

246

247 align_get_bits(&ctx->gb);

248

249 return 0;

250 }

251

252

253 /**

254 * Decode Indeo 4 band header.

255 *

256 * @param[in,out] ctx pointer to the decoder context

257 * @param[in,out] band pointer to the band descriptor

258 * @param[in] avctx pointer to the AVCodecContext

259 * @return result code: 0 = OK, negative number = error

260 */

261 static int decode_band_hdr(IVI45DecContext *ctx, IVIBandDesc *band,

262 AVCodecContext *avctx)

263 {

264 int plane, band_num, indx, transform_id, scan_indx;

265 int i;

266 int quant_mat;

267

268 plane = get_bits(&ctx->gb, 2);

269 band_num = get_bits(&ctx->gb, 4);

270 if (band->plane != plane || band->band_num != band_num) {

271 av_log(avctx, AV_LOG_ERROR, "Invalid band header sequence!\n");

272 return AVERROR_INVALIDDATA;

273 }

274

275 band->is_empty = get_bits1(&ctx->gb);

276 if (!band->is_empty) {

277 int old_blk_size = band->blk_size;

278 /* skip header size

279 * If header size is not given, header size is 4 bytes. */

280 if (get_bits1(&ctx->gb))

281 skip_bits(&ctx->gb, 16);

282

283 band->is_halfpel = get_bits(&ctx->gb, 2);

284 if (band->is_halfpel >= 2) {

285 av_log(avctx, AV_LOG_ERROR, "Invalid/unsupported mv resolution: %d!\n",

286 band->is_halfpel);

287 return AVERROR_INVALIDDATA;

288 }

289 if (!band->is_halfpel)

290 ctx->uses_fullpel = 1;

291

292 band->checksum_present = get_bits1(&ctx->gb);

293 if (band->checksum_present)

294 band->checksum = get_bits(&ctx->gb, 16);

295

296 indx = get_bits(&ctx->gb, 2);

297 if (indx == 3) {

298 av_log(avctx, AV_LOG_ERROR, "Invalid block size!\n");

299 return AVERROR_INVALIDDATA;

300 }

301 band->mb_size = 16 >> indx;

302 band->blk_size = 8 >> (indx >> 1);

303

304 band->inherit_mv = get_bits1(&ctx->gb);

305 band->inherit_qdelta = get_bits1(&ctx->gb);

306

307 band->glob_quant = get_bits(&ctx->gb, 5);

308

309 if (!get_bits1(&ctx->gb) || ctx->frame_type == IVI4_FRAMETYPE_INTRA) {

310 transform_id = get_bits(&ctx->gb, 5);

311 if (transform_id >= FF_ARRAY_ELEMS(transforms) ||

312 !transforms[transform_id].inv_trans) {

313 avpriv_request_sample(avctx, "Transform %d", transform_id);

314 return AVERROR_PATCHWELCOME;

315 }

316 if ((transform_id >= 7 && transform_id <= 9) ||

317 transform_id == 17) {

318 avpriv_request_sample(avctx, "DCT transform");

319 return AVERROR_PATCHWELCOME;

320 }

321

322 if (transform_id < 10 && band->blk_size < 8) {

323 av_log(avctx, AV_LOG_ERROR, "wrong transform size!\n");

324 return AVERROR_INVALIDDATA;

325 }

326 if ((transform_id >= 0 && transform_id <= 2) || transform_id == 10)

327 ctx->uses_haar = 1;

328

329 band->inv_transform = transforms[transform_id].inv_trans;

330 band->dc_transform = transforms[transform_id].dc_trans;

331 band->is_2d_trans = transforms[transform_id].is_2d_trans;

332

333 if (transform_id < 10)

334 band->transform_size = 8;

335 else

336 band->transform_size = 4;

337

338 if (band->blk_size != band->transform_size) {

339 av_log(avctx, AV_LOG_ERROR, "transform and block size mismatch (%d != %d)\n", band->transform_size, band->blk_size);

340 return AVERROR_INVALIDDATA;

341 }

342

343 scan_indx = get_bits(&ctx->gb, 4);

344 if (scan_indx == 15) {

345 av_log(avctx, AV_LOG_ERROR, "Custom scan pattern encountered!\n");

346 return AVERROR_INVALIDDATA;

347 }

348 if (scan_indx > 4 && scan_indx < 10) {

349 if (band->blk_size != 4) {

350 av_log(avctx, AV_LOG_ERROR, "mismatching scan table!\n");

351 return AVERROR_INVALIDDATA;

352 }

353 } else if (band->blk_size != 8) {

354 av_log(avctx, AV_LOG_ERROR, "mismatching scan table!\n");

355 return AVERROR_INVALIDDATA;

356 }

357

358 band->scan = scan_index_to_tab[scan_indx];

359 band->scan_size = band->blk_size;

360

361 quant_mat = get_bits(&ctx->gb, 5);

362 if (quant_mat == 31) {

363 av_log(avctx, AV_LOG_ERROR, "Custom quant matrix encountered!\n");

364 return AVERROR_INVALIDDATA;

365 }

366 if (quant_mat >= FF_ARRAY_ELEMS(quant_index_to_tab)) {

367 avpriv_request_sample(avctx, "Quantization matrix %d",

368 quant_mat);

369 return AVERROR_INVALIDDATA;

370 }

371 band->quant_mat = quant_mat;

372 } else {

373 if (old_blk_size != band->blk_size) {

374 av_log(avctx, AV_LOG_ERROR,

375 "The band block size does not match the configuration "

376 "inherited\n");

377 return AVERROR_INVALIDDATA;

378 }

379 }

380 if (quant_index_to_tab[band->quant_mat] > 4 && band->blk_size == 4) {

381 av_log(avctx, AV_LOG_ERROR, "Invalid quant matrix for 4x4 block encountered!\n");

382 band->quant_mat = 0;

383 return AVERROR_INVALIDDATA;

384 }

385 if (band->scan_size != band->blk_size) {

386 av_log(avctx, AV_LOG_ERROR, "mismatching scan table!\n");

387 return AVERROR_INVALIDDATA;

388 }

389 if (band->transform_size == 8 && band->blk_size < 8) {

390 av_log(avctx, AV_LOG_ERROR, "mismatching transform_size!\n");

391 return AVERROR_INVALIDDATA;

392 }

393

394 /* decode block huffman codebook */

395 if (!get_bits1(&ctx->gb))

396 band->blk_vlc.tab = ctx->blk_vlc.tab;

397 else

398 if (ff_ivi_dec_huff_desc(&ctx->gb, 1, IVI_BLK_HUFF,

399 &band->blk_vlc, avctx))

400 return AVERROR_INVALIDDATA;

401

402 /* select appropriate rvmap table for this band */

403 band->rvmap_sel = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 3) : 8;

404

405 /* decode rvmap probability corrections if any */

406 band->num_corr = 0; /* there is no corrections */

407 if (get_bits1(&ctx->gb)) {

408 band->num_corr = get_bits(&ctx->gb, 8); /* get number of correction pairs */

409 if (band->num_corr > 61) {

410 av_log(avctx, AV_LOG_ERROR, "Too many corrections: %d\n",

411 band->num_corr);

412 return AVERROR_INVALIDDATA;

413 }

414

415 /* read correction pairs */

416 for (i = 0; i < band->num_corr * 2; i++)

417 band->corr[i] = get_bits(&ctx->gb, 8);

418 }

419 }

420

421 if (band->blk_size == 8) {

422 band->intra_base = &ivi4_quant_8x8_intra[quant_index_to_tab[band->quant_mat]][0];

423 band->inter_base = &ivi4_quant_8x8_inter[quant_index_to_tab[band->quant_mat]][0];

424 } else {

425 band->intra_base = &ivi4_quant_4x4_intra[quant_index_to_tab[band->quant_mat]][0];

426 band->inter_base = &ivi4_quant_4x4_inter[quant_index_to_tab[band->quant_mat]][0];

427 }

428

429 /* Indeo 4 doesn't use scale tables */

430 band->intra_scale = NULL;

431 band->inter_scale = NULL;

432

433 align_get_bits(&ctx->gb);

434

435 if (!band->scan) {

436 av_log(avctx, AV_LOG_ERROR, "band->scan not set\n");

437 return AVERROR_INVALIDDATA;

438 }

439

440 return 0;

441 }

442

443

444 /**

445 * Decode information (block type, cbp, quant delta, motion vector)

446 * for all macroblocks in the current tile.

447 *

448 * @param[in,out] ctx pointer to the decoder context

449 * @param[in,out] band pointer to the band descriptor

450 * @param[in,out] tile pointer to the tile descriptor

451 * @param[in] avctx pointer to the AVCodecContext

452 * @return result code: 0 = OK, negative number = error

453 */

454 static int decode_mb_info(IVI45DecContext *ctx, IVIBandDesc *band,

455 IVITile *tile, AVCodecContext *avctx)

456 {

457 int x, y, mv_x, mv_y, mv_delta, offs, mb_offset, blks_per_mb,

458 mv_scale, mb_type_bits, s;

459 IVIMbInfo *mb, *ref_mb;

460 int row_offset = band->mb_size * band->pitch;

461

462 mb = tile->mbs;

463 ref_mb = tile->ref_mbs;

464 offs = tile->ypos * band->pitch + tile->xpos;

465

466 blks_per_mb = band->mb_size != band->blk_size ? 4 : 1;

467 mb_type_bits = ctx->frame_type == IVI4_FRAMETYPE_BIDIR ? 2 : 1;

468

469 /* scale factor for motion vectors */

470 mv_scale = (ctx->planes[0].bands[0].mb_size >> 3) - (band->mb_size >> 3);

471 mv_x = mv_y = 0;

472

473 if (((tile->width + band->mb_size-1)/band->mb_size) * ((tile->height + band->mb_size-1)/band->mb_size) != tile->num_MBs) {

474 av_log(avctx, AV_LOG_ERROR, "num_MBs mismatch %d %d %d %d\n", tile->width, tile->height, band->mb_size, tile->num_MBs);

475 return -1;

476 }

477

478 for (y = tile->ypos; y < tile->ypos + tile->height; y += band->mb_size) {

479 mb_offset = offs;

480

481 for (x = tile->xpos; x < tile->xpos + tile->width; x += band->mb_size) {

482 mb->xpos = x;

483 mb->ypos = y;

484 mb->buf_offs = mb_offset;

485 mb->b_mv_x =

486 mb->b_mv_y = 0;

487

488 if (get_bits1(&ctx->gb)) {

489 if (ctx->frame_type == IVI4_FRAMETYPE_INTRA) {

490 av_log(avctx, AV_LOG_ERROR, "Empty macroblock in an INTRA picture!\n");

491 return AVERROR_INVALIDDATA;

492 }

493 mb->type = 1; /* empty macroblocks are always INTER */

494 mb->cbp = 0; /* all blocks are empty */

495

496 mb->q_delta = 0;

497 if (!band->plane && !band->band_num && ctx->in_q) {

498 mb->q_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table,

499 IVI_VLC_BITS, 1);

500 mb->q_delta = IVI_TOSIGNED(mb->q_delta);

501 }

502

503 mb->mv_x = mb->mv_y = 0; /* no motion vector coded */

504 if (band->inherit_mv && ref_mb) {

505 /* motion vector inheritance */

506 if (mv_scale) {

507 mb->mv_x = ivi_scale_mv(ref_mb->mv_x, mv_scale);

508 mb->mv_y = ivi_scale_mv(ref_mb->mv_y, mv_scale);

509 } else {

510 mb->mv_x = ref_mb->mv_x;

511 mb->mv_y = ref_mb->mv_y;

512 }

513 }

514 } else {

515 if (band->inherit_mv) {

516 /* copy mb_type from corresponding reference mb */

517 if (!ref_mb) {

518 av_log(avctx, AV_LOG_ERROR, "ref_mb unavailable\n");

519 return AVERROR_INVALIDDATA;

520 }

521 mb->type = ref_mb->type;

522 } else if (ctx->frame_type == IVI4_FRAMETYPE_INTRA ||

523 ctx->frame_type == IVI4_FRAMETYPE_INTRA1) {

524 mb->type = 0; /* mb_type is always INTRA for intra-frames */

525 } else {

526 mb->type = get_bits(&ctx->gb, mb_type_bits);

527 }

528

529 mb->cbp = get_bits(&ctx->gb, blks_per_mb);

530

531 mb->q_delta = 0;

532 if (band->inherit_qdelta) {

533 if (ref_mb) mb->q_delta = ref_mb->q_delta;

534 } else if (mb->cbp || (!band->plane && !band->band_num &&

535 ctx->in_q)) {

536 mb->q_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table,

537 IVI_VLC_BITS, 1);

538 mb->q_delta = IVI_TOSIGNED(mb->q_delta);

539 }

540

541 if (!mb->type) {

542 mb->mv_x = mb->mv_y = 0; /* there is no motion vector in intra-macroblocks */

543 } else {

544 if (band->inherit_mv) {

545 if (ref_mb)

546 /* motion vector inheritance */

547 if (mv_scale) {

548 mb->mv_x = ivi_scale_mv(ref_mb->mv_x, mv_scale);

549 mb->mv_y = ivi_scale_mv(ref_mb->mv_y, mv_scale);

550 } else {

551 mb->mv_x = ref_mb->mv_x;

552 mb->mv_y = ref_mb->mv_y;

553 }

554 } else {

555 /* decode motion vector deltas */

556 mv_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table,

557 IVI_VLC_BITS, 1);

558 mv_y += IVI_TOSIGNED(mv_delta);

559 mv_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table,

560 IVI_VLC_BITS, 1);

561 mv_x += IVI_TOSIGNED(mv_delta);

562 mb->mv_x = mv_x;

563 mb->mv_y = mv_y;

564 if (mb->type == 3) {

565 mv_delta = get_vlc2(&ctx->gb,

566 ctx->mb_vlc.tab->table,

567 IVI_VLC_BITS, 1);

568 mv_y += IVI_TOSIGNED(mv_delta);

569 mv_delta = get_vlc2(&ctx->gb,

570 ctx->mb_vlc.tab->table,

571 IVI_VLC_BITS, 1);

572 mv_x += IVI_TOSIGNED(mv_delta);

573 mb->b_mv_x = -mv_x;

574 mb->b_mv_y = -mv_y;

575 }

576 }

577 if (mb->type == 2) {

578 mb->b_mv_x = -mb->mv_x;

579 mb->b_mv_y = -mb->mv_y;

580 mb->mv_x = 0;

581 mb->mv_y = 0;

582 }

583 }

584 }

585

586 s= band->is_halfpel;

587 if (mb->type)

588 if ( x + (mb->mv_x >>s) + (y+ (mb->mv_y >>s))*band->pitch < 0 ||

589 x + ((mb->mv_x+s)>>s) + band->mb_size - 1

590 + (y+band->mb_size - 1 +((mb->mv_y+s)>>s))*band->pitch > band->bufsize -1) {

591 av_log(avctx, AV_LOG_ERROR, "motion vector %d %d outside reference\n", x*s + mb->mv_x, y*s + mb->mv_y);

592 return AVERROR_INVALIDDATA;

593 }

594

595 mb++;

596 if (ref_mb)

597 ref_mb++;

598 mb_offset += band->mb_size;

599 }

600

601 offs += row_offset;

602 }

603

604 align_get_bits(&ctx->gb);

605

606 return 0;

607 }

608

609

610 /**

611 * Rearrange decoding and reference buffers.

612 *

613 * @param[in,out] ctx pointer to the decoder context

614 */

615 static void switch_buffers(IVI45DecContext *ctx)

616 {

617 int is_prev_ref = 0, is_ref = 0;

618

619 switch (ctx->prev_frame_type) {

620 case IVI4_FRAMETYPE_INTRA:

621 case IVI4_FRAMETYPE_INTRA1:

622 case IVI4_FRAMETYPE_INTER:

623 is_prev_ref = 1;

624 break;

625 }

626

627 switch (ctx->frame_type) {

628 case IVI4_FRAMETYPE_INTRA:

629 case IVI4_FRAMETYPE_INTRA1:

630 case IVI4_FRAMETYPE_INTER:

631 is_ref = 1;

632 break;

633 }

634

635 if (is_prev_ref && is_ref) {

636 FFSWAP(int, ctx->dst_buf, ctx->ref_buf);

637 } else if (is_prev_ref) {

638 FFSWAP(int, ctx->ref_buf, ctx->b_ref_buf);

639 FFSWAP(int, ctx->dst_buf, ctx->ref_buf);

640 }

641 }

642

643

644 static int is_nonnull_frame(IVI45DecContext *ctx)

645 {

646 return ctx->frame_type < IVI4_FRAMETYPE_NULL_FIRST;

647 }

648

649

650 static av_cold int decode_init(AVCodecContext *avctx)

651 {

652 IVI45DecContext *ctx = avctx->priv_data;

653

654 ff_ivi_init_static_vlc();

655

656 /* copy rvmap tables in our context so we can apply changes to them */

657 memcpy(ctx->rvmap_tabs, ff_ivi_rvmap_tabs, sizeof(ff_ivi_rvmap_tabs));

658

659 /* Force allocation of the internal buffers */

660 /* during picture header decoding. */

661 ctx->pic_conf.pic_width = 0;

662 ctx->pic_conf.pic_height = 0;

663

664 avctx->pix_fmt = AV_PIX_FMT_YUV410P;

665

666 ctx->decode_pic_hdr = decode_pic_hdr;

667 ctx->decode_band_hdr = decode_band_hdr;

668 ctx->decode_mb_info = decode_mb_info;

669 ctx->switch_buffers = switch_buffers;

670 ctx->is_nonnull_frame = is_nonnull_frame;

671

672 ctx->is_indeo4 = 1;

673 ctx->show_indeo4_info = 1;

674

675 ctx->dst_buf = 0;

676 ctx->ref_buf = 1;

677 ctx->b_ref_buf = 3; /* buffer 2 is used for scalability mode */

678 ctx->p_frame = av_frame_alloc();

679 if (!ctx->p_frame)

680 return AVERROR(ENOMEM);

681

682 return 0;

683 }

684

685

686 AVCodec ff_indeo4_decoder = {

687 .name = "indeo4",

688 .long_name = NULL_IF_CONFIG_SMALL("Intel Indeo Video Interactive 4"),

689 .type = AVMEDIA_TYPE_VIDEO,

690 .id = AV_CODEC_ID_INDEO4,

691 .priv_data_size = sizeof(IVI45DecContext),

692 .init = decode_init,

693 .close = ff_ivi_decode_close,

694 .decode = ff_ivi_decode_frame,

695 .capabilities = AV_CODEC_CAP_DR1,

696 };

plane

int plane

Definition: avisynth_c.h:422

IVIBandDesc::is_empty

int is_empty

= 1 if this band doesn't contain any data

Definition: ivi.h:157

IVI45DecContext::data_size

uint32_t data_size

size of the frame data in bytes from picture header

Definition: ivi.h:220

IVIMbInfo::type

uint8_t type

macroblock type: 0 - INTRA, 1 - INTER

Definition: ivi.h:114

IVITile::num_MBs

int num_MBs

number of macroblocks in this tile

Definition: ivi.h:135

ivi4_quant_8x8_intra

static const uint16_t ivi4_quant_8x8_intra[9][64]

Indeo 4 dequant tables.

Definition: indeo4data.h:89

NULL

#define NULL

Definition: coverity.c:32

scale_tile_size

static int scale_tile_size(int def_size, int size_factor)

Definition: indeo4.c:93

ff_ivi_row_slant4

void ff_ivi_row_slant4(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags)

inverse 1D row slant transform

Definition: ivi_dsp.c:708

const char * s

Definition: avisynth_c.h:768

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:59

ff_ivi_col_slant4

void ff_ivi_col_slant4(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags)

inverse 1D column slant transform

Definition: ivi_dsp.c:728

mv_scale

static av_always_inline void mv_scale(Mv *dst, Mv *src, int td, int tb)

Definition: hevc_mvs.c:114

indeo4data.h

This file contains data needed for the Indeo 4 decoder.

IVI4_FRAMETYPE_NULL_FIRST

empty frame with no data

Definition: ivi.h:45

IVIBandDesc::inv_transform

InvTransformPtr * inv_transform

Definition: ivi.h:177

IVI4_FRAMETYPE_INTER

non-droppable P-frame

Definition: ivi.h:42

DCTransformPtr

void( DCTransformPtr)(const int32_t *in, int16_t *out, uint32_t pitch, int blk_size)

Definition: ivi.h:91

IVI4_PIC_SIZE_ESC

#define IVI4_PIC_SIZE_ESC

Definition: indeo4.c:38

decode_pic_hdr

static int decode_pic_hdr(IVI45DecContext *ctx, AVCodecContext *avctx)

Decode Indeo 4 picture header.

Definition: indeo4.c:105

get_bits

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:247

decode_plane_subdivision

static int decode_plane_subdivision(GetBitContext *gb)

Decode subdivision of a plane.

Definition: indeo4.c:76

IVI45DecContext::decode_pic_hdr

int(* decode_pic_hdr)(struct IVI45DecContext *ctx, AVCodecContext *avctx)

Definition: ivi.h:258

skip_bits_long

static void skip_bits_long(GetBitContext *s, int n)

Definition: get_bits.h:204

init

static av_cold int init(AVCodecContext *avctx)

Definition: avrndec.c:35

ff_ivi_dc_haar_2d

void ff_ivi_dc_haar_2d(const int32_t *in, int16_t *out, uint32_t pitch, int blk_size)

DC-only two-dimensional inverse Haar transform for Indeo 4.

Definition: ivi_dsp.c:472

IVIMbInfo::b_mv_y

int8_t b_mv_y

second motion vector (y component)

Definition: ivi.h:120

ff_ivi_decode_close

av_cold int ff_ivi_decode_close(AVCodecContext *avctx)

Close Indeo5 decoder and clean up its context.

Definition: ivi.c:1198

IVI45DecContext::decode_mb_info

int(* decode_mb_info)(struct IVI45DecContext *ctx, IVIBandDesc *band, IVITile *tile, AVCodecContext *avctx)

Definition: ivi.h:260

IVI_VLC_BITS

#define IVI_VLC_BITS

max number of bits of the ivi's huffman codes

Definition: ivi.h:49

IVI45DecContext::dst_buf

int dst_buf

buffer index for the currently decoded frame

Definition: ivi.h:233

ff_ivi_put_dc_pixel_8x8

void ff_ivi_put_dc_pixel_8x8(const int32_t *in, int16_t *out, uint32_t pitch, int blk_size)

Copy the DC coefficient into the first pixel of the block and zero all others.

Definition: ivi_dsp.c:761

ff_ivi_decode_frame

int ff_ivi_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)

Definition: ivi.c:1054

ivi_dsp.h

DSP functions (inverse transforms, motion compensations, wavelet recomposition) for Indeo Video Inter...

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:1904

IVIBandDesc::is_halfpel

int is_halfpel

precision of the motion compensation: 0 - fullpel, 1 - halfpel

Definition: ivi.h:160

IVIPicConfig::chroma_bands

uint8_t chroma_bands

Definition: ivi.h:210

IVIBandDesc::plane

int plane

plane number this band belongs to

Definition: ivi.h:145

IVIBandDesc::bufsize

int bufsize

band buffer size in bytes

Definition: ivi.h:183

IVI45DecContext::pic_conf

IVIPicConfig pic_conf

Definition: ivi.h:229

AVCodec

AVCodec.

Definition: avcodec.h:3600

IVIBandDesc::quant_mat

int quant_mat

dequant matrix index

Definition: ivi.h:164

IVI45DecContext::has_b_frames

uint8_t has_b_frames

Definition: ivi.h:252

band

Definition: af_biquads.c:76

IVIMbInfo::b_mv_x

int8_t b_mv_x

second motion vector (x component)

Definition: ivi.h:119

ff_ivi_put_pixels_8x8

void ff_ivi_put_pixels_8x8(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags)

Copy the pixels into the frame buffer.

Definition: ivi_dsp.c:751

avpriv_request_sample

void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2

Log a generic warning message about a missing feature.

IVI45DecContext::uses_tiling

uint8_t uses_tiling

Definition: ivi.h:254

IVIPicConfig::luma_bands

uint8_t luma_bands

Definition: ivi.h:209

IVIHuffTab::tab

VLC * tab

index of one of the predefined tables or "7" for custom one

Definition: ivi.h:66

av_cold

#define av_cold

Definition: attributes.h:82

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:145

#define mb

Definition: vf_colormatrix.c:101

IVI45DecContext::pic_glob_quant

uint8_t pic_glob_quant

Definition: ivi.h:244

IVIBandDesc::inter_base

const uint16_t * inter_base

quantization matrix for inter blocks

Definition: ivi.h:185

ff_ivi_init_planes

av_cold int ff_ivi_init_planes(IVIPlaneDesc *planes, const IVIPicConfig *cfg, int is_indeo4)

Initialize planes (prepares descriptors, allocates buffers etc).

Definition: ivi.c:305

IVIPicConfig::pic_height

uint16_t pic_height

Definition: ivi.h:204

ivi4_common_pic_sizes

static const uint16_t ivi4_common_pic_sizes[14]

standard picture dimensions

Definition: indeo4data.h:37

IVIBandDesc::inherit_mv

int inherit_mv

tells if motion vector is inherited from reference macroblock

Definition: ivi.h:161

decode_band_hdr

static int decode_band_hdr(IVI45DecContext *ctx, IVIBandDesc *band, AVCodecContext *avctx)

Decode Indeo 4 band header.

Definition: indeo4.c:261

IVIPicConfig::tile_height

uint16_t tile_height

Definition: ivi.h:208

IVI45DecContext::gb

GetBitContext gb

Definition: ivi.h:214

InvTransformPtr

void( InvTransformPtr)(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags)

Declare inverse transform function types.

Definition: ivi.h:90

IVIPicConfig::chroma_width

uint16_t chroma_width

Definition: ivi.h:205

IVIBandDesc::pitch

int pitch

pitch associated with the buffers above

Definition: ivi.h:156

ivi4_quant_8x8_inter

static const uint16_t ivi4_quant_8x8_inter[9][64]

Definition: indeo4data.h:182

IVIMbInfo::cbp

uint8_t cbp

coded block pattern

Definition: ivi.h:115

ff_ivi_row_haar8

void ff_ivi_row_haar8(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags)

one-dimensional inverse 8-point Haar transform on rows for Indeo 4

Definition: ivi_dsp.c:325

ff_dlog

#define ff_dlog(a,...)

Definition: tableprint_vlc.h:29

IVI45DecContext::checksum

uint16_t checksum

frame checksum

Definition: ivi.h:227

get_bits.h

bitstream reader API header.

IVIPicConfig::pic_width

uint16_t pic_width

Definition: ivi.h:203

ivi4_quant_4x4_inter

static const uint16_t ivi4_quant_4x4_inter[5][16]

Definition: indeo4data.h:308

IVI45DecContext::planes

IVIPlaneDesc planes[3]

color planes

Definition: ivi.h:230

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

ff_ivi_row_slant8

void ff_ivi_row_slant8(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags)

inverse 1D row slant transform

Definition: ivi_dsp.c:629

IVIBandDesc::intra_base

const uint16_t * intra_base

quantization matrix for intra blocks

Definition: ivi.h:184

ff_ivi_dc_row_slant

void ff_ivi_dc_row_slant(const int32_t *in, int16_t *out, uint32_t pitch, int blk_size)

DC-only inverse row slant transform.

Definition: ivi_dsp.c:649

IVI45DecContext::unknown1

uint8_t unknown1

Definition: ivi.h:245

IVIBandDesc::blk_size

int blk_size

block size

Definition: ivi.h:159

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

IVIBandDesc::corr

uint8_t corr[61 *2]

rvmap correction pairs

Definition: ivi.h:172

ff_ivi_inverse_haar_8x8

void ff_ivi_inverse_haar_8x8(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags)

two-dimensional inverse Haar 8x8 transform for Indeo 4

Definition: ivi_dsp.c:270

IVI45DecContext::rvmap_tabs

RVMapDesc rvmap_tabs[9]

local corrected copy of the static rvmap tables

Definition: ivi.h:215

ff_ivi_col_haar4

void ff_ivi_col_haar4(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags)

one-dimensional inverse 4-point Haar transform on columns for Indeo 4

Definition: ivi_dsp.c:448

AVERROR

#define AVERROR(e)

Definition: error.h:43

IVI45DecContext::in_q

uint8_t in_q

flag for explicitly stored quantiser delta

Definition: ivi.h:243

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...

Definition: internal.h:176

IVI45DecContext::show_indeo4_info

int show_indeo4_info

Definition: ivi.h:251

IVI45DecContext::is_indeo4

int is_indeo4

Definition: ivi.h:267

ff_ivi_init_tiles

av_cold int ff_ivi_init_tiles(IVIPlaneDesc *planes, int tile_width, int tile_height)

Initialize tile and macroblock descriptors.

Definition: ivi.c:421

dc_trans

DCTransformPtr * dc_trans

Definition: indeo4.c:43

ff_ivi_dc_col_slant

void ff_ivi_dc_col_slant(const int32_t *in, int16_t *out, uint32_t pitch, int blk_size)

DC-only inverse column slant transform.

Definition: ivi_dsp.c:694

IVI45DecContext::ref_buf

int ref_buf

inter frame reference buffer index

Definition: ivi.h:234

IVIBandDesc::dc_transform

DCTransformPtr * dc_transform

Definition: ivi.h:179

ivi.h

This file contains structures and macros shared by both Indeo4 and Indeo5 decoders.

AVCodec::name

const char * name

Name of the codec implementation.

Definition: avcodec.h:3607

ivi_pic_config_cmp

static int ivi_pic_config_cmp(IVIPicConfig *str1, IVIPicConfig *str2)

compare some properties of two pictures

Definition: ivi.h:274

ff_ivi_inverse_haar_4x4

void ff_ivi_inverse_haar_4x4(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags)

two-dimensional inverse Haar 4x4 transform for Indeo 4

Definition: ivi_dsp.c:379

IVIBandDesc::inherit_qdelta

int inherit_qdelta

tells if quantiser delta is inherited from reference macroblock

Definition: ivi.h:162

IVI45DecContext::frame_num

uint32_t frame_num

Definition: ivi.h:217

IVI45DecContext::p_frame

AVFrame * p_frame

Definition: ivi.h:269

IVI45DecContext::decode_band_hdr

int(* decode_band_hdr)(struct IVI45DecContext *ctx, IVIBandDesc *band, AVCodecContext *avctx)

Definition: ivi.h:259

ff_ivi_rvmap_tabs

const RVMapDesc ff_ivi_rvmap_tabs[9]

Run-value (RLE) tables.

Definition: ivi.c:1246

IVI45DecContext::is_scalable

int is_scalable

Definition: ivi.h:221

is_2d_trans

int is_2d_trans

Definition: indeo4.c:44

IVI4_FRAMETYPE_BIDIR

bidirectional frame

Definition: ivi.h:43

IVITile::mbs

IVIMbInfo * mbs

array of macroblock descriptors

Definition: ivi.h:136

ctx

AVFormatContext * ctx

Definition: movenc.c:48

switch_buffers

static void switch_buffers(IVI45DecContext *ctx)

Rearrange decoding and reference buffers.

Definition: indeo4.c:615

IVIBandDesc::inter_scale

const uint8_t * inter_scale

quantization coefficient for inter blocks

Definition: ivi.h:187

get_vlc2

static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)

Parse a vlc code.

Definition: get_bits.h:535

ff_ivi_dec_huff_desc

int ff_ivi_dec_huff_desc(GetBitContext *gb, int desc_coded, int which_tab, IVIHuffTab *huff_tab, AVCodecContext *avctx)

Decode a huffman codebook descriptor from the bitstream and select specified huffman table...

Definition: ivi.c:226

IVIPicConfig::chroma_height

uint16_t chroma_height

Definition: ivi.h:206

IVI4_FRAMETYPE_INTRA1

intra frame with slightly different bitstream coding

Definition: ivi.h:41

transforms

static const struct @73 transforms[18]

scan_index_to_tab

static const uint8_t *const scan_index_to_tab[15]

Definition: indeo4data.h:63

IVIMbInfo::q_delta

int8_t q_delta

quant delta

Definition: ivi.h:116

quant_index_to_tab

static const uint8_t quant_index_to_tab[22]

Table for mapping quant matrix index from the bitstream into internal quant table number...

Definition: indeo4data.h:345

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen_template.c:36

ff_ivi_inverse_slant_8x8

void ff_ivi_inverse_slant_8x8(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags)

two-dimensional inverse slant 8x8 transform

Definition: ivi_dsp.c:536

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:62

IVIPicConfig::tile_width

uint16_t tile_width

Definition: ivi.h:207

IVITile::ypos

int ypos

Definition: ivi.h:129

IVI45DecContext::mb_vlc

IVIHuffTab mb_vlc

current macroblock table descriptor

Definition: ivi.h:238

IVIBandDesc::is_2d_trans

int is_2d_trans

1 indicates that the two-dimensional inverse transform is used

Definition: ivi.h:180

avcodec.h

Libavcodec external API header.

IVIBandDesc::glob_quant

int glob_quant

quant base for this band

Definition: ivi.h:165

IVITile::height

int height

Definition: ivi.h:131

AVCodecContext

main external API structure.

Definition: avcodec.h:1676

IVIBandDesc::num_corr

int num_corr

number of correction entries

Definition: ivi.h:171

ivi_scale_mv

static int ivi_scale_mv(int mv, int mv_scale)

scale motion vector

Definition: ivi.h:293

IVITile

information for Indeo tile

Definition: ivi.h:127

IVI45DecContext::is_nonnull_frame

int(* is_nonnull_frame)(struct IVI45DecContext *ctx)

Definition: ivi.h:262

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:299

AV_PIX_FMT_YUV410P

planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)

Definition: pixfmt.h:68

IVI45DecContext::in_imf

uint8_t in_imf

Definition: ivi.h:242

skip_bits

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:292

ff_ivi_col_haar8

void ff_ivi_col_haar8(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags)

one-dimensional inverse 8-point Haar transform on columns for Indeo 4

Definition: ivi_dsp.c:350

IVI45DecContext::uses_haar

uint8_t uses_haar

Definition: ivi.h:255

ivi4_quant_4x4_intra

static const uint16_t ivi4_quant_4x4_intra[5][16]

Definition: indeo4data.h:275

IVI45DecContext::switch_buffers

void(* switch_buffers)(struct IVI45DecContext *ctx)

Definition: ivi.h:261

IVIPlaneDesc::bands

IVIBandDesc * bands

array of band descriptors

Definition: ivi.h:198

IVIBandDesc::checksum

int32_t checksum

for debug purposes

Definition: ivi.h:181

IVIBandDesc::rvmap_sel

int rvmap_sel

rvmap table selector

Definition: ivi.h:173

IVIMbInfo::mv_x

int8_t mv_x

motion vector (x component)

Definition: ivi.h:117

IVIMbInfo::mv_y

int8_t mv_y

motion vector (y component)

Definition: ivi.h:118

IVI_TOSIGNED

#define IVI_TOSIGNED(val)

convert unsigned values into signed ones (the sign is in the LSB)

Definition: ivi.h:290

IVIBandDesc::mb_size

int mb_size

macroblock size

Definition: ivi.h:158

IVITile::ref_mbs

IVIMbInfo * ref_mbs

ptr to the macroblock descriptors of the reference tile

Definition: ivi.h:137

IVITile::xpos

int xpos

Definition: ivi.h:128

IVI_MB_HUFF

Definition: ivi.h:74

IVI45DecContext::blk_vlc

IVIHuffTab blk_vlc

current block table descriptor

Definition: ivi.h:239

ff_ivi_inverse_slant_4x4

void ff_ivi_inverse_slant_4x4(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags)

two-dimensional inverse slant 4x4 transform

Definition: ivi_dsp.c:576

IVIMbInfo::xpos

int16_t xpos

Definition: ivi.h:111

IVIPicConfig

Definition: ivi.h:202

IVIBandDesc::band_num

int band_num

band number

Definition: ivi.h:146

inv_trans

InvTransformPtr * inv_trans

Definition: indeo4.c:42

IVI4_FRAMETYPE_INTRA

Definition: ivi.h:40

GetBitContext

Definition: get_bits.h:55

internal.h

common internal api header.

IVIBandDesc::transform_size

int transform_size

Definition: ivi.h:178

is_nonnull_frame

static int is_nonnull_frame(IVI45DecContext *ctx)

Definition: indeo4.c:644

decode_mb_info

static int decode_mb_info(IVI45DecContext *ctx, IVIBandDesc *band, IVITile *tile, AVCodecContext *avctx)

Decode information (block type, cbp, quant delta, motion vector) for all macroblocks in the current t...

Definition: indeo4.c:454

IVIBandDesc::scan

const uint8_t * scan

ptr to the scan pattern

Definition: ivi.h:166

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:1718

IVITile::width

int width

Definition: ivi.h:130

decode_init

static av_cold int decode_init(AVCodecContext *avctx)

Definition: indeo4.c:650

IVIBandDesc::checksum_present

int checksum_present

Definition: ivi.h:182

IVI45DecContext::has_transp

uint8_t has_transp

transparency mode status: 1 - enabled

Definition: ivi.h:253

AV_CODEC_ID_INDEO4

Definition: avcodec.h:308

VLC::table

VLC_TYPE(* table)[2]

code, bits

Definition: vlc.h:28

ff_ivi_dc_slant_2d

void ff_ivi_dc_slant_2d(const int32_t *in, int16_t *out, uint32_t pitch, int blk_size)

DC-only two-dimensional inverse slant transform.

Definition: ivi_dsp.c:616

align_get_bits

static const uint8_t * align_get_bits(GetBitContext *s)

Definition: get_bits.h:445

IVIMbInfo::ypos

int16_t ypos

Definition: ivi.h:112

IVI45DecContext::prev_frame_type

int prev_frame_type

frame type of the previous frame

Definition: ivi.h:219

IVIMbInfo

information for Indeo macroblock (16x16, 8x8 or 4x4)

Definition: ivi.h:110

IVIBandDesc::blk_vlc

IVIHuffTab blk_vlc

vlc table for decoding block data

Definition: ivi.h:169

IVIBandDesc::scan_size

int scan_size

size of the scantable

Definition: ivi.h:167

IVI45DecContext

Definition: ivi.h:213

ff_ivi_init_static_vlc

av_cold void ff_ivi_init_static_vlc(void)

Initialize static codes used for macroblock and block decoding.

Definition: ivi.c:179

decode

static int decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt)

Definition: ffmpeg.c:2035

ff_ivi_row_haar4

void ff_ivi_row_haar4(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags)

one-dimensional inverse 4-point Haar transform on rows for Indeo 4

Definition: ivi_dsp.c:426

AVMEDIA_TYPE_VIDEO

Definition: avutil.h:195

IVIBandDesc::intra_scale

const uint8_t * intra_scale

quantization coefficient for intra blocks

Definition: ivi.h:186

IVI45DecContext::uses_fullpel

uint8_t uses_fullpel

Definition: ivi.h:256

FFSWAP

#define FFSWAP(type, a, b)

Definition: common.h:99

IVIMbInfo::buf_offs

uint32_t buf_offs

address in the output buffer for this mb

Definition: ivi.h:113

IVI45DecContext::b_ref_buf

int b_ref_buf

second reference frame buffer index

Definition: ivi.h:236

IVIBandDesc

information for Indeo wavelet band

Definition: ivi.h:144

IVI_BLK_HUFF

Huffman table is used for coding macroblocks.

Definition: ivi.h:75

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

Codec uses get_buffer() for allocating buffers and supports custom allocators.

Definition: avcodec.h:959

IVI45DecContext::rvmap_sel

uint8_t rvmap_sel

Definition: ivi.h:241

ff_indeo4_decoder

AVCodec ff_indeo4_decoder

Definition: indeo4.c:686

IVI45DecContext::frame_type

int frame_type

Definition: ivi.h:218

ff_ivi_col_slant8

void ff_ivi_col_slant8(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags)

inverse 1D column slant transform

Definition: ivi_dsp.c:667

Generated on Thu Oct 27 2016 19:33:25 for FFmpeg by doxygen 1.8.6