FFmpeg: libavcodec/ivi.c Source File

FFmpeg

[フレーム]

libavcodec

ivi.c

Go to the documentation of this file.

1 /*

2 * common functions for Indeo Video Interactive codecs (Indeo4 and Indeo5)

3 *

5 *

6 * This file is part of FFmpeg.

7 *

8 * FFmpeg is free software; you can redistribute it and/or

9 * modify it under the terms of the GNU Lesser General Public

10 * License as published by the Free Software Foundation; either

11 * version 2.1 of the License, or (at your option) any later version.

12 *

13 * FFmpeg is distributed in the hope that it will be useful,

14 * but WITHOUT ANY WARRANTY; without even the implied warranty of

15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

16 * Lesser General Public License for more details.

17 *

18 * You should have received a copy of the GNU Lesser General Public

19 * License along with FFmpeg; if not, write to the Free Software

20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

21 */

23 /**

24 * @file

25 * This file contains functions and data shared by both Indeo4 and

26 * Indeo5 decoders.

27 */

29 #include <inttypes.h>

31 #include "libavutil/attributes.h"

32 #include "libavutil/imgutils.h"

33 #include "libavutil/thread.h"

35 #define BITSTREAM_READER_LE

36 #include "avcodec.h"

37 #include "get_bits.h"

38 #include "internal.h"

39 #include "ivi.h"

40 #include "ivi_dsp.h"

42 /**

43 * These are 2x8 predefined Huffman codebooks for coding macroblock/block

44 * signals. They are specified using "huffman descriptors" in order to

45 * avoid huge static tables. The decoding tables will be generated at

46 * startup from these descriptors.

47 */

48 /** static macroblock huffman tables */

49 static const IVIHuffDesc ivi_mb_huff_desc[8] = {

50 {8, {0, 4, 5, 4, 4, 4, 6, 6}},

51 {12, {0, 2, 2, 3, 3, 3, 3, 5, 3, 2, 2, 2}},

52 {12, {0, 2, 3, 4, 3, 3, 3, 3, 4, 3, 2, 2}},

53 {12, {0, 3, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2}},

54 {13, {0, 4, 4, 3, 3, 3, 3, 2, 3, 3, 2, 1, 1}},

55 {9, {0, 4, 4, 4, 4, 3, 3, 3, 2}},

56 {10, {0, 4, 4, 4, 4, 3, 3, 2, 2, 2}},

57 {12, {0, 4, 4, 4, 3, 3, 2, 3, 2, 2, 2, 2}}

58 };

60 /** static block huffman tables */

61 static const IVIHuffDesc ivi_blk_huff_desc[8] = {

62 {10, {1, 2, 3, 4, 4, 7, 5, 5, 4, 1}},

63 {11, {2, 3, 4, 4, 4, 7, 5, 4, 3, 3, 2}},

64 {12, {2, 4, 5, 5, 5, 5, 6, 4, 4, 3, 1, 1}},

65 {13, {3, 3, 4, 4, 5, 6, 6, 4, 4, 3, 2, 1, 1}},

66 {11, {3, 4, 4, 5, 5, 5, 6, 5, 4, 2, 2}},

67 {13, {3, 4, 5, 5, 5, 5, 6, 4, 3, 3, 2, 1, 1}},

68 {13, {3, 4, 5, 5, 5, 6, 5, 4, 3, 3, 2, 1, 1}},

69 {9, {3, 4, 4, 5, 5, 5, 6, 5, 5}}

70 };

72 static VLC ivi_mb_vlc_tabs [8]; ///< static macroblock Huffman tables

73 static VLC ivi_blk_vlc_tabs[8]; ///< static block Huffman tables

75 typedef void (*ivi_mc_func) (int16_t *buf, const int16_t *ref_buf,

76 ptrdiff_t pitch, int mc_type);

77 typedef void (*ivi_mc_avg_func) (int16_t *buf, const int16_t *ref_buf1,

78 const int16_t *ref_buf2,

79 ptrdiff_t pitch, int mc_type, int mc_type2);

81 static int ivi_mc(const IVIBandDesc *band, ivi_mc_func mc, ivi_mc_avg_func mc_avg,

82 int offs, int mv_x, int mv_y, int mv_x2, int mv_y2,

83 int mc_type, int mc_type2)

84 {

85 int ref_offs = offs + mv_y * band->pitch + mv_x;

86 int buf_size = band->pitch * band->aheight;

87 int min_size = band->pitch * (band->blk_size - 1) + band->blk_size;

88 int ref_size = (mc_type > 1) * band->pitch + (mc_type & 1);

90 if (mc_type != -1) {

91 av_assert0(offs >= 0 && ref_offs >= 0 && band->ref_buf);

92 av_assert0(buf_size - min_size >= offs);

93 av_assert0(buf_size - min_size - ref_size >= ref_offs);

94 }

96 if (mc_type2 == -1) {

97 mc(band->buf + offs, band->ref_buf + ref_offs, band->pitch, mc_type);

98 } else {

99 int ref_offs2 = offs + mv_y2 * band->pitch + mv_x2;

100 int ref_size2 = (mc_type2 > 1) * band->pitch + (mc_type2 & 1);

101 if (offs < 0 || ref_offs2 < 0 || !band->b_ref_buf)

102 return AVERROR_INVALIDDATA;

103 if (buf_size - min_size - ref_size2 < ref_offs2)

104 return AVERROR_INVALIDDATA;

105

106 if (mc_type == -1)

107 mc(band->buf + offs, band->b_ref_buf + ref_offs2,

108 band->pitch, mc_type2);

109 else

110 mc_avg(band->buf + offs, band->ref_buf + ref_offs,

111 band->b_ref_buf + ref_offs2, band->pitch,

112 mc_type, mc_type2);

113 }

114

115 return 0;

116 }

117

118 /*

119 * Generate a huffman codebook from the given descriptor

120 * and convert it into the FFmpeg VLC table.

121 *

122 * @param[in] cb pointer to codebook descriptor

123 * @param[out] vlc where to place the generated VLC table

124 * @param[in] flag flag: 1 - for static or 0 for dynamic tables

125 * @return result code: 0 - OK, -1 = error (invalid codebook descriptor)

126 */

127 static int ivi_create_huff_from_desc(const IVIHuffDesc *cb, VLC *vlc, int flag)

128 {

129 int pos, i, j, codes_per_row, prefix, not_last_row;

130 uint16_t codewords[256]; /* FIXME: move this temporal storage out? */

131 uint8_t bits[256];

132

133 pos = 0; /* current position = 0 */

134

135 for (i = 0; i < cb->num_rows; i++) {

136 codes_per_row = 1 << cb->xbits[i];

137 not_last_row = (i != cb->num_rows - 1);

138 prefix = ((1 << i) - 1) << (cb->xbits[i] + not_last_row);

139

140 for (j = 0; j < codes_per_row; j++) {

141 if (pos >= 256) /* Some Indeo5 codebooks can have more than 256 */

142 break; /* elements, but only 256 codes are allowed! */

143

144 bits[pos] = i + cb->xbits[i] + not_last_row;

145 if (bits[pos] > IVI_VLC_BITS)

146 return AVERROR_INVALIDDATA; /* invalid descriptor */

147

148 codewords[pos] = prefix | j;

149 if (!bits[pos])

150 bits[pos] = 1;

151

152 pos++;

153 }//for j

154 }//for i

155

156 /* number of codewords = pos */

157 return init_vlc(vlc, IVI_VLC_BITS, pos, bits, 1, 1, codewords, 2, 2,

158 (flag ? INIT_VLC_USE_NEW_STATIC : 0) | INIT_VLC_OUTPUT_LE);

159 }

160

161 static av_cold void ivi_init_static_vlc(void)

162 {

163 int i;

164 static VLCElem table_data[8192 * 16];

165

166 for (i = 0; i < 8; i++) {

167 ivi_mb_vlc_tabs[i].table = table_data + i * 2 * 8192;

168 ivi_mb_vlc_tabs[i].table_allocated = 8192;

169 ivi_create_huff_from_desc(&ivi_mb_huff_desc[i],

170 &ivi_mb_vlc_tabs[i], 1);

171 ivi_blk_vlc_tabs[i].table = table_data + (i * 2 + 1) * 8192;

172 ivi_blk_vlc_tabs[i].table_allocated = 8192;

173 ivi_create_huff_from_desc(&ivi_blk_huff_desc[i],

174 &ivi_blk_vlc_tabs[i], 1);

175 }

176 }

177

178 av_cold void ff_ivi_init_static_vlc(void)

179 {

180 static AVOnce init_static_once = AV_ONCE_INIT;

181 ff_thread_once(&init_static_once, ivi_init_static_vlc);

182 }

183

184 /*

185 * Copy huffman codebook descriptors.

186 *

187 * @param[out] dst ptr to the destination descriptor

188 * @param[in] src ptr to the source descriptor

189 */

190 static void ivi_huff_desc_copy(IVIHuffDesc *dst, const IVIHuffDesc *src)

191 {

192 dst->num_rows = src->num_rows;

193 memcpy(dst->xbits, src->xbits, src->num_rows);

194 }

195

196 /*

197 * Compare two huffman codebook descriptors.

198 *

199 * @param[in] desc1 ptr to the 1st descriptor to compare

200 * @param[in] desc2 ptr to the 2nd descriptor to compare

201 * @return comparison result: 0 - equal, 1 - not equal

202 */

203 static int ivi_huff_desc_cmp(const IVIHuffDesc *desc1,

204 const IVIHuffDesc *desc2)

205 {

206 return desc1->num_rows != desc2->num_rows ||

207 memcmp(desc1->xbits, desc2->xbits, desc1->num_rows);

208 }

209

210 int ff_ivi_dec_huff_desc(GetBitContext *gb, int desc_coded, int which_tab,

211 IVIHuffTab *huff_tab, AVCodecContext *avctx)

212 {

213 int i, result;

214 IVIHuffDesc new_huff;

215

216 if (!desc_coded) {

217 /* select default table */

218 huff_tab->tab = (which_tab) ? &ivi_blk_vlc_tabs[7]

219 : &ivi_mb_vlc_tabs [7];

220 return 0;

221 }

222

223 huff_tab->tab_sel = get_bits(gb, 3);

224 if (huff_tab->tab_sel == 7) {

225 /* custom huffman table (explicitly encoded) */

226 new_huff.num_rows = get_bits(gb, 4);

227 if (!new_huff.num_rows) {

228 av_log(avctx, AV_LOG_ERROR, "Empty custom Huffman table!\n");

229 return AVERROR_INVALIDDATA;

230 }

231

232 for (i = 0; i < new_huff.num_rows; i++)

233 new_huff.xbits[i] = get_bits(gb, 4);

234

235 /* Have we got the same custom table? Rebuild if not. */

236 if (ivi_huff_desc_cmp(&new_huff, &huff_tab->cust_desc) || !huff_tab->cust_tab.table) {

237 ivi_huff_desc_copy(&huff_tab->cust_desc, &new_huff);

238

239 if (huff_tab->cust_tab.table)

240 ff_free_vlc(&huff_tab->cust_tab);

241 result = ivi_create_huff_from_desc(&huff_tab->cust_desc,

242 &huff_tab->cust_tab, 0);

243 if (result) {

244 // reset faulty description

245 huff_tab->cust_desc.num_rows = 0;

246 av_log(avctx, AV_LOG_ERROR,

247 "Error while initializing custom vlc table!\n");

248 return result;

249 }

250 }

251 huff_tab->tab = &huff_tab->cust_tab;

252 } else {

253 /* select one of predefined tables */

254 huff_tab->tab = (which_tab) ? &ivi_blk_vlc_tabs[huff_tab->tab_sel]

255 : &ivi_mb_vlc_tabs [huff_tab->tab_sel];

256 }

257

258 return 0;

259 }

260

261 /*

262 * Free planes, bands and macroblocks buffers.

263 *

264 * @param[in] planes pointer to the array of the plane descriptors

265 */

266 static av_cold void ivi_free_buffers(IVIPlaneDesc *planes)

267 {

268 int p, b, t;

269

270 for (p = 0; p < 3; p++) {

271 if (planes[p].bands) {

272 for (b = 0; b < planes[p].num_bands; b++) {

273 IVIBandDesc *band = &planes[p].bands[b];

274 av_freep(&band->bufs[0]);

275 av_freep(&band->bufs[1]);

276 av_freep(&band->bufs[2]);

277 av_freep(&band->bufs[3]);

278

279 if (band->blk_vlc.cust_tab.table)

280 ff_free_vlc(&band->blk_vlc.cust_tab);

281 for (t = 0; t < band->num_tiles; t++)

282 av_freep(&band->tiles[t].mbs);

283 av_freep(&band->tiles);

284 }

285 }

286 av_freep(&planes[p].bands);

287 planes[p].num_bands = 0;

288 }

289 }

290

291 av_cold int ff_ivi_init_planes(AVCodecContext *avctx, IVIPlaneDesc *planes, const IVIPicConfig *cfg,

292 int is_indeo4)

293 {

294 int p, b;

295 uint32_t b_width, b_height, align_fac, width_aligned,

296 height_aligned, buf_size;

297 IVIBandDesc *band;

298

299 ivi_free_buffers(planes);

300

301 if (av_image_check_size2(cfg->pic_width, cfg->pic_height, avctx->max_pixels, AV_PIX_FMT_YUV410P, 0, avctx) < 0 ||

302 cfg->luma_bands < 1 || cfg->chroma_bands < 1)

303 return AVERROR_INVALIDDATA;

304

305 /* fill in the descriptor of the luminance plane */

306 planes[0].width = cfg->pic_width;

307 planes[0].height = cfg->pic_height;

308 planes[0].num_bands = cfg->luma_bands;

309

310 /* fill in the descriptors of the chrominance planes */

311 planes[1].width = planes[2].width = (cfg->pic_width + 3) >> 2;

312 planes[1].height = planes[2].height = (cfg->pic_height + 3) >> 2;

313 planes[1].num_bands = planes[2].num_bands = cfg->chroma_bands;

314

315 for (p = 0; p < 3; p++) {

316 planes[p].bands = av_calloc(planes[p].num_bands, sizeof(*planes[p].bands));

317 if (!planes[p].bands)

318 return AVERROR(ENOMEM);

319

320 /* select band dimensions: if there is only one band then it

321 * has the full size, if there are several bands each of them

322 * has only half size */

323 b_width = planes[p].num_bands == 1 ? planes[p].width

324 : (planes[p].width + 1) >> 1;

325 b_height = planes[p].num_bands == 1 ? planes[p].height

326 : (planes[p].height + 1) >> 1;

327

328 /* luma band buffers will be aligned on 16x16 (max macroblock size) */

329 /* chroma band buffers will be aligned on 8x8 (max macroblock size) */

330 align_fac = p ? 8 : 16;

331 width_aligned = FFALIGN(b_width , align_fac);

332 height_aligned = FFALIGN(b_height, align_fac);

333 buf_size = width_aligned * height_aligned * sizeof(int16_t);

334

335 for (b = 0; b < planes[p].num_bands; b++) {

336 band = &planes[p].bands[b]; /* select appropriate plane/band */

337 band->plane = p;

338 band->band_num = b;

339 band->width = b_width;

340 band->height = b_height;

341 band->pitch = width_aligned;

342 band->aheight = height_aligned;

343 av_assert0(!band->bufs[0] && !band->bufs[1] &&

344 !band->bufs[2] && !band->bufs[3]);

345 band->bufsize = buf_size/2;

346 av_assert0(buf_size % 2 == 0);

347

348 /* reset custom vlc */

349 planes[p].bands[0].blk_vlc.cust_desc.num_rows = 0;

350 }

351 }

352

353 return 0;

354 }

355

356 static int ivi_init_tiles(const IVIBandDesc *band, IVITile *ref_tile,

357 int p, int b, int t_height, int t_width)

358 {

359 int x, y;

360 IVITile *tile = band->tiles;

361

362 for (y = 0; y < band->height; y += t_height) {

363 for (x = 0; x < band->width; x += t_width) {

364 tile->xpos = x;

365 tile->ypos = y;

366 tile->mb_size = band->mb_size;

367 tile->width = FFMIN(band->width - x, t_width);

368 tile->height = FFMIN(band->height - y, t_height);

369 tile->is_empty = tile->data_size = 0;

370 /* calculate number of macroblocks */

371 tile->num_MBs = IVI_MBs_PER_TILE(tile->width, tile->height,

372 band->mb_size);

373

374 av_freep(&tile->mbs);

375 tile->mbs = av_calloc(tile->num_MBs, sizeof(*tile->mbs));

376 if (!tile->mbs)

377 return AVERROR(ENOMEM);

378

379 tile->ref_mbs = 0;

380 if (p || b) {

381 if (tile->num_MBs != ref_tile->num_MBs) {

382 av_log(NULL, AV_LOG_DEBUG, "ref_tile mismatch\n");

383 return AVERROR_INVALIDDATA;

384 }

385 tile->ref_mbs = ref_tile->mbs;

386 ref_tile++;

387 }

388 tile++;

389 }

390 }

391

392 return 0;

393 }

394

395 av_cold int ff_ivi_init_tiles(IVIPlaneDesc *planes,

396 int tile_width, int tile_height)

397 {

398 int p, b, x_tiles, y_tiles, t_width, t_height, ret;

399 IVIBandDesc *band;

400

401 for (p = 0; p < 3; p++) {

402 t_width = !p ? tile_width : (tile_width + 3) >> 2;

403 t_height = !p ? tile_height : (tile_height + 3) >> 2;

404

405 if (!p && planes[0].num_bands == 4) {

406 if (t_width % 2 || t_height % 2) {

407 avpriv_request_sample(NULL, "Odd tiles");

408 return AVERROR_PATCHWELCOME;

409 }

410 t_width >>= 1;

411 t_height >>= 1;

412 }

413 if(t_width<=0 || t_height<=0)

414 return AVERROR(EINVAL);

415

416 for (b = 0; b < planes[p].num_bands; b++) {

417 band = &planes[p].bands[b];

418

419 if (band->tiles) {

420 int t;

421 for (t = 0; t < band->num_tiles; t++) {

422 av_freep(&band->tiles[t].mbs);

423 }

424 }

425

426 x_tiles = IVI_NUM_TILES(band->width, t_width);

427 y_tiles = IVI_NUM_TILES(band->height, t_height);

428 band->num_tiles = x_tiles * y_tiles;

429

430 av_freep(&band->tiles);

431 band->tiles = av_calloc(band->num_tiles, sizeof(*band->tiles));

432 if (!band->tiles) {

433 band->num_tiles = 0;

434 return AVERROR(ENOMEM);

435 }

436

437 /* use the first luma band as reference for motion vectors

438 * and quant */

439 ret = ivi_init_tiles(band, planes[0].bands[0].tiles,

440 p, b, t_height, t_width);

441 if (ret < 0)

442 return ret;

443 }

444 }

445

446 return 0;

447 }

448

449 /*

450 * Decode size of the tile data.

451 * The size is stored as a variable-length field having the following format:

452 * if (tile_data_size < 255) than this field is only one byte long

453 * if (tile_data_size >= 255) than this field four is byte long: 0xFF X1 X2 X3

454 * where X1-X3 is size of the tile data

455 *

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

457 * @return size of the tile data in bytes

458 */

459 static int ivi_dec_tile_data_size(GetBitContext *gb)

460 {

461 int len;

462

463 len = 0;

464 if (get_bits1(gb)) {

465 len = get_bits(gb, 8);

466 if (len == 255)

467 len = get_bits(gb, 24);

468 }

469

470 /* align the bitstream reader on the byte boundary */

471 align_get_bits(gb);

472

473 return len;

474 }

475

476 static int ivi_dc_transform(const IVIBandDesc *band, int *prev_dc, int buf_offs,

477 int blk_size)

478 {

479 band->dc_transform(prev_dc, band->buf + buf_offs,

480 band->pitch, blk_size);

481

482 return 0;

483 }

484

485 static int ivi_decode_coded_blocks(GetBitContext *gb, const IVIBandDesc *band,

486 ivi_mc_func mc, ivi_mc_avg_func mc_avg,

487 int mv_x, int mv_y,

488 int mv_x2, int mv_y2,

489 int *prev_dc, int is_intra,

490 int mc_type, int mc_type2,

491 uint32_t quant, int offs,

492 AVCodecContext *avctx)

493 {

494 const uint16_t *base_tab = is_intra ? band->intra_base : band->inter_base;

495 RVMapDesc *rvmap = band->rv_map;

496 uint8_t col_flags[8];

497 int32_t trvec[64];

498 uint32_t sym = 0, lo, hi, q;

499 int pos, run, val;

500 int blk_size = band->blk_size;

501 int num_coeffs = blk_size * blk_size;

502 int col_mask = blk_size - 1;

503 int scan_pos = -1;

504 int min_size = band->pitch * (band->transform_size - 1) +

505 band->transform_size;

506 int buf_size = band->pitch * band->aheight - offs;

507

508 if (min_size > buf_size)

509 return AVERROR_INVALIDDATA;

510

511 if (!band->scan) {

512 av_log(avctx, AV_LOG_ERROR, "Scan pattern is not set.\n");

513 return AVERROR_INVALIDDATA;

514 }

515

516 /* zero transform vector */

517 memset(trvec, 0, num_coeffs * sizeof(trvec[0]));

518 /* zero column flags */

519 memset(col_flags, 0, sizeof(col_flags));

520 while (scan_pos <= num_coeffs) {

521 sym = get_vlc2(gb, band->blk_vlc.tab->table,

522 IVI_VLC_BITS, 1);

523 if (sym == rvmap->eob_sym)

524 break; /* End of block */

525

526 /* Escape - run/val explicitly coded using 3 vlc codes */

527 if (sym == rvmap->esc_sym) {

528 run = get_vlc2(gb, band->blk_vlc.tab->table, IVI_VLC_BITS, 1) + 1;

529 lo = get_vlc2(gb, band->blk_vlc.tab->table, IVI_VLC_BITS, 1);

530 hi = get_vlc2(gb, band->blk_vlc.tab->table, IVI_VLC_BITS, 1);

531 /* merge them and convert into signed val */

532 val = IVI_TOSIGNED((hi << 6) | lo);

533 } else {

534 if (sym >= 256U) {

535 av_log(avctx, AV_LOG_ERROR, "Invalid sym encountered: %"PRIu32".\n", sym);

536 return AVERROR_INVALIDDATA;

537 }

538 run = rvmap->runtab[sym];

539 val = rvmap->valtab[sym];

540 }

541

542 /* de-zigzag and dequantize */

543 scan_pos += run;

544 if (scan_pos >= num_coeffs || scan_pos < 0)

545 break;

546 pos = band->scan[scan_pos];

547

548 if (!val)

549 ff_dlog(avctx, "Val = 0 encountered!\n");

550

551 q = (base_tab[pos] * quant) >> 9;

552 if (q > 1)

553 val = val * q + FFSIGN(val) * (((q ^ 1) - 1) >> 1);

554 trvec[pos] = val;

555 /* track columns containing non-zero coeffs */

556 col_flags[pos & col_mask] |= !!val;

557 }

558

559 if (scan_pos < 0 || scan_pos >= num_coeffs && sym != rvmap->eob_sym)

560 return AVERROR_INVALIDDATA; /* corrupt block data */

561

562 /* undoing DC coeff prediction for intra-blocks */

563 if (is_intra && band->is_2d_trans) {

564 *prev_dc += trvec[0];

565 trvec[0] = *prev_dc;

566 col_flags[0] |= !!*prev_dc;

567 }

568

569 if(band->transform_size > band->blk_size){

570 av_log(NULL, AV_LOG_ERROR, "Too large transform\n");

571 return AVERROR_INVALIDDATA;

572 }

573

574 /* apply inverse transform */

575 band->inv_transform(trvec, band->buf + offs,

576 band->pitch, col_flags);

577

578 /* apply motion compensation */

579 if (!is_intra)

580 return ivi_mc(band, mc, mc_avg, offs, mv_x, mv_y, mv_x2, mv_y2,

581 mc_type, mc_type2);

582

583 return 0;

584 }

585 /*

586 * Decode block data:

587 * extract huffman-coded transform coefficients from the bitstream,

588 * dequantize them, apply inverse transform and motion compensation

589 * in order to reconstruct the picture.

590 *

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

592 * @param[in] band pointer to the band descriptor

593 * @param[in] tile pointer to the tile descriptor

594 * @return result code: 0 - OK, -1 = error (corrupted blocks data)

595 */

596 static int ivi_decode_blocks(GetBitContext *gb, const IVIBandDesc *band,

597 IVITile *tile, AVCodecContext *avctx)

598 {

599 int mbn, blk, num_blocks, blk_size, ret, is_intra;

600 int mc_type = 0, mc_type2 = -1;

601 int mv_x = 0, mv_y = 0, mv_x2 = 0, mv_y2 = 0;

602 int32_t prev_dc;

603 uint32_t cbp, quant, buf_offs;

604 IVIMbInfo *mb;

605 ivi_mc_func mc_with_delta_func, mc_no_delta_func;

606 ivi_mc_avg_func mc_avg_with_delta_func, mc_avg_no_delta_func;

607 const uint8_t *scale_tab;

608

609 /* init intra prediction for the DC coefficient */

610 prev_dc = 0;

611 blk_size = band->blk_size;

612 /* number of blocks per mb */

613 num_blocks = (band->mb_size != blk_size) ? 4 : 1;

614 if (blk_size == 8) {

615 mc_with_delta_func = ff_ivi_mc_8x8_delta;

616 mc_no_delta_func = ff_ivi_mc_8x8_no_delta;

617 mc_avg_with_delta_func = ff_ivi_mc_avg_8x8_delta;

618 mc_avg_no_delta_func = ff_ivi_mc_avg_8x8_no_delta;

619 } else {

620 mc_with_delta_func = ff_ivi_mc_4x4_delta;

621 mc_no_delta_func = ff_ivi_mc_4x4_no_delta;

622 mc_avg_with_delta_func = ff_ivi_mc_avg_4x4_delta;

623 mc_avg_no_delta_func = ff_ivi_mc_avg_4x4_no_delta;

624 }

625

626 for (mbn = 0, mb = tile->mbs; mbn < tile->num_MBs; mb++, mbn++) {

627 is_intra = !mb->type;

628 cbp = mb->cbp;

629 buf_offs = mb->buf_offs;

630

631 quant = band->glob_quant + mb->q_delta;

632 if (avctx->codec_id == AV_CODEC_ID_INDEO4)

633 quant = av_clip_uintp2(quant, 5);

634 else

635 quant = av_clip(quant, 0, 23);

636

637 scale_tab = is_intra ? band->intra_scale : band->inter_scale;

638 if (scale_tab)

639 quant = scale_tab[quant];

640

641 if (!is_intra) {

642 mv_x = mb->mv_x;

643 mv_y = mb->mv_y;

644 mv_x2 = mb->b_mv_x;

645 mv_y2 = mb->b_mv_y;

646 if (band->is_halfpel) {

647 mc_type = ((mv_y & 1) << 1) | (mv_x & 1);

648 mc_type2 = ((mv_y2 & 1) << 1) | (mv_x2 & 1);

649 mv_x >>= 1;

650 mv_y >>= 1;

651 mv_x2 >>= 1;

652 mv_y2 >>= 1; /* convert halfpel vectors into fullpel ones */

653 }

654 if (mb->type == 2)

655 mc_type = -1;

656 if (mb->type != 2 && mb->type != 3)

657 mc_type2 = -1;

658 if (mb->type) {

659 int dmv_x, dmv_y, cx, cy;

660

661 dmv_x = mb->mv_x >> band->is_halfpel;

662 dmv_y = mb->mv_y >> band->is_halfpel;

663 cx = mb->mv_x & band->is_halfpel;

664 cy = mb->mv_y & band->is_halfpel;

665

666 if (mb->xpos + dmv_x < 0 ||

667 mb->xpos + dmv_x + band->mb_size + cx > band->pitch ||

668 mb->ypos + dmv_y < 0 ||

669 mb->ypos + dmv_y + band->mb_size + cy > band->aheight) {

670 return AVERROR_INVALIDDATA;

671 }

672 }

673 if (mb->type == 2 || mb->type == 3) {

674 int dmv_x, dmv_y, cx, cy;

675

676 dmv_x = mb->b_mv_x >> band->is_halfpel;

677 dmv_y = mb->b_mv_y >> band->is_halfpel;

678 cx = mb->b_mv_x & band->is_halfpel;

679 cy = mb->b_mv_y & band->is_halfpel;

680

681 if (mb->xpos + dmv_x < 0 ||

682 mb->xpos + dmv_x + band->mb_size + cx > band->pitch ||

683 mb->ypos + dmv_y < 0 ||

684 mb->ypos + dmv_y + band->mb_size + cy > band->aheight) {

685 return AVERROR_INVALIDDATA;

686 }

687 }

688 }

689

690 for (blk = 0; blk < num_blocks; blk++) {

691 /* adjust block position in the buffer according to its number */

692 if (blk & 1) {

693 buf_offs += blk_size;

694 } else if (blk == 2) {

695 buf_offs -= blk_size;

696 buf_offs += blk_size * band->pitch;

697 }

698

699 if (cbp & 1) { /* block coded ? */

700 ret = ivi_decode_coded_blocks(gb, band, mc_with_delta_func,

701 mc_avg_with_delta_func,

702 mv_x, mv_y, mv_x2, mv_y2,

703 &prev_dc, is_intra,

704 mc_type, mc_type2, quant,

705 buf_offs, avctx);

706 if (ret < 0)

707 return ret;

708 } else {

709 int buf_size = band->pitch * band->aheight - buf_offs;

710 int min_size = (blk_size - 1) * band->pitch + blk_size;

711

712 if (min_size > buf_size)

713 return AVERROR_INVALIDDATA;

714 /* block not coded */

715 /* for intra blocks apply the dc slant transform */

716 /* for inter - perform the motion compensation without delta */

717 if (is_intra) {

718 ret = ivi_dc_transform(band, &prev_dc, buf_offs, blk_size);

719 if (ret < 0)

720 return ret;

721 } else {

722 ret = ivi_mc(band, mc_no_delta_func, mc_avg_no_delta_func,

723 buf_offs, mv_x, mv_y, mv_x2, mv_y2,

724 mc_type, mc_type2);

725 if (ret < 0)

726 return ret;

727 }

728 }

729

730 cbp >>= 1;

731 }// for blk

732 }// for mbn

733

734 align_get_bits(gb);

735

736 return 0;

737 }

738

739 /**

740 * Handle empty tiles by performing data copying and motion

741 * compensation respectively.

742 *

743 * @param[in] avctx ptr to the AVCodecContext

744 * @param[in] band pointer to the band descriptor

745 * @param[in] tile pointer to the tile descriptor

746 * @param[in] mv_scale scaling factor for motion vectors

747 */

748 static int ivi_process_empty_tile(AVCodecContext *avctx, const IVIBandDesc *band,

749 IVITile *tile, int32_t mv_scale)

750 {

751 int x, y, need_mc, mbn, blk, num_blocks, mv_x, mv_y, mc_type;

752 int offs, mb_offset, row_offset, ret;

753 IVIMbInfo *mb, *ref_mb;

754 const int16_t *src;

755 int16_t *dst;

756 ivi_mc_func mc_no_delta_func;

757 int clear_first = !band->qdelta_present && !band->plane && !band->band_num;

758 int mb_size = band->mb_size;

759 int xend = tile->xpos + tile->width;

760 int is_halfpel = band->is_halfpel;

761 int pitch = band->pitch;

762

763 if (tile->num_MBs != IVI_MBs_PER_TILE(tile->width, tile->height, mb_size)) {

764 av_log(avctx, AV_LOG_ERROR, "Allocated tile size %d mismatches "

765 "parameters %d in ivi_process_empty_tile()\n",

766 tile->num_MBs, IVI_MBs_PER_TILE(tile->width, tile->height, mb_size));

767 return AVERROR_INVALIDDATA;

768 }

769

770 offs = tile->ypos * pitch + tile->xpos;

771 mb = tile->mbs;

772 ref_mb = tile->ref_mbs;

773 row_offset = mb_size * pitch;

774 need_mc = 0; /* reset the mc tracking flag */

775

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

777 mb_offset = offs;

778

779 for (x = tile->xpos; x < xend; x += mb_size) {

780 mb->xpos = x;

781 mb->ypos = y;

782 mb->buf_offs = mb_offset;

783

784 mb->type = 1; /* set the macroblocks type = INTER */

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

786

787 if (clear_first) {

788 mb->q_delta = band->glob_quant;

789 mb->mv_x = 0;

790 mb->mv_y = 0;

791 }

792

793 if (ref_mb) {

794 if (band->inherit_qdelta)

795 mb->q_delta = ref_mb->q_delta;

796

797 if (band->inherit_mv) {

798 /* motion vector inheritance */

799 if (mv_scale) {

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

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

802 } else {

803 mb->mv_x = ref_mb->mv_x;

804 mb->mv_y = ref_mb->mv_y;

805 }

806 need_mc |= mb->mv_x || mb->mv_y; /* tracking non-zero motion vectors */

807 {

808 int dmv_x, dmv_y, cx, cy;

809

810 dmv_x = mb->mv_x >> is_halfpel;

811 dmv_y = mb->mv_y >> is_halfpel;

812 cx = mb->mv_x & is_halfpel;

813 cy = mb->mv_y & is_halfpel;

814

815 if ( mb->xpos + dmv_x < 0

816 || mb->xpos + dmv_x + mb_size + cx > pitch

817 || mb->ypos + dmv_y < 0

818 || mb->ypos + dmv_y + mb_size + cy > band->aheight) {

819 av_log(avctx, AV_LOG_ERROR, "MV out of bounds\n");

820 return AVERROR_INVALIDDATA;

821 }

822 }

823 }

824 ref_mb++;

825 }

826

827 mb++;

828 mb_offset += mb_size;

829 } // for x

830 offs += row_offset;

831 } // for y

832

833 if (band->inherit_mv && need_mc) { /* apply motion compensation if there is at least one non-zero motion vector */

834 num_blocks = (mb_size != band->blk_size) ? 4 : 1; /* number of blocks per mb */

835 mc_no_delta_func = (band->blk_size == 8) ? ff_ivi_mc_8x8_no_delta

836 : ff_ivi_mc_4x4_no_delta;

837

838 for (mbn = 0, mb = tile->mbs; mbn < tile->num_MBs; mb++, mbn++) {

839 mv_x = mb->mv_x;

840 mv_y = mb->mv_y;

841 if (!band->is_halfpel) {

842 mc_type = 0; /* we have only fullpel vectors */

843 } else {

844 mc_type = ((mv_y & 1) << 1) | (mv_x & 1);

845 mv_x >>= 1;

846 mv_y >>= 1; /* convert halfpel vectors into fullpel ones */

847 }

848

849 for (blk = 0; blk < num_blocks; blk++) {

850 /* adjust block position in the buffer according with its number */

851 offs = mb->buf_offs + band->blk_size * ((blk & 1) + !!(blk & 2) * pitch);

852 ret = ivi_mc(band, mc_no_delta_func, 0, offs,

853 mv_x, mv_y, 0, 0, mc_type, -1);

854 if (ret < 0)

855 return ret;

856 }

857 }

858 } else {

859 /* copy data from the reference tile into the current one */

860 src = band->ref_buf + tile->ypos * pitch + tile->xpos;

861 dst = band->buf + tile->ypos * pitch + tile->xpos;

862 for (y = 0; y < tile->height; y++) {

863 memcpy(dst, src, tile->width*sizeof(band->buf[0]));

864 src += pitch;

865 dst += pitch;

866 }

867 }

868

869 return 0;

870 }

871

872

873 #ifdef DEBUG

874 static uint16_t ivi_calc_band_checksum(const IVIBandDesc *band)

875 {

876 int x, y;

877 int16_t *src, checksum;

878

879 src = band->buf;

880 checksum = 0;

881

882 for (y = 0; y < band->height; src += band->pitch, y++)

883 for (x = 0; x < band->width; x++)

884 checksum += src[x];

885

886 return checksum;

887 }

888 #endif

889

890 /*

891 * Convert and output the current plane.

892 * This conversion is done by adding back the bias value of 128

893 * (subtracted in the encoder) and clipping the result.

894 *

895 * @param[in] plane pointer to the descriptor of the plane being processed

896 * @param[out] dst pointer to the buffer receiving converted pixels

897 * @param[in] dst_pitch pitch for moving to the next y line

898 */

899 static void ivi_output_plane(IVIPlaneDesc *plane, uint8_t *dst, ptrdiff_t dst_pitch)

900 {

901 int x, y;

902 const int16_t *src = plane->bands[0].buf;

903 ptrdiff_t pitch = plane->bands[0].pitch;

904

905 if (!src)

906 return;

907

908 for (y = 0; y < plane->height; y++) {

909 int m = 0;

910 int w = plane->width;

911 for (x = 0; x < w; x++) {

912 int t = src[x] + 128;

913 dst[x] = t;

914 m |= t;

915 }

916 if (m & ~255)

917 for (x = 0; x < w; x++)

918 dst[x] = av_clip_uint8(src[x] + 128);

919 src += pitch;

920 dst += dst_pitch;

921 }

922 }

923

924 static void *prepare_buf(IVI45DecContext *ctx, IVIBandDesc *band, int i)

925 {

926 if (ctx->pic_conf.luma_bands <= 1 && i == 2)

927 return NULL;

928 if (!band->bufs[i])

929 band->bufs[i] = av_mallocz(2 * band->bufsize);

930 return band->bufs[i];

931 }

932

933 /**

934 * Decode an Indeo 4 or 5 band.

935 *

936 * @param[in,out] ctx ptr to the decoder context

937 * @param[in,out] band ptr to the band descriptor

938 * @param[in] avctx ptr to the AVCodecContext

939 * @return result code: 0 = OK, -1 = error

940 */

941 static int decode_band(IVI45DecContext *ctx,

942 IVIBandDesc *band, AVCodecContext *avctx)

943 {

944 int result, i, t, idx1, idx2, pos;

945 IVITile *tile;

946

947 band->buf = prepare_buf(ctx, band, ctx->dst_buf);

948 if (!band->buf) {

949 av_log(avctx, AV_LOG_ERROR, "Band buffer points to no data!\n");

950 return AVERROR_INVALIDDATA;

951 }

952 if (ctx->is_indeo4 && ctx->frame_type == IVI4_FRAMETYPE_BIDIR) {

953 band->ref_buf = prepare_buf(ctx, band, ctx->b_ref_buf);

954 band->b_ref_buf = prepare_buf(ctx, band, ctx->ref_buf);

955 if (!band->b_ref_buf)

956 return AVERROR(ENOMEM);

957 } else {

958 band->ref_buf = prepare_buf(ctx, band, ctx->ref_buf);

959 band->b_ref_buf = 0;

960 }

961 if (!band->ref_buf)

962 return AVERROR(ENOMEM);

963 band->data_ptr = ctx->frame_data + (get_bits_count(&ctx->gb) >> 3);

964

965 result = ctx->decode_band_hdr(ctx, band, avctx);

966 if (result) {

967 av_log(avctx, AV_LOG_ERROR, "Error while decoding band header: %d\n",

968 result);

969 return result;

970 }

971

972 if (band->is_empty) {

973 av_log(avctx, AV_LOG_ERROR, "Empty band encountered!\n");

974 return AVERROR_INVALIDDATA;

975 }

976

977 band->rv_map = &ctx->rvmap_tabs[band->rvmap_sel];

978

979 /* apply corrections to the selected rvmap table if present */

980 for (i = 0; i < band->num_corr; i++) {

981 idx1 = band->corr[i * 2];

982 idx2 = band->corr[i * 2 + 1];

983 FFSWAP(uint8_t, band->rv_map->runtab[idx1], band->rv_map->runtab[idx2]);

984 FFSWAP(int16_t, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]);

985 if (idx1 == band->rv_map->eob_sym || idx2 == band->rv_map->eob_sym)

986 band->rv_map->eob_sym ^= idx1 ^ idx2;

987 if (idx1 == band->rv_map->esc_sym || idx2 == band->rv_map->esc_sym)

988 band->rv_map->esc_sym ^= idx1 ^ idx2;

989 }

990

991 pos = get_bits_count(&ctx->gb);

992

993 for (t = 0; t < band->num_tiles; t++) {

994 tile = &band->tiles[t];

995

996 if (tile->mb_size != band->mb_size) {

997 av_log(avctx, AV_LOG_ERROR, "MB sizes mismatch: %d vs. %d\n",

998 band->mb_size, tile->mb_size);

999 return AVERROR_INVALIDDATA;

1000 }

1001 tile->is_empty = get_bits1(&ctx->gb);

1002 if (tile->is_empty) {

1003 result = ivi_process_empty_tile(avctx, band, tile,

1004 (ctx->planes[0].bands[0].mb_size >> 3) - (band->mb_size >> 3));

1005 if (result < 0)

1006 break;

1007 ff_dlog(avctx, "Empty tile encountered!\n");

1008 } else {

1009 tile->data_size = ivi_dec_tile_data_size(&ctx->gb);

1010 if (!tile->data_size) {

1011 av_log(avctx, AV_LOG_ERROR, "Tile data size is zero!\n");

1012 result = AVERROR_INVALIDDATA;

1013 break;

1014 }

1015

1016 result = ctx->decode_mb_info(ctx, band, tile, avctx);

1017 if (result < 0)

1018 break;

1019

1020 result = ivi_decode_blocks(&ctx->gb, band, tile, avctx);

1021 if (result < 0) {

1022 av_log(avctx, AV_LOG_ERROR,

1023 "Corrupted tile data encountered!\n");

1024 break;

1025 }

1026

1027 if (((get_bits_count(&ctx->gb) - pos) >> 3) != tile->data_size) {

1028 av_log(avctx, AV_LOG_ERROR,

1029 "Tile data_size mismatch!\n");

1030 result = AVERROR_INVALIDDATA;

1031 break;

1032 }

1033

1034 pos += tile->data_size << 3; // skip to next tile

1035 }

1036 }

1037

1038 /* restore the selected rvmap table by applying its corrections in

1039 * reverse order */

1040 for (i = band->num_corr-1; i >= 0; i--) {

1041 idx1 = band->corr[i*2];

1042 idx2 = band->corr[i*2+1];

1043 FFSWAP(uint8_t, band->rv_map->runtab[idx1], band->rv_map->runtab[idx2]);

1044 FFSWAP(int16_t, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]);

1045 if (idx1 == band->rv_map->eob_sym || idx2 == band->rv_map->eob_sym)

1046 band->rv_map->eob_sym ^= idx1 ^ idx2;

1047 if (idx1 == band->rv_map->esc_sym || idx2 == band->rv_map->esc_sym)

1048 band->rv_map->esc_sym ^= idx1 ^ idx2;

1049 }

1050

1051 #ifdef DEBUG

1052 if (band->checksum_present) {

1053 uint16_t chksum = ivi_calc_band_checksum(band);

1054 if (chksum != band->checksum) {

1055 av_log(avctx, AV_LOG_ERROR,

1056 "Band checksum mismatch! Plane %d, band %d, "

1057 "received: %"PRIx32", calculated: %"PRIx16"\n",

1058 band->plane, band->band_num, band->checksum, chksum);

1059 }

1060 }

1061 #endif

1062

1063 align_get_bits(&ctx->gb);

1064

1065 return result;

1066 }

1067

1068 int ff_ivi_decode_frame(AVCodecContext *avctx, AVFrame *frame,

1069 int *got_frame, AVPacket *avpkt)

1070 {

1071 IVI45DecContext *ctx = avctx->priv_data;

1072 const uint8_t *buf = avpkt->data;

1073 int buf_size = avpkt->size;

1074 int result, p, b;

1075

1076 result = init_get_bits8(&ctx->gb, buf, buf_size);

1077 if (result < 0)

1078 return result;

1079 ctx->frame_data = buf;

1080 ctx->frame_size = buf_size;

1081

1082 result = ctx->decode_pic_hdr(ctx, avctx);

1083 if (result) {

1084 av_log(avctx, AV_LOG_ERROR,

1085 "Error while decoding picture header: %d\n", result);

1086 return result;

1087 }

1088 if (ctx->gop_invalid)

1089 return AVERROR_INVALIDDATA;

1090

1091 if (ctx->is_indeo4 && ctx->frame_type == IVI4_FRAMETYPE_NULL_LAST) {

1092 if (ctx->got_p_frame) {

1093 av_frame_move_ref(frame, ctx->p_frame);

1094 *got_frame = 1;

1095 ctx->got_p_frame = 0;

1096 } else {

1097 *got_frame = 0;

1098 }

1099 return buf_size;

1100 }

1101

1102 if (ctx->gop_flags & IVI5_IS_PROTECTED) {

1103 avpriv_report_missing_feature(avctx, "Password-protected clip");

1104 return AVERROR_PATCHWELCOME;

1105 }

1106

1107 if (!ctx->planes[0].bands) {

1108 av_log(avctx, AV_LOG_ERROR, "Color planes not initialized yet\n");

1109 return AVERROR_INVALIDDATA;

1110 }

1111

1112 ctx->switch_buffers(ctx);

1113

1114 if (ctx->is_nonnull_frame(ctx)) {

1115 ctx->buf_invalid[ctx->dst_buf] = 1;

1116 for (p = 0; p < 3; p++) {

1117 for (b = 0; b < ctx->planes[p].num_bands; b++) {

1118 result = decode_band(ctx, &ctx->planes[p].bands[b], avctx);

1119 if (result < 0) {

1120 av_log(avctx, AV_LOG_ERROR,

1121 "Error while decoding band: %d, plane: %d\n", b, p);

1122 return result;

1123 }

1124 }

1125 }

1126 ctx->buf_invalid[ctx->dst_buf] = 0;

1127 } else {

1128 if (ctx->is_scalable)

1129 return AVERROR_INVALIDDATA;

1130

1131 for (p = 0; p < 3; p++) {

1132 if (!ctx->planes[p].bands[0].buf)

1133 return AVERROR_INVALIDDATA;

1134 }

1135 }

1136 if (ctx->buf_invalid[ctx->dst_buf])

1137 return -1;

1138

1139 if (!ctx->is_nonnull_frame(ctx))

1140 return buf_size;

1141

1142 result = ff_set_dimensions(avctx, ctx->planes[0].width, ctx->planes[0].height);

1143 if (result < 0)

1144 return result;

1145

1146 if ((result = ff_get_buffer(avctx, frame, 0)) < 0)

1147 return result;

1148

1149 if (ctx->is_scalable) {

1150 if (ctx->is_indeo4)

1151 ff_ivi_recompose_haar(&ctx->planes[0], frame->data[0], frame->linesize[0]);

1152 else

1153 ff_ivi_recompose53 (&ctx->planes[0], frame->data[0], frame->linesize[0]);

1154 } else {

1155 ivi_output_plane(&ctx->planes[0], frame->data[0], frame->linesize[0]);

1156 }

1157

1158 ivi_output_plane(&ctx->planes[2], frame->data[1], frame->linesize[1]);

1159 ivi_output_plane(&ctx->planes[1], frame->data[2], frame->linesize[2]);

1160

1161 *got_frame = 1;

1162

1163 /* If the bidirectional mode is enabled, next I and the following P

1164 * frame will be sent together. Unfortunately the approach below seems

1165 * to be the only way to handle the B-frames mode.

1166 * That's exactly the same Intel decoders do.

1167 */

1168 if (ctx->is_indeo4 && ctx->frame_type == IVI4_FRAMETYPE_INTRA) {

1169 int left;

1170

1171 // skip version string

1172 while (get_bits(&ctx->gb, 8)) {

1173 if (get_bits_left(&ctx->gb) < 8)

1174 return AVERROR_INVALIDDATA;

1175 }

1176 left = get_bits_count(&ctx->gb) & 0x18;

1177 skip_bits_long(&ctx->gb, 64 - left);

1178 if (get_bits_left(&ctx->gb) > 18 &&

1179 show_bits(&ctx->gb, 21) == 0xBFFF8) { // syncheader + inter type

1180 AVPacket pkt;

1181 pkt.data = avpkt->data + (get_bits_count(&ctx->gb) >> 3);

1182 pkt.size = get_bits_left(&ctx->gb) >> 3;

1183 ctx->got_p_frame = 0;

1184 av_frame_unref(ctx->p_frame);

1185 ff_ivi_decode_frame(avctx, ctx->p_frame, &ctx->got_p_frame, &pkt);

1186 }

1187 }

1188

1189 if (ctx->show_indeo4_info) {

1190 if (ctx->is_scalable)

1191 av_log(avctx, AV_LOG_DEBUG, "This video uses scalability mode\n");

1192 if (ctx->uses_tiling)

1193 av_log(avctx, AV_LOG_DEBUG, "This video uses local decoding\n");

1194 if (ctx->has_b_frames)

1195 av_log(avctx, AV_LOG_DEBUG, "This video contains B-frames\n");

1196 if (ctx->has_transp)

1197 av_log(avctx, AV_LOG_DEBUG, "Transparency mode is enabled\n");

1198 if (ctx->uses_haar)

1199 av_log(avctx, AV_LOG_DEBUG, "This video uses Haar transform\n");

1200 if (ctx->uses_fullpel)

1201 av_log(avctx, AV_LOG_DEBUG, "This video uses fullpel motion vectors\n");

1202 ctx->show_indeo4_info = 0;

1203 }

1204

1205 return buf_size;

1206 }

1207

1208 /**

1209 * Close Indeo5 decoder and clean up its context.

1210 */

1211 av_cold int ff_ivi_decode_close(AVCodecContext *avctx)

1212 {

1213 IVI45DecContext *ctx = avctx->priv_data;

1214

1215 ivi_free_buffers(&ctx->planes[0]);

1216

1217 if (ctx->mb_vlc.cust_tab.table)

1218 ff_free_vlc(&ctx->mb_vlc.cust_tab);

1219

1220 if (ctx->blk_vlc.cust_tab.table)

1221 ff_free_vlc(&ctx->blk_vlc.cust_tab);

1222

1223 av_frame_free(&ctx->p_frame);

1224

1225 return 0;

1226 }

1227

1228

1229 /**

1230 * Scan patterns shared between indeo4 and indeo5

1231 */

1232 const uint8_t ff_ivi_vertical_scan_8x8[64] = {

1233 0, 8, 16, 24, 32, 40, 48, 56,

1234 1, 9, 17, 25, 33, 41, 49, 57,

1235 2, 10, 18, 26, 34, 42, 50, 58,

1236 3, 11, 19, 27, 35, 43, 51, 59,

1237 4, 12, 20, 28, 36, 44, 52, 60,

1238 5, 13, 21, 29, 37, 45, 53, 61,

1239 6, 14, 22, 30, 38, 46, 54, 62,

1240 7, 15, 23, 31, 39, 47, 55, 63

1241 };

1242

1243 const uint8_t ff_ivi_horizontal_scan_8x8[64] = {

1244 0, 1, 2, 3, 4, 5, 6, 7,

1245 8, 9, 10, 11, 12, 13, 14, 15,

1246 16, 17, 18, 19, 20, 21, 22, 23,

1247 24, 25, 26, 27, 28, 29, 30, 31,

1248 32, 33, 34, 35, 36, 37, 38, 39,

1249 40, 41, 42, 43, 44, 45, 46, 47,

1250 48, 49, 50, 51, 52, 53, 54, 55,

1251 56, 57, 58, 59, 60, 61, 62, 63

1252 };

1253

1254 const uint8_t ff_ivi_direct_scan_4x4[16] = {

1255 0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15

1256 };

1257

1258

1259 /**

1260 * Run-value (RLE) tables.

1261 */

1262 const RVMapDesc ff_ivi_rvmap_tabs[9] = {

1263 { /* MapTab0 */

1264 5, /* eob_sym */

1265 2, /* esc_sym */

1266 /* run table */

1267 {1, 1, 0, 1, 1, 0, 1, 1, 2, 2, 1, 1, 1, 1, 3, 3,

1268 1, 1, 2, 2, 1, 1, 4, 4, 1, 1, 1, 1, 2, 2, 5, 5,

1269 1, 1, 3, 3, 1, 1, 6, 6, 1, 2, 1, 2, 7, 7, 1, 1,

1270 8, 8, 1, 1, 4, 2, 1, 4, 2, 1, 3, 3, 1, 1, 1, 9,

1271 9, 1, 2, 1, 2, 1, 5, 5, 1, 1, 10, 10, 1, 1, 3, 3,

1272 2, 2, 1, 1, 11, 11, 6, 4, 4, 1, 6, 1, 2, 1, 2, 12,

1273 8, 1, 12, 7, 8, 7, 1, 16, 1, 16, 1, 3, 3, 13, 1, 13,

1274 2, 2, 1, 15, 1, 5, 14, 15, 1, 5, 14, 1, 17, 8, 17, 8,

1275 1, 4, 4, 2, 2, 1, 25, 25, 24, 24, 1, 3, 1, 3, 1, 8,

1276 6, 7, 6, 1, 18, 8, 18, 1, 7, 23, 2, 2, 23, 1, 1, 21,

1277 22, 9, 9, 22, 19, 1, 21, 5, 19, 5, 1, 33, 20, 33, 20, 8,

1278 4, 4, 1, 32, 2, 2, 8, 3, 32, 26, 3, 1, 7, 7, 26, 6,

1279 1, 6, 1, 1, 16, 1, 10, 1, 10, 2, 16, 29, 28, 2, 29, 28,

1280 1, 27, 5, 8, 5, 27, 1, 8, 3, 7, 3, 31, 41, 31, 1, 41,

1281 6, 1, 6, 7, 4, 4, 1, 1, 2, 1, 2, 11, 34, 30, 11, 1,

1282 30, 15, 15, 34, 36, 40, 36, 40, 35, 35, 37, 37, 39, 39, 38, 38},

1283

1284 /* value table */

1285 { 1, -1, 0, 2, -2, 0, 3, -3, 1, -1, 4, -4, 5, -5, 1, -1,

1286 6, -6, 2, -2, 7, -7, 1, -1, 8, -8, 9, -9, 3, -3, 1, -1,

1287 10, -10, 2, -2, 11, -11, 1, -1, 12, 4, -12, -4, 1, -1, 13, -13,

1288 1, -1, 14, -14, 2, 5, 15, -2, -5, -15, -3, 3, 16, -16, 17, 1,

1289 -1, -17, 6, 18, -6, -18, 2, -2, 19, -19, 1, -1, 20, -20, 4, -4,

1290 7, -7, 21, -21, 1, -1, 2, 3, -3, 22, -2, -22, 8, 23, -8, 1,

1291 2, -23, -1, 2, -2, -2, 24, 1, -24, -1, 25, 5, -5, 1, -25, -1,

1292 9, -9, 26, 1, -26, 3, 1, -1, 27, -3, -1, -27, 1, 3, -1, -3,

1293 28, -4, 4, 10, -10, -28, 1, -1, 1, -1, 29, 6, -29, -6, 30, -4,

1294 3, 3, -3, -30, 1, 4, -1, 31, -3, 1, 11, -11, -1, -31, 32, -1,

1295 -1, 2, -2, 1, 1, -32, 1, 4, -1, -4, 33, -1, 1, 1, -1, 5,

1296 5, -5, -33, -1, -12, 12, -5, -7, 1, 1, 7, 34, 4, -4, -1, 4,

1297 -34, -4, 35, 36, -2, -35, -2, -36, 2, 13, 2, -1, 1, -13, 1, -1,

1298 37, 1, -5, 6, 5, -1, 38, -6, -8, 5, 8, -1, 1, 1, -37, -1,

1299 5, 39, -5, -5, 6, -6, -38, -39, -14, 40, 14, 2, 1, 1, -2, -40,

1300 -1, -2, 2, -1, -1, -1, 1, 1, 1, -1, 1, -1, 1, -1, 1, -1}

1301 },{

1302 /* MapTab1 */

1303 0, /* eob_sym */

1304 38, /* esc_sym */

1305 /* run table */

1306 {0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 8, 6, 8, 7,

1307 7, 9, 9, 10, 10, 11, 11, 1, 12, 1, 12, 13, 13, 16, 14, 16,

1308 14, 15, 15, 17, 17, 18, 0, 18, 19, 20, 21, 19, 22, 21, 20, 22,

1309 25, 24, 2, 25, 24, 23, 23, 2, 26, 28, 26, 28, 29, 27, 29, 27,

1310 33, 33, 1, 32, 1, 3, 32, 30, 36, 3, 36, 30, 31, 31, 35, 34,

1311 37, 41, 34, 35, 37, 4, 41, 4, 49, 8, 8, 49, 40, 38, 5, 38,

1312 40, 39, 5, 39, 42, 43, 42, 7, 57, 6, 43, 44, 6, 50, 7, 44,

1313 57, 48, 50, 48, 45, 45, 46, 47, 51, 46, 47, 58, 1, 51, 58, 1,

1314 52, 59, 53, 9, 52, 55, 55, 59, 53, 56, 54, 56, 54, 9, 64, 64,

1315 60, 63, 60, 63, 61, 62, 61, 62, 2, 10, 2, 10, 11, 1, 11, 13,

1316 12, 1, 12, 13, 16, 16, 8, 8, 14, 3, 3, 15, 14, 15, 4, 4,

1317 1, 17, 17, 5, 1, 7, 7, 5, 6, 1, 2, 2, 6, 22, 1, 25,

1318 21, 22, 8, 24, 1, 21, 25, 24, 8, 18, 18, 23, 9, 20, 23, 33,

1319 29, 33, 20, 1, 19, 1, 29, 36, 9, 36, 19, 41, 28, 57, 32, 3,

1320 28, 3, 1, 27, 49, 49, 1, 32, 26, 26, 2, 4, 4, 7, 57, 41,

1321 2, 7, 10, 5, 37, 16, 10, 27, 8, 8, 13, 16, 37, 13, 1, 5},

1322

1323 /* value table */

1324 {0, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, 1, -1, -1, 1,

1325 -1, 1, -1, 1, -1, 1, -1, 2, 1, -2, -1, 1, -1, 1, 1, -1,

1326 -1, 1, -1, 1, -1, 1, 0, -1, 1, 1, 1, -1, 1, -1, -1, -1,

1327 1, 1, 2, -1, -1, 1, -1, -2, 1, 1, -1, -1, 1, 1, -1, -1,

1328 1, -1, 3, 1, -3, 2, -1, 1, 1, -2, -1, -1, -1, 1, 1, 1,

1329 1, 1, -1, -1, -1, 2, -1, -2, 1, 2, -2, -1, 1, 1, 2, -1,

1330 -1, 1, -2, -1, 1, 1, -1, 2, 1, 2, -1, 1, -2, -1, -2, -1,

1331 -1, 1, 1, -1, 1, -1, 1, 1, 1, -1, -1, 1, 4, -1, -1, -4,

1332 1, 1, 1, 2, -1, -1, 1, -1, -1, 1, -1, -1, 1, -2, 1, -1,

1333 1, 1, -1, -1, 1, 1, -1, -1, 3, 2, -3, -2, 2, 5, -2, 2,

1334 2, -5, -2, -2, -2, 2, -3, 3, 2, 3, -3, 2, -2, -2, 3, -3,

1335 6, 2, -2, 3, -6, 3, -3, -3, 3, 7, -4, 4, -3, 2, -7, 2,

1336 2, -2, -4, 2, 8, -2, -2, -2, 4, 2, -2, 2, 3, 2, -2, -2,

1337 2, 2, -2, -8, -2, 9, -2, 2, -3, -2, 2, -2, 2, 2, 2, 4,

1338 -2, -4, 10, 2, 2, -2, -9, -2, 2, -2, 5, 4, -4, 4, -2, 2,

1339 -5, -4, -3, 4, 2, -3, 3, -2, -5, 5, 3, 3, -2, -3, -10, -4}

1340 },{

1341 /* MapTab2 */

1342 2, /* eob_sym */

1343 11, /* esc_sym */

1344 /* run table */

1345 {1, 1, 0, 2, 2, 1, 1, 3, 3, 4, 4, 0, 1, 1, 5, 5,

1346 2, 2, 6, 6, 7, 7, 1, 8, 1, 8, 3, 3, 9, 9, 1, 2,

1347 2, 1, 4, 10, 4, 10, 11, 11, 1, 5, 12, 12, 1, 5, 13, 13,

1348 3, 3, 6, 6, 2, 2, 14, 14, 16, 16, 15, 7, 15, 8, 8, 7,

1349 1, 1, 17, 17, 4, 4, 1, 1, 18, 18, 2, 2, 5, 5, 25, 3,

1350 9, 3, 25, 9, 19, 24, 19, 24, 1, 21, 20, 1, 21, 22, 20, 22,

1351 23, 23, 8, 6, 33, 6, 8, 33, 7, 7, 26, 26, 1, 32, 1, 32,

1352 28, 4, 28, 10, 29, 27, 27, 10, 41, 4, 29, 2, 2, 41, 36, 31,

1353 49, 31, 34, 30, 34, 36, 30, 35, 1, 49, 11, 5, 35, 11, 1, 3,

1354 3, 5, 37, 37, 8, 40, 8, 40, 12, 12, 42, 42, 1, 38, 16, 57,

1355 1, 6, 16, 39, 38, 6, 7, 7, 13, 13, 39, 43, 2, 43, 57, 2,

1356 50, 9, 44, 9, 50, 4, 15, 48, 44, 4, 1, 15, 48, 14, 14, 1,

1357 45, 45, 8, 3, 5, 8, 51, 47, 3, 46, 46, 47, 5, 51, 1, 17,

1358 17, 58, 1, 58, 2, 52, 52, 2, 53, 7, 59, 6, 6, 56, 53, 55,

1359 7, 55, 1, 54, 59, 56, 54, 10, 1, 10, 4, 60, 1, 60, 8, 4,

1360 8, 64, 64, 61, 1, 63, 3, 63, 62, 61, 5, 11, 5, 3, 11, 62},

1361

1362 /* value table */

1363 { 1, -1, 0, 1, -1, 2, -2, 1, -1, 1, -1, 0, 3, -3, 1, -1,

1364 2, -2, 1, -1, 1, -1, 4, 1, -4, -1, 2, -2, 1, -1, 5, 3,

1365 -3, -5, 2, 1, -2, -1, 1, -1, 6, 2, 1, -1, -6, -2, 1, -1,

1366 3, -3, 2, -2, 4, -4, 1, -1, 1, -1, 1, 2, -1, 2, -2, -2,

1367 7, -7, 1, -1, 3, -3, 8, -8, 1, -1, 5, -5, 3, -3, 1, 4,

1368 2, -4, -1, -2, 1, 1, -1, -1, 9, 1, 1, -9, -1, 1, -1, -1,

1369 1, -1, 3, -3, 1, 3, -3, -1, 3, -3, 1, -1, 10, 1, -10, -1,

1370 1, 4, -1, 2, 1, -1, 1, -2, 1, -4, -1, 6, -6, -1, 1, 1,

1371 1, -1, 1, 1, -1, -1, -1, 1, 11, -1, -2, 4, -1, 2, -11, 5,

1372 -5, -4, -1, 1, 4, 1, -4, -1, -2, 2, 1, -1, 12, 1, -2, 1,

1373 -12, 4, 2, 1, -1, -4, 4, -4, 2, -2, -1, 1, 7, -1, -1, -7,

1374 -1, -3, 1, 3, 1, 5, 2, 1, -1, -5, 13, -2, -1, 2, -2, -13,

1375 1, -1, 5, 6, 5, -5, 1, 1, -6, 1, -1, -1, -5, -1, 14, 2,

1376 -2, 1, -14, -1, 8, 1, -1, -8, 1, 5, 1, 5, -5, 1, -1, 1,

1377 -5, -1, 15, 1, -1, -1, -1, 3, -15, -3, 6, 1, 16, -1, 6, -6,

1378 -6, 1, -1, 1, -16, 1, 7, -1, 1, -1, -6, -3, 6, -7, 3, -1}

1379 },{

1380 /* MapTab3 */

1381 0, /* eob_sym */

1382 35, /* esc_sym */

1383 /* run table */

1384 {0, 1, 1, 2, 2, 3, 3, 4, 4, 1, 1, 5, 5, 6, 6, 7,

1385 7, 8, 8, 9, 9, 2, 2, 10, 10, 1, 1, 11, 11, 12, 12, 3,

1386 3, 13, 13, 0, 14, 14, 16, 15, 16, 15, 4, 4, 17, 1, 17, 1,

1387 5, 5, 18, 18, 2, 2, 6, 6, 8, 19, 7, 8, 7, 19, 20, 20,

1388 21, 21, 22, 24, 22, 24, 23, 23, 1, 1, 25, 25, 3, 3, 26, 26,

1389 9, 9, 27, 27, 28, 28, 33, 29, 4, 33, 29, 1, 4, 1, 32, 32,

1390 2, 2, 31, 10, 30, 10, 30, 31, 34, 34, 5, 5, 36, 36, 35, 41,

1391 35, 11, 41, 11, 37, 1, 8, 8, 37, 6, 1, 6, 40, 7, 7, 40,

1392 12, 38, 12, 39, 39, 38, 49, 13, 49, 13, 3, 42, 3, 42, 16, 16,

1393 43, 43, 14, 14, 1, 1, 44, 15, 44, 15, 2, 2, 57, 48, 50, 48,

1394 57, 50, 4, 45, 45, 4, 46, 47, 47, 46, 1, 51, 1, 17, 17, 51,

1395 8, 9, 9, 5, 58, 8, 58, 5, 52, 52, 55, 56, 53, 56, 55, 59,

1396 59, 53, 54, 1, 6, 54, 7, 7, 6, 1, 2, 3, 2, 3, 64, 60,

1397 60, 10, 10, 64, 61, 62, 61, 63, 1, 63, 62, 1, 18, 24, 18, 4,

1398 25, 4, 8, 21, 21, 1, 24, 22, 25, 22, 8, 11, 19, 11, 23, 1,

1399 20, 23, 19, 20, 5, 12, 5, 1, 16, 2, 12, 13, 2, 13, 1, 16},

1400

1401 /* value table */

1402 { 0, 1, -1, 1, -1, 1, -1, 1, -1, 2, -2, 1, -1, 1, -1, 1,

1403 -1, 1, -1, 1, -1, 2, -2, 1, -1, 3, -3, 1, -1, 1, -1, 2,

1404 -2, 1, -1, 0, 1, -1, 1, 1, -1, -1, 2, -2, 1, 4, -1, -4,

1405 2, -2, 1, -1, -3, 3, 2, -2, 2, 1, 2, -2, -2, -1, 1, -1,

1406 1, -1, 1, 1, -1, -1, 1, -1, 5, -5, 1, -1, 3, -3, 1, -1,

1407 2, -2, 1, -1, 1, -1, 1, 1, 3, -1, -1, 6, -3, -6, -1, 1,

1408 4, -4, 1, 2, 1, -2, -1, -1, 1, -1, 3, -3, 1, -1, 1, 1,

1409 -1, 2, -1, -2, 1, 7, -3, 3, -1, 3, -7, -3, 1, -3, 3, -1,

1410 2, 1, -2, 1, -1, -1, 1, 2, -1, -2, -4, -1, 4, 1, 2, -2,

1411 1, -1, -2, 2, 8, -8, -1, 2, 1, -2, -5, 5, 1, -1, -1, 1,

1412 -1, 1, 4, -1, 1, -4, -1, -1, 1, 1, 9, 1, -9, 2, -2, -1,

1413 -4, 3, -3, -4, -1, 4, 1, 4, 1, -1, 1, -1, 1, 1, -1, 1,

1414 -1, -1, -1, 10, 4, 1, 4, -4, -4, -10, 6, 5, -6, -5, 1, -1,

1415 1, 3, -3, -1, 1, -1, -1, -1, 11, 1, 1, -11, -2, -2, 2, 5,

1416 -2, -5, -5, 2, -2, 12, 2, -2, 2, 2, 5, -3, -2, 3, -2, -12,

1417 -2, 2, 2, 2, -5, 3, 5, 13, -3, 7, -3, -3, -7, 3, -13, 3}

1418 },{

1419 /* MapTab4 */

1420 0, /* eob_sym */

1421 34, /* esc_sym */

1422 /* run table */

1423 {0, 1, 1, 1, 2, 2, 1, 3, 3, 1, 1, 1, 4, 4, 1, 5,

1424 2, 1, 5, 2, 1, 1, 6, 6, 1, 1, 1, 1, 1, 7, 3, 1,

1425 2, 3, 0, 1, 2, 7, 1, 1, 1, 8, 1, 1, 8, 1, 1, 1,

1426 9, 1, 9, 1, 2, 1, 1, 2, 1, 1, 10, 4, 1, 10, 1, 4,

1427 1, 1, 1, 1, 1, 3, 1, 1, 1, 3, 2, 1, 5, 1, 1, 1,

1428 2, 5, 1, 11, 1, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1429 2, 1, 6, 1, 6, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 12,

1430 3, 1, 12, 1, 1, 1, 2, 1, 1, 3, 1, 1, 1, 1, 1, 1,

1431 4, 1, 1, 1, 2, 1, 1, 4, 1, 1, 1, 1, 1, 1, 2, 1,

1432 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 2, 1, 1, 5,

1433 1, 1, 1, 1, 1, 7, 1, 7, 1, 1, 2, 3, 1, 1, 1, 1,

1434 5, 1, 1, 1, 1, 1, 1, 2, 13, 1, 1, 1, 1, 1, 1, 1,

1435 1, 1, 1, 1, 1, 1, 1, 1, 13, 2, 1, 1, 4, 1, 1, 1,

1436 3, 1, 6, 1, 1, 1, 14, 1, 1, 1, 1, 1, 14, 6, 1, 1,

1437 1, 1, 15, 2, 4, 1, 2, 3, 15, 1, 1, 1, 8, 1, 1, 8,

1438 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1},

1439

1440 /* value table */

1441 { 0, 1, -1, 2, 1, -1, -2, 1, -1, 3, -3, 4, 1, -1, -4, 1,

1442 2, 5, -1, -2, -5, 6, 1, -1, -6, 7, -7, 8, -8, 1, 2, 9,

1443 3, -2, 0, -9, -3, -1, 10, -10, 11, 1, -11, 12, -1, -12, 13, -13,

1444 1, 14, -1, -14, 4, 15, -15, -4, 16, -16, 1, 2, 17, -1, -17, -2,

1445 18, -18, 19, -19, 20, 3, -20, 21, -21, -3, 5, 22, 2, -22, -23, 23,

1446 -5, -2, 24, 1, -24, -1, 25, -25, 26, -26, -27, 27, 28, 29, -28, -29,

1447 6, 30, 2, -31, -2, -30, 31, -6, -32, 32, 33, -33, 34, -35, -34, 1,

1448 4, -36, -1, 35, 37, 36, 7, -37, 38, -4, -38, 39, 41, 40, -40, -39,

1449 3, 42, -43, -41, -7, -42, 43, -3, 44, -44, 45, -45, 46, 47, 8, -47,

1450 -48, -46, 50, -50, 48, 49, 51, -49, 52, -52, 5, -51, -8, -53, 53, 3,

1451 -56, 56, 55, 54, -54, 2, 60, -2, -55, 58, 9, -5, 59, 57, -57, -63,

1452 -3, -58, -60, -61, 61, -59, -62, -9, 1, 64, 62, 69, -64, 63, 65, -67,

1453 -68, 66, -65, 68, -66, -69, 67, -70, -1, 10, 71, -71, 4, 73, 72, 70,

1454 6, -76, -3, 74, -78, -74, 1, 78, 80, -72, -75, 76, -1, 3, -73, 79,

1455 75, 77, 1, 11, -4, -79, -10, -6, -1, -77, -83, -80, 2, 81, -84, -2,

1456 83, -81, 82, -82, 84, -87, -86, 85, -11, -85, 86, -89, 87, -88, 88, 89}

1457 },{

1458 /* MapTab5 */

1459 2, /* eob_sym */

1460 33, /* esc_sym */

1461 /* run table */

1462 {1, 1, 0, 2, 1, 2, 1, 3, 3, 1, 1, 4, 4, 2, 2, 1,

1463 1, 5, 5, 6, 1, 6, 1, 7, 7, 3, 3, 2, 8, 2, 8, 1,

1464 1, 0, 9, 9, 1, 1, 10, 4, 10, 4, 11, 11, 2, 1, 2, 1,

1465 12, 12, 3, 3, 1, 1, 13, 5, 5, 13, 14, 1, 1, 14, 2, 2,

1466 6, 6, 15, 1, 1, 15, 16, 4, 7, 16, 4, 7, 1, 1, 3, 3,

1467 8, 8, 2, 2, 1, 1, 17, 17, 1, 1, 18, 18, 5, 5, 2, 2,

1468 1, 1, 9, 19, 9, 19, 20, 3, 3, 20, 1, 10, 21, 1, 10, 4,

1469 4, 21, 22, 6, 6, 22, 1, 1, 23, 24, 2, 2, 23, 24, 11, 1,

1470 1, 11, 7, 25, 7, 1, 1, 25, 8, 8, 3, 26, 3, 1, 12, 2,

1471 2, 26, 1, 12, 5, 5, 27, 4, 1, 4, 1, 27, 28, 1, 28, 13,

1472 1, 13, 2, 29, 2, 1, 32, 6, 1, 30, 14, 29, 14, 6, 3, 31,

1473 3, 1, 30, 1, 32, 31, 33, 9, 33, 1, 1, 7, 9, 7, 2, 2,

1474 1, 1, 4, 36, 34, 4, 5, 10, 10, 5, 34, 1, 1, 35, 8, 8,

1475 36, 3, 35, 1, 15, 3, 2, 1, 16, 15, 16, 2, 37, 1, 37, 1,

1476 1, 1, 6, 6, 38, 1, 38, 11, 1, 39, 39, 40, 11, 2, 41, 4,

1477 40, 1, 2, 4, 1, 1, 1, 41, 3, 1, 3, 1, 5, 7, 5, 7},

1478

1479 /* value table */

1480 { 1, -1, 0, 1, 2, -1, -2, 1, -1, 3, -3, 1, -1, 2, -2, 4,

1481 -4, 1, -1, 1, 5, -1, -5, 1, -1, 2, -2, 3, 1, -3, -1, 6,

1482 -6, 0, 1, -1, 7, -7, 1, 2, -1, -2, 1, -1, 4, 8, -4, -8,

1483 1, -1, 3, -3, 9, -9, 1, 2, -2, -1, 1, 10, -10, -1, 5, -5,

1484 2, -2, 1, 11, -11, -1, 1, 3, 2, -1, -3, -2, 12, -12, 4, -4,

1485 2, -2, -6, 6, 13, -13, 1, -1, 14, -14, 1, -1, 3, -3, 7, -7,

1486 15, -15, 2, 1, -2, -1, 1, 5, -5, -1, -16, 2, 1, 16, -2, 4,

1487 -4, -1, 1, 3, -3, -1, 17, -17, 1, 1, -8, 8, -1, -1, 2, 18,

1488 -18, -2, 3, 1, -3, 19, -19, -1, 3, -3, 6, 1, -6, 20, 2, 9,

1489 -9, -1, -20, -2, 4, -4, 1, -5, 21, 5, -21, -1, 1, -22, -1, 2,

1490 22, -2, 10, 1, -10, 23, 1, 4, -23, 1, 2, -1, -2, -4, -7, 1,

1491 7, -24, -1, 24, -1, -1, 1, 3, -1, -25, 25, 4, -3, -4, 11, -11,

1492 26, -26, 6, 1, 1, -6, -5, -3, 3, 5, -1, -27, 27, 1, 4, -4,

1493 -1, -8, -1, 28, 2, 8, -12, -28, -2, -2, 2, 12, -1, 29, 1, -29,

1494 30, -30, 5, -5, 1, -31, -1, 3, 31, -1, 1, 1, -3, -13, 1, -7,

1495 -1, -32, 13, 7, 32, 33, -33, -1, -9, -34, 9, 34, -6, 5, 6, -5}

1496 },{

1497 /* MapTab6 */

1498 2, /* eob_sym */

1499 13, /* esc_sym */

1500 /* run table */

1501 {1, 1, 0, 1, 1, 2, 2, 1, 1, 3, 3, 1, 1, 0, 2, 2,

1502 4, 1, 4, 1, 1, 1, 5, 5, 1, 1, 6, 6, 2, 2, 1, 1,

1503 3, 3, 7, 7, 1, 1, 8, 8, 1, 1, 2, 2, 1, 9, 1, 9,

1504 4, 4, 10, 1, 1, 10, 1, 1, 11, 11, 3, 3, 1, 2, 1, 2,

1505 1, 1, 12, 12, 5, 5, 1, 1, 13, 1, 1, 13, 2, 2, 1, 1,

1506 6, 6, 1, 1, 4, 14, 4, 14, 3, 1, 3, 1, 1, 1, 15, 7,

1507 15, 2, 2, 7, 1, 1, 1, 8, 1, 8, 16, 16, 1, 1, 1, 1,

1508 2, 1, 1, 2, 1, 1, 3, 5, 5, 3, 4, 1, 1, 4, 1, 1,

1509 17, 17, 9, 1, 1, 9, 2, 2, 1, 1, 10, 10, 1, 6, 1, 1,

1510 6, 18, 1, 1, 18, 1, 1, 1, 2, 2, 3, 1, 3, 1, 1, 1,

1511 4, 1, 19, 1, 19, 7, 1, 1, 20, 1, 4, 20, 1, 7, 11, 2,

1512 1, 11, 21, 2, 8, 5, 1, 8, 1, 5, 21, 1, 1, 1, 22, 1,

1513 1, 22, 1, 1, 3, 3, 1, 23, 2, 12, 24, 1, 1, 2, 1, 1,

1514 12, 23, 1, 1, 24, 1, 1, 1, 4, 1, 1, 1, 2, 1, 6, 6,

1515 4, 2, 1, 1, 1, 1, 1, 1, 1, 14, 13, 3, 1, 25, 9, 25,

1516 14, 1, 9, 3, 13, 1, 1, 1, 1, 1, 10, 1, 1, 2, 10, 2},

1517

1518 /* value table */

1519 {-20, -1, 0, 2, -2, 1, -1, 3, -3, 1, -1, 4, -4, 0, 2, -2,

1520 1, 5, -1, -5, 6, -6, 1, -1, 7, -7, 1, -1, 3, -3, 8, -8,

1521 2, -2, 1, -1, 9, -9, 1, -1, 10, -10, 4, -4, 11, 1, -11, -1,

1522 2, -2, 1, 12, -12, -1, 13, -13, 1, -1, 3, -3, 14, 5, -14, -5,

1523 -15, 15, -1, 1, 2, -2, 16, -16, 1, 17, -17, -1, 6, -6, 18, -18,

1524 2, -2, -19, 19, -3, 1, 3, -1, 4, 20, -4, 1, -21, 21, 1, 2,

1525 -1, -7, 7, -2, 22, -22, 23, 2, -23, -2, 1, -1, -24, 24, -25, 25,

1526 -8, -26, 26, 8, -27, 27, 5, 3, -3, -5, -4, 28, -28, 4, 29, -29,

1527 1, -1, -2, -30, 30, 2, 9, -9, -31, 31, 2, -2, -32, 3, 32, -33,

1528 -3, 1, 33, -34, -1, 34, -35, 35, -10, 10, -6, 36, 6, -36, 37, -37,

1529 -5, 38, 1, -38, -1, 3, 39, -39, -1, 40, 5, 1, -40, -3, 2, -11,

1530 -41, -2, 1, 11, -3, -4, 41, 3, 42, 4, -1, -43, -42, 43, 1, -44,

1531 45, -1, 44, -45, -7, 7, -46, 1, -12, 2, 1, -47, 46, 12, 47, 48,

1532 -2, -1, -48, 49, -1, -50, -49, 50, -6, -51, 51, 52, -13, 53, -4, 4,

1533 6, 13, -53, -52, -54, 55, 54, -55, -56, -2, 2, -8, 56, 1, -3, -1,

1534 2, 58, 3, 8, -2, 57, -58, -60, -59, -57, -3, 60, 59, -14, 3, 14}

1535 },{

1536 /* MapTab7 */

1537 2, /* eob_sym */

1538 38, /* esc_sym */

1539 /* run table */

1540 {1, 1, 0, 2, 2, 1, 1, 3, 3, 4, 4, 5, 5, 1, 1, 6,

1541 6, 2, 2, 7, 7, 8, 8, 1, 1, 3, 3, 9, 9, 10, 10, 1,

1542 1, 2, 2, 4, 4, 11, 0, 11, 12, 12, 13, 13, 1, 1, 5, 5,

1543 14, 14, 15, 16, 15, 16, 3, 3, 1, 6, 1, 6, 2, 2, 7, 7,

1544 8, 8, 17, 17, 1, 1, 4, 4, 18, 18, 2, 2, 1, 19, 1, 20,

1545 19, 20, 21, 21, 3, 3, 22, 22, 5, 5, 24, 1, 1, 23, 9, 23,

1546 24, 9, 2, 2, 10, 1, 1, 10, 6, 6, 25, 4, 4, 25, 7, 7,

1547 26, 8, 1, 8, 3, 1, 26, 3, 11, 11, 27, 27, 2, 28, 1, 2,

1548 28, 1, 12, 12, 5, 5, 29, 13, 13, 29, 32, 1, 1, 33, 31, 30,

1549 32, 4, 30, 33, 4, 31, 3, 14, 1, 1, 3, 34, 34, 2, 2, 14,

1550 6, 6, 35, 36, 35, 36, 1, 15, 1, 16, 16, 15, 7, 9, 7, 9,

1551 37, 8, 8, 37, 1, 1, 39, 2, 38, 39, 2, 40, 5, 38, 40, 5,

1552 3, 3, 4, 4, 10, 10, 1, 1, 1, 1, 41, 2, 41, 2, 6, 6,

1553 1, 1, 11, 42, 11, 43, 3, 42, 3, 17, 4, 43, 1, 17, 7, 1,

1554 8, 44, 4, 7, 44, 5, 8, 2, 5, 1, 2, 48, 45, 1, 12, 45,

1555 12, 48, 13, 13, 1, 9, 9, 46, 1, 46, 47, 47, 49, 18, 18, 49},

1556

1557 /* value table */

1558 { 1, -1, 0, 1, -1, 2, -2, 1, -1, 1, -1, 1, -1, 3, -3, 1,

1559 -1, -2, 2, 1, -1, 1, -1, 4, -4, -2, 2, 1, -1, 1, -1, 5,

1560 -5, -3, 3, 2, -2, 1, 0, -1, 1, -1, 1, -1, 6, -6, 2, -2,

1561 1, -1, 1, 1, -1, -1, -3, 3, 7, 2, -7, -2, -4, 4, 2, -2,

1562 2, -2, 1, -1, 8, -8, 3, -3, 1, -1, -5, 5, 9, 1, -9, 1,

1563 -1, -1, 1, -1, -4, 4, 1, -1, 3, -3, 1, -10, 10, 1, 2, -1,

1564 -1, -2, 6, -6, 2, 11, -11, -2, 3, -3, 1, -4, 4, -1, 3, -3,

1565 1, 3, 12, -3, -5, -12, -1, 5, 2, -2, 1, -1, -7, 1, 13, 7,

1566 -1, -13, 2, -2, 4, -4, 1, 2, -2, -1, 1, 14, -14, 1, 1, 1,

1567 -1, -5, -1, -1, 5, -1, -6, 2, -15, 15, 6, 1, -1, -8, 8, -2,

1568 -4, 4, 1, 1, -1, -1, 16, 2, -16, -2, 2, -2, 4, 3, -4, -3,

1569 -1, -4, 4, 1, -17, 17, -1, -9, 1, 1, 9, 1, -5, -1, -1, 5,

1570 -7, 7, 6, -6, 3, -3, 18, -18, 19, -19, 1, -10, -1, 10, -5, 5,

1571 20, -20, -3, 1, 3, 1, 8, -1, -8, 2, 7, -1, -21, -2, 5, 21,

1572 5, -1, -7, -5, 1, -6, -5, -11, 6, 22, 11, 1, 1, -22, -3, -1,

1573 3, -1, 3, -3, -23, 4, -4, 1, 23, -1, 1, -1, 1, -2, 2, -1}

1574 },{

1575 /* MapTab8 */

1576 4, /* eob_sym */

1577 11, /* esc_sym */

1578 /* run table */

1579 {1, 1, 1, 1, 0, 2, 2, 1, 1, 3, 3, 0, 1, 1, 2, 2,

1580 4, 4, 1, 1, 5, 5, 1, 1, 2, 2, 3, 3, 6, 6, 1, 1,

1581 7, 7, 8, 1, 8, 2, 2, 1, 4, 4, 1, 3, 1, 3, 9, 9,

1582 2, 2, 1, 5, 1, 5, 10, 10, 1, 1, 11, 11, 3, 6, 3, 4,

1583 4, 6, 2, 2, 1, 12, 1, 12, 7, 13, 7, 13, 1, 1, 8, 8,

1584 2, 2, 14, 14, 16, 15, 16, 5, 5, 1, 3, 15, 1, 3, 4, 4,

1585 1, 1, 17, 17, 2, 2, 6, 6, 1, 18, 1, 18, 22, 21, 22, 21,

1586 25, 24, 25, 19, 9, 20, 9, 23, 19, 24, 20, 3, 23, 7, 3, 1,

1587 1, 7, 28, 26, 29, 5, 28, 26, 5, 8, 29, 4, 8, 27, 2, 2,

1588 4, 27, 1, 1, 10, 36, 10, 33, 33, 36, 30, 1, 32, 32, 1, 30,

1589 6, 31, 31, 35, 3, 6, 11, 11, 3, 2, 35, 2, 34, 1, 34, 1,

1590 37, 37, 12, 7, 12, 5, 41, 5, 4, 7, 1, 8, 13, 4, 1, 41,

1591 13, 38, 8, 38, 9, 1, 40, 40, 9, 1, 39, 2, 2, 49, 39, 42,

1592 3, 3, 14, 16, 49, 14, 16, 42, 43, 43, 6, 6, 15, 1, 1, 15,

1593 44, 44, 1, 1, 50, 48, 4, 5, 4, 7, 5, 2, 10, 10, 48, 7,

1594 50, 45, 2, 1, 45, 8, 8, 1, 46, 46, 3, 47, 47, 3, 1, 1},

1595

1596 /* value table */

1597 { 1, -1, 2, -2, 0, 1, -1, 3, -3, 1, -1, 0, 4, -4, 2, -2,

1598 1, -1, 5, -5, 1, -1, 6, -6, 3, -3, 2, -2, 1, -1, 7, -7,

1599 1, -1, 1, 8, -1, 4, -4, -8, 2, -2, 9, 3, -9, -3, 1, -1,

1600 5, -5, 10, 2, -10, -2, 1, -1, 11, -11, 1, -1, -4, 2, 4, 3,

1601 -3, -2, 6, -6, 12, 1, -12, -1, 2, 1, -2, -1, 13, -13, 2, -2,

1602 7, -7, 1, -1, 1, 1, -1, 3, -3, 14, 5, -1, -14, -5, 4, -4,

1603 15, -15, 1, -1, 8, -8, -3, 3, 16, 1, -16, -1, 1, 1, -1, -1,

1604 1, 1, -1, 1, 2, 1, -2, 1, -1, -1, -1, 6, -1, 3, -6, 17,

1605 -17, -3, 1, 1, 1, 4, -1, -1, -4, 3, -1, 5, -3, -1, -9, 9,

1606 -5, 1, 18, -18, 2, 1, -2, 1, -1, -1, 1, 19, -1, 1, -19, -1,

1607 4, 1, -1, 1, 7, -4, -2, 2, -7, 10, -1, -10, 1, 20, -1, -20,

1608 1, -1, 2, 4, -2, 5, 1, -5, 6, -4, 21, 4, 2, -6, -21, -1,

1609 -2, 1, -4, -1, -3, 22, -1, 1, 3, -22, -1, 11, -11, 1, 1, 1,

1610 8, -8, 2, 2, -1, -2, -2, -1, 1, -1, -5, 5, 2, 23, -23, -2,

1611 1, -1, 24, -24, -1, -1, 7, 6, -7, 5, -6, 12, -3, 3, 1, -5,

1612 1, 1, -12, 25, -1, -5, 5, -25, -1, 1, 9, 1, -1, -9, 26, -26}

1613 }

1614 };

ff_ivi_mc_4x4_no_delta

void ff_ivi_mc_4x4_no_delta(int16_t *buf, const int16_t *ref_buf, ptrdiff_t pitch, int mc_type)

4x4 block motion compensation without adding delta

ivi_process_empty_tile

static int ivi_process_empty_tile(AVCodecContext *avctx, const IVIBandDesc *band, IVITile *tile, int32_t mv_scale)

Handle empty tiles by performing data copying and motion compensation respectively.

Definition: ivi.c:748

skip_bits_long

static void skip_bits_long(GetBitContext *s, int n)

Skips the specified number of bits.

Definition: get_bits.h:291

RVMapDesc::runtab

uint8_t runtab[256]

Definition: ivi.h:100

IVITile::height

int height

Definition: ivi.h:131

av_clip

#define av_clip

Definition: common.h:95

RVMapDesc::valtab

int8_t valtab[256]

Definition: ivi.h:101

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:839

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

IVIHuffDesc::xbits

uint8_t xbits[16]

Definition: ivi.h:57

INIT_VLC_OUTPUT_LE

#define INIT_VLC_OUTPUT_LE

Definition: vlc.h:98

static double cb(void *priv, double x, double y)

Definition: vf_geq.c:239

IVIBandDesc::inter_scale

const uint8_t * inter_scale

quantization coefficient for inter blocks

Definition: ivi.h:187

thread.h

av_clip_uintp2

#define av_clip_uintp2

Definition: common.h:119

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:178

IVIPicConfig::pic_width

uint16_t pic_width

Definition: ivi.h:203

IVIBandDesc::height

int height

Definition: ivi.h:148

IVIHuffDesc

huffman codebook descriptor

Definition: ivi.h:55

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:219

ivi_decode_blocks

static int ivi_decode_blocks(GetBitContext *gb, const IVIBandDesc *band, IVITile *tile, AVCodecContext *avctx)

Definition: ivi.c:596

av_frame_free

void av_frame_free(AVFrame **frame)

Free the frame and any dynamically allocated objects in it, e.g.

Definition: frame.c:111

decode_band

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

Decode an Indeo 4 or 5 band.

Definition: ivi.c:941

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:325

IVIBandDesc::inv_transform

InvTransformPtr * inv_transform

Definition: ivi.h:177

uint8_t w

Definition: llviddspenc.c:38

internal.h

AVPacket::data

uint8_t * data

Definition: packet.h:374

init_vlc

#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)

Definition: vlc.h:43

#define b

Definition: input.c:34

RVMapDesc::eob_sym

uint8_t eob_sym

end of block symbol

Definition: ivi.h:98

ivi_init_static_vlc

static av_cold void ivi_init_static_vlc(void)

Definition: ivi.c:161

ff_ivi_mc_avg_4x4_no_delta

void ff_ivi_mc_avg_4x4_no_delta(int16_t *buf, const int16_t *ref_buf, const int16_t *ref_buf2, ptrdiff_t pitch, int mc_type, int mc_type2)

4x4 block motion compensation without adding delta for B-frames

IVIBandDesc::rvmap_sel

int rvmap_sel

rvmap table selector

Definition: ivi.h:173

IVIBandDesc::dc_transform

DCTransformPtr * dc_transform

Definition: ivi.h:179

IVIHuffTab::tab

VLC * tab

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

Definition: ivi.h:66

ivi_scale_mv

static int ivi_scale_mv(int mv, int mv_scale)

scale motion vector

Definition: ivi.h:293

ivi_dsp.h

IVITile::num_MBs

int num_MBs

number of macroblocks in this tile

Definition: ivi.h:135

IVIPicConfig::luma_bands

uint8_t luma_bands

Definition: ivi.h:209

IVI_TOSIGNED

#define IVI_TOSIGNED(val)

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

Definition: ivi.h:290

IVIBandDesc::data_ptr

const uint8_t * data_ptr

ptr to the first byte of the band data

Definition: ivi.h:150

IVITile::is_empty

int is_empty

= 1 if this tile doesn't contain any data

Definition: ivi.h:133

ivi.h

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:379

ivi_blk_huff_desc

static const IVIHuffDesc ivi_blk_huff_desc[8]

static block huffman tables

Definition: ivi.c:61

IVIBandDesc::num_corr

int num_corr

number of correction entries

Definition: ivi.h:171

#define U(x)

Definition: vp56_arith.h:37

IVIBandDesc

information for Indeo wavelet band

Definition: ivi.h:144

IVIPlaneDesc::height

uint16_t height

Definition: ivi.h:196

FFSIGN

#define FFSIGN(a)

Definition: common.h:65

ff_ivi_decode_close

av_cold int ff_ivi_decode_close(AVCodecContext *avctx)

Close Indeo5 decoder and clean up its context.

Definition: ivi.c:1211

GetBitContext

Definition: get_bits.h:61

IVI5_IS_PROTECTED

#define IVI5_IS_PROTECTED

Definition: ivi.h:50

val

static double val(void *priv, double ch)

Definition: aeval.c:77

IVIHuffTab

macroblock/block huffman table descriptor

Definition: ivi.h:63

IVITile::width

int width

Definition: ivi.h:130

IVIBandDesc::tiles

IVITile * tiles

array of tile descriptors

Definition: ivi.h:176

quant

static int quant(float coef, const float Q, const float rounding)

Quantize one coefficient.

Definition: aacenc_utils.h:59

IVIHuffDesc::num_rows

int32_t num_rows

Definition: ivi.h:56

IVIBandDesc::intra_base

const uint16_t * intra_base

quantization matrix for intra blocks

Definition: ivi.h:184

av_image_check_size2

int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx)

Check if the given dimension of an image is valid, meaning that all bytes of a plane of an image with...

Definition: imgutils.c:289

IVI_MBs_PER_TILE

#define IVI_MBs_PER_TILE(tile_width, tile_height, mb_size)

calculate number of macroblocks in a tile

Definition: ivi.h:286

IVIMbInfo

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

Definition: ivi.h:110

ivi_create_huff_from_desc

static int ivi_create_huff_from_desc(const IVIHuffDesc *cb, VLC *vlc, int flag)

Definition: ivi.c:127

IVIHuffTab::tab_sel

int32_t tab_sel

Definition: ivi.h:64

ff_thread_once

static int ff_thread_once(char *control, void(*routine)(void))

Definition: thread.h:179

pkt

AVPacket * pkt

Definition: movenc.c:59

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

av_cold

#define av_cold

Definition: attributes.h:90

init_get_bits8

static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)

Initialize GetBitContext.

Definition: get_bits.h:667

IVI_VLC_BITS

#define IVI_VLC_BITS

max number of bits of the ivi's huffman codes

Definition: ivi.h:49

IVITile::ypos

int ypos

Definition: ivi.h:129

IVIBandDesc::checksum_present

int checksum_present

Definition: ivi.h:182

IVIBandDesc::width

int width

Definition: ivi.h:147

IVIBandDesc::num_tiles

int num_tiles

number of tiles in this band

Definition: ivi.h:175

ivi_mb_huff_desc

static const IVIHuffDesc ivi_mb_huff_desc[8]

These are 2x8 predefined Huffman codebooks for coding macroblock/block signals.

Definition: ivi.c:49

IVIMbInfo::mv_x

int8_t mv_x

motion vector (x component)

Definition: ivi.h:117

IVIBandDesc::ref_buf

int16_t * ref_buf

pointer to the reference frame buffer (for motion compensation)

Definition: ivi.h:153

IVIPicConfig::chroma_bands

uint8_t chroma_bands

Definition: ivi.h:210

bits

uint8_t bits

Definition: vp3data.h:141

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

ivi_mb_vlc_tabs

static VLC ivi_mb_vlc_tabs[8]

static macroblock Huffman tables

Definition: ivi.c:72

IVIPicConfig

Definition: ivi.h:202

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

ctx

AVFormatContext * ctx

Definition: movenc.c:48

get_bits.h

IVIBandDesc::scan

const uint8_t * scan

ptr to the scan pattern

Definition: ivi.h:166

AVCodecContext::max_pixels

int64_t max_pixels

The number of pixels per image to maximally accept.

Definition: avcodec.h:1908

blk

#define blk(i)

Definition: sha.c:186

IVITile::data_size

int data_size

size of the data in bytes

Definition: ivi.h:134

IVIBandDesc::inter_base

const uint16_t * inter_base

quantization matrix for inter blocks

Definition: ivi.h:185

bands

static const float bands[]

Definition: af_superequalizer.c:56

IVIHuffTab::cust_desc

IVIHuffDesc cust_desc

pointer to the table associated with tab_sel

Definition: ivi.h:69

prepare_buf

static void * prepare_buf(IVI45DecContext *ctx, IVIBandDesc *band, int i)

Definition: ivi.c:924

AVCodecContext::codec_id

enum AVCodecID codec_id

Definition: avcodec.h:399

if(ret)

Definition: filter_design.txt:179

ivi_huff_desc_cmp

static int ivi_huff_desc_cmp(const IVIHuffDesc *desc1, const IVIHuffDesc *desc2)

Definition: ivi.c:203

IVIPlaneDesc

color plane (luma or chroma) information

Definition: ivi.h:194

AV_ONCE_INIT

#define AV_ONCE_INIT

Definition: thread.h:177

result

and forward the result(frame or status change) to the corresponding input. If nothing is possible

NULL

#define NULL

Definition: coverity.c:32

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:64

run

uint8_t run

Definition: svq3.c:205

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:395

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:498

IVIBandDesc::inherit_mv

int inherit_mv

tells if motion vector is inherited from reference macroblock

Definition: ivi.h:161

IVIBandDesc::band_num

int band_num

band number

Definition: ivi.h:146

INIT_VLC_USE_NEW_STATIC

#define INIT_VLC_USE_NEW_STATIC

Definition: vlc.h:100

ff_ivi_recompose53

void ff_ivi_recompose53(const IVIPlaneDesc *plane, uint8_t *dst, const ptrdiff_t dst_pitch)

5/3 wavelet recomposition filter for Indeo5

Definition: ivi_dsp.c:34

IVIPicConfig::pic_height

uint16_t pic_height

Definition: ivi.h:204

IVI4_FRAMETYPE_INTRA

@ IVI4_FRAMETYPE_INTRA

Definition: ivi.h:40

IVIBandDesc::aheight

int aheight

aligned band height

Definition: ivi.h:149

IVI45DecContext

Definition: ivi.h:213

get_vlc2

static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)

Parse a vlc code.

Definition: get_bits.h:787

ivi_huff_desc_copy

static void ivi_huff_desc_copy(IVIHuffDesc *dst, const IVIHuffDesc *src)

Definition: ivi.c:190

AVOnce

#define AVOnce

Definition: thread.h:176

ivi_mc_func

void(* ivi_mc_func)(int16_t *buf, const int16_t *ref_buf, ptrdiff_t pitch, int mc_type)

Definition: ivi.c:75

mv_scale

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

Definition: hevc_mvs.c:116

ivi_blk_vlc_tabs

static VLC ivi_blk_vlc_tabs[8]

static block Huffman tables

Definition: ivi.c:73

planes

static const struct @328 planes[]

ff_ivi_vertical_scan_8x8

const uint8_t ff_ivi_vertical_scan_8x8[64]

Scan patterns shared between indeo4 and indeo5.

Definition: ivi.c:1232

ff_dlog

#define ff_dlog(a,...)

Definition: tableprint_vlc.h:28

VLC::table_allocated

int table_allocated

Definition: vlc.h:34

ff_ivi_horizontal_scan_8x8

const uint8_t ff_ivi_horizontal_scan_8x8[64]

Definition: ivi.c:1243

ff_get_buffer

int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)

Get a buffer for a frame.

Definition: decode.c:1403

ff_ivi_rvmap_tabs

const RVMapDesc ff_ivi_rvmap_tabs[9]

Run-value (RLE) tables.

Definition: ivi.c:1262

AVPacket::size

int size

Definition: packet.h:375

IVIBandDesc::checksum

int32_t checksum

for debug purposes

Definition: ivi.h:181

IVIPlaneDesc::width

uint16_t width

Definition: ivi.h:195

VLCElem

Definition: vlc.h:27

RVMapDesc

run-value (RLE) table descriptor

Definition: ivi.h:97

avpriv_report_missing_feature

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

Log a generic warning message about a missing feature.

ff_ivi_init_planes

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

Initialize planes (prepares descriptors, allocates buffers etc).

Definition: ivi.c:291

IVIBandDesc::plane

int plane

plane number this band belongs to

Definition: ivi.h:145

IVIBandDesc::transform_size

int transform_size

Definition: ivi.h:178

ivi_mc

static int ivi_mc(const IVIBandDesc *band, ivi_mc_func mc, ivi_mc_avg_func mc_avg, int offs, int mv_x, int mv_y, int mv_x2, int mv_y2, int mc_type, int mc_type2)

Definition: ivi.c:81

IVIBandDesc::mb_size

int mb_size

macroblock size

Definition: ivi.h:158

attributes.h

AV_CODEC_ID_INDEO4

@ AV_CODEC_ID_INDEO4

Definition: codec_id.h:161

IVIBandDesc::bufs

int16_t * bufs[4]

array of pointers to the band buffers

Definition: ivi.h:155

ff_ivi_mc_avg_8x8_delta

void ff_ivi_mc_avg_8x8_delta(int16_t *buf, const int16_t *ref_buf, const int16_t *ref_buf2, ptrdiff_t pitch, int mc_type, int mc_type2)

8x8 block motion compensation with adding delta

#define mb

Definition: vf_colormatrix.c:101

IVITile

information for Indeo tile

Definition: ivi.h:127

ff_ivi_mc_avg_4x4_delta

void ff_ivi_mc_avg_4x4_delta(int16_t *buf, const int16_t *ref_buf, const int16_t *ref_buf2, ptrdiff_t pitch, int mc_type, int mc_type2)

4x4 block motion compensation with adding delta

flag

#define flag(name)

Definition: cbs_av1.c:553

IVIBandDesc::intra_scale

const uint8_t * intra_scale

quantization coefficient for intra blocks

Definition: ivi.h:186

IVITile::mbs

IVIMbInfo * mbs

array of macroblock descriptors

Definition: ivi.h:136

ivi_free_buffers

static av_cold void ivi_free_buffers(IVIPlaneDesc *planes)

Definition: ivi.c:266

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:269

ff_ivi_mc_4x4_delta

void ff_ivi_mc_4x4_delta(int16_t *buf, const int16_t *ref_buf, ptrdiff_t pitch, int mc_type)

4x4 block motion compensation with adding delta

IVIBandDesc::bufsize

int bufsize

band buffer size in bytes

Definition: ivi.h:183

show_bits

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

Show 1-25 bits.

Definition: get_bits.h:446

IVITile::mb_size

int mb_size

Definition: ivi.h:132

ivi_output_plane

static void ivi_output_plane(IVIPlaneDesc *plane, uint8_t *dst, ptrdiff_t dst_pitch)

Definition: ivi.c:899

IVITile::ref_mbs

IVIMbInfo * ref_mbs

ptr to the macroblock descriptors of the reference tile

Definition: ivi.h:137

IVIBandDesc::buf

int16_t * buf

pointer to the output buffer for this band

Definition: ivi.h:152

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

av_frame_move_ref

void av_frame_move_ref(AVFrame *dst, AVFrame *src)

Move everything contained in src to dst and reset src.

Definition: frame.c:506

ff_ivi_mc_8x8_delta

void ff_ivi_mc_8x8_delta(int16_t *buf, const int16_t *ref_buf, ptrdiff_t pitch, int mc_type)

8x8 block motion compensation with adding delta

av_frame_unref

void av_frame_unref(AVFrame *frame)

Unreference all the buffers referenced by frame and reset the frame fields.

Definition: frame.c:477

av_mallocz

void * av_mallocz(size_t size)

Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...

Definition: mem.c:264

RVMapDesc::esc_sym

uint8_t esc_sym

escape symbol

Definition: ivi.h:99

len

int len

Definition: vorbis_enc_data.h:426

table_data

static VLCElem table_data[117592]

Definition: rv34.c:84

av_calloc

void * av_calloc(size_t nmemb, size_t size)

Definition: mem.c:272

ff_free_vlc

void ff_free_vlc(VLC *vlc)

Definition: vlc.c:375

IVIBandDesc::b_ref_buf

int16_t * b_ref_buf

pointer to the second reference frame buffer (for motion compensation)

Definition: ivi.h:154

IVIMbInfo::q_delta

int8_t q_delta

quant delta

Definition: ivi.h:116

avcodec.h

ff_ivi_recompose_haar

void ff_ivi_recompose_haar(const IVIPlaneDesc *plane, uint8_t *dst, const ptrdiff_t dst_pitch)

Haar wavelet recomposition filter for Indeo 4.

Definition: ivi_dsp.c:191

ret

Definition: filter_design.txt:187

ff_ivi_mc_8x8_no_delta

void ff_ivi_mc_8x8_no_delta(int16_t *buf, const int16_t *ref_buf, ptrdiff_t pitch, int mc_type)

motion compensation without adding delta

FFSWAP

#define FFSWAP(type, a, b)

Definition: macros.h:52

frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Definition: filter_design.txt:264

IVIBandDesc::qdelta_present

int qdelta_present

tells if Qdelta signal is present in the bitstream (Indeo5 only)

Definition: ivi.h:163

IVIBandDesc::rv_map

RVMapDesc * rv_map

ptr to the RLE table for this band

Definition: ivi.h:174

IVI4_FRAMETYPE_BIDIR

@ IVI4_FRAMETYPE_BIDIR

bidirectional frame

Definition: ivi.h:43

ff_ivi_direct_scan_4x4

const uint8_t ff_ivi_direct_scan_4x4[16]

Definition: ivi.c:1254

align_get_bits

static const uint8_t * align_get_bits(GetBitContext *s)

Definition: get_bits.h:683

IVIBandDesc::is_2d_trans

int is_2d_trans

1 indicates that the two-dimensional inverse transform is used

Definition: ivi.h:180

pos

unsigned int pos

Definition: spdifenc.c:412

left

Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left

Definition: snow.txt:386

IVI_NUM_TILES

#define IVI_NUM_TILES(stride, tile_size)

calculate number of tiles in a stride

Definition: ivi.h:283

ivi_mc_avg_func

void(* ivi_mc_avg_func)(int16_t *buf, const int16_t *ref_buf1, const int16_t *ref_buf2, ptrdiff_t pitch, int mc_type, int mc_type2)

Definition: ivi.c:77

ff_ivi_decode_frame

int ff_ivi_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)

Definition: ivi.c:1068

IVIBandDesc::is_empty

int is_empty

= 1 if this band doesn't contain any data

Definition: ivi.h:157

AVCodecContext

main external API structure.

Definition: avcodec.h:389

ivi_dc_transform

static int ivi_dc_transform(const IVIBandDesc *band, int *prev_dc, int buf_offs, int blk_size)

Definition: ivi.c:476

VLC

Definition: vlc.h:31

IVIBandDesc::blk_size

int blk_size

block size

Definition: ivi.h:159

ivi_decode_coded_blocks

static int ivi_decode_coded_blocks(GetBitContext *gb, const IVIBandDesc *band, ivi_mc_func mc, ivi_mc_avg_func mc_avg, int mv_x, int mv_y, int mv_x2, int mv_y2, int *prev_dc, int is_intra, int mc_type, int mc_type2, uint32_t quant, int offs, AVCodecContext *avctx)

Definition: ivi.c:485

VLC::table

VLCElem * table

Definition: vlc.h:33

IVI4_FRAMETYPE_NULL_LAST

@ IVI4_FRAMETYPE_NULL_LAST

empty frame with no data

Definition: ivi.h:46

av_clip_uint8

#define av_clip_uint8

Definition: common.h:101

ff_ivi_mc_avg_8x8_no_delta