FFmpeg: libavcodec/ivi_common.c Source File

FFmpeg

[フレーム]

libavcodec

ivi_common.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 #define BITSTREAM_READER_LE

32 #include "libavutil/attributes.h"

33 #include "libavutil/timer.h"

34 #include "avcodec.h"

35 #include "get_bits.h"

36 #include "internal.h"

37 #include "mathops.h"

38 #include "ivi_common.h"

39 #include "ivi_dsp.h"

41 /**

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

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

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

45 * startup from these descriptors.

46 */

47 /** static macroblock huffman tables */

48 static const IVIHuffDesc ivi_mb_huff_desc[8] = {

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

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

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

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

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

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

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

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

57 };

59 /** static block huffman tables */

60 static const IVIHuffDesc ivi_blk_huff_desc[8] = {

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

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

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

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

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

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

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

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

69 };

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

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

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

75 uint32_t pitch, int mc_type);

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

77 const int16_t *ref_buf2,

78 uint32_t pitch, int mc_type, int mc_type2);

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

81 int offs, int mv_x, int mv_y, int mv_x2, int mv_y2,

82 int mc_type, int mc_type2)

83 {

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

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

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

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

89 if (mc_type != -1) {

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

91 av_assert0(buf_size - min_size >= offs);

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

93 }

95 if (mc_type2 == -1) {

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

97 } else {

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

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

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

101 return AVERROR_INVALIDDATA;

102 if (buf_size - min_size - ref_size2 < ref_offs2)

103 return AVERROR_INVALIDDATA;

104

105 if (mc_type == -1)

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

107 band->pitch, mc_type2);

108 else

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

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

111 mc_type, mc_type2);

112 }

113

114 return 0;

115 }

116

117 /**

118 * Reverse "nbits" bits of the value "val" and return the result

119 * in the least significant bits.

120 */

121 static uint16_t inv_bits(uint16_t val, int nbits)

122 {

123 uint16_t res;

124

125 if (nbits <= 8) {

126 res = ff_reverse[val] >> (8 - nbits);

127 } else

128 res = ((ff_reverse[val & 0xFF] << 8) +

129 (ff_reverse[val >> 8])) >> (16 - nbits);

130

131 return res;

132 }

133

134 /*

135 * Generate a huffman codebook from the given descriptor

136 * and convert it into the FFmpeg VLC table.

137 *

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

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

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

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

142 */

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

144 {

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

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

147 uint8_t bits[256];

148

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

150

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

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

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

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

155

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

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

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

159

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

161 if (bits[pos] > IVI_VLC_BITS)

162 return AVERROR_INVALIDDATA; /* invalid descriptor */

163

164 codewords[pos] = inv_bits((prefix | j), bits[pos]);

165 if (!bits[pos])

166 bits[pos] = 1;

167

168 pos++;

169 }//for j

170 }//for i

171

172 /* number of codewords = pos */

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

174 (flag ? INIT_VLC_USE_NEW_STATIC : 0) | INIT_VLC_LE);

175 }

176

177 av_cold void ff_ivi_init_static_vlc(void)

178 {

179 int i;

180 static VLC_TYPE table_data[8192 * 16][2];

181 static int initialized_vlcs = 0;

182

183 if (initialized_vlcs)

184 return;

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

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

187 ivi_mb_vlc_tabs[i].table_allocated = 8192;

188 ivi_create_huff_from_desc(&ivi_mb_huff_desc[i],

189 &ivi_mb_vlc_tabs[i], 1);

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

191 ivi_blk_vlc_tabs[i].table_allocated = 8192;

192 ivi_create_huff_from_desc(&ivi_blk_huff_desc[i],

193 &ivi_blk_vlc_tabs[i], 1);

194 }

195 initialized_vlcs = 1;

196 }

197

198 /*

199 * Copy huffman codebook descriptors.

200 *

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

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

203 */

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

205 {

206 dst->num_rows = src->num_rows;

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

208 }

209

210 /*

211 * Compare two huffman codebook descriptors.

212 *

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

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

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

216 */

217 static int ivi_huff_desc_cmp(const IVIHuffDesc *desc1,

218 const IVIHuffDesc *desc2)

219 {

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

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

222 }

223

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

225 IVIHuffTab *huff_tab, AVCodecContext *avctx)

226 {

227 int i, result;

228 IVIHuffDesc new_huff;

229

230 if (!desc_coded) {

231 /* select default table */

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

233 : &ivi_mb_vlc_tabs [7];

234 return 0;

235 }

236

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

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

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

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

241 if (!new_huff.num_rows) {

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

243 return AVERROR_INVALIDDATA;

244 }

245

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

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

248

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

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

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

252

253 if (huff_tab->cust_tab.table)

254 ff_free_vlc(&huff_tab->cust_tab);

255 result = ivi_create_huff_from_desc(&huff_tab->cust_desc,

256 &huff_tab->cust_tab, 0);

257 if (result) {

258 // reset faulty description

259 huff_tab->cust_desc.num_rows = 0;

260 av_log(avctx, AV_LOG_ERROR,

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

262 return result;

263 }

264 }

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

266 } else {

267 /* select one of predefined tables */

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

269 : &ivi_mb_vlc_tabs [huff_tab->tab_sel];

270 }

271

272 return 0;

273 }

274

275 /*

276 * Free planes, bands and macroblocks buffers.

277 *

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

279 */

280 static av_cold void ivi_free_buffers(IVIPlaneDesc *planes)

281 {

282 int p, b, t;

283

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

285 if (planes[p].bands)

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

287 av_freep(&planes[p].bands[b].bufs[0]);

288 av_freep(&planes[p].bands[b].bufs[1]);

289 av_freep(&planes[p].bands[b].bufs[2]);

290 av_freep(&planes[p].bands[b].bufs[3]);

291

292 if (planes[p].bands[b].blk_vlc.cust_tab.table)

293 ff_free_vlc(&planes[p].bands[b].blk_vlc.cust_tab);

294 for (t = 0; t < planes[p].bands[b].num_tiles; t++)

295 av_freep(&planes[p].bands[b].tiles[t].mbs);

296 av_freep(&planes[p].bands[b].tiles);

297 }

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

299 planes[p].num_bands = 0;

300 }

301 }

302

303 av_cold int ff_ivi_init_planes(IVIPlaneDesc *planes, const IVIPicConfig *cfg,

304 int is_indeo4)

305 {

306 int p, b;

307 uint32_t b_width, b_height, align_fac, width_aligned,

308 height_aligned, buf_size;

309 IVIBandDesc *band;

310

311 ivi_free_buffers(planes);

312

313 if (cfg->pic_width < 1 || cfg->pic_height < 1 ||

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

315 return AVERROR_INVALIDDATA;

316

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

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

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

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

321

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

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

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

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

326

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

328 planes[p].bands = av_mallocz_array(planes[p].num_bands, sizeof(IVIBandDesc));

329 if (!planes[p].bands)

330 return AVERROR(ENOMEM);

331

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

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

334 * has only half size */

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

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

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

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

339

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

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

342 align_fac = p ? 8 : 16;

343 width_aligned = FFALIGN(b_width , align_fac);

344 height_aligned = FFALIGN(b_height, align_fac);

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

346

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

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

349 band->plane = p;

350 band->band_num = b;

351 band->width = b_width;

352 band->height = b_height;

353 band->pitch = width_aligned;

354 band->aheight = height_aligned;

355 band->bufs[0] = av_mallocz(buf_size);

356 band->bufs[1] = av_mallocz(buf_size);

357 band->bufsize = buf_size/2;

358 if (!band->bufs[0] || !band->bufs[1])

359 return AVERROR(ENOMEM);

360

361 /* allocate the 3rd band buffer for scalability mode */

362 if (cfg->luma_bands > 1) {

363 band->bufs[2] = av_mallocz(buf_size);

364 if (!band->bufs[2])

365 return AVERROR(ENOMEM);

366 }

367 if (is_indeo4) {

368 band->bufs[3] = av_mallocz(buf_size);

369 if (!band->bufs[3])

370 return AVERROR(ENOMEM);

371 }

372 /* reset custom vlc */

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

374 }

375 }

376

377 return 0;

378 }

379

380 static int ivi_init_tiles(IVIBandDesc *band, IVITile *ref_tile,

381 int p, int b, int t_height, int t_width)

382 {

383 int x, y;

384 IVITile *tile = band->tiles;

385

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

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

388 tile->xpos = x;

389 tile->ypos = y;

390 tile->mb_size = band->mb_size;

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

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

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

394 /* calculate number of macroblocks */

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

396 band->mb_size);

397

398 av_freep(&tile->mbs);

399 tile->mbs = av_mallocz_array(tile->num_MBs, sizeof(IVIMbInfo));

400 if (!tile->mbs)

401 return AVERROR(ENOMEM);

402

403 tile->ref_mbs = 0;

404 if (p || b) {

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

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

407 return AVERROR_INVALIDDATA;

408 }

409 tile->ref_mbs = ref_tile->mbs;

410 ref_tile++;

411 }

412 tile++;

413 }

414 }

415

416 return 0;

417 }

418

419 av_cold int ff_ivi_init_tiles(IVIPlaneDesc *planes,

420 int tile_width, int tile_height)

421 {

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

423 IVIBandDesc *band;

424

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

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

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

428

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

430 t_width >>= 1;

431 t_height >>= 1;

432 }

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

434 return AVERROR(EINVAL);

435

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

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

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

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

440 band->num_tiles = x_tiles * y_tiles;

441

442 av_freep(&band->tiles);

443 band->tiles = av_mallocz_array(band->num_tiles, sizeof(IVITile));

444 if (!band->tiles)

445 return AVERROR(ENOMEM);

446

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

448 * and quant */

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

450 p, b, t_height, t_width);

451 if (ret < 0)

452 return ret;

453 }

454 }

455

456 return 0;

457 }

458

459 /*

460 * Decode size of the tile data.

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

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

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

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

465 *

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

467 * @return size of the tile data in bytes

468 */

469 static int ivi_dec_tile_data_size(GetBitContext *gb)

470 {

471 int len;

472

473 len = 0;

474 if (get_bits1(gb)) {

475 len = get_bits(gb, 8);

476 if (len == 255)

477 len = get_bits_long(gb, 24);

478 }

479

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

481 align_get_bits(gb);

482

483 return len;

484 }

485

486 static int ivi_dc_transform(IVIBandDesc *band, int *prev_dc, int buf_offs,

487 int blk_size)

488 {

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

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

491

492 if (min_size > buf_size)

493 return AVERROR_INVALIDDATA;

494

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

496 band->pitch, blk_size);

497

498 return 0;

499 }

500

501 static int ivi_decode_coded_blocks(GetBitContext *gb, IVIBandDesc *band,

502 ivi_mc_func mc, ivi_mc_avg_func mc_avg,

503 int mv_x, int mv_y,

504 int mv_x2, int mv_y2,

505 int *prev_dc, int is_intra,

506 int mc_type, int mc_type2,

507 uint32_t quant, int offs,

508 AVCodecContext *avctx)

509 {

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

511 RVMapDesc *rvmap = band->rv_map;

512 uint8_t col_flags[8];

513 int32_t trvec[64];

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

515 int pos, run, val;

516 int blk_size = band->blk_size;

517 int num_coeffs = blk_size * blk_size;

518 int col_mask = blk_size - 1;

519 int scan_pos = -1;

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

521 band->transform_size;

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

523

524 if (min_size > buf_size)

525 return AVERROR_INVALIDDATA;

526

527 if (!band->scan) {

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

529 return AVERROR_INVALIDDATA;

530 }

531

532 /* zero transform vector */

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

534 /* zero column flags */

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

536 while (scan_pos <= num_coeffs) {

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

538 IVI_VLC_BITS, 1);

539 if (sym == rvmap->eob_sym)

540 break; /* End of block */

541

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

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

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

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

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

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

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

549 } else {

550 if (sym >= 256U) {

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

552 return AVERROR_INVALIDDATA;

553 }

554 run = rvmap->runtab[sym];

555 val = rvmap->valtab[sym];

556 }

557

558 /* de-zigzag and dequantize */

559 scan_pos += run;

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

561 break;

562 pos = band->scan[scan_pos];

563

564 if (!val)

565 av_dlog(avctx, "Val = 0 encountered!\n");

566

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

568 if (q > 1)

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

570 trvec[pos] = val;

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

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

573 }

574

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

576 return AVERROR_INVALIDDATA; /* corrupt block data */

577

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

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

580 *prev_dc += trvec[0];

581 trvec[0] = *prev_dc;

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

583 }

584

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

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

587 return AVERROR_INVALIDDATA;

588 }

589

590 /* apply inverse transform */

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

592 band->pitch, col_flags);

593

594 /* apply motion compensation */

595 if (!is_intra)

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

597 mc_type, mc_type2);

598

599 return 0;

600 }

601 /*

602 * Decode block data:

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

604 * dequantize them, apply inverse transform and motion compensation

605 * in order to reconstruct the picture.

606 *

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

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

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

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

611 */

612 static int ivi_decode_blocks(GetBitContext *gb, IVIBandDesc *band,

613 IVITile *tile, AVCodecContext *avctx)

614 {

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

616 int mc_type = 0, mc_type2 = -1;

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

618 int32_t prev_dc;

619 uint32_t cbp, quant, buf_offs;

620 IVIMbInfo *mb;

621 ivi_mc_func mc_with_delta_func, mc_no_delta_func;

622 ivi_mc_avg_func mc_avg_with_delta_func, mc_avg_no_delta_func;

623 const uint8_t *scale_tab;

624

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

626 prev_dc = 0;

627 blk_size = band->blk_size;

628 /* number of blocks per mb */

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

630 if (blk_size == 8) {

631 mc_with_delta_func = ff_ivi_mc_8x8_delta;

632 mc_no_delta_func = ff_ivi_mc_8x8_no_delta;

633 mc_avg_with_delta_func = ff_ivi_mc_avg_8x8_delta;

634 mc_avg_no_delta_func = ff_ivi_mc_avg_8x8_no_delta;

635 } else {

636 mc_with_delta_func = ff_ivi_mc_4x4_delta;

637 mc_no_delta_func = ff_ivi_mc_4x4_no_delta;

638 mc_avg_with_delta_func = ff_ivi_mc_avg_4x4_delta;

639 mc_avg_no_delta_func = ff_ivi_mc_avg_4x4_no_delta;

640 }

641

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

643 is_intra = !mb->type;

644 cbp = mb->cbp;

645 buf_offs = mb->buf_offs;

646

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

648 if (avctx->codec_id == AV_CODEC_ID_INDEO4)

649 quant = av_clip_uintp2(quant, 5);

650 else

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

652

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

654 if (scale_tab)

655 quant = scale_tab[quant];

656

657 if (!is_intra) {

658 mv_x = mb->mv_x;

659 mv_y = mb->mv_y;

660 mv_x2 = mb->b_mv_x;

661 mv_y2 = mb->b_mv_y;

662 if (band->is_halfpel) {

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

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

665 mv_x >>= 1;

666 mv_y >>= 1;

667 mv_x2 >>= 1;

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

669 }

670 if (mb->type == 2)

671 mc_type = -1;

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

673 mc_type2 = -1;

674 if (mb->type) {

675 int dmv_x, dmv_y, cx, cy;

676

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

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

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

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

681

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

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

684 mb->ypos + dmv_y < 0 ||

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

686 return AVERROR_INVALIDDATA;

687 }

688 }

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

690 int dmv_x, dmv_y, cx, cy;

691

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

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

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

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

696

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

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

699 mb->ypos + dmv_y < 0 ||

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

701 return AVERROR_INVALIDDATA;

702 }

703 }

704 }

705

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

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

708 if (blk & 1) {

709 buf_offs += blk_size;

710 } else if (blk == 2) {

711 buf_offs -= blk_size;

712 buf_offs += blk_size * band->pitch;

713 }

714

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

716 ret = ivi_decode_coded_blocks(gb, band, mc_with_delta_func,

717 mc_avg_with_delta_func,

718 mv_x, mv_y, mv_x2, mv_y2,

719 &prev_dc, is_intra,

720 mc_type, mc_type2, quant,

721 buf_offs, avctx);

722 if (ret < 0)

723 return ret;

724 } else {

725 /* block not coded */

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

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

728 if (is_intra) {

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

730 if (ret < 0)

731 return ret;

732 } else {

733 ret = ivi_mc(band, mc_no_delta_func, mc_avg_no_delta_func,

734 buf_offs, mv_x, mv_y, mv_x2, mv_y2,

735 mc_type, mc_type2);

736 if (ret < 0)

737 return ret;

738 }

739 }

740

741 cbp >>= 1;

742 }// for blk

743 }// for mbn

744

745 align_get_bits(gb);

746

747 return 0;

748 }

749

750 /**

751 * Handle empty tiles by performing data copying and motion

752 * compensation respectively.

753 *

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

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

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

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

758 */

759 static int ivi_process_empty_tile(AVCodecContext *avctx, IVIBandDesc *band,

760 IVITile *tile, int32_t mv_scale)

761 {

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

763 int offs, mb_offset, row_offset, ret;

764 IVIMbInfo *mb, *ref_mb;

765 const int16_t *src;

766 int16_t *dst;

767 ivi_mc_func mc_no_delta_func;

768

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

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

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

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

773 return AVERROR_INVALIDDATA;

774 }

775

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

777 mb = tile->mbs;

778 ref_mb = tile->ref_mbs;

779 row_offset = band->mb_size * band->pitch;

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

781

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

783 mb_offset = offs;

784

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

786 mb->xpos = x;

787 mb->ypos = y;

788 mb->buf_offs = mb_offset;

789

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

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

792

793 if (!band->qdelta_present && !band->plane && !band->band_num) {

794 mb->q_delta = band->glob_quant;

795 mb->mv_x = 0;

796 mb->mv_y = 0;

797 }

798

799 if (band->inherit_qdelta && ref_mb)

800 mb->q_delta = ref_mb->q_delta;

801

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

803 /* motion vector inheritance */

804 if (mv_scale) {

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

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

807 } else {

808 mb->mv_x = ref_mb->mv_x;

809 mb->mv_y = ref_mb->mv_y;

810 }

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

812 {

813 int dmv_x, dmv_y, cx, cy;

814

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

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

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

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

819

820 if ( mb->xpos + dmv_x < 0

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

822 || mb->ypos + dmv_y < 0

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

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

825 return AVERROR_INVALIDDATA;

826 }

827 }

828 }

829

830 mb++;

831 if (ref_mb)

832 ref_mb++;

833 mb_offset += band->mb_size;

834 } // for x

835 offs += row_offset;

836 } // for y

837

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

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

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

841 : ff_ivi_mc_4x4_no_delta;

842

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

844 mv_x = mb->mv_x;

845 mv_y = mb->mv_y;

846 if (!band->is_halfpel) {

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

848 } else {

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

850 mv_x >>= 1;

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

852 }

853

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

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

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

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

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

859 if (ret < 0)

860 return ret;

861 }

862 }

863 } else {

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

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

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

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

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

869 src += band->pitch;

870 dst += band->pitch;

871 }

872 }

873

874 return 0;

875 }

876

877

878 #ifdef DEBUG

879 static uint16_t ivi_calc_band_checksum(IVIBandDesc *band)

880 {

881 int x, y;

882 int16_t *src, checksum;

883

884 src = band->buf;

885 checksum = 0;

886

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

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

889 checksum += src[x];

890

891 return checksum;

892 }

893 #endif

894

895 /*

896 * Convert and output the current plane.

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

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

899 *

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

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

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

903 */

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

905 {

906 int x, y;

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

908 uint32_t pitch = plane->bands[0].pitch;

909

910 if (!src)

911 return;

912

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

914 for (x = 0; x < plane->width; x++)

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

916 src += pitch;

917 dst += dst_pitch;

918 }

919 }

920

921 /**

922 * Decode an Indeo 4 or 5 band.

923 *

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

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

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

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

928 */

929 static int decode_band(IVI45DecContext *ctx,

930 IVIBandDesc *band, AVCodecContext *avctx)

931 {

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

933 IVITile *tile;

934

935 band->buf = band->bufs[ctx->dst_buf];

936 if (!band->buf) {

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

938 return AVERROR_INVALIDDATA;

939 }

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

941 band->ref_buf = band->bufs[ctx->b_ref_buf];

942 band->b_ref_buf = band->bufs[ctx->ref_buf];

943 } else {

944 band->ref_buf = band->bufs[ctx->ref_buf];

945 band->b_ref_buf = 0;

946 }

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

948

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

950 if (result) {

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

952 result);

953 return result;

954 }

955

956 if (band->is_empty) {

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

958 return AVERROR_INVALIDDATA;

959 }

960

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

962

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

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

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

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

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

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

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

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

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

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

973 }

974

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

976

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

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

979

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

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

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

983 return AVERROR_INVALIDDATA;

984 }

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

986 if (tile->is_empty) {

987 result = ivi_process_empty_tile(avctx, band, tile,

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

989 if (result < 0)

990 break;

991 av_dlog(avctx, "Empty tile encountered!\n");

992 } else {

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

994 if (!tile->data_size) {

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

996 result = AVERROR_INVALIDDATA;

997 break;

998 }

999

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

1001 if (result < 0)

1002 break;

1003

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

1005 if (result < 0) {

1006 av_log(avctx, AV_LOG_ERROR,

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

1008 break;

1009 }

1010

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

1012 av_log(avctx, AV_LOG_ERROR,

1013 "Tile data_size mismatch!\n");

1014 result = AVERROR_INVALIDDATA;

1015 break;

1016 }

1017

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

1019 }

1020 }

1021

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

1023 * reverse order */

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

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

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

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

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

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

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

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

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

1033 }

1034

1035 #ifdef DEBUG

1036 if (band->checksum_present) {

1037 uint16_t chksum = ivi_calc_band_checksum(band);

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

1039 av_log(avctx, AV_LOG_ERROR,

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

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

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

1043 }

1044 }

1045 #endif

1046

1047 align_get_bits(&ctx->gb);

1048

1049 return result;

1050 }

1051

1052 int ff_ivi_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,

1053 AVPacket *avpkt)

1054 {

1055 IVI45DecContext *ctx = avctx->priv_data;

1056 const uint8_t *buf = avpkt->data;

1057 AVFrame *frame = data;

1058 int buf_size = avpkt->size;

1059 int result, p, b;

1060

1061 init_get_bits(&ctx->gb, buf, buf_size * 8);

1062 ctx->frame_data = buf;

1063 ctx->frame_size = buf_size;

1064

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

1066 if (result) {

1067 av_log(avctx, AV_LOG_ERROR,

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

1069 return result;

1070 }

1071 if (ctx->gop_invalid)

1072 return AVERROR_INVALIDDATA;

1073

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

1075 if (ctx->got_p_frame) {

1076 av_frame_move_ref(data, ctx->p_frame);

1077 *got_frame = 1;

1078 ctx->got_p_frame = 0;

1079 } else {

1080 *got_frame = 0;

1081 }

1082 return buf_size;

1083 }

1084

1085 if (ctx->gop_flags & IVI5_IS_PROTECTED) {

1086 avpriv_report_missing_feature(avctx, "Password-protected clip!\n");

1087 return AVERROR_PATCHWELCOME;

1088 }

1089

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

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

1092 return AVERROR_INVALIDDATA;

1093 }

1094

1095 ctx->switch_buffers(ctx);

1096

1097 //{ START_TIMER;

1098

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

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

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

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

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

1104 if (result < 0) {

1105 av_log(avctx, AV_LOG_ERROR,

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

1107 return result;

1108 }

1109 }

1110 }

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

1112 } else {

1113 if (ctx->is_scalable)

1114 return AVERROR_INVALIDDATA;

1115

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

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

1118 return AVERROR_INVALIDDATA;

1119 }

1120 }

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

1122 return -1;

1123

1124 //STOP_TIMER("decode_planes"); }

1125

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

1127 return buf_size;

1128

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

1130 if (result < 0)

1131 return result;

1132

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

1134 return result;

1135

1136 if (ctx->is_scalable) {

1137 if (ctx->is_indeo4)

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

1139 else

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

1141 } else {

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

1143 }

1144

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

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

1147

1148 *got_frame = 1;

1149

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

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

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

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

1154 */

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

1156 int left;

1157

1158 // skip version string

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

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

1161 return AVERROR_INVALIDDATA;

1162 }

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

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

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

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

1167 AVPacket pkt;

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

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

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

1171 }

1172 }

1173

1174 return buf_size;

1175 }

1176

1177 /**

1178 * Close Indeo5 decoder and clean up its context.

1179 */

1180 av_cold int ff_ivi_decode_close(AVCodecContext *avctx)

1181 {

1182 IVI45DecContext *ctx = avctx->priv_data;

1183

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

1185

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

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

1188

1189 #if IVI4_STREAM_ANALYSER

1190 if (ctx->is_indeo4) {

1191 if (ctx->is_scalable)

1192 av_log(avctx, AV_LOG_ERROR, "This video uses scalability mode!\n");

1193 if (ctx->uses_tiling)

1194 av_log(avctx, AV_LOG_ERROR, "This video uses local decoding!\n");

1195 if (ctx->has_b_frames)

1196 av_log(avctx, AV_LOG_ERROR, "This video contains B-frames!\n");

1197 if (ctx->has_transp)

1198 av_log(avctx, AV_LOG_ERROR, "Transparency mode is enabled!\n");

1199 if (ctx->uses_haar)

1200 av_log(avctx, AV_LOG_ERROR, "This video uses Haar transform!\n");

1201 if (ctx->uses_fullpel)

1202 av_log(avctx, AV_LOG_ERROR, "This video uses fullpel motion vectors!\n");

1203 }

1204 #endif

1205

1206 av_frame_free(&ctx->p_frame);

1207

1208 return 0;

1209 }

1210

1211

1212 /**

1213 * Scan patterns shared between indeo4 and indeo5

1214 */

1215 const uint8_t ff_ivi_vertical_scan_8x8[64] = {

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

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

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

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

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

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

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

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

1224 };

1225

1226 const uint8_t ff_ivi_horizontal_scan_8x8[64] = {

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

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

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

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

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

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

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

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

1235 };

1236

1237 const uint8_t ff_ivi_direct_scan_4x4[16] = {

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

1239 };

1240

1241

1242 /**

1243 * Run-value (RLE) tables.

1244 */

1245 const RVMapDesc ff_ivi_rvmap_tabs[9] = {

1246 { /* MapTab0 */

1247 5, /* eob_sym */

1248 2, /* esc_sym */

1249 /* run table */

1250 {1, 1, 0, 1, 1, 0, 1, 1, 2, 2, 1, 1, 1, 1, 3, 3,

1251 1, 1, 2, 2, 1, 1, 4, 4, 1, 1, 1, 1, 2, 2, 5, 5,

1252 1, 1, 3, 3, 1, 1, 6, 6, 1, 2, 1, 2, 7, 7, 1, 1,

1253 8, 8, 1, 1, 4, 2, 1, 4, 2, 1, 3, 3, 1, 1, 1, 9,

1254 9, 1, 2, 1, 2, 1, 5, 5, 1, 1, 10, 10, 1, 1, 3, 3,

1255 2, 2, 1, 1, 11, 11, 6, 4, 4, 1, 6, 1, 2, 1, 2, 12,

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

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

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

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

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

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

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

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

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

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

1266

1267 /* value table */

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

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

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

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

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

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

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

1275 9, -9, 26, 1, -26, 3, 1, -1, 27, -3, -1, -27, 1, 3, -1, -3,

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

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

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

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

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

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

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

1283 -1, -2, 2, -1, -1, -1, 1, 1, 1, -1, 1, -1, 1, -1, 1, -1}

1284 },{

1285 /* MapTab1 */

1286 0, /* eob_sym */

1287 38, /* esc_sym */

1288 /* run table */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1305

1306 /* value table */

1307 {0, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, 1, -1, -1, 1,

1308 -1, 1, -1, 1, -1, 1, -1, 2, 1, -2, -1, 1, -1, 1, 1, -1,

1309 -1, 1, -1, 1, -1, 1, 0, -1, 1, 1, 1, -1, 1, -1, -1, -1,

1310 1, 1, 2, -1, -1, 1, -1, -2, 1, 1, -1, -1, 1, 1, -1, -1,

1311 1, -1, 3, 1, -3, 2, -1, 1, 1, -2, -1, -1, -1, 1, 1, 1,

1312 1, 1, -1, -1, -1, 2, -1, -2, 1, 2, -2, -1, 1, 1, 2, -1,

1313 -1, 1, -2, -1, 1, 1, -1, 2, 1, 2, -1, 1, -2, -1, -2, -1,

1314 -1, 1, 1, -1, 1, -1, 1, 1, 1, -1, -1, 1, 4, -1, -1, -4,

1315 1, 1, 1, 2, -1, -1, 1, -1, -1, 1, -1, -1, 1, -2, 1, -1,

1316 1, 1, -1, -1, 1, 1, -1, -1, 3, 2, -3, -2, 2, 5, -2, 2,

1317 2, -5, -2, -2, -2, 2, -3, 3, 2, 3, -3, 2, -2, -2, 3, -3,

1318 6, 2, -2, 3, -6, 3, -3, -3, 3, 7, -4, 4, -3, 2, -7, 2,

1319 2, -2, -4, 2, 8, -2, -2, -2, 4, 2, -2, 2, 3, 2, -2, -2,

1320 2, 2, -2, -8, -2, 9, -2, 2, -3, -2, 2, -2, 2, 2, 2, 4,

1321 -2, -4, 10, 2, 2, -2, -9, -2, 2, -2, 5, 4, -4, 4, -2, 2,

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

1323 },{

1324 /* MapTab2 */

1325 2, /* eob_sym */

1326 11, /* esc_sym */

1327 /* run table */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1344

1345 /* value table */

1346 { 1, -1, 0, 1, -1, 2, -2, 1, -1, 1, -1, 0, 3, -3, 1, -1,

1347 2, -2, 1, -1, 1, -1, 4, 1, -4, -1, 2, -2, 1, -1, 5, 3,

1348 -3, -5, 2, 1, -2, -1, 1, -1, 6, 2, 1, -1, -6, -2, 1, -1,

1349 3, -3, 2, -2, 4, -4, 1, -1, 1, -1, 1, 2, -1, 2, -2, -2,

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

1351 2, -4, -1, -2, 1, 1, -1, -1, 9, 1, 1, -9, -1, 1, -1, -1,

1352 1, -1, 3, -3, 1, 3, -3, -1, 3, -3, 1, -1, 10, 1, -10, -1,

1353 1, 4, -1, 2, 1, -1, 1, -2, 1, -4, -1, 6, -6, -1, 1, 1,

1354 1, -1, 1, 1, -1, -1, -1, 1, 11, -1, -2, 4, -1, 2, -11, 5,

1355 -5, -4, -1, 1, 4, 1, -4, -1, -2, 2, 1, -1, 12, 1, -2, 1,

1356 -12, 4, 2, 1, -1, -4, 4, -4, 2, -2, -1, 1, 7, -1, -1, -7,

1357 -1, -3, 1, 3, 1, 5, 2, 1, -1, -5, 13, -2, -1, 2, -2, -13,

1358 1, -1, 5, 6, 5, -5, 1, 1, -6, 1, -1, -1, -5, -1, 14, 2,

1359 -2, 1, -14, -1, 8, 1, -1, -8, 1, 5, 1, 5, -5, 1, -1, 1,

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

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

1362 },{

1363 /* MapTab3 */

1364 0, /* eob_sym */

1365 35, /* esc_sym */

1366 /* run table */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1383

1384 /* value table */

1385 { 0, 1, -1, 1, -1, 1, -1, 1, -1, 2, -2, 1, -1, 1, -1, 1,

1386 -1, 1, -1, 1, -1, 2, -2, 1, -1, 3, -3, 1, -1, 1, -1, 2,

1387 -2, 1, -1, 0, 1, -1, 1, 1, -1, -1, 2, -2, 1, 4, -1, -4,

1388 2, -2, 1, -1, -3, 3, 2, -2, 2, 1, 2, -2, -2, -1, 1, -1,

1389 1, -1, 1, 1, -1, -1, 1, -1, 5, -5, 1, -1, 3, -3, 1, -1,

1390 2, -2, 1, -1, 1, -1, 1, 1, 3, -1, -1, 6, -3, -6, -1, 1,

1391 4, -4, 1, 2, 1, -2, -1, -1, 1, -1, 3, -3, 1, -1, 1, 1,

1392 -1, 2, -1, -2, 1, 7, -3, 3, -1, 3, -7, -3, 1, -3, 3, -1,

1393 2, 1, -2, 1, -1, -1, 1, 2, -1, -2, -4, -1, 4, 1, 2, -2,

1394 1, -1, -2, 2, 8, -8, -1, 2, 1, -2, -5, 5, 1, -1, -1, 1,

1395 -1, 1, 4, -1, 1, -4, -1, -1, 1, 1, 9, 1, -9, 2, -2, -1,

1396 -4, 3, -3, -4, -1, 4, 1, 4, 1, -1, 1, -1, 1, 1, -1, 1,

1397 -1, -1, -1, 10, 4, 1, 4, -4, -4, -10, 6, 5, -6, -5, 1, -1,

1398 1, 3, -3, -1, 1, -1, -1, -1, 11, 1, 1, -11, -2, -2, 2, 5,

1399 -2, -5, -5, 2, -2, 12, 2, -2, 2, 2, 5, -3, -2, 3, -2, -12,

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

1401 },{

1402 /* MapTab4 */

1403 0, /* eob_sym */

1404 34, /* esc_sym */

1405 /* run table */

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

1407 2, 1, 5, 2, 1, 1, 6, 6, 1, 1, 1, 1, 1, 7, 3, 1,

1408 2, 3, 0, 1, 2, 7, 1, 1, 1, 8, 1, 1, 8, 1, 1, 1,

1409 9, 1, 9, 1, 2, 1, 1, 2, 1, 1, 10, 4, 1, 10, 1, 4,

1410 1, 1, 1, 1, 1, 3, 1, 1, 1, 3, 2, 1, 5, 1, 1, 1,

1411 2, 5, 1, 11, 1, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1412 2, 1, 6, 1, 6, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 12,

1413 3, 1, 12, 1, 1, 1, 2, 1, 1, 3, 1, 1, 1, 1, 1, 1,

1414 4, 1, 1, 1, 2, 1, 1, 4, 1, 1, 1, 1, 1, 1, 2, 1,

1415 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 2, 1, 1, 5,

1416 1, 1, 1, 1, 1, 7, 1, 7, 1, 1, 2, 3, 1, 1, 1, 1,

1417 5, 1, 1, 1, 1, 1, 1, 2, 13, 1, 1, 1, 1, 1, 1, 1,

1418 1, 1, 1, 1, 1, 1, 1, 1, 13, 2, 1, 1, 4, 1, 1, 1,

1419 3, 1, 6, 1, 1, 1, 14, 1, 1, 1, 1, 1, 14, 6, 1, 1,

1420 1, 1, 15, 2, 4, 1, 2, 3, 15, 1, 1, 1, 8, 1, 1, 8,

1421 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1},

1422

1423 /* value table */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1440 },{

1441 /* MapTab5 */

1442 2, /* eob_sym */

1443 33, /* esc_sym */

1444 /* run table */

1445 {1, 1, 0, 2, 1, 2, 1, 3, 3, 1, 1, 4, 4, 2, 2, 1,

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

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

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

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

1450 8, 8, 2, 2, 1, 1, 17, 17, 1, 1, 18, 18, 5, 5, 2, 2,

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

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

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

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

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

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

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

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

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

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

1461

1462 /* value table */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1479 },{

1480 /* MapTab6 */

1481 2, /* eob_sym */

1482 13, /* esc_sym */

1483 /* run table */

1484 {1, 1, 0, 1, 1, 2, 2, 1, 1, 3, 3, 1, 1, 0, 2, 2,

1485 4, 1, 4, 1, 1, 1, 5, 5, 1, 1, 6, 6, 2, 2, 1, 1,

1486 3, 3, 7, 7, 1, 1, 8, 8, 1, 1, 2, 2, 1, 9, 1, 9,

1487 4, 4, 10, 1, 1, 10, 1, 1, 11, 11, 3, 3, 1, 2, 1, 2,

1488 1, 1, 12, 12, 5, 5, 1, 1, 13, 1, 1, 13, 2, 2, 1, 1,

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

1490 15, 2, 2, 7, 1, 1, 1, 8, 1, 8, 16, 16, 1, 1, 1, 1,

1491 2, 1, 1, 2, 1, 1, 3, 5, 5, 3, 4, 1, 1, 4, 1, 1,

1492 17, 17, 9, 1, 1, 9, 2, 2, 1, 1, 10, 10, 1, 6, 1, 1,

1493 6, 18, 1, 1, 18, 1, 1, 1, 2, 2, 3, 1, 3, 1, 1, 1,

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

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

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

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

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

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

1500

1501 /* value table */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1518 },{

1519 /* MapTab7 */

1520 2, /* eob_sym */

1521 38, /* esc_sym */

1522 /* run table */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1539

1540 /* value table */

1541 { 1, -1, 0, 1, -1, 2, -2, 1, -1, 1, -1, 1, -1, 3, -3, 1,

1542 -1, -2, 2, 1, -1, 1, -1, 4, -4, -2, 2, 1, -1, 1, -1, 5,

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

1544 1, -1, 1, 1, -1, -1, -3, 3, 7, 2, -7, -2, -4, 4, 2, -2,

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

1546 -1, -1, 1, -1, -4, 4, 1, -1, 3, -3, 1, -10, 10, 1, 2, -1,

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

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

1549 -1, -13, 2, -2, 4, -4, 1, 2, -2, -1, 1, 14, -14, 1, 1, 1,

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

1551 -4, 4, 1, 1, -1, -1, 16, 2, -16, -2, 2, -2, 4, 3, -4, -3,

1552 -1, -4, 4, 1, -17, 17, -1, -9, 1, 1, 9, 1, -5, -1, -1, 5,

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

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

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

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

1557 },{

1558 /* MapTab8 */

1559 4, /* eob_sym */

1560 11, /* esc_sym */

1561 /* run table */

1562 {1, 1, 1, 1, 0, 2, 2, 1, 1, 3, 3, 0, 1, 1, 2, 2,

1563 4, 4, 1, 1, 5, 5, 1, 1, 2, 2, 3, 3, 6, 6, 1, 1,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1578

1579 /* value table */

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

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

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

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

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

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

1586 15, -15, 1, -1, 8, -8, -3, 3, 16, 1, -16, -1, 1, 1, -1, -1,

1587 1, 1, -1, 1, 2, 1, -2, 1, -1, -1, -1, 6, -1, 3, -6, 17,

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

1589 -5, 1, 18, -18, 2, 1, -2, 1, -1, -1, 1, 19, -1, 1, -19, -1,

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

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

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

1593 8, -8, 2, 2, -1, -2, -2, -1, 1, -1, -5, 5, 2, 23, -23, -2,

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

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

1596 }

1597 };

Generated on Sun Mar 8 2015 02:34:54 for FFmpeg by doxygen 1.8.2