FFmpeg: libavcodec/vc1.c Source File

FFmpeg

[フレーム]

libavcodec

vc1.c

Go to the documentation of this file.

1 /*

2 * VC-1 and WMV3 decoder common code

6 *

7 * This file is part of FFmpeg.

8 *

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

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

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

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

13 *

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

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

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

17 * Lesser General Public License for more details.

18 *

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

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

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

22 */

24 /**

25 * @file

26 * VC-1 and WMV3 decoder common code

27 *

28 */

30 #include "libavutil/attributes.h"

31 #include "internal.h"

32 #include "avcodec.h"

33 #include "mpegvideo.h"

34 #include "vc1.h"

35 #include "vc1data.h"

36 #include "msmpeg4data.h"

37 #include "unary.h"

38 #include "simple_idct.h"

40 #undef NDEBUG

41 #include <assert.h>

43 /***********************************************************************/

44 /**

45 * @name VC-1 Bitplane decoding

46 * @see 8.7, p56

47 * @{

48 */

50 /** Decode rows by checking if they are skipped

51 * @param plane Buffer to store decoded bits

52 * @param[in] width Width of this buffer

53 * @param[in] height Height of this buffer

54 * @param[in] stride of this buffer

55 */

56 static void decode_rowskip(uint8_t* plane, int width, int height, int stride,

57 GetBitContext *gb)

58 {

59 int x, y;

61 for (y = 0; y < height; y++) {

62 if (!get_bits1(gb)) //rowskip

63 memset(plane, 0, width);

64 else

65 for (x = 0; x < width; x++)

66 plane[x] = get_bits1(gb);

67 plane += stride;

68 }

69 }

71 /** Decode columns by checking if they are skipped

72 * @param plane Buffer to store decoded bits

73 * @param[in] width Width of this buffer

74 * @param[in] height Height of this buffer

75 * @param[in] stride of this buffer

76 * @todo FIXME: Optimize

77 */

78 static void decode_colskip(uint8_t* plane, int width, int height, int stride,

79 GetBitContext *gb)

80 {

81 int x, y;

83 for (x = 0; x < width; x++) {

84 if (!get_bits1(gb)) //colskip

85 for (y = 0; y < height; y++)

86 plane[y*stride] = 0;

87 else

88 for (y = 0; y < height; y++)

89 plane[y*stride] = get_bits1(gb);

90 plane ++;

91 }

92 }

94 /** Decode a bitplane's bits

95 * @param data bitplane where to store the decode bits

96 * @param[out] raw_flag pointer to the flag indicating that this bitplane is not coded explicitly

97 * @param v VC-1 context for bit reading and logging

98 * @return Status

99 * @todo FIXME: Optimize

100 */

101 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)

102 {

103 GetBitContext *gb = &v->s.gb;

104

105 int imode, x, y, code, offset;

106 uint8_t invert, *planep = data;

107 int width, height, stride;

108

109 width = v->s.mb_width;

110 height = v->s.mb_height >> v->field_mode;

111 stride = v->s.mb_stride;

112 invert = get_bits1(gb);

113 imode = get_vlc2(gb, ff_vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);

114

115 *raw_flag = 0;

116 switch (imode) {

117 case IMODE_RAW:

118 //Data is actually read in the MB layer (same for all tests == "raw")

119 *raw_flag = 1; //invert ignored

120 return invert;

121 case IMODE_DIFF2:

122 case IMODE_NORM2:

123 if ((height * width) & 1) {

124 *planep++ = get_bits1(gb);

125 y = offset = 1;

126 if (offset == width) {

127 offset = 0;

128 planep += stride - width;

129 }

130 }

131 else

132 y = offset = 0;

133 // decode bitplane as one long line

134 for (; y < height * width; y += 2) {

135 code = get_vlc2(gb, ff_vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);

136 *planep++ = code & 1;

137 offset++;

138 if (offset == width) {

139 offset = 0;

140 planep += stride - width;

141 }

142 *planep++ = code >> 1;

143 offset++;

144 if (offset == width) {

145 offset = 0;

146 planep += stride - width;

147 }

148 }

149 break;

150 case IMODE_DIFF6:

151 case IMODE_NORM6:

152 if (!(height % 3) && (width % 3)) { // use 2x3 decoding

153 for (y = 0; y < height; y += 3) {

154 for (x = width & 1; x < width; x += 2) {

155 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);

156 if (code < 0) {

157 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");

158 return -1;

159 }

160 planep[x + 0] = (code >> 0) & 1;

161 planep[x + 1] = (code >> 1) & 1;

162 planep[x + 0 + stride] = (code >> 2) & 1;

163 planep[x + 1 + stride] = (code >> 3) & 1;

164 planep[x + 0 + stride * 2] = (code >> 4) & 1;

165 planep[x + 1 + stride * 2] = (code >> 5) & 1;

166 }

167 planep += stride * 3;

168 }

169 if (width & 1)

170 decode_colskip(data, 1, height, stride, &v->s.gb);

171 } else { // 3x2

172 planep += (height & 1) * stride;

173 for (y = height & 1; y < height; y += 2) {

174 for (x = width % 3; x < width; x += 3) {

175 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);

176 if (code < 0) {

177 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");

178 return -1;

179 }

180 planep[x + 0] = (code >> 0) & 1;

181 planep[x + 1] = (code >> 1) & 1;

182 planep[x + 2] = (code >> 2) & 1;

183 planep[x + 0 + stride] = (code >> 3) & 1;

184 planep[x + 1 + stride] = (code >> 4) & 1;

185 planep[x + 2 + stride] = (code >> 5) & 1;

186 }

187 planep += stride * 2;

188 }

189 x = width % 3;

190 if (x)

191 decode_colskip(data, x, height, stride, &v->s.gb);

192 if (height & 1)

193 decode_rowskip(data + x, width - x, 1, stride, &v->s.gb);

194 }

195 break;

196 case IMODE_ROWSKIP:

197 decode_rowskip(data, width, height, stride, &v->s.gb);

198 break;

199 case IMODE_COLSKIP:

200 decode_colskip(data, width, height, stride, &v->s.gb);

201 break;

202 default:

203 break;

204 }

205

206 /* Applying diff operator */

207 if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6) {

208 planep = data;

209 planep[0] ^= invert;

210 for (x = 1; x < width; x++)

211 planep[x] ^= planep[x-1];

212 for (y = 1; y < height; y++) {

213 planep += stride;

214 planep[0] ^= planep[-stride];

215 for (x = 1; x < width; x++) {

216 if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;

217 else planep[x] ^= planep[x-1];

218 }

219 }

220 } else if (invert) {

221 planep = data;

222 for (x = 0; x < stride * height; x++)

223 planep[x] = !planep[x]; //FIXME stride

224 }

225 return (imode << 1) + invert;

226 }

227

228 /** @} */ //Bitplane group

229

230 /***********************************************************************/

231 /** VOP Dquant decoding

232 * @param v VC-1 Context

233 */

234 static int vop_dquant_decoding(VC1Context *v)

235 {

236 GetBitContext *gb = &v->s.gb;

237 int pqdiff;

238

239 //variable size

240 if (v->dquant == 2) {

241 pqdiff = get_bits(gb, 3);

242 if (pqdiff == 7)

243 v->altpq = get_bits(gb, 5);

244 else

245 v->altpq = v->pq + pqdiff + 1;

246 } else {

247 v->dquantfrm = get_bits1(gb);

248 if (v->dquantfrm) {

249 v->dqprofile = get_bits(gb, 2);

250 switch (v->dqprofile) {

251 case DQPROFILE_SINGLE_EDGE:

252 case DQPROFILE_DOUBLE_EDGES:

253 v->dqsbedge = get_bits(gb, 2);

254 break;

255 case DQPROFILE_ALL_MBS:

256 v->dqbilevel = get_bits1(gb);

257 if (!v->dqbilevel)

258 v->halfpq = 0;

259 default:

260 break; //Forbidden ?

261 }

262 if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS) {

263 pqdiff = get_bits(gb, 3);

264 if (pqdiff == 7)

265 v->altpq = get_bits(gb, 5);

266 else

267 v->altpq = v->pq + pqdiff + 1;

268 }

269 }

270 }

271 return 0;

272 }

273

274 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb);

275

276 /**

277 * Decode Simple/Main Profiles sequence header

278 * @see Figure 7-8, p16-17

279 * @param avctx Codec context

280 * @param gb GetBit context initialized from Codec context extra_data

281 * @return Status

282 */

283 int ff_vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)

284 {

285 av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits_long(gb, 32));

286 v->profile = get_bits(gb, 2);

287 if (v->profile == PROFILE_COMPLEX) {

288 av_log(avctx, AV_LOG_WARNING, "WMV3 Complex Profile is not fully supported\n");

289 }

290

291 if (v->profile == PROFILE_ADVANCED) {

292 v->zz_8x4 = ff_vc1_adv_progressive_8x4_zz;

293 v->zz_4x8 = ff_vc1_adv_progressive_4x8_zz;

294 return decode_sequence_header_adv(v, gb);

295 } else {

296 v->chromaformat = 1;

297 v->zz_8x4 = ff_wmv2_scantableA;

298 v->zz_4x8 = ff_wmv2_scantableB;

299 v->res_y411 = get_bits1(gb);

300 v->res_sprite = get_bits1(gb);

301 if (v->res_y411) {

302 av_log(avctx, AV_LOG_ERROR,

303 "Old interlaced mode is not supported\n");

304 return -1;

305 }

306 }

307

308 // (fps-2)/4 (->30)

309 v->frmrtq_postproc = get_bits(gb, 3); //common

310 // (bitrate-32kbps)/64kbps

311 v->bitrtq_postproc = get_bits(gb, 5); //common

312 v->s.loop_filter = get_bits1(gb); //common

313 if (v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE) {

314 av_log(avctx, AV_LOG_ERROR,

315 "LOOPFILTER shall not be enabled in Simple Profile\n");

316 }

317 if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)

318 v->s.loop_filter = 0;

319

320 v->res_x8 = get_bits1(gb); //reserved

321 v->multires = get_bits1(gb);

322 v->res_fasttx = get_bits1(gb);

323 if (!v->res_fasttx) {

324 v->vc1dsp.vc1_inv_trans_8x8 = ff_simple_idct_8;

325 v->vc1dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add;

326 v->vc1dsp.vc1_inv_trans_4x8 = ff_simple_idct48_add;

327 v->vc1dsp.vc1_inv_trans_4x4 = ff_simple_idct44_add;

328 v->vc1dsp.vc1_inv_trans_8x8_dc = ff_simple_idct_add_8;

329 v->vc1dsp.vc1_inv_trans_8x4_dc = ff_simple_idct84_add;

330 v->vc1dsp.vc1_inv_trans_4x8_dc = ff_simple_idct48_add;

331 v->vc1dsp.vc1_inv_trans_4x4_dc = ff_simple_idct44_add;

332 }

333

334 v->fastuvmc = get_bits1(gb); //common

335 if (!v->profile && !v->fastuvmc) {

336 av_log(avctx, AV_LOG_ERROR,

337 "FASTUVMC unavailable in Simple Profile\n");

338 return -1;

339 }

340 v->extended_mv = get_bits1(gb); //common

341 if (!v->profile && v->extended_mv)

342 {

343 av_log(avctx, AV_LOG_ERROR,

344 "Extended MVs unavailable in Simple Profile\n");

345 return -1;

346 }

347 v->dquant = get_bits(gb, 2); //common

348 v->vstransform = get_bits1(gb); //common

349

350 v->res_transtab = get_bits1(gb);

351 if (v->res_transtab)

352 {

353 av_log(avctx, AV_LOG_ERROR,

354 "1 for reserved RES_TRANSTAB is forbidden\n");

355 return -1;

356 }

357

358 v->overlap = get_bits1(gb); //common

359

360 v->resync_marker = get_bits1(gb);

361 v->rangered = get_bits1(gb);

362 if (v->rangered && v->profile == PROFILE_SIMPLE) {

363 av_log(avctx, AV_LOG_INFO,

364 "RANGERED should be set to 0 in Simple Profile\n");

365 }

366

367 v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common

368 v->quantizer_mode = get_bits(gb, 2); //common

369

370 v->finterpflag = get_bits1(gb); //common

371

372 if (v->res_sprite) {

373 int w = get_bits(gb, 11);

374 int h = get_bits(gb, 11);

375 int ret = ff_set_dimensions(v->s.avctx, w, h);

376 if (ret < 0) {

377 av_log(avctx, AV_LOG_ERROR, "Failed to set dimensions %d %d\n", w, h);

378 return ret;

379 }

380 skip_bits(gb, 5); //frame rate

381 v->res_x8 = get_bits1(gb);

382 if (get_bits1(gb)) { // something to do with DC VLC selection

383 av_log(avctx, AV_LOG_ERROR, "Unsupported sprite feature\n");

384 return -1;

385 }

386 skip_bits(gb, 3); //slice code

387 v->res_rtm_flag = 0;

388 } else {

389 v->res_rtm_flag = get_bits1(gb); //reserved

390 }

391 if (!v->res_rtm_flag) {

392 av_log(avctx, AV_LOG_ERROR,

393 "Old WMV3 version detected, some frames may be decoded incorrectly\n");

394 //return -1;

395 }

396 //TODO: figure out what they mean (always 0x402F)

397 if (!v->res_fasttx)

398 skip_bits(gb, 16);

399 av_log(avctx, AV_LOG_DEBUG,

400 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"

401 "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"

402 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"

403 "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",

404 v->profile, v->frmrtq_postproc, v->bitrtq_postproc,

405 v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,

406 v->rangered, v->vstransform, v->overlap, v->resync_marker,

407 v->dquant, v->quantizer_mode, avctx->max_b_frames);

408 return 0;

409 }

410

411 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)

412 {

413 v->res_rtm_flag = 1;

414 v->level = get_bits(gb, 3);

415 if (v->level >= 5) {

416 av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);

417 }

418 v->chromaformat = get_bits(gb, 2);

419 if (v->chromaformat != 1) {

420 av_log(v->s.avctx, AV_LOG_ERROR,

421 "Only 4:2:0 chroma format supported\n");

422 return -1;

423 }

424

425 // (fps-2)/4 (->30)

426 v->frmrtq_postproc = get_bits(gb, 3); //common

427 // (bitrate-32kbps)/64kbps

428 v->bitrtq_postproc = get_bits(gb, 5); //common

429 v->postprocflag = get_bits1(gb); //common

430

431 v->max_coded_width = (get_bits(gb, 12) + 1) << 1;

432 v->max_coded_height = (get_bits(gb, 12) + 1) << 1;

433 v->broadcast = get_bits1(gb);

434 v->interlace = get_bits1(gb);

435 v->tfcntrflag = get_bits1(gb);

436 v->finterpflag = get_bits1(gb);

437 skip_bits1(gb); // reserved

438

439 av_log(v->s.avctx, AV_LOG_DEBUG,

440 "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"

441 "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"

442 "TFCTRflag=%i, FINTERPflag=%i\n",

443 v->level, v->frmrtq_postproc, v->bitrtq_postproc,

444 v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,

445 v->tfcntrflag, v->finterpflag);

446

447 v->psf = get_bits1(gb);

448 if (v->psf) { //PsF, 6.1.13

449 av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");

450 return -1;

451 }

452 v->s.max_b_frames = v->s.avctx->max_b_frames = 7;

453 if (get_bits1(gb)) { //Display Info - decoding is not affected by it

454 int w, h, ar = 0;

455 av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");

456 w = get_bits(gb, 14) + 1;

457 h = get_bits(gb, 14) + 1;

458 av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);

459 if (get_bits1(gb))

460 ar = get_bits(gb, 4);

461 if (ar && ar < 14) {

462 v->s.avctx->sample_aspect_ratio = ff_vc1_pixel_aspect[ar];

463 } else if (ar == 15) {

464 w = get_bits(gb, 8) + 1;

465 h = get_bits(gb, 8) + 1;

466 v->s.avctx->sample_aspect_ratio = (AVRational){w, h};

467 } else {

468 av_reduce(&v->s.avctx->sample_aspect_ratio.num,

469 &v->s.avctx->sample_aspect_ratio.den,

470 v->s.avctx->height * w,

471 v->s.avctx->width * h,

472 1 << 30);

473 }

474 ff_set_sar(v->s.avctx, v->s.avctx->sample_aspect_ratio);

475 av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n",

476 v->s.avctx->sample_aspect_ratio.num,

477 v->s.avctx->sample_aspect_ratio.den);

478

479 if (get_bits1(gb)) { //framerate stuff

480 if (get_bits1(gb)) {

481 v->s.avctx->time_base.num = 32;

482 v->s.avctx->time_base.den = get_bits(gb, 16) + 1;

483 } else {

484 int nr, dr;

485 nr = get_bits(gb, 8);

486 dr = get_bits(gb, 4);

487 if (nr > 0 && nr < 8 && dr > 0 && dr < 3) {

488 v->s.avctx->time_base.num = ff_vc1_fps_dr[dr - 1];

489 v->s.avctx->time_base.den = ff_vc1_fps_nr[nr - 1] * 1000;

490 }

491 }

492 if (v->broadcast) { // Pulldown may be present

493 v->s.avctx->time_base.den *= 2;

494 v->s.avctx->ticks_per_frame = 2;

495 }

496 }

497

498 if (get_bits1(gb)) {

499 v->s.avctx->color_primaries = get_bits(gb, 8);

500 v->s.avctx->color_trc = get_bits(gb, 8);

501 v->s.avctx->colorspace = get_bits(gb, 8);

502 v->s.avctx->color_range = AVCOL_RANGE_MPEG;

503 }

504 }

505

506 v->hrd_param_flag = get_bits1(gb);

507 if (v->hrd_param_flag) {

508 int i;

509 v->hrd_num_leaky_buckets = get_bits(gb, 5);

510 skip_bits(gb, 4); //bitrate exponent

511 skip_bits(gb, 4); //buffer size exponent

512 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {

513 skip_bits(gb, 16); //hrd_rate[n]

514 skip_bits(gb, 16); //hrd_buffer[n]

515 }

516 }

517 return 0;

518 }

519

520 int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)

521 {

522 int i;

523 int w,h;

524 int ret;

525

526 av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));

527 v->broken_link = get_bits1(gb);

528 v->closed_entry = get_bits1(gb);

529 v->panscanflag = get_bits1(gb);

530 v->refdist_flag = get_bits1(gb);

531 v->s.loop_filter = get_bits1(gb);

532 if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)

533 v->s.loop_filter = 0;

534 v->fastuvmc = get_bits1(gb);

535 v->extended_mv = get_bits1(gb);

536 v->dquant = get_bits(gb, 2);

537 v->vstransform = get_bits1(gb);

538 v->overlap = get_bits1(gb);

539 v->quantizer_mode = get_bits(gb, 2);

540

541 if (v->hrd_param_flag) {

542 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {

543 skip_bits(gb, 8); //hrd_full[n]

544 }

545 }

546

547 if(get_bits1(gb)){

548 w = (get_bits(gb, 12)+1)<<1;

549 h = (get_bits(gb, 12)+1)<<1;

550 } else {

551 w = v->max_coded_width;

552 h = v->max_coded_height;

553 }

554 if ((ret = ff_set_dimensions(avctx, w, h)) < 0) {

555 av_log(avctx, AV_LOG_ERROR, "Failed to set dimensions %d %d\n", w, h);

556 return ret;

557 }

558

559 if (v->extended_mv)

560 v->extended_dmv = get_bits1(gb);

561 if ((v->range_mapy_flag = get_bits1(gb))) {

562 av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");

563 v->range_mapy = get_bits(gb, 3);

564 }

565 if ((v->range_mapuv_flag = get_bits1(gb))) {

566 av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");

567 v->range_mapuv = get_bits(gb, 3);

568 }

569

570 av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"

571 "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"

572 "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"

573 "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",

574 v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter,

575 v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);

576

577 return 0;

578 }

579

580 /* fill lookup tables for intensity compensation */

581 #define INIT_LUT(lumscale, lumshift, luty, lutuv, chain) do { \

582 int scale, shift, i; \

583 if (!lumscale) { \

584 scale = -64; \

585 shift = (255 - lumshift * 2) << 6; \

586 if (lumshift > 31) \

587 shift += 128 << 6; \

588 } else { \

589 scale = lumscale + 32; \

590 if (lumshift > 31) \

591 shift = (lumshift - 64) << 6; \

592 else \

593 shift = lumshift << 6; \

594 } \

595 for (i = 0; i < 256; i++) { \

596 int iy = chain ? luty[i] : i; \

597 int iu = chain ? lutuv[i] : i; \

598 luty[i] = av_clip_uint8((scale * iy + shift + 32) >> 6); \

599 lutuv[i] = av_clip_uint8((scale * (iu - 128) + 128*64 + 32) >> 6);\

600 } \

601 } while(0)

602

603 static void rotate_luts(VC1Context *v)

604 {

605 #define ROTATE(DEF, L, N, C, A) do { \

606 if (v->s.pict_type == AV_PICTURE_TYPE_BI || v->s.pict_type == AV_PICTURE_TYPE_B) { \

607 C = A; \

608 } else { \

609 DEF; \

610 memcpy(&tmp, L , sizeof(tmp)); \

611 memcpy(L , N , sizeof(tmp)); \

612 memcpy(N , &tmp, sizeof(tmp)); \

613 C = N; \

614 } \

615 } while(0)

616

617 ROTATE(int tmp, &v->last_use_ic, &v->next_use_ic, v->curr_use_ic, &v->aux_use_ic);

618 ROTATE(uint8_t tmp[2][256], v->last_luty, v->next_luty, v->curr_luty, v->aux_luty);

619 ROTATE(uint8_t tmp[2][256], v->last_lutuv, v->next_lutuv, v->curr_lutuv, v->aux_lutuv);

620

621 INIT_LUT(32, 0, v->curr_luty[0], v->curr_lutuv[0], 0);

622 INIT_LUT(32, 0, v->curr_luty[1], v->curr_lutuv[1], 0);

623 *v->curr_use_ic = 0;

624 }

625

626 static int read_bfraction(VC1Context *v, GetBitContext* gb) {

627 int bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);

628

629 if (bfraction_lut_index == 21 || bfraction_lut_index < 0) {

630 av_log(v->s.avctx, AV_LOG_ERROR, "bfraction invalid\n");

631 return AVERROR_INVALIDDATA;

632 }

633 v->bfraction_lut_index = bfraction_lut_index;

634 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];

635 return 0;

636 }

637

638 int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)

639 {

640 int pqindex, lowquant, status;

641

642 v->field_mode = 0;

643 v->fcm = 0;

644 if (v->finterpflag)

645 v->interpfrm = get_bits1(gb);

646 if (!v->s.avctx->codec)

647 return -1;

648 if (v->s.avctx->codec_id == AV_CODEC_ID_MSS2)

649 v->respic =

650 v->rangered =

651 v->multires = get_bits(gb, 2) == 1;

652 else

653 skip_bits(gb, 2); //framecnt unused

654 v->rangeredfrm = 0;

655 if (v->rangered)

656 v->rangeredfrm = get_bits1(gb);

657 v->s.pict_type = get_bits1(gb);

658 if (v->s.avctx->max_b_frames) {

659 if (!v->s.pict_type) {

660 if (get_bits1(gb))

661 v->s.pict_type = AV_PICTURE_TYPE_I;

662 else

663 v->s.pict_type = AV_PICTURE_TYPE_B;

664 } else

665 v->s.pict_type = AV_PICTURE_TYPE_P;

666 } else

667 v->s.pict_type = v->s.pict_type ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;

668

669 v->bi_type = 0;

670 if (v->s.pict_type == AV_PICTURE_TYPE_B) {

671 if (read_bfraction(v, gb) < 0)

672 return AVERROR_INVALIDDATA;

673 if (v->bfraction == 0) {

674 v->s.pict_type = AV_PICTURE_TYPE_BI;

675 }

676 }

677 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)

678 skip_bits(gb, 7); // skip buffer fullness

679

680 if (v->parse_only)

681 return 0;

682

683 /* calculate RND */

684 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)

685 v->rnd = 1;

686 if (v->s.pict_type == AV_PICTURE_TYPE_P)

687 v->rnd ^= 1;

688

689 /* Quantizer stuff */

690 pqindex = get_bits(gb, 5);

691 if (!pqindex)

692 return -1;

693 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)

694 v->pq = ff_vc1_pquant_table[0][pqindex];

695 else

696 v->pq = ff_vc1_pquant_table[1][pqindex];

697

698 v->pquantizer = 1;

699 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)

700 v->pquantizer = pqindex < 9;

701 if (v->quantizer_mode == QUANT_NON_UNIFORM)

702 v->pquantizer = 0;

703 v->pqindex = pqindex;

704 if (pqindex < 9)

705 v->halfpq = get_bits1(gb);

706 else

707 v->halfpq = 0;

708 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)

709 v->pquantizer = get_bits1(gb);

710 v->dquantfrm = 0;

711 if (v->extended_mv == 1)

712 v->mvrange = get_unary(gb, 0, 3);

713 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13

714 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11

715 v->range_x = 1 << (v->k_x - 1);

716 v->range_y = 1 << (v->k_y - 1);

717 if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)

718 v->respic = get_bits(gb, 2);

719

720 if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {

721 v->x8_type = get_bits1(gb);

722 } else

723 v->x8_type = 0;

724 av_dlog(v->s.avctx, "%c Frame: QP=[%i]%i (+%i/2) %i\n",

725 (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'),

726 pqindex, v->pq, v->halfpq, v->rangeredfrm);

727

728 if (v->first_pic_header_flag)

729 rotate_luts(v);

730

731 switch (v->s.pict_type) {

732 case AV_PICTURE_TYPE_P:

733 if (v->pq < 5) v->tt_index = 0;

734 else if (v->pq < 13) v->tt_index = 1;

735 else v->tt_index = 2;

736

737 lowquant = (v->pq > 12) ? 0 : 1;

738 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];

739 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {

740 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];

741 v->lumscale = get_bits(gb, 6);

742 v->lumshift = get_bits(gb, 6);

743 v->last_use_ic = 1;

744 /* fill lookup tables for intensity compensation */

745 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);

746 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);

747 }

748 v->qs_last = v->s.quarter_sample;

749 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)

750 v->s.quarter_sample = 0;

751 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {

752 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)

753 v->s.quarter_sample = 0;

754 else

755 v->s.quarter_sample = 1;

756 } else

757 v->s.quarter_sample = 1;

758 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || (v->mv_mode == MV_PMODE_INTENSITY_COMP && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));

759

760 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&

761 v->mv_mode2 == MV_PMODE_MIXED_MV) ||

762 v->mv_mode == MV_PMODE_MIXED_MV) {

763 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);

764 if (status < 0)

765 return -1;

766 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "

767 "Imode: %i, Invert: %i\n", status>>1, status&1);

768 } else {

769 v->mv_type_is_raw = 0;

770 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);

771 }

772 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);

773 if (status < 0)

774 return -1;

775 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "

776 "Imode: %i, Invert: %i\n", status>>1, status&1);

777

778 /* Hopefully this is correct for P frames */

779 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables

780 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];

781

782 if (v->dquant) {

783 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");

784 vop_dquant_decoding(v);

785 }

786

787 v->ttfrm = 0; //FIXME Is that so ?

788 if (v->vstransform) {

789 v->ttmbf = get_bits1(gb);

790 if (v->ttmbf) {

791 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];

792 }

793 } else {

794 v->ttmbf = 1;

795 v->ttfrm = TT_8X8;

796 }

797 break;

798 case AV_PICTURE_TYPE_B:

799 if (v->pq < 5) v->tt_index = 0;

800 else if (v->pq < 13) v->tt_index = 1;

801 else v->tt_index = 2;

802

803 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;

804 v->qs_last = v->s.quarter_sample;

805 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);

806 v->s.mspel = v->s.quarter_sample;

807

808 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);

809 if (status < 0)

810 return -1;

811 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "

812 "Imode: %i, Invert: %i\n", status>>1, status&1);

813 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);

814 if (status < 0)

815 return -1;

816 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "

817 "Imode: %i, Invert: %i\n", status>>1, status&1);

818

819 v->s.mv_table_index = get_bits(gb, 2);

820 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];

821

822 if (v->dquant) {

823 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");

824 vop_dquant_decoding(v);

825 }

826

827 v->ttfrm = 0;

828 if (v->vstransform) {

829 v->ttmbf = get_bits1(gb);

830 if (v->ttmbf) {

831 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];

832 }

833 } else {

834 v->ttmbf = 1;

835 v->ttfrm = TT_8X8;

836 }

837 break;

838 }

839

840 if (!v->x8_type) {

841 /* AC Syntax */

842 v->c_ac_table_index = decode012(gb);

843 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {

844 v->y_ac_table_index = decode012(gb);

845 }

846 /* DC Syntax */

847 v->s.dc_table_index = get_bits1(gb);

848 }

849

850 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {

851 v->s.pict_type = AV_PICTURE_TYPE_B;

852 v->bi_type = 1;

853 }

854 return 0;

855 }

856

857 int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)

858 {

859 int pqindex, lowquant;

860 int status;

861 int mbmodetab, imvtab, icbptab, twomvbptab, fourmvbptab; /* useful only for debugging */

862 int field_mode, fcm;

863

864 v->numref = 0;

865 v->p_frame_skipped = 0;

866 if (v->second_field) {

867 if(v->fcm!=2 || v->field_mode!=1)

868 return -1;

869 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;

870 if (v->fptype & 4)

871 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;

872 v->s.current_picture_ptr->f->pict_type = v->s.pict_type;

873 if (!v->pic_header_flag)

874 goto parse_common_info;

875 }

876

877 field_mode = 0;

878 if (v->interlace) {

879 fcm = decode012(gb);

880 if (fcm) {

881 if (fcm == ILACE_FIELD)

882 field_mode = 1;

883 }

884 } else {

885 fcm = PROGRESSIVE;

886 }

887 if (!v->first_pic_header_flag && v->field_mode != field_mode)

888 return AVERROR_INVALIDDATA;

889 v->field_mode = field_mode;

890 v->fcm = fcm;

891

892 av_assert0( v->s.mb_height == v->s.height + 15 >> 4

893 || v->s.mb_height == FFALIGN(v->s.height + 15 >> 4, 2));

894 if (v->field_mode) {

895 v->s.mb_height = FFALIGN(v->s.height + 15 >> 4, 2);

896 v->fptype = get_bits(gb, 3);

897 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;

898 if (v->fptype & 4) // B-picture

899 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;

900

901 } else {

902 v->s.mb_height = v->s.height + 15 >> 4;

903 switch (get_unary(gb, 0, 4)) {

904 case 0:

905 v->s.pict_type = AV_PICTURE_TYPE_P;

906 break;

907 case 1:

908 v->s.pict_type = AV_PICTURE_TYPE_B;

909 break;

910 case 2:

911 v->s.pict_type = AV_PICTURE_TYPE_I;

912 break;

913 case 3:

914 v->s.pict_type = AV_PICTURE_TYPE_BI;

915 break;

916 case 4:

917 v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic

918 v->p_frame_skipped = 1;

919 break;

920 }

921 }

922 if (v->tfcntrflag)

923 skip_bits(gb, 8);

924 if (v->broadcast) {

925 if (!v->interlace || v->psf) {

926 v->rptfrm = get_bits(gb, 2);

927 } else {

928 v->tff = get_bits1(gb);

929 v->rff = get_bits1(gb);

930 }

931 } else {

932 v->tff = 1;

933 }

934 if (v->panscanflag) {

935 avpriv_report_missing_feature(v->s.avctx, "Pan-scan");

936 //...

937 }

938 if (v->p_frame_skipped) {

939 return 0;

940 }

941 v->rnd = get_bits1(gb);

942 if (v->interlace)

943 v->uvsamp = get_bits1(gb);

944 if(!ff_vc1_bfraction_vlc.table)

945 return 0; //parsing only, vlc tables havnt been allocated

946 if (v->field_mode) {

947 if (!v->refdist_flag)

948 v->refdist = 0;

949 else if ((v->s.pict_type != AV_PICTURE_TYPE_B) && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {

950 v->refdist = get_bits(gb, 2);

951 if (v->refdist == 3)

952 v->refdist += get_unary(gb, 0, 16);

953 }

954 if ((v->s.pict_type == AV_PICTURE_TYPE_B) || (v->s.pict_type == AV_PICTURE_TYPE_BI)) {

955 if (read_bfraction(v, gb) < 0)

956 return AVERROR_INVALIDDATA;

957 v->frfd = (v->bfraction * v->refdist) >> 8;

958 v->brfd = v->refdist - v->frfd - 1;

959 if (v->brfd < 0)

960 v->brfd = 0;

961 }

962 goto parse_common_info;

963 }

964 if (v->fcm == PROGRESSIVE) {

965 if (v->finterpflag)

966 v->interpfrm = get_bits1(gb);

967 if (v->s.pict_type == AV_PICTURE_TYPE_B) {

968 if (read_bfraction(v, gb) < 0)

969 return AVERROR_INVALIDDATA;

970 if (v->bfraction == 0) {

971 v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */

972 }

973 }

974 }

975

976 parse_common_info:

977 if (v->field_mode)

978 v->cur_field_type = !(v->tff ^ v->second_field);

979 pqindex = get_bits(gb, 5);

980 if (!pqindex)

981 return -1;

982 v->pqindex = pqindex;

983 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)

984 v->pq = ff_vc1_pquant_table[0][pqindex];

985 else

986 v->pq = ff_vc1_pquant_table[1][pqindex];

987

988 v->pquantizer = 1;

989 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)

990 v->pquantizer = pqindex < 9;

991 if (v->quantizer_mode == QUANT_NON_UNIFORM)

992 v->pquantizer = 0;

993 v->pqindex = pqindex;

994 if (pqindex < 9)

995 v->halfpq = get_bits1(gb);

996 else

997 v->halfpq = 0;

998 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)

999 v->pquantizer = get_bits1(gb);

1000 if (v->postprocflag)

1001 v->postproc = get_bits(gb, 2);

1002

1003 if (v->parse_only)

1004 return 0;

1005

1006 if (v->first_pic_header_flag)

1007 rotate_luts(v);

1008

1009 switch (v->s.pict_type) {

1010 case AV_PICTURE_TYPE_I:

1011 case AV_PICTURE_TYPE_BI:

1012 if (v->fcm == ILACE_FRAME) { //interlace frame picture

1013 status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);

1014 if (status < 0)

1015 return -1;

1016 av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "

1017 "Imode: %i, Invert: %i\n", status>>1, status&1);

1018 }

1019 status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);

1020 if (status < 0)

1021 return -1;

1022 av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "

1023 "Imode: %i, Invert: %i\n", status>>1, status&1);

1024 v->condover = CONDOVER_NONE;

1025 if (v->overlap && v->pq <= 8) {

1026 v->condover = decode012(gb);

1027 if (v->condover == CONDOVER_SELECT) {

1028 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);

1029 if (status < 0)

1030 return -1;

1031 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "

1032 "Imode: %i, Invert: %i\n", status>>1, status&1);

1033 }

1034 }

1035 break;

1036 case AV_PICTURE_TYPE_P:

1037 if (v->field_mode) {

1038 v->numref = get_bits1(gb);

1039 if (!v->numref) {

1040 v->reffield = get_bits1(gb);

1041 v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;

1042 }

1043 }

1044 if (v->extended_mv)

1045 v->mvrange = get_unary(gb, 0, 3);

1046 else

1047 v->mvrange = 0;

1048 if (v->interlace) {

1049 if (v->extended_dmv)

1050 v->dmvrange = get_unary(gb, 0, 3);

1051 else

1052 v->dmvrange = 0;

1053 if (v->fcm == ILACE_FRAME) { // interlaced frame picture

1054 v->fourmvswitch = get_bits1(gb);

1055 v->intcomp = get_bits1(gb);

1056 if (v->intcomp) {

1057 v->lumscale = get_bits(gb, 6);

1058 v->lumshift = get_bits(gb, 6);

1059 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);

1060 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);

1061 v->last_use_ic = 1;

1062 }

1063 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);

1064 av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "

1065 "Imode: %i, Invert: %i\n", status>>1, status&1);

1066 mbmodetab = get_bits(gb, 2);

1067 if (v->fourmvswitch)

1068 v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];

1069 else

1070 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];

1071 imvtab = get_bits(gb, 2);

1072 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];

1073 // interlaced p-picture cbpcy range is [1, 63]

1074 icbptab = get_bits(gb, 3);

1075 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];

1076 twomvbptab = get_bits(gb, 2);

1077 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];

1078 if (v->fourmvswitch) {

1079 fourmvbptab = get_bits(gb, 2);

1080 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];

1081 }

1082 }

1083 }

1084 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13

1085 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11

1086 v->range_x = 1 << (v->k_x - 1);

1087 v->range_y = 1 << (v->k_y - 1);

1088

1089 if (v->pq < 5)

1090 v->tt_index = 0;

1091 else if (v->pq < 13)

1092 v->tt_index = 1;

1093 else

1094 v->tt_index = 2;

1095 if (v->fcm != ILACE_FRAME) {

1096 int mvmode;

1097 mvmode = get_unary(gb, 1, 4);

1098 lowquant = (v->pq > 12) ? 0 : 1;

1099 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];

1100 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {

1101 int mvmode2;

1102 mvmode2 = get_unary(gb, 1, 3);

1103 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];

1104 if (v->field_mode) {

1105 v->intcompfield = decode210(gb) ^ 3;

1106 } else

1107 v->intcompfield = 3;

1108

1109 v->lumscale2 = v->lumscale = 32;

1110 v->lumshift2 = v->lumshift = 0;

1111 if (v->intcompfield & 1) {

1112 v->lumscale = get_bits(gb, 6);

1113 v->lumshift = get_bits(gb, 6);

1114 }

1115 if ((v->intcompfield & 2) && v->field_mode) {

1116 v->lumscale2 = get_bits(gb, 6);

1117 v->lumshift2 = get_bits(gb, 6);

1118 } else if(!v->field_mode) {

1119 v->lumscale2 = v->lumscale;

1120 v->lumshift2 = v->lumshift;

1121 }

1122 if (v->field_mode && v->second_field) {

1123 if (v->cur_field_type) {

1124 INIT_LUT(v->lumscale , v->lumshift , v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);

1125 INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[v->cur_field_type ], v->last_lutuv[v->cur_field_type ], 1);

1126 } else {

1127 INIT_LUT(v->lumscale2, v->lumshift2, v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);

1128 INIT_LUT(v->lumscale , v->lumshift , v->last_luty[v->cur_field_type ], v->last_lutuv[v->cur_field_type ], 1);

1129 }

1130 v->next_use_ic = *v->curr_use_ic = 1;

1131 } else {

1132 INIT_LUT(v->lumscale , v->lumshift , v->last_luty[0], v->last_lutuv[0], 1);

1133 INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[1], v->last_lutuv[1], 1);

1134 }

1135 v->last_use_ic = 1;

1136 }

1137 v->qs_last = v->s.quarter_sample;

1138 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)

1139 v->s.quarter_sample = 0;

1140 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {

1141 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)

1142 v->s.quarter_sample = 0;

1143 else

1144 v->s.quarter_sample = 1;

1145 } else

1146 v->s.quarter_sample = 1;

1147 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN

1148 || (v->mv_mode == MV_PMODE_INTENSITY_COMP

1149 && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));

1150 }

1151 if (v->fcm == PROGRESSIVE) { // progressive

1152 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&

1153 v->mv_mode2 == MV_PMODE_MIXED_MV)

1154 || v->mv_mode == MV_PMODE_MIXED_MV) {

1155 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);

1156 if (status < 0)

1157 return -1;

1158 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "

1159 "Imode: %i, Invert: %i\n", status>>1, status&1);

1160 } else {

1161 v->mv_type_is_raw = 0;

1162 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);

1163 }

1164 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);

1165 if (status < 0)

1166 return -1;

1167 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "

1168 "Imode: %i, Invert: %i\n", status>>1, status&1);

1169

1170 /* Hopefully this is correct for P frames */

1171 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables

1172 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];

1173 } else if (v->fcm == ILACE_FRAME) { // frame interlaced

1174 v->qs_last = v->s.quarter_sample;

1175 v->s.quarter_sample = 1;

1176 v->s.mspel = 1;

1177 } else { // field interlaced

1178 mbmodetab = get_bits(gb, 3);

1179 imvtab = get_bits(gb, 2 + v->numref);

1180 if (!v->numref)

1181 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];

1182 else

1183 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];

1184 icbptab = get_bits(gb, 3);

1185 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];

1186 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&

1187 v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) {

1188 fourmvbptab = get_bits(gb, 2);

1189 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];

1190 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];

1191 } else {

1192 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];

1193 }

1194 }

1195 if (v->dquant) {

1196 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");

1197 vop_dquant_decoding(v);

1198 }

1199

1200 v->ttfrm = 0; //FIXME Is that so ?

1201 if (v->vstransform) {

1202 v->ttmbf = get_bits1(gb);

1203 if (v->ttmbf) {

1204 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];

1205 }

1206 } else {

1207 v->ttmbf = 1;

1208 v->ttfrm = TT_8X8;

1209 }

1210 break;

1211 case AV_PICTURE_TYPE_B:

1212 if (v->fcm == ILACE_FRAME) {

1213 if (read_bfraction(v, gb) < 0)

1214 return AVERROR_INVALIDDATA;

1215 if (v->bfraction == 0) {

1216 return -1;

1217 }

1218 }

1219 if (v->extended_mv)

1220 v->mvrange = get_unary(gb, 0, 3);

1221 else

1222 v->mvrange = 0;

1223 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13

1224 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11

1225 v->range_x = 1 << (v->k_x - 1);

1226 v->range_y = 1 << (v->k_y - 1);

1227

1228 if (v->pq < 5)

1229 v->tt_index = 0;

1230 else if (v->pq < 13)

1231 v->tt_index = 1;

1232 else

1233 v->tt_index = 2;

1234

1235 if (v->field_mode) {

1236 int mvmode;

1237 av_log(v->s.avctx, AV_LOG_DEBUG, "B Fields\n");

1238 if (v->extended_dmv)

1239 v->dmvrange = get_unary(gb, 0, 3);

1240 mvmode = get_unary(gb, 1, 3);

1241 lowquant = (v->pq > 12) ? 0 : 1;

1242 v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode];

1243 v->qs_last = v->s.quarter_sample;

1244 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV);

1245 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || v->mv_mode == MV_PMODE_1MV_HPEL);

1246 status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);

1247 if (status < 0)

1248 return -1;

1249 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "

1250 "Imode: %i, Invert: %i\n", status>>1, status&1);

1251 mbmodetab = get_bits(gb, 3);

1252 if (v->mv_mode == MV_PMODE_MIXED_MV)

1253 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];

1254 else

1255 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];

1256 imvtab = get_bits(gb, 3);

1257 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];

1258 icbptab = get_bits(gb, 3);

1259 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];

1260 if (v->mv_mode == MV_PMODE_MIXED_MV) {

1261 fourmvbptab = get_bits(gb, 2);

1262 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];

1263 }

1264 v->numref = 1; // interlaced field B pictures are always 2-ref

1265 } else if (v->fcm == ILACE_FRAME) {

1266 if (v->extended_dmv)

1267 v->dmvrange = get_unary(gb, 0, 3);

1268 if (get_bits1(gb)) /* intcomp - present but shall always be 0 */

1269 av_log(v->s.avctx, AV_LOG_WARNING, "Intensity compensation set for B picture\n");

1270 v->intcomp = 0;

1271 v->mv_mode = MV_PMODE_1MV;

1272 v->fourmvswitch = 0;

1273 v->qs_last = v->s.quarter_sample;

1274 v->s.quarter_sample = 1;

1275 v->s.mspel = 1;

1276 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);

1277 if (status < 0)

1278 return -1;

1279 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "

1280 "Imode: %i, Invert: %i\n", status>>1, status&1);

1281 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);

1282 if (status < 0)

1283 return -1;

1284 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "

1285 "Imode: %i, Invert: %i\n", status>>1, status&1);

1286 mbmodetab = get_bits(gb, 2);

1287 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];

1288 imvtab = get_bits(gb, 2);

1289 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];

1290 // interlaced p/b-picture cbpcy range is [1, 63]

1291 icbptab = get_bits(gb, 3);

1292 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];

1293 twomvbptab = get_bits(gb, 2);

1294 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];

1295 fourmvbptab = get_bits(gb, 2);

1296 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];

1297 } else {

1298 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;

1299 v->qs_last = v->s.quarter_sample;

1300 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);

1301 v->s.mspel = v->s.quarter_sample;

1302 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);

1303 if (status < 0)

1304 return -1;

1305 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "

1306 "Imode: %i, Invert: %i\n", status>>1, status&1);

1307 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);

1308 if (status < 0)

1309 return -1;

1310 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "

1311 "Imode: %i, Invert: %i\n", status>>1, status&1);

1312 v->s.mv_table_index = get_bits(gb, 2);

1313 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];

1314 }

1315

1316 if (v->dquant) {

1317 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");

1318 vop_dquant_decoding(v);

1319 }

1320

1321 v->ttfrm = 0;

1322 if (v->vstransform) {

1323 v->ttmbf = get_bits1(gb);

1324 if (v->ttmbf) {

1325 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];

1326 }

1327 } else {

1328 v->ttmbf = 1;

1329 v->ttfrm = TT_8X8;

1330 }

1331 break;

1332 }

1333

1334 if (v->fcm != PROGRESSIVE && !v->s.quarter_sample) {

1335 v->range_x <<= 1;

1336 v->range_y <<= 1;

1337 }

1338

1339 /* AC Syntax */

1340 v->c_ac_table_index = decode012(gb);

1341 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {

1342 v->y_ac_table_index = decode012(gb);

1343 }

1344 /* DC Syntax */

1345 v->s.dc_table_index = get_bits1(gb);

1346 if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)

1347 && v->dquant) {

1348 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");

1349 vop_dquant_decoding(v);

1350 }

1351

1352 v->bi_type = 0;

1353 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {

1354 v->s.pict_type = AV_PICTURE_TYPE_B;

1355 v->bi_type = 1;

1356 }

1357 return 0;

1358 }

1359

1360 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {

1361 {

1362 { 0x0001, 2}, { 0x0005, 3}, { 0x000D, 4}, { 0x0012, 5}, { 0x000E, 6}, { 0x0015, 7},

1363 { 0x0013, 8}, { 0x003F, 8}, { 0x004B, 9}, { 0x011F, 9}, { 0x00B8, 10}, { 0x03E3, 10},

1364 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},

1365 { 0x3EAE, 14}, { 0x0000, 4}, { 0x0010, 5}, { 0x0008, 7}, { 0x0020, 8}, { 0x0029, 9},

1366 { 0x01F4, 9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},

1367 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003, 5}, { 0x0011, 7},

1368 { 0x00C4, 8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},

1369 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013, 5}, { 0x0078, 7},

1370 { 0x0069, 9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},

1371 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C, 6}, { 0x0024, 9}, { 0x0094, 11},

1372 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D, 6}, { 0x0053, 9}, { 0x01A0, 11},

1373 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013, 7}, { 0x007C, 9}, { 0x07C1, 11}, { 0x04AC, 14},

1374 { 0x001B, 7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079, 7}, { 0x03E1, 10},

1375 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021, 8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},

1376 { 0x0035, 8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5, 8}, { 0x0174, 11}, { 0x0785, 13},

1377 { 0x0048, 9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C, 9}, { 0x00FA, 10}, { 0x07D6, 11},

1378 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},

1379 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},

1380 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},

1381 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E, 4},

1382 { 0x0045, 7}, { 0x01F3, 9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019, 5},

1383 { 0x0028, 9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030, 6}, { 0x00A2, 10},

1384 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F, 6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},

1385 { 0x0044, 7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063, 7}, { 0x03C3, 12}, { 0x0015, 8},

1386 { 0x08F6, 12}, { 0x0017, 8}, { 0x0498, 13}, { 0x002C, 8}, { 0x07B2, 13}, { 0x002F, 8},

1387 { 0x1F54, 13}, { 0x008D, 8}, { 0x07BD, 13}, { 0x008E, 8}, { 0x1182, 13}, { 0x00FB, 8},

1388 { 0x050B, 13}, { 0x002D, 8}, { 0x07C0, 11}, { 0x0079, 9}, { 0x1F5F, 13}, { 0x007A, 9},

1389 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},

1390 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},

1391 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},

1392 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A, 9}

1393 },

1394 {

1395 { 0x0000, 3}, { 0x0003, 4}, { 0x000B, 5}, { 0x0014, 6}, { 0x003F, 6}, { 0x005D, 7},

1396 { 0x00A2, 8}, { 0x00AC, 9}, { 0x016E, 9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},

1397 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},

1398 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004, 4},

1399 { 0x001E, 5}, { 0x0042, 7}, { 0x00B6, 8}, { 0x0173, 9}, { 0x0395, 10}, { 0x072E, 11},

1400 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005, 5}, { 0x0040, 7},

1401 { 0x0049, 9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},

1402 { 0x0018, 5}, { 0x0025, 8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},

1403 { 0x139C, 15}, { 0x0029, 6}, { 0x004F, 9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},

1404 { 0x0038, 6}, { 0x010E, 9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058, 7},

1405 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023, 8}, { 0x02E3, 10}, { 0x04E5, 13},

1406 { 0x2E40, 14}, { 0x00A1, 8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083, 8}, { 0x013A, 11},

1407 { 0x1721, 13}, { 0x0044, 9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},

1408 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},

1409 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},

1410 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},

1411 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003, 3}, { 0x002A, 6}, { 0x00E4, 8},

1412 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},

1413 { 0x0009, 4}, { 0x0054, 8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D, 4},

1414 { 0x00AD, 9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011, 5}, { 0x016B, 9}, { 0x0B7F, 12},

1415 { 0x51A4, 15}, { 0x0019, 5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D, 5}, { 0x0394, 10},

1416 { 0x28D3, 14}, { 0x002B, 6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F, 6}, { 0x0247, 12},

1417 { 0x0010, 7}, { 0x0A35, 12}, { 0x003E, 6}, { 0x0B7A, 12}, { 0x0059, 7}, { 0x105E, 13},

1418 { 0x0026, 8}, { 0x09CF, 14}, { 0x0055, 8}, { 0x1CB5, 13}, { 0x0057, 8}, { 0x0E5B, 12},

1419 { 0x00A0, 8}, { 0x1468, 13}, { 0x0170, 9}, { 0x0090, 10}, { 0x01CE, 9}, { 0x021A, 10},

1420 { 0x0218, 10}, { 0x0168, 9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},

1421 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},

1422 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},

1423 { 0x0169, 9}

1424 },

1425 {

1426 { 0x0001, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x0016, 5}, { 0x0020, 6}, { 0x0018, 7},

1427 { 0x0008, 8}, { 0x009A, 8}, { 0x0056, 9}, { 0x013E, 9}, { 0x00F0, 10}, { 0x03A5, 10},

1428 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001, 4}, { 0x0011, 5},

1429 { 0x0002, 7}, { 0x000B, 8}, { 0x0012, 9}, { 0x01D6, 9}, { 0x027E, 10}, { 0x0191, 11},

1430 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004, 5}, { 0x0014, 7}, { 0x009E, 8},

1431 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017, 5},

1432 { 0x004E, 7}, { 0x005E, 9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},

1433 { 0x000E, 6}, { 0x00E1, 8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B, 6},

1434 { 0x001C, 9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006, 7}, { 0x007A, 9}, { 0x0190, 11},

1435 { 0x0137, 13}, { 0x001B, 7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071, 7}, { 0x00D7, 10},

1436 { 0x09BF, 12}, { 0x0007, 8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034, 8}, { 0x0265, 10},

1437 { 0x009F, 12}, { 0x00E0, 8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015, 9}, { 0x017D, 11},

1438 { 0x0EBB, 12}, { 0x0014, 9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},

1439 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},

1440 { 0x013A, 13}, { 0x000A, 4}, { 0x0042, 7}, { 0x01D3, 9}, { 0x04DD, 11}, { 0x0012, 5},

1441 { 0x00E8, 8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039, 6}, { 0x0264, 10}, { 0x0EBA, 12},

1442 { 0x0000, 7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F, 7}, { 0x04DE, 11}, { 0x0043, 7},

1443 { 0x04DC, 11}, { 0x0003, 8}, { 0x03CB, 12}, { 0x0006, 8}, { 0x099E, 12}, { 0x002A, 8},

1444 { 0x05F1, 13}, { 0x000F, 8}, { 0x09FE, 12}, { 0x0033, 8}, { 0x09FF, 12}, { 0x0098, 8},

1445 { 0x099F, 12}, { 0x00EA, 8}, { 0x013C, 13}, { 0x002E, 8}, { 0x0192, 11}, { 0x0136, 9},

1446 { 0x006A, 9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},

1447 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},

1448 { 0x0016, 7}

1449 },

1450 {

1451 { 0x0004, 3}, { 0x0014, 5}, { 0x0017, 7}, { 0x007F, 8}, { 0x0154, 9}, { 0x01F2, 10},

1452 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},

1453 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B, 4}, { 0x0037, 7}, { 0x0062, 9}, { 0x0007, 11},

1454 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007, 5},

1455 { 0x006D, 8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002, 6}, { 0x0061, 9},

1456 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A, 6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},

1457 { 0x001E, 6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006, 7}, { 0x0004, 11},

1458 { 0x02F8, 13}, { 0x0019, 7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057, 7}, { 0x0182, 11},

1459 { 0x2AA2, 14}, { 0x0004, 8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D, 8}, { 0x0164, 12},

1460 { 0x076D, 15}, { 0x0002, 9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD, 8}, { 0x0060, 12},

1461 { 0x0C67, 14}, { 0x001C, 9}, { 0x00EE, 13}, { 0x0003, 9}, { 0x02CF, 13}, { 0x00D9, 9},

1462 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},

1463 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},

1464 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003, 2}, { 0x0054, 7}, { 0x02AB, 10},

1465 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005, 4}, { 0x00F8, 9}, { 0x0AA9, 12}, { 0x005F, 15},

1466 { 0x0004, 4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004, 5}, { 0x0077, 11}, { 0x076C, 15},

1467 { 0x000E, 5}, { 0x000A, 12}, { 0x000C, 5}, { 0x0562, 11}, { 0x0004, 6}, { 0x031C, 12},

1468 { 0x0006, 6}, { 0x00C8, 13}, { 0x000D, 6}, { 0x01DA, 13}, { 0x0007, 6}, { 0x00C9, 13},

1469 { 0x0001, 7}, { 0x002E, 14}, { 0x0014, 7}, { 0x1596, 13}, { 0x000A, 7}, { 0x0AC2, 12},

1470 { 0x0016, 7}, { 0x015B, 14}, { 0x0015, 7}, { 0x015A, 14}, { 0x000F, 8}, { 0x005E, 15},

1471 { 0x007E, 8}, { 0x00AB, 8}, { 0x002D, 9}, { 0x00D8, 9}, { 0x000B, 9}, { 0x0014, 10},

1472 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E, 9},

1473 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},

1474 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},

1475 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D, 9}

1476 },

1477 {

1478 { 0x0002, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x000D, 5}, { 0x000C, 5}, { 0x0015, 6},

1479 { 0x0013, 6}, { 0x0012, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x001E, 8}, { 0x001D, 8},

1480 { 0x0025, 9}, { 0x0024, 9}, { 0x0023, 9}, { 0x0021, 9}, { 0x0021, 10}, { 0x0020, 10},

1481 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},

1482 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E, 4}, { 0x0014, 6}, { 0x0016, 7},

1483 { 0x001C, 8}, { 0x0020, 9}, { 0x001F, 9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},

1484 { 0x0055, 12}, { 0x000B, 5}, { 0x0015, 7}, { 0x001E, 9}, { 0x000C, 10}, { 0x0056, 12},

1485 { 0x0011, 6}, { 0x001B, 8}, { 0x001D, 9}, { 0x000B, 10}, { 0x0010, 6}, { 0x0022, 9},

1486 { 0x000A, 10}, { 0x000D, 6}, { 0x001C, 9}, { 0x0008, 10}, { 0x0012, 7}, { 0x001B, 9},

1487 { 0x0054, 12}, { 0x0014, 7}, { 0x001A, 9}, { 0x0057, 12}, { 0x0019, 8}, { 0x0009, 10},

1488 { 0x0018, 8}, { 0x0023, 11}, { 0x0017, 8}, { 0x0019, 9}, { 0x0018, 9}, { 0x0007, 10},

1489 { 0x0058, 12}, { 0x0007, 4}, { 0x000C, 6}, { 0x0016, 8}, { 0x0017, 9}, { 0x0006, 10},

1490 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F, 6}, { 0x0016, 9}, { 0x0005, 10},

1491 { 0x000E, 6}, { 0x0004, 10}, { 0x0011, 7}, { 0x0024, 11}, { 0x0010, 7}, { 0x0025, 11},

1492 { 0x0013, 7}, { 0x005A, 12}, { 0x0015, 8}, { 0x005B, 12}, { 0x0014, 8}, { 0x0013, 8},

1493 { 0x001A, 8}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9}, { 0x0012, 9}, { 0x0011, 9},

1494 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},

1495 { 0x0003, 7}

1496 },

1497 {

1498 { 0x0002, 2}, { 0x000F, 4}, { 0x0015, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x0025, 9},

1499 { 0x0024, 9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},

1500 { 0x0006, 3}, { 0x0014, 6}, { 0x001E, 8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},

1501 { 0x000E, 4}, { 0x001D, 8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D, 5}, { 0x0023, 9},

1502 { 0x000D, 10}, { 0x000C, 5}, { 0x0022, 9}, { 0x0052, 12}, { 0x000B, 5}, { 0x000C, 10},

1503 { 0x0053, 12}, { 0x0013, 6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012, 6}, { 0x000A, 10},

1504 { 0x0011, 6}, { 0x0009, 10}, { 0x0010, 6}, { 0x0008, 10}, { 0x0016, 7}, { 0x0055, 12},

1505 { 0x0015, 7}, { 0x0014, 7}, { 0x001C, 8}, { 0x001B, 8}, { 0x0021, 9}, { 0x0020, 9},

1506 { 0x001F, 9}, { 0x001E, 9}, { 0x001D, 9}, { 0x001C, 9}, { 0x001B, 9}, { 0x001A, 9},

1507 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007, 4}, { 0x0019, 9},

1508 { 0x0005, 11}, { 0x000F, 6}, { 0x0004, 11}, { 0x000E, 6}, { 0x000D, 6}, { 0x000C, 6},

1509 { 0x0013, 7}, { 0x0012, 7}, { 0x0011, 7}, { 0x0010, 7}, { 0x001A, 8}, { 0x0019, 8},

1510 { 0x0018, 8}, { 0x0017, 8}, { 0x0016, 8}, { 0x0015, 8}, { 0x0014, 8}, { 0x0013, 8},

1511 { 0x0018, 9}, { 0x0017, 9}, { 0x0016, 9}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9},

1512 { 0x0012, 9}, { 0x0011, 9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},

1513 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},

1514 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},

1515 { 0x0003, 7}

1516 },

1517 {

1518 { 0x0000, 2}, { 0x0003, 3}, { 0x000D, 4}, { 0x0005, 4}, { 0x001C, 5}, { 0x0016, 5},

1519 { 0x003F, 6}, { 0x003A, 6}, { 0x002E, 6}, { 0x0022, 6}, { 0x007B, 7}, { 0x0067, 7},

1520 { 0x005F, 7}, { 0x0047, 7}, { 0x0026, 7}, { 0x00EF, 8}, { 0x00CD, 8}, { 0x00C1, 8},

1521 { 0x00A9, 8}, { 0x004F, 8}, { 0x01F2, 9}, { 0x01DD, 9}, { 0x0199, 9}, { 0x0185, 9},

1522 { 0x015D, 9}, { 0x011B, 9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},

1523 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},

1524 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},

1525 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},

1526 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},

1527 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009, 4}, { 0x0010, 5}, { 0x0029, 6}, { 0x0062, 7},

1528 { 0x00F3, 8}, { 0x00AD, 8}, { 0x01E5, 9}, { 0x0179, 9}, { 0x009C, 9}, { 0x03B1, 10},

1529 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},

1530 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008, 5}, { 0x0063, 7},

1531 { 0x00AF, 8}, { 0x017B, 9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},

1532 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028, 6}, { 0x00C3, 8}, { 0x0151, 9}, { 0x02A1, 10},

1533 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065, 7}, { 0x01DA, 9}, { 0x02AF, 10},

1534 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025, 7}, { 0x0118, 9}, { 0x0646, 11},

1535 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9, 8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},

1536 { 0x0048, 8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180, 9}, { 0x0465, 11}, { 0x1905, 13},

1537 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},

1538 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},

1539 { 0x0078, 7}, { 0x0155, 9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA, 8}, { 0x07DC, 11},

1540 { 0x1907, 13}, { 0x00AC, 8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6, 9}, { 0x0AE2, 12},

1541 { 0x01DC, 9}, { 0x04ED, 12}, { 0x0184, 9}, { 0x1904, 13}, { 0x0156, 9}, { 0x09D9, 13},

1542 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},

1543 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},

1544 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},

1545 { 0x007A, 7}

1546 },

1547 {

1548 { 0x0002, 2}, { 0x0000, 3}, { 0x001E, 5}, { 0x0004, 5}, { 0x0012, 6}, { 0x0070, 7},

1549 { 0x001A, 7}, { 0x005F, 8}, { 0x0047, 8}, { 0x01D3, 9}, { 0x00B5, 9}, { 0x0057, 9},

1550 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},

1551 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},

1552 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},

1553 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003, 3}, { 0x000A, 5}, { 0x0077, 7}, { 0x00E5, 8},

1554 { 0x01D9, 9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},

1555 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C, 4}, { 0x007D, 7}, { 0x0044, 8},

1556 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B, 5},

1557 { 0x00E2, 8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007, 5},

1558 { 0x01D8, 9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035, 6}, { 0x03E1, 10},

1559 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C, 6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},

1560 { 0x0068, 7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020, 7}, { 0x0F90, 12}, { 0x7CF6, 15},

1561 { 0x00E8, 8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045, 8}, { 0x0B3A, 13}, { 0x01F1, 9},

1562 { 0x3B46, 14}, { 0x01A7, 9}, { 0x1676, 14}, { 0x0056, 9}, { 0x692A, 15}, { 0x038D, 10},

1563 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},

1564 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},

1565 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},

1566 { 0x055F, 13}, { 0x003F, 6}, { 0x006D, 9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013, 6},

1567 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B, 6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075, 7},

1568 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E, 7}, { 0x1F22, 13}, { 0x0021, 7}, { 0x054F, 13},

1569 { 0x0014, 7}, { 0x3A44, 14}, { 0x00E4, 8}, { 0x7CF7, 15}, { 0x005E, 8}, { 0x7185, 15},

1570 { 0x0037, 8}, { 0x2C73, 15}, { 0x01DB, 9}, { 0x59DD, 16}, { 0x01C7, 9}, { 0x692B, 15},

1571 { 0x01A6, 9}, { 0x58E5, 16}, { 0x00B4, 9}, { 0x1F3D0, 17}, { 0x00B0, 9}, { 0xB1C9, 17},

1572 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},

1573 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},

1574 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},

1575 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},

1576 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},

1577 { 0x0073, 7}

1578 }

1579 };

1580

1581 static const uint16_t vlc_offs[] = {

1582 0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,

1583 2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8342,

1584 9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,

1585 20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,

1586 27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,

1587 29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,

1588 31714, 31746, 31778, 32306, 32340, 32372

1589 };

1590

1591 /**

1592 * Init VC-1 specific tables and VC1Context members

1593 * @param v The VC1Context to initialize

1594 * @return Status

1595 */

1596 av_cold int ff_vc1_init_common(VC1Context *v)

1597 {

1598 static int done = 0;

1599 int i = 0;

1600 static VLC_TYPE vlc_table[32372][2];

1601

1602 v->hrd_rate = v->hrd_buffer = NULL;

1603

1604 /* VLC tables */

1605 if (!done) {

1606 INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,

1607 ff_vc1_bfraction_bits, 1, 1,

1608 ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);

1609 INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,

1610 ff_vc1_norm2_bits, 1, 1,

1611 ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);

1612 INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,

1613 ff_vc1_norm6_bits, 1, 1,

1614 ff_vc1_norm6_codes, 2, 2, 556);

1615 INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,

1616 ff_vc1_imode_bits, 1, 1,

1617 ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);

1618 for (i = 0; i < 3; i++) {

1619 ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]];

1620 ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];

1621 init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,

1622 ff_vc1_ttmb_bits[i], 1, 1,

1623 ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);

1624 ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]];

1625 ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];

1626 init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,

1627 ff_vc1_ttblk_bits[i], 1, 1,

1628 ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);

1629 ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]];

1630 ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];

1631 init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,

1632 ff_vc1_subblkpat_bits[i], 1, 1,

1633 ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);

1634 }

1635 for (i = 0; i < 4; i++) {

1636 ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]];

1637 ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];

1638 init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,

1639 ff_vc1_4mv_block_pattern_bits[i], 1, 1,

1640 ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);

1641 ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]];

1642 ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];

1643 init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,

1644 ff_vc1_cbpcy_p_bits[i], 1, 1,

1645 ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);

1646 ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]];

1647 ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];

1648 init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,

1649 ff_vc1_mv_diff_bits[i], 1, 1,

1650 ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);

1651 }

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

1653 ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]];

1654 ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];

1655 init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i],

1656 &vc1_ac_tables[i][0][1], 8, 4,

1657 &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);

1658 /* initialize interlaced MVDATA tables (2-Ref) */

1659 ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]];

1660 ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];

1661 init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,

1662 ff_vc1_2ref_mvdata_bits[i], 1, 1,

1663 ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);

1664 }

1665 for (i = 0; i < 4; i++) {

1666 /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */

1667 ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]];

1668 ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];

1669 init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,

1670 ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,

1671 ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);

1672 /* initialize NON-4MV MBMODE VLC tables for the same */

1673 ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]];

1674 ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];

1675 init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,

1676 ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,

1677 ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);

1678 /* initialize interlaced MVDATA tables (1-Ref) */

1679 ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]];

1680 ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];

1681 init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,

1682 ff_vc1_1ref_mvdata_bits[i], 1, 1,

1683 ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);

1684 }

1685 for (i = 0; i < 4; i++) {

1686 /* Initialize 2MV Block pattern VLC tables */

1687 ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]];

1688 ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];

1689 init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,

1690 ff_vc1_2mv_block_pattern_bits[i], 1, 1,

1691 ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);

1692 }

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

1694 /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */

1695 ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]];

1696 ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];

1697 init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,

1698 ff_vc1_icbpcy_p_bits[i], 1, 1,

1699 ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);

1700 /* Initialize interlaced field picture MBMODE VLC tables */

1701 ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]];

1702 ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];

1703 init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,

1704 ff_vc1_if_mmv_mbmode_bits[i], 1, 1,

1705 ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);

1706 ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]];

1707 ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];

1708 init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,

1709 ff_vc1_if_1mv_mbmode_bits[i], 1, 1,

1710 ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);

1711 }

1712 done = 1;

1713 }

1714

1715 /* Other defaults */

1716 v->pq = -1;

1717 v->mvrange = 0; /* 7.1.1.18, p80 */

1718

1719 ff_vc1dsp_init(&v->vc1dsp);

1720

1721 return 0;

1722 }

Generated on Sun Jul 20 2014 23:05:56 for FFmpeg by doxygen 1.8.2