FFmpeg: libavcodec/vp3.c Source File

FFmpeg

[フレーム]

libavcodec

vp3.c

Go to the documentation of this file.

1 /*

3 *

4 * This file is part of FFmpeg.

5 *

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

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

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

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

10 *

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

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

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

14 * Lesser General Public License for more details.

15 *

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

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

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

19 */

21 /**

22 * @file

23 * On2 VP3 Video Decoder

24 *

25 * VP3 Video Decoder by Mike Melanson (mike at multimedia.cx)

26 * For more information about the VP3 coding process, visit:

27 * http://wiki.multimedia.cx/index.php?title=On2_VP3

28 *

29 * Theora decoder by Alex Beregszaszi

30 */

32 #include <stdio.h>

33 #include <stdlib.h>

34 #include <string.h>

36 #include "libavutil/imgutils.h"

38 #include "avcodec.h"

39 #include "get_bits.h"

40 #include "hpeldsp.h"

41 #include "internal.h"

42 #include "mathops.h"

43 #include "thread.h"

44 #include "videodsp.h"

45 #include "vp3data.h"

46 #include "vp3dsp.h"

47 #include "xiph.h"

49 #define FRAGMENT_PIXELS 8

51 // FIXME split things out into their own arrays

52 typedef struct Vp3Fragment {

53 int16_t dc;

54 uint8_t coding_method;

55 uint8_t qpi;

56 } Vp3Fragment;

58 #define SB_NOT_CODED 0

59 #define SB_PARTIALLY_CODED 1

60 #define SB_FULLY_CODED 2

62 // This is the maximum length of a single long bit run that can be encoded

63 // for superblock coding or block qps. Theora special-cases this to read a

64 // bit instead of flipping the current bit to allow for runs longer than 4129.

65 #define MAXIMUM_LONG_BIT_RUN 4129

67 #define MODE_INTER_NO_MV 0

68 #define MODE_INTRA 1

69 #define MODE_INTER_PLUS_MV 2

70 #define MODE_INTER_LAST_MV 3

71 #define MODE_INTER_PRIOR_LAST 4

72 #define MODE_USING_GOLDEN 5

73 #define MODE_GOLDEN_MV 6

74 #define MODE_INTER_FOURMV 7

75 #define CODING_MODE_COUNT 8

77 /* special internal mode */

78 #define MODE_COPY 8

80 static int theora_decode_header(AVCodecContext *avctx, GetBitContext *gb);

81 static int theora_decode_tables(AVCodecContext *avctx, GetBitContext *gb);

84 /* There are 6 preset schemes, plus a free-form scheme */

85 static const int ModeAlphabet[6][CODING_MODE_COUNT] = {

86 /* scheme 1: Last motion vector dominates */

87 { MODE_INTER_LAST_MV, MODE_INTER_PRIOR_LAST,

88 MODE_INTER_PLUS_MV, MODE_INTER_NO_MV,

89 MODE_INTRA, MODE_USING_GOLDEN,

90 MODE_GOLDEN_MV, MODE_INTER_FOURMV },

92 /* scheme 2 */

93 { MODE_INTER_LAST_MV, MODE_INTER_PRIOR_LAST,

94 MODE_INTER_NO_MV, MODE_INTER_PLUS_MV,

95 MODE_INTRA, MODE_USING_GOLDEN,

96 MODE_GOLDEN_MV, MODE_INTER_FOURMV },

98 /* scheme 3 */

99 { MODE_INTER_LAST_MV, MODE_INTER_PLUS_MV,

100 MODE_INTER_PRIOR_LAST, MODE_INTER_NO_MV,

101 MODE_INTRA, MODE_USING_GOLDEN,

102 MODE_GOLDEN_MV, MODE_INTER_FOURMV },

103

104 /* scheme 4 */

105 { MODE_INTER_LAST_MV, MODE_INTER_PLUS_MV,

106 MODE_INTER_NO_MV, MODE_INTER_PRIOR_LAST,

107 MODE_INTRA, MODE_USING_GOLDEN,

108 MODE_GOLDEN_MV, MODE_INTER_FOURMV },

109

110 /* scheme 5: No motion vector dominates */

111 { MODE_INTER_NO_MV, MODE_INTER_LAST_MV,

112 MODE_INTER_PRIOR_LAST, MODE_INTER_PLUS_MV,

113 MODE_INTRA, MODE_USING_GOLDEN,

114 MODE_GOLDEN_MV, MODE_INTER_FOURMV },

115

116 /* scheme 6 */

117 { MODE_INTER_NO_MV, MODE_USING_GOLDEN,

118 MODE_INTER_LAST_MV, MODE_INTER_PRIOR_LAST,

119 MODE_INTER_PLUS_MV, MODE_INTRA,

120 MODE_GOLDEN_MV, MODE_INTER_FOURMV },

121 };

122

123 static const uint8_t hilbert_offset[16][2] = {

124 { 0, 0 }, { 1, 0 }, { 1, 1 }, { 0, 1 },

125 { 0, 2 }, { 0, 3 }, { 1, 3 }, { 1, 2 },

126 { 2, 2 }, { 2, 3 }, { 3, 3 }, { 3, 2 },

127 { 3, 1 }, { 2, 1 }, { 2, 0 }, { 3, 0 }

128 };

129

130 #define MIN_DEQUANT_VAL 2

131

132 typedef struct Vp3DecodeContext {

133 AVCodecContext *avctx;

134 int theora, theora_tables;

135 int version;

136 int width, height;

137 int chroma_x_shift, chroma_y_shift;

138 ThreadFrame golden_frame;

139 ThreadFrame last_frame;

140 ThreadFrame current_frame;

141 int keyframe;

142 uint8_t idct_permutation[64];

143 uint8_t idct_scantable[64];

144 HpelDSPContext hdsp;

145 VideoDSPContext vdsp;

146 VP3DSPContext vp3dsp;

147 DECLARE_ALIGNED(16, int16_t, block)[64];

148 int flipped_image;

149 int last_slice_end;

150 int skip_loop_filter;

151

152 int qps[3];

153 int nqps;

154 int last_qps[3];

155

156 int superblock_count;

157 int y_superblock_width;

158 int y_superblock_height;

159 int y_superblock_count;

160 int c_superblock_width;

161 int c_superblock_height;

162 int c_superblock_count;

163 int u_superblock_start;

164 int v_superblock_start;

165 unsigned char *superblock_coding;

166

167 int macroblock_count;

168 int macroblock_width;

169 int macroblock_height;

170

171 int fragment_count;

172 int fragment_width[2];

173 int fragment_height[2];

174

175 Vp3Fragment *all_fragments;

176 int fragment_start[3];

177 int data_offset[3];

178 uint8_t offset_x;

179 uint8_t offset_y;

180 int offset_x_warned;

181

182 int8_t (*motion_val[2])[2];

183

184 /* tables */

185 uint16_t coded_dc_scale_factor[64];

186 uint32_t coded_ac_scale_factor[64];

187 uint8_t base_matrix[384][64];

188 uint8_t qr_count[2][3];

189 uint8_t qr_size[2][3][64];

190 uint16_t qr_base[2][3][64];

191

192 /**

193 * This is a list of all tokens in bitstream order. Reordering takes place

194 * by pulling from each level during IDCT. As a consequence, IDCT must be

195 * in Hilbert order, making the minimum slice height 64 for 4:2:0 and 32

196 * otherwise. The 32 different tokens with up to 12 bits of extradata are

197 * collapsed into 3 types, packed as follows:

198 * (from the low to high bits)

199 *

200 * 2 bits: type (0,1,2)

201 * 0: EOB run, 14 bits for run length (12 needed)

202 * 1: zero run, 7 bits for run length

203 * 7 bits for the next coefficient (3 needed)

204 * 2: coefficient, 14 bits (11 needed)

205 *

206 * Coefficients are signed, so are packed in the highest bits for automatic

207 * sign extension.

208 */

209 int16_t *dct_tokens[3][64];

210 int16_t *dct_tokens_base;

211 #define TOKEN_EOB(eob_run) ((eob_run) << 2)

212 #define TOKEN_ZERO_RUN(coeff, zero_run) (((coeff) << 9) + ((zero_run) << 2) + 1)

213 #define TOKEN_COEFF(coeff) (((coeff) << 2) + 2)

214

215 /**

216 * number of blocks that contain DCT coefficients at

217 * the given level or higher

218 */

219 int num_coded_frags[3][64];

220 int total_num_coded_frags;

221

222 /* this is a list of indexes into the all_fragments array indicating

223 * which of the fragments are coded */

224 int *coded_fragment_list[3];

225

226 VLC dc_vlc[16];

227 VLC ac_vlc_1[16];

228 VLC ac_vlc_2[16];

229 VLC ac_vlc_3[16];

230 VLC ac_vlc_4[16];

231

232 VLC superblock_run_length_vlc;

233 VLC fragment_run_length_vlc;

234 VLC mode_code_vlc;

235 VLC motion_vector_vlc;

236

237 /* these arrays need to be on 16-byte boundaries since SSE2 operations

238 * index into them */

239 DECLARE_ALIGNED(16, int16_t, qmat)[3][2][3][64]; ///< qmat[qpi][is_inter][plane]

240

241 /* This table contains superblock_count * 16 entries. Each set of 16

242 * numbers corresponds to the fragment indexes 0..15 of the superblock.

243 * An entry will be -1 to indicate that no entry corresponds to that

244 * index. */

245 int *superblock_fragments;

246

247 /* This is an array that indicates how a particular macroblock

248 * is coded. */

249 unsigned char *macroblock_coding;

250

251 uint8_t *edge_emu_buffer;

252

253 /* Huffman decode */

254 int hti;

255 unsigned int hbits;

256 int entries;

257 int huff_code_size;

258 uint32_t huffman_table[80][32][2];

259

260 uint8_t filter_limit_values[64];

261 DECLARE_ALIGNED(8, int, bounding_values_array)[256 + 2];

262 } Vp3DecodeContext;

263

264 /************************************************************************

265 * VP3 specific functions

266 ************************************************************************/

267

268 static av_cold void free_tables(AVCodecContext *avctx)

269 {

270 Vp3DecodeContext *s = avctx->priv_data;

271

272 av_freep(&s->superblock_coding);

273 av_freep(&s->all_fragments);

274 av_freep(&s->coded_fragment_list[0]);

275 av_freep(&s->dct_tokens_base);

276 av_freep(&s->superblock_fragments);

277 av_freep(&s->macroblock_coding);

278 av_freep(&s->motion_val[0]);

279 av_freep(&s->motion_val[1]);

280 }

281

282 static void vp3_decode_flush(AVCodecContext *avctx)

283 {

284 Vp3DecodeContext *s = avctx->priv_data;

285

286 if (s->golden_frame.f)

287 ff_thread_release_buffer(avctx, &s->golden_frame);

288 if (s->last_frame.f)

289 ff_thread_release_buffer(avctx, &s->last_frame);

290 if (s->current_frame.f)

291 ff_thread_release_buffer(avctx, &s->current_frame);

292 }

293

294 static av_cold int vp3_decode_end(AVCodecContext *avctx)

295 {

296 Vp3DecodeContext *s = avctx->priv_data;

297 int i;

298

299 free_tables(avctx);

300 av_freep(&s->edge_emu_buffer);

301

302 s->theora_tables = 0;

303

304 /* release all frames */

305 vp3_decode_flush(avctx);

306 av_frame_free(&s->current_frame.f);

307 av_frame_free(&s->last_frame.f);

308 av_frame_free(&s->golden_frame.f);

309

310 if (avctx->internal->is_copy)

311 return 0;

312

313 for (i = 0; i < 16; i++) {

314 ff_free_vlc(&s->dc_vlc[i]);

315 ff_free_vlc(&s->ac_vlc_1[i]);

316 ff_free_vlc(&s->ac_vlc_2[i]);

317 ff_free_vlc(&s->ac_vlc_3[i]);

318 ff_free_vlc(&s->ac_vlc_4[i]);

319 }

320

321 ff_free_vlc(&s->superblock_run_length_vlc);

322 ff_free_vlc(&s->fragment_run_length_vlc);

323 ff_free_vlc(&s->mode_code_vlc);

324 ff_free_vlc(&s->motion_vector_vlc);

325

326 return 0;

327 }

328

329 /**

330 * This function sets up all of the various blocks mappings:

331 * superblocks <-> fragments, macroblocks <-> fragments,

332 * superblocks <-> macroblocks

333 *

334 * @return 0 is successful; returns 1 if *anything* went wrong.

335 */

336 static int init_block_mapping(Vp3DecodeContext *s)

337 {

338 int sb_x, sb_y, plane;

339 int x, y, i, j = 0;

340

341 for (plane = 0; plane < 3; plane++) {

342 int sb_width = plane ? s->c_superblock_width

343 : s->y_superblock_width;

344 int sb_height = plane ? s->c_superblock_height

345 : s->y_superblock_height;

346 int frag_width = s->fragment_width[!!plane];

347 int frag_height = s->fragment_height[!!plane];

348

349 for (sb_y = 0; sb_y < sb_height; sb_y++)

350 for (sb_x = 0; sb_x < sb_width; sb_x++)

351 for (i = 0; i < 16; i++) {

352 x = 4 * sb_x + hilbert_offset[i][0];

353 y = 4 * sb_y + hilbert_offset[i][1];

354

355 if (x < frag_width && y < frag_height)

356 s->superblock_fragments[j++] = s->fragment_start[plane] +

357 y * frag_width + x;

358 else

359 s->superblock_fragments[j++] = -1;

360 }

361 }

362

363 return 0; /* successful path out */

364 }

365

366 /*

367 * This function sets up the dequantization tables used for a particular

368 * frame.

369 */

370 static void init_dequantizer(Vp3DecodeContext *s, int qpi)

371 {

372 int ac_scale_factor = s->coded_ac_scale_factor[s->qps[qpi]];

373 int dc_scale_factor = s->coded_dc_scale_factor[s->qps[qpi]];

374 int i, plane, inter, qri, bmi, bmj, qistart;

375

376 for (inter = 0; inter < 2; inter++) {

377 for (plane = 0; plane < 3; plane++) {

378 int sum = 0;

379 for (qri = 0; qri < s->qr_count[inter][plane]; qri++) {

380 sum += s->qr_size[inter][plane][qri];

381 if (s->qps[qpi] <= sum)

382 break;

383 }

384 qistart = sum - s->qr_size[inter][plane][qri];

385 bmi = s->qr_base[inter][plane][qri];

386 bmj = s->qr_base[inter][plane][qri + 1];

387 for (i = 0; i < 64; i++) {

388 int coeff = (2 * (sum - s->qps[qpi]) * s->base_matrix[bmi][i] -

389 2 * (qistart - s->qps[qpi]) * s->base_matrix[bmj][i] +

390 s->qr_size[inter][plane][qri]) /

391 (2 * s->qr_size[inter][plane][qri]);

392

393 int qmin = 8 << (inter + !i);

394 int qscale = i ? ac_scale_factor : dc_scale_factor;

395

396 s->qmat[qpi][inter][plane][s->idct_permutation[i]] =

397 av_clip((qscale * coeff) / 100 * 4, qmin, 4096);

398 }

399 /* all DC coefficients use the same quant so as not to interfere

400 * with DC prediction */

401 s->qmat[qpi][inter][plane][0] = s->qmat[0][inter][plane][0];

402 }

403 }

404 }

405

406 /*

407 * This function initializes the loop filter boundary limits if the frame's

408 * quality index is different from the previous frame's.

409 *

410 * The filter_limit_values may not be larger than 127.

411 */

412 static void init_loop_filter(Vp3DecodeContext *s)

413 {

414 int *bounding_values = s->bounding_values_array + 127;

415 int filter_limit;

416 int x;

417 int value;

418

419 filter_limit = s->filter_limit_values[s->qps[0]];

420 av_assert0(filter_limit < 128U);

421

422 /* set up the bounding values */

423 memset(s->bounding_values_array, 0, 256 * sizeof(int));

424 for (x = 0; x < filter_limit; x++) {

425 bounding_values[-x] = -x;

426 bounding_values[x] = x;

427 }

428 for (x = value = filter_limit; x < 128 && value; x++, value--) {

429 bounding_values[ x] = value;

430 bounding_values[-x] = -value;

431 }

432 if (value)

433 bounding_values[128] = value;

434 bounding_values[129] = bounding_values[130] = filter_limit * 0x02020202;

435 }

436

437 /*

438 * This function unpacks all of the superblock/macroblock/fragment coding

439 * information from the bitstream.

440 */

441 static int unpack_superblocks(Vp3DecodeContext *s, GetBitContext *gb)

442 {

443 int superblock_starts[3] = {

444 0, s->u_superblock_start, s->v_superblock_start

445 };

446 int bit = 0;

447 int current_superblock = 0;

448 int current_run = 0;

449 int num_partial_superblocks = 0;

450

451 int i, j;

452 int current_fragment;

453 int plane;

454

455 if (s->keyframe) {

456 memset(s->superblock_coding, SB_FULLY_CODED, s->superblock_count);

457 } else {

458 /* unpack the list of partially-coded superblocks */

459 bit = get_bits1(gb) ^ 1;

460 current_run = 0;

461

462 while (current_superblock < s->superblock_count && get_bits_left(gb) > 0) {

463 if (s->theora && current_run == MAXIMUM_LONG_BIT_RUN)

464 bit = get_bits1(gb);

465 else

466 bit ^= 1;

467

468 current_run = get_vlc2(gb, s->superblock_run_length_vlc.table,

469 6, 2) + 1;

470 if (current_run == 34)

471 current_run += get_bits(gb, 12);

472

473 if (current_superblock + current_run > s->superblock_count) {

474 av_log(s->avctx, AV_LOG_ERROR,

475 "Invalid partially coded superblock run length\n");

476 return -1;

477 }

478

479 memset(s->superblock_coding + current_superblock, bit, current_run);

480

481 current_superblock += current_run;

482 if (bit)

483 num_partial_superblocks += current_run;

484 }

485

486 /* unpack the list of fully coded superblocks if any of the blocks were

487 * not marked as partially coded in the previous step */

488 if (num_partial_superblocks < s->superblock_count) {

489 int superblocks_decoded = 0;

490

491 current_superblock = 0;

492 bit = get_bits1(gb) ^ 1;

493 current_run = 0;

494

495 while (superblocks_decoded < s->superblock_count - num_partial_superblocks &&

496 get_bits_left(gb) > 0) {

497 if (s->theora && current_run == MAXIMUM_LONG_BIT_RUN)

498 bit = get_bits1(gb);

499 else

500 bit ^= 1;

501

502 current_run = get_vlc2(gb, s->superblock_run_length_vlc.table,

503 6, 2) + 1;

504 if (current_run == 34)

505 current_run += get_bits(gb, 12);

506

507 for (j = 0; j < current_run; current_superblock++) {

508 if (current_superblock >= s->superblock_count) {

509 av_log(s->avctx, AV_LOG_ERROR,

510 "Invalid fully coded superblock run length\n");

511 return -1;

512 }

513

514 /* skip any superblocks already marked as partially coded */

515 if (s->superblock_coding[current_superblock] == SB_NOT_CODED) {

516 s->superblock_coding[current_superblock] = 2 * bit;

517 j++;

518 }

519 }

520 superblocks_decoded += current_run;

521 }

522 }

523

524 /* if there were partial blocks, initialize bitstream for

525 * unpacking fragment codings */

526 if (num_partial_superblocks) {

527 current_run = 0;

528 bit = get_bits1(gb);

529 /* toggle the bit because as soon as the first run length is

530 * fetched the bit will be toggled again */

531 bit ^= 1;

532 }

533 }

534

535 /* figure out which fragments are coded; iterate through each

536 * superblock (all planes) */

537 s->total_num_coded_frags = 0;

538 memset(s->macroblock_coding, MODE_COPY, s->macroblock_count);

539

540 for (plane = 0; plane < 3; plane++) {

541 int sb_start = superblock_starts[plane];

542 int sb_end = sb_start + (plane ? s->c_superblock_count

543 : s->y_superblock_count);

544 int num_coded_frags = 0;

545

546 for (i = sb_start; i < sb_end && get_bits_left(gb) > 0; i++) {

547 /* iterate through all 16 fragments in a superblock */

548 for (j = 0; j < 16; j++) {

549 /* if the fragment is in bounds, check its coding status */

550 current_fragment = s->superblock_fragments[i * 16 + j];

551 if (current_fragment != -1) {

552 int coded = s->superblock_coding[i];

553

554 if (s->superblock_coding[i] == SB_PARTIALLY_CODED) {

555 /* fragment may or may not be coded; this is the case

556 * that cares about the fragment coding runs */

557 if (current_run-- == 0) {

558 bit ^= 1;

559 current_run = get_vlc2(gb, s->fragment_run_length_vlc.table, 5, 2);

560 }

561 coded = bit;

562 }

563

564 if (coded) {

565 /* default mode; actual mode will be decoded in

566 * the next phase */

567 s->all_fragments[current_fragment].coding_method =

568 MODE_INTER_NO_MV;

569 s->coded_fragment_list[plane][num_coded_frags++] =

570 current_fragment;

571 } else {

572 /* not coded; copy this fragment from the prior frame */

573 s->all_fragments[current_fragment].coding_method =

574 MODE_COPY;

575 }

576 }

577 }

578 }

579 s->total_num_coded_frags += num_coded_frags;

580 for (i = 0; i < 64; i++)

581 s->num_coded_frags[plane][i] = num_coded_frags;

582 if (plane < 2)

583 s->coded_fragment_list[plane + 1] = s->coded_fragment_list[plane] +

584 num_coded_frags;

585 }

586 return 0;

587 }

588

589 /*

590 * This function unpacks all the coding mode data for individual macroblocks

591 * from the bitstream.

592 */

593 static int unpack_modes(Vp3DecodeContext *s, GetBitContext *gb)

594 {

595 int i, j, k, sb_x, sb_y;

596 int scheme;

597 int current_macroblock;

598 int current_fragment;

599 int coding_mode;

600 int custom_mode_alphabet[CODING_MODE_COUNT];

601 const int *alphabet;

602 Vp3Fragment *frag;

603

604 if (s->keyframe) {

605 for (i = 0; i < s->fragment_count; i++)

606 s->all_fragments[i].coding_method = MODE_INTRA;

607 } else {

608 /* fetch the mode coding scheme for this frame */

609 scheme = get_bits(gb, 3);

610

611 /* is it a custom coding scheme? */

612 if (scheme == 0) {

613 for (i = 0; i < 8; i++)

614 custom_mode_alphabet[i] = MODE_INTER_NO_MV;

615 for (i = 0; i < 8; i++)

616 custom_mode_alphabet[get_bits(gb, 3)] = i;

617 alphabet = custom_mode_alphabet;

618 } else

619 alphabet = ModeAlphabet[scheme - 1];

620

621 /* iterate through all of the macroblocks that contain 1 or more

622 * coded fragments */

623 for (sb_y = 0; sb_y < s->y_superblock_height; sb_y++) {

624 for (sb_x = 0; sb_x < s->y_superblock_width; sb_x++) {

625 if (get_bits_left(gb) <= 0)

626 return -1;

627

628 for (j = 0; j < 4; j++) {

629 int mb_x = 2 * sb_x + (j >> 1);

630 int mb_y = 2 * sb_y + (((j >> 1) + j) & 1);

631 current_macroblock = mb_y * s->macroblock_width + mb_x;

632

633 if (mb_x >= s->macroblock_width ||

634 mb_y >= s->macroblock_height)

635 continue;

636

637 #define BLOCK_X (2 * mb_x + (k & 1))

638 #define BLOCK_Y (2 * mb_y + (k >> 1))

639 /* coding modes are only stored if the macroblock has

640 * at least one luma block coded, otherwise it must be

641 * INTER_NO_MV */

642 for (k = 0; k < 4; k++) {

643 current_fragment = BLOCK_Y *

644 s->fragment_width[0] + BLOCK_X;

645 if (s->all_fragments[current_fragment].coding_method != MODE_COPY)

646 break;

647 }

648 if (k == 4) {

649 s->macroblock_coding[current_macroblock] = MODE_INTER_NO_MV;

650 continue;

651 }

652

653 /* mode 7 means get 3 bits for each coding mode */

654 if (scheme == 7)

655 coding_mode = get_bits(gb, 3);

656 else

657 coding_mode = alphabet[get_vlc2(gb, s->mode_code_vlc.table, 3, 3)];

658

659 s->macroblock_coding[current_macroblock] = coding_mode;

660 for (k = 0; k < 4; k++) {

661 frag = s->all_fragments + BLOCK_Y * s->fragment_width[0] + BLOCK_X;

662 if (frag->coding_method != MODE_COPY)

663 frag->coding_method = coding_mode;

664 }

665

666 #define SET_CHROMA_MODES \

667 if (frag[s->fragment_start[1]].coding_method != MODE_COPY) \

668 frag[s->fragment_start[1]].coding_method = coding_mode; \

669 if (frag[s->fragment_start[2]].coding_method != MODE_COPY) \

670 frag[s->fragment_start[2]].coding_method = coding_mode;

671

672 if (s->chroma_y_shift) {

673 frag = s->all_fragments + mb_y *

674 s->fragment_width[1] + mb_x;

675 SET_CHROMA_MODES

676 } else if (s->chroma_x_shift) {

677 frag = s->all_fragments +

678 2 * mb_y * s->fragment_width[1] + mb_x;

679 for (k = 0; k < 2; k++) {

680 SET_CHROMA_MODES

681 frag += s->fragment_width[1];

682 }

683 } else {

684 for (k = 0; k < 4; k++) {

685 frag = s->all_fragments +

686 BLOCK_Y * s->fragment_width[1] + BLOCK_X;

687 SET_CHROMA_MODES

688 }

689 }

690 }

691 }

692 }

693 }

694

695 return 0;

696 }

697

698 /*

699 * This function unpacks all the motion vectors for the individual

700 * macroblocks from the bitstream.

701 */

702 static int unpack_vectors(Vp3DecodeContext *s, GetBitContext *gb)

703 {

704 int j, k, sb_x, sb_y;

705 int coding_mode;

706 int motion_x[4];

707 int motion_y[4];

708 int last_motion_x = 0;

709 int last_motion_y = 0;

710 int prior_last_motion_x = 0;

711 int prior_last_motion_y = 0;

712 int current_macroblock;

713 int current_fragment;

714 int frag;

715

716 if (s->keyframe)

717 return 0;

718

719 /* coding mode 0 is the VLC scheme; 1 is the fixed code scheme */

720 coding_mode = get_bits1(gb);

721

722 /* iterate through all of the macroblocks that contain 1 or more

723 * coded fragments */

724 for (sb_y = 0; sb_y < s->y_superblock_height; sb_y++) {

725 for (sb_x = 0; sb_x < s->y_superblock_width; sb_x++) {

726 if (get_bits_left(gb) <= 0)

727 return -1;

728

729 for (j = 0; j < 4; j++) {

730 int mb_x = 2 * sb_x + (j >> 1);

731 int mb_y = 2 * sb_y + (((j >> 1) + j) & 1);

732 current_macroblock = mb_y * s->macroblock_width + mb_x;

733

734 if (mb_x >= s->macroblock_width ||

735 mb_y >= s->macroblock_height ||

736 s->macroblock_coding[current_macroblock] == MODE_COPY)

737 continue;

738

739 switch (s->macroblock_coding[current_macroblock]) {

740 case MODE_INTER_PLUS_MV:

741 case MODE_GOLDEN_MV:

742 /* all 6 fragments use the same motion vector */

743 if (coding_mode == 0) {

744 motion_x[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];

745 motion_y[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];

746 } else {

747 motion_x[0] = fixed_motion_vector_table[get_bits(gb, 6)];

748 motion_y[0] = fixed_motion_vector_table[get_bits(gb, 6)];

749 }

750

751 /* vector maintenance, only on MODE_INTER_PLUS_MV */

752 if (s->macroblock_coding[current_macroblock] == MODE_INTER_PLUS_MV) {

753 prior_last_motion_x = last_motion_x;

754 prior_last_motion_y = last_motion_y;

755 last_motion_x = motion_x[0];

756 last_motion_y = motion_y[0];

757 }

758 break;

759

760 case MODE_INTER_FOURMV:

761 /* vector maintenance */

762 prior_last_motion_x = last_motion_x;

763 prior_last_motion_y = last_motion_y;

764

765 /* fetch 4 vectors from the bitstream, one for each

766 * Y fragment, then average for the C fragment vectors */

767 for (k = 0; k < 4; k++) {

768 current_fragment = BLOCK_Y * s->fragment_width[0] + BLOCK_X;

769 if (s->all_fragments[current_fragment].coding_method != MODE_COPY) {

770 if (coding_mode == 0) {

771 motion_x[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];

772 motion_y[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];

773 } else {

774 motion_x[k] = fixed_motion_vector_table[get_bits(gb, 6)];

775 motion_y[k] = fixed_motion_vector_table[get_bits(gb, 6)];

776 }

777 last_motion_x = motion_x[k];

778 last_motion_y = motion_y[k];

779 } else {

780 motion_x[k] = 0;

781 motion_y[k] = 0;

782 }

783 }

784 break;

785

786 case MODE_INTER_LAST_MV:

787 /* all 6 fragments use the last motion vector */

788 motion_x[0] = last_motion_x;

789 motion_y[0] = last_motion_y;

790

791 /* no vector maintenance (last vector remains the

792 * last vector) */

793 break;

794

795 case MODE_INTER_PRIOR_LAST:

796 /* all 6 fragments use the motion vector prior to the

797 * last motion vector */

798 motion_x[0] = prior_last_motion_x;

799 motion_y[0] = prior_last_motion_y;

800

801 /* vector maintenance */

802 prior_last_motion_x = last_motion_x;

803 prior_last_motion_y = last_motion_y;

804 last_motion_x = motion_x[0];

805 last_motion_y = motion_y[0];

806 break;

807

808 default:

809 /* covers intra, inter without MV, golden without MV */

810 motion_x[0] = 0;

811 motion_y[0] = 0;

812

813 /* no vector maintenance */

814 break;

815 }

816

817 /* assign the motion vectors to the correct fragments */

818 for (k = 0; k < 4; k++) {

819 current_fragment =

820 BLOCK_Y * s->fragment_width[0] + BLOCK_X;

821 if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) {

822 s->motion_val[0][current_fragment][0] = motion_x[k];

823 s->motion_val[0][current_fragment][1] = motion_y[k];

824 } else {

825 s->motion_val[0][current_fragment][0] = motion_x[0];

826 s->motion_val[0][current_fragment][1] = motion_y[0];

827 }

828 }

829

830 if (s->chroma_y_shift) {

831 if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) {

832 motion_x[0] = RSHIFT(motion_x[0] + motion_x[1] +

833 motion_x[2] + motion_x[3], 2);

834 motion_y[0] = RSHIFT(motion_y[0] + motion_y[1] +

835 motion_y[2] + motion_y[3], 2);

836 }

837 motion_x[0] = (motion_x[0] >> 1) | (motion_x[0] & 1);

838 motion_y[0] = (motion_y[0] >> 1) | (motion_y[0] & 1);

839 frag = mb_y * s->fragment_width[1] + mb_x;

840 s->motion_val[1][frag][0] = motion_x[0];

841 s->motion_val[1][frag][1] = motion_y[0];

842 } else if (s->chroma_x_shift) {

843 if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) {

844 motion_x[0] = RSHIFT(motion_x[0] + motion_x[1], 1);

845 motion_y[0] = RSHIFT(motion_y[0] + motion_y[1], 1);

846 motion_x[1] = RSHIFT(motion_x[2] + motion_x[3], 1);

847 motion_y[1] = RSHIFT(motion_y[2] + motion_y[3], 1);

848 } else {

849 motion_x[1] = motion_x[0];

850 motion_y[1] = motion_y[0];

851 }

852 motion_x[0] = (motion_x[0] >> 1) | (motion_x[0] & 1);

853 motion_x[1] = (motion_x[1] >> 1) | (motion_x[1] & 1);

854

855 frag = 2 * mb_y * s->fragment_width[1] + mb_x;

856 for (k = 0; k < 2; k++) {

857 s->motion_val[1][frag][0] = motion_x[k];

858 s->motion_val[1][frag][1] = motion_y[k];

859 frag += s->fragment_width[1];

860 }

861 } else {

862 for (k = 0; k < 4; k++) {

863 frag = BLOCK_Y * s->fragment_width[1] + BLOCK_X;

864 if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) {

865 s->motion_val[1][frag][0] = motion_x[k];

866 s->motion_val[1][frag][1] = motion_y[k];

867 } else {

868 s->motion_val[1][frag][0] = motion_x[0];

869 s->motion_val[1][frag][1] = motion_y[0];

870 }

871 }

872 }

873 }

874 }

875 }

876

877 return 0;

878 }

879

880 static int unpack_block_qpis(Vp3DecodeContext *s, GetBitContext *gb)

881 {

882 int qpi, i, j, bit, run_length, blocks_decoded, num_blocks_at_qpi;

883 int num_blocks = s->total_num_coded_frags;

884

885 for (qpi = 0; qpi < s->nqps - 1 && num_blocks > 0; qpi++) {

886 i = blocks_decoded = num_blocks_at_qpi = 0;

887

888 bit = get_bits1(gb) ^ 1;

889 run_length = 0;

890

891 do {

892 if (run_length == MAXIMUM_LONG_BIT_RUN)

893 bit = get_bits1(gb);

894 else

895 bit ^= 1;

896

897 run_length = get_vlc2(gb, s->superblock_run_length_vlc.table, 6, 2) + 1;

898 if (run_length == 34)

899 run_length += get_bits(gb, 12);

900 blocks_decoded += run_length;

901

902 if (!bit)

903 num_blocks_at_qpi += run_length;

904

905 for (j = 0; j < run_length; i++) {

906 if (i >= s->total_num_coded_frags)

907 return -1;

908

909 if (s->all_fragments[s->coded_fragment_list[0][i]].qpi == qpi) {

910 s->all_fragments[s->coded_fragment_list[0][i]].qpi += bit;

911 j++;

912 }

913 }

914 } while (blocks_decoded < num_blocks && get_bits_left(gb) > 0);

915

916 num_blocks -= num_blocks_at_qpi;

917 }

918

919 return 0;

920 }

921

922 /*

923 * This function is called by unpack_dct_coeffs() to extract the VLCs from

924 * the bitstream. The VLCs encode tokens which are used to unpack DCT

925 * data. This function unpacks all the VLCs for either the Y plane or both

926 * C planes, and is called for DC coefficients or different AC coefficient

927 * levels (since different coefficient types require different VLC tables.

928 *

929 * This function returns a residual eob run. E.g, if a particular token gave

930 * instructions to EOB the next 5 fragments and there were only 2 fragments

931 * left in the current fragment range, 3 would be returned so that it could

932 * be passed into the next call to this same function.

933 */

934 static int unpack_vlcs(Vp3DecodeContext *s, GetBitContext *gb,

935 VLC *table, int coeff_index,

936 int plane,

937 int eob_run)

938 {

939 int i, j = 0;

940 int token;

941 int zero_run = 0;

942 int16_t coeff = 0;

943 int bits_to_get;

944 int blocks_ended;

945 int coeff_i = 0;

946 int num_coeffs = s->num_coded_frags[plane][coeff_index];

947 int16_t *dct_tokens = s->dct_tokens[plane][coeff_index];

948

949 /* local references to structure members to avoid repeated deferences */

950 int *coded_fragment_list = s->coded_fragment_list[plane];

951 Vp3Fragment *all_fragments = s->all_fragments;

952 VLC_TYPE(*vlc_table)[2] = table->table;

953

954 if (num_coeffs < 0)

955 av_log(s->avctx, AV_LOG_ERROR,

956 "Invalid number of coefficents at level %d\n", coeff_index);

957

958 if (eob_run > num_coeffs) {

959 coeff_i =

960 blocks_ended = num_coeffs;

961 eob_run -= num_coeffs;

962 } else {

963 coeff_i =

964 blocks_ended = eob_run;

965 eob_run = 0;

966 }

967

968 // insert fake EOB token to cover the split between planes or zzi

969 if (blocks_ended)

970 dct_tokens[j++] = blocks_ended << 2;

971

972 while (coeff_i < num_coeffs && get_bits_left(gb) > 0) {

973 /* decode a VLC into a token */

974 token = get_vlc2(gb, vlc_table, 11, 3);

975 /* use the token to get a zero run, a coefficient, and an eob run */

976 if ((unsigned) token <= 6U) {

977 eob_run = eob_run_base[token];

978 if (eob_run_get_bits[token])

979 eob_run += get_bits(gb, eob_run_get_bits[token]);

980

981 // record only the number of blocks ended in this plane,

982 // any spill will be recorded in the next plane.

983 if (eob_run > num_coeffs - coeff_i) {

984 dct_tokens[j++] = TOKEN_EOB(num_coeffs - coeff_i);

985 blocks_ended += num_coeffs - coeff_i;

986 eob_run -= num_coeffs - coeff_i;

987 coeff_i = num_coeffs;

988 } else {

989 dct_tokens[j++] = TOKEN_EOB(eob_run);

990 blocks_ended += eob_run;

991 coeff_i += eob_run;

992 eob_run = 0;

993 }

994 } else if (token >= 0) {

995 bits_to_get = coeff_get_bits[token];

996 if (bits_to_get)

997 bits_to_get = get_bits(gb, bits_to_get);

998 coeff = coeff_tables[token][bits_to_get];

999

1000 zero_run = zero_run_base[token];

1001 if (zero_run_get_bits[token])

1002 zero_run += get_bits(gb, zero_run_get_bits[token]);

1003

1004 if (zero_run) {

1005 dct_tokens[j++] = TOKEN_ZERO_RUN(coeff, zero_run);

1006 } else {

1007 // Save DC into the fragment structure. DC prediction is

1008 // done in raster order, so the actual DC can't be in with

1009 // other tokens. We still need the token in dct_tokens[]

1010 // however, or else the structure collapses on itself.

1011 if (!coeff_index)

1012 all_fragments[coded_fragment_list[coeff_i]].dc = coeff;

1013

1014 dct_tokens[j++] = TOKEN_COEFF(coeff);

1015 }

1016

1017 if (coeff_index + zero_run > 64) {

1018 av_log(s->avctx, AV_LOG_DEBUG,

1019 "Invalid zero run of %d with %d coeffs left\n",

1020 zero_run, 64 - coeff_index);

1021 zero_run = 64 - coeff_index;

1022 }

1023

1024 // zero runs code multiple coefficients,

1025 // so don't try to decode coeffs for those higher levels

1026 for (i = coeff_index + 1; i <= coeff_index + zero_run; i++)

1027 s->num_coded_frags[plane][i]--;

1028 coeff_i++;

1029 } else {

1030 av_log(s->avctx, AV_LOG_ERROR, "Invalid token %d\n", token);

1031 return -1;

1032 }

1033 }

1034

1035 if (blocks_ended > s->num_coded_frags[plane][coeff_index])

1036 av_log(s->avctx, AV_LOG_ERROR, "More blocks ended than coded!\n");

1037

1038 // decrement the number of blocks that have higher coefficients for each

1039 // EOB run at this level

1040 if (blocks_ended)

1041 for (i = coeff_index + 1; i < 64; i++)

1042 s->num_coded_frags[plane][i] -= blocks_ended;

1043

1044 // setup the next buffer

1045 if (plane < 2)

1046 s->dct_tokens[plane + 1][coeff_index] = dct_tokens + j;

1047 else if (coeff_index < 63)

1048 s->dct_tokens[0][coeff_index + 1] = dct_tokens + j;

1049

1050 return eob_run;

1051 }

1052

1053 static void reverse_dc_prediction(Vp3DecodeContext *s,

1054 int first_fragment,

1055 int fragment_width,

1056 int fragment_height);

1057 /*

1058 * This function unpacks all of the DCT coefficient data from the

1059 * bitstream.

1060 */

1061 static int unpack_dct_coeffs(Vp3DecodeContext *s, GetBitContext *gb)

1062 {

1063 int i;

1064 int dc_y_table;

1065 int dc_c_table;

1066 int ac_y_table;

1067 int ac_c_table;

1068 int residual_eob_run = 0;

1069 VLC *y_tables[64];

1070 VLC *c_tables[64];

1071

1072 s->dct_tokens[0][0] = s->dct_tokens_base;

1073

1074 /* fetch the DC table indexes */

1075 dc_y_table = get_bits(gb, 4);

1076 dc_c_table = get_bits(gb, 4);

1077

1078 /* unpack the Y plane DC coefficients */

1079 residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_y_table], 0,

1080 0, residual_eob_run);

1081 if (residual_eob_run < 0)

1082 return residual_eob_run;

1083

1084 /* reverse prediction of the Y-plane DC coefficients */

1085 reverse_dc_prediction(s, 0, s->fragment_width[0], s->fragment_height[0]);

1086

1087 /* unpack the C plane DC coefficients */

1088 residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_c_table], 0,

1089 1, residual_eob_run);

1090 if (residual_eob_run < 0)

1091 return residual_eob_run;

1092 residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_c_table], 0,

1093 2, residual_eob_run);

1094 if (residual_eob_run < 0)

1095 return residual_eob_run;

1096

1097 /* reverse prediction of the C-plane DC coefficients */

1098 if (!(s->avctx->flags & CODEC_FLAG_GRAY)) {

1099 reverse_dc_prediction(s, s->fragment_start[1],

1100 s->fragment_width[1], s->fragment_height[1]);

1101 reverse_dc_prediction(s, s->fragment_start[2],

1102 s->fragment_width[1], s->fragment_height[1]);

1103 }

1104

1105 /* fetch the AC table indexes */

1106 ac_y_table = get_bits(gb, 4);

1107 ac_c_table = get_bits(gb, 4);

1108

1109 /* build tables of AC VLC tables */

1110 for (i = 1; i <= 5; i++) {

1111 y_tables[i] = &s->ac_vlc_1[ac_y_table];

1112 c_tables[i] = &s->ac_vlc_1[ac_c_table];

1113 }

1114 for (i = 6; i <= 14; i++) {

1115 y_tables[i] = &s->ac_vlc_2[ac_y_table];

1116 c_tables[i] = &s->ac_vlc_2[ac_c_table];

1117 }

1118 for (i = 15; i <= 27; i++) {

1119 y_tables[i] = &s->ac_vlc_3[ac_y_table];

1120 c_tables[i] = &s->ac_vlc_3[ac_c_table];

1121 }

1122 for (i = 28; i <= 63; i++) {

1123 y_tables[i] = &s->ac_vlc_4[ac_y_table];

1124 c_tables[i] = &s->ac_vlc_4[ac_c_table];

1125 }

1126

1127 /* decode all AC coefficents */

1128 for (i = 1; i <= 63; i++) {

1129 residual_eob_run = unpack_vlcs(s, gb, y_tables[i], i,

1130 0, residual_eob_run);

1131 if (residual_eob_run < 0)

1132 return residual_eob_run;

1133

1134 residual_eob_run = unpack_vlcs(s, gb, c_tables[i], i,

1135 1, residual_eob_run);

1136 if (residual_eob_run < 0)

1137 return residual_eob_run;

1138 residual_eob_run = unpack_vlcs(s, gb, c_tables[i], i,

1139 2, residual_eob_run);

1140 if (residual_eob_run < 0)

1141 return residual_eob_run;

1142 }

1143

1144 return 0;

1145 }

1146

1147 /*

1148 * This function reverses the DC prediction for each coded fragment in

1149 * the frame. Much of this function is adapted directly from the original

1150 * VP3 source code.

1151 */

1152 #define COMPATIBLE_FRAME(x) \

1153 (compatible_frame[s->all_fragments[x].coding_method] == current_frame_type)

1154 #define DC_COEFF(u) s->all_fragments[u].dc

1155

1156 static void reverse_dc_prediction(Vp3DecodeContext *s,

1157 int first_fragment,

1158 int fragment_width,

1159 int fragment_height)

1160 {

1161 #define PUL 8

1162 #define PU 4

1163 #define PUR 2

1164 #define PL 1

1165

1166 int x, y;

1167 int i = first_fragment;

1168

1169 int predicted_dc;

1170

1171 /* DC values for the left, up-left, up, and up-right fragments */

1172 int vl, vul, vu, vur;

1173

1174 /* indexes for the left, up-left, up, and up-right fragments */

1175 int l, ul, u, ur;

1176

1177 /*

1178 * The 6 fields mean:

1179 * 0: up-left multiplier

1180 * 1: up multiplier

1181 * 2: up-right multiplier

1182 * 3: left multiplier

1183 */

1184 static const int predictor_transform[16][4] = {

1185 { 0, 0, 0, 0 },

1186 { 0, 0, 0, 128 }, // PL

1187 { 0, 0, 128, 0 }, // PUR

1188 { 0, 0, 53, 75 }, // PUR|PL

1189 { 0, 128, 0, 0 }, // PU

1190 { 0, 64, 0, 64 }, // PU |PL

1191 { 0, 128, 0, 0 }, // PU |PUR

1192 { 0, 0, 53, 75 }, // PU |PUR|PL

1193 { 128, 0, 0, 0 }, // PUL

1194 { 0, 0, 0, 128 }, // PUL|PL

1195 { 64, 0, 64, 0 }, // PUL|PUR

1196 { 0, 0, 53, 75 }, // PUL|PUR|PL

1197 { 0, 128, 0, 0 }, // PUL|PU

1198 { -104, 116, 0, 116 }, // PUL|PU |PL

1199 { 24, 80, 24, 0 }, // PUL|PU |PUR

1200 { -104, 116, 0, 116 } // PUL|PU |PUR|PL

1201 };

1202

1203 /* This table shows which types of blocks can use other blocks for

1204 * prediction. For example, INTRA is the only mode in this table to

1205 * have a frame number of 0. That means INTRA blocks can only predict

1206 * from other INTRA blocks. There are 2 golden frame coding types;

1207 * blocks encoding in these modes can only predict from other blocks

1208 * that were encoded with these 1 of these 2 modes. */

1209 static const unsigned char compatible_frame[9] = {

1210 1, /* MODE_INTER_NO_MV */

1211 0, /* MODE_INTRA */

1212 1, /* MODE_INTER_PLUS_MV */

1213 1, /* MODE_INTER_LAST_MV */

1214 1, /* MODE_INTER_PRIOR_MV */

1215 2, /* MODE_USING_GOLDEN */

1216 2, /* MODE_GOLDEN_MV */

1217 1, /* MODE_INTER_FOUR_MV */

1218 3 /* MODE_COPY */

1219 };

1220 int current_frame_type;

1221

1222 /* there is a last DC predictor for each of the 3 frame types */

1223 short last_dc[3];

1224

1225 int transform = 0;

1226

1227 vul =

1228 vu =

1229 vur =

1230 vl = 0;

1231 last_dc[0] =

1232 last_dc[1] =

1233 last_dc[2] = 0;

1234

1235 /* for each fragment row... */

1236 for (y = 0; y < fragment_height; y++) {

1237 /* for each fragment in a row... */

1238 for (x = 0; x < fragment_width; x++, i++) {

1239

1240 /* reverse prediction if this block was coded */

1241 if (s->all_fragments[i].coding_method != MODE_COPY) {

1242 current_frame_type =

1243 compatible_frame[s->all_fragments[i].coding_method];

1244

1245 transform = 0;

1246 if (x) {

1247 l = i - 1;

1248 vl = DC_COEFF(l);

1249 if (COMPATIBLE_FRAME(l))

1250 transform |= PL;

1251 }

1252 if (y) {

1253 u = i - fragment_width;

1254 vu = DC_COEFF(u);

1255 if (COMPATIBLE_FRAME(u))

1256 transform |= PU;

1257 if (x) {

1258 ul = i - fragment_width - 1;

1259 vul = DC_COEFF(ul);

1260 if (COMPATIBLE_FRAME(ul))

1261 transform |= PUL;

1262 }

1263 if (x + 1 < fragment_width) {

1264 ur = i - fragment_width + 1;

1265 vur = DC_COEFF(ur);

1266 if (COMPATIBLE_FRAME(ur))

1267 transform |= PUR;

1268 }

1269 }

1270

1271 if (transform == 0) {

1272 /* if there were no fragments to predict from, use last

1273 * DC saved */

1274 predicted_dc = last_dc[current_frame_type];

1275 } else {

1276 /* apply the appropriate predictor transform */

1277 predicted_dc =

1278 (predictor_transform[transform][0] * vul) +

1279 (predictor_transform[transform][1] * vu) +

1280 (predictor_transform[transform][2] * vur) +

1281 (predictor_transform[transform][3] * vl);

1282

1283 predicted_dc /= 128;

1284

1285 /* check for outranging on the [ul u l] and

1286 * [ul u ur l] predictors */

1287 if ((transform == 15) || (transform == 13)) {

1288 if (FFABS(predicted_dc - vu) > 128)

1289 predicted_dc = vu;

1290 else if (FFABS(predicted_dc - vl) > 128)

1291 predicted_dc = vl;

1292 else if (FFABS(predicted_dc - vul) > 128)

1293 predicted_dc = vul;

1294 }

1295 }

1296

1297 /* at long last, apply the predictor */

1298 DC_COEFF(i) += predicted_dc;

1299 /* save the DC */

1300 last_dc[current_frame_type] = DC_COEFF(i);

1301 }

1302 }

1303 }

1304 }

1305

1306 static void apply_loop_filter(Vp3DecodeContext *s, int plane,

1307 int ystart, int yend)

1308 {

1309 int x, y;

1310 int *bounding_values = s->bounding_values_array + 127;

1311

1312 int width = s->fragment_width[!!plane];

1313 int height = s->fragment_height[!!plane];

1314 int fragment = s->fragment_start[plane] + ystart * width;

1315 ptrdiff_t stride = s->current_frame.f->linesize[plane];

1316 uint8_t *plane_data = s->current_frame.f->data[plane];

1317 if (!s->flipped_image)

1318 stride = -stride;

1319 plane_data += s->data_offset[plane] + 8 * ystart * stride;

1320

1321 for (y = ystart; y < yend; y++) {

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

1323 /* This code basically just deblocks on the edges of coded blocks.

1324 * However, it has to be much more complicated because of the

1325 * braindamaged deblock ordering used in VP3/Theora. Order matters

1326 * because some pixels get filtered twice. */

1327 if (s->all_fragments[fragment].coding_method != MODE_COPY) {

1328 /* do not perform left edge filter for left columns frags */

1329 if (x > 0) {

1330 s->vp3dsp.h_loop_filter(

1331 plane_data + 8 * x,

1332 stride, bounding_values);

1333 }

1334

1335 /* do not perform top edge filter for top row fragments */

1336 if (y > 0) {

1337 s->vp3dsp.v_loop_filter(

1338 plane_data + 8 * x,

1339 stride, bounding_values);

1340 }

1341

1342 /* do not perform right edge filter for right column

1343 * fragments or if right fragment neighbor is also coded

1344 * in this frame (it will be filtered in next iteration) */

1345 if ((x < width - 1) &&

1346 (s->all_fragments[fragment + 1].coding_method == MODE_COPY)) {

1347 s->vp3dsp.h_loop_filter(

1348 plane_data + 8 * x + 8,

1349 stride, bounding_values);

1350 }

1351

1352 /* do not perform bottom edge filter for bottom row

1353 * fragments or if bottom fragment neighbor is also coded

1354 * in this frame (it will be filtered in the next row) */

1355 if ((y < height - 1) &&

1356 (s->all_fragments[fragment + width].coding_method == MODE_COPY)) {

1357 s->vp3dsp.v_loop_filter(

1358 plane_data + 8 * x + 8 * stride,

1359 stride, bounding_values);

1360 }

1361 }

1362

1363 fragment++;

1364 }

1365 plane_data += 8 * stride;

1366 }

1367 }

1368

1369 /**

1370 * Pull DCT tokens from the 64 levels to decode and dequant the coefficients

1371 * for the next block in coding order

1372 */

1373 static inline int vp3_dequant(Vp3DecodeContext *s, Vp3Fragment *frag,

1374 int plane, int inter, int16_t block[64])

1375 {

1376 int16_t *dequantizer = s->qmat[frag->qpi][inter][plane];

1377 uint8_t *perm = s->idct_scantable;

1378 int i = 0;

1379

1380 do {

1381 int token = *s->dct_tokens[plane][i];

1382 switch (token & 3) {

1383 case 0: // EOB

1384 if (--token < 4) // 0-3 are token types so the EOB run must now be 0

1385 s->dct_tokens[plane][i]++;

1386 else

1387 *s->dct_tokens[plane][i] = token & ~3;

1388 goto end;

1389 case 1: // zero run

1390 s->dct_tokens[plane][i]++;

1391 i += (token >> 2) & 0x7f;

1392 if (i > 63) {

1393 av_log(s->avctx, AV_LOG_ERROR, "Coefficient index overflow\n");

1394 return i;

1395 }

1396 block[perm[i]] = (token >> 9) * dequantizer[perm[i]];

1397 i++;

1398 break;

1399 case 2: // coeff

1400 block[perm[i]] = (token >> 2) * dequantizer[perm[i]];

1401 s->dct_tokens[plane][i++]++;

1402 break;

1403 default: // shouldn't happen

1404 return i;

1405 }

1406 } while (i < 64);

1407 // return value is expected to be a valid level

1408 i--;

1409 end:

1410 // the actual DC+prediction is in the fragment structure

1411 block[0] = frag->dc * s->qmat[0][inter][plane][0];

1412 return i;

1413 }

1414

1415 /**

1416 * called when all pixels up to row y are complete

1417 */

1418 static void vp3_draw_horiz_band(Vp3DecodeContext *s, int y)

1419 {

1420 int h, cy, i;

1421 int offset[AV_NUM_DATA_POINTERS];

1422

1423 if (HAVE_THREADS && s->avctx->active_thread_type & FF_THREAD_FRAME) {

1424 int y_flipped = s->flipped_image ? s->height - y : y;

1425

1426 /* At the end of the frame, report INT_MAX instead of the height of

1427 * the frame. This makes the other threads' ff_thread_await_progress()

1428 * calls cheaper, because they don't have to clip their values. */

1429 ff_thread_report_progress(&s->current_frame,

1430 y_flipped == s->height ? INT_MAX

1431 : y_flipped - 1,

1432 0);

1433 }

1434

1435 if (!s->avctx->draw_horiz_band)

1436 return;

1437

1438 h = y - s->last_slice_end;

1439 s->last_slice_end = y;

1440 y -= h;

1441

1442 if (!s->flipped_image)

1443 y = s->height - y - h;

1444

1445 cy = y >> s->chroma_y_shift;

1446 offset[0] = s->current_frame.f->linesize[0] * y;

1447 offset[1] = s->current_frame.f->linesize[1] * cy;

1448 offset[2] = s->current_frame.f->linesize[2] * cy;

1449 for (i = 3; i < AV_NUM_DATA_POINTERS; i++)

1450 offset[i] = 0;

1451

1452 emms_c();

1453 s->avctx->draw_horiz_band(s->avctx, s->current_frame.f, offset, y, 3, h);

1454 }

1455

1456 /**

1457 * Wait for the reference frame of the current fragment.

1458 * The progress value is in luma pixel rows.

1459 */

1460 static void await_reference_row(Vp3DecodeContext *s, Vp3Fragment *fragment,

1461 int motion_y, int y)

1462 {

1463 ThreadFrame *ref_frame;

1464 int ref_row;

1465 int border = motion_y & 1;

1466

1467 if (fragment->coding_method == MODE_USING_GOLDEN ||

1468 fragment->coding_method == MODE_GOLDEN_MV)

1469 ref_frame = &s->golden_frame;

1470 else

1471 ref_frame = &s->last_frame;

1472

1473 ref_row = y + (motion_y >> 1);

1474 ref_row = FFMAX(FFABS(ref_row), ref_row + 8 + border);

1475

1476 ff_thread_await_progress(ref_frame, ref_row, 0);

1477 }

1478

1479 /*

1480 * Perform the final rendering for a particular slice of data.

1481 * The slice number ranges from 0..(c_superblock_height - 1).

1482 */

1483 static void render_slice(Vp3DecodeContext *s, int slice)

1484 {

1485 int x, y, i, j, fragment;

1486 int16_t *block = s->block;

1487 int motion_x = 0xdeadbeef, motion_y = 0xdeadbeef;

1488 int motion_halfpel_index;

1489 uint8_t *motion_source;

1490 int plane, first_pixel;

1491

1492 if (slice >= s->c_superblock_height)

1493 return;

1494

1495 for (plane = 0; plane < 3; plane++) {

1496 uint8_t *output_plane = s->current_frame.f->data[plane] +

1497 s->data_offset[plane];

1498 uint8_t *last_plane = s->last_frame.f->data[plane] +

1499 s->data_offset[plane];

1500 uint8_t *golden_plane = s->golden_frame.f->data[plane] +

1501 s->data_offset[plane];

1502 ptrdiff_t stride = s->current_frame.f->linesize[plane];

1503 int plane_width = s->width >> (plane && s->chroma_x_shift);

1504 int plane_height = s->height >> (plane && s->chroma_y_shift);

1505 int8_t(*motion_val)[2] = s->motion_val[!!plane];

1506

1507 int sb_x, sb_y = slice << (!plane && s->chroma_y_shift);

1508 int slice_height = sb_y + 1 + (!plane && s->chroma_y_shift);

1509 int slice_width = plane ? s->c_superblock_width

1510 : s->y_superblock_width;

1511

1512 int fragment_width = s->fragment_width[!!plane];

1513 int fragment_height = s->fragment_height[!!plane];

1514 int fragment_start = s->fragment_start[plane];

1515

1516 int do_await = !plane && HAVE_THREADS &&

1517 (s->avctx->active_thread_type & FF_THREAD_FRAME);

1518

1519 if (!s->flipped_image)

1520 stride = -stride;

1521 if (CONFIG_GRAY && plane && (s->avctx->flags & CODEC_FLAG_GRAY))

1522 continue;

1523

1524 /* for each superblock row in the slice (both of them)... */

1525 for (; sb_y < slice_height; sb_y++) {

1526 /* for each superblock in a row... */

1527 for (sb_x = 0; sb_x < slice_width; sb_x++) {

1528 /* for each block in a superblock... */

1529 for (j = 0; j < 16; j++) {

1530 x = 4 * sb_x + hilbert_offset[j][0];

1531 y = 4 * sb_y + hilbert_offset[j][1];

1532 fragment = y * fragment_width + x;

1533

1534 i = fragment_start + fragment;

1535

1536 // bounds check

1537 if (x >= fragment_width || y >= fragment_height)

1538 continue;

1539

1540 first_pixel = 8 * y * stride + 8 * x;

1541

1542 if (do_await &&

1543 s->all_fragments[i].coding_method != MODE_INTRA)

1544 await_reference_row(s, &s->all_fragments[i],

1545 motion_val[fragment][1],

1546 (16 * y) >> s->chroma_y_shift);

1547

1548 /* transform if this block was coded */

1549 if (s->all_fragments[i].coding_method != MODE_COPY) {

1550 if ((s->all_fragments[i].coding_method == MODE_USING_GOLDEN) ||

1551 (s->all_fragments[i].coding_method == MODE_GOLDEN_MV))

1552 motion_source = golden_plane;

1553 else

1554 motion_source = last_plane;

1555

1556 motion_source += first_pixel;

1557 motion_halfpel_index = 0;

1558

1559 /* sort out the motion vector if this fragment is coded

1560 * using a motion vector method */

1561 if ((s->all_fragments[i].coding_method > MODE_INTRA) &&

1562 (s->all_fragments[i].coding_method != MODE_USING_GOLDEN)) {

1563 int src_x, src_y;

1564 motion_x = motion_val[fragment][0];

1565 motion_y = motion_val[fragment][1];

1566

1567 src_x = (motion_x >> 1) + 8 * x;

1568 src_y = (motion_y >> 1) + 8 * y;

1569

1570 motion_halfpel_index = motion_x & 0x01;

1571 motion_source += (motion_x >> 1);

1572

1573 motion_halfpel_index |= (motion_y & 0x01) << 1;

1574 motion_source += ((motion_y >> 1) * stride);

1575

1576 if (src_x < 0 || src_y < 0 ||

1577 src_x + 9 >= plane_width ||

1578 src_y + 9 >= plane_height) {

1579 uint8_t *temp = s->edge_emu_buffer;

1580 if (stride < 0)

1581 temp -= 8 * stride;

1582

1583 s->vdsp.emulated_edge_mc(temp, motion_source,

1584 stride, stride,

1585 9, 9, src_x, src_y,

1586 plane_width,

1587 plane_height);

1588 motion_source = temp;

1589 }

1590 }

1591

1592 /* first, take care of copying a block from either the

1593 * previous or the golden frame */

1594 if (s->all_fragments[i].coding_method != MODE_INTRA) {

1595 /* Note, it is possible to implement all MC cases

1596 * with put_no_rnd_pixels_l2 which would look more

1597 * like the VP3 source but this would be slower as

1598 * put_no_rnd_pixels_tab is better optimzed */

1599 if (motion_halfpel_index != 3) {

1600 s->hdsp.put_no_rnd_pixels_tab[1][motion_halfpel_index](

1601 output_plane + first_pixel,

1602 motion_source, stride, 8);

1603 } else {

1604 /* d is 0 if motion_x and _y have the same sign,

1605 * else -1 */

1606 int d = (motion_x ^ motion_y) >> 31;

1607 s->vp3dsp.put_no_rnd_pixels_l2(output_plane + first_pixel,

1608 motion_source - d,

1609 motion_source + stride + 1 + d,

1610 stride, 8);

1611 }

1612 }

1613

1614 /* invert DCT and place (or add) in final output */

1615

1616 if (s->all_fragments[i].coding_method == MODE_INTRA) {

1617 vp3_dequant(s, s->all_fragments + i,

1618 plane, 0, block);

1619 s->vp3dsp.idct_put(output_plane + first_pixel,

1620 stride,

1621 block);

1622 } else {

1623 if (vp3_dequant(s, s->all_fragments + i,

1624 plane, 1, block)) {

1625 s->vp3dsp.idct_add(output_plane + first_pixel,

1626 stride,

1627 block);

1628 } else {

1629 s->vp3dsp.idct_dc_add(output_plane + first_pixel,

1630 stride, block);

1631 }

1632 }

1633 } else {

1634 /* copy directly from the previous frame */

1635 s->hdsp.put_pixels_tab[1][0](

1636 output_plane + first_pixel,

1637 last_plane + first_pixel,

1638 stride, 8);

1639 }

1640 }

1641 }

1642

1643 // Filter up to the last row in the superblock row

1644 if (!s->skip_loop_filter)

1645 apply_loop_filter(s, plane, 4 * sb_y - !!sb_y,

1646 FFMIN(4 * sb_y + 3, fragment_height - 1));

1647 }

1648 }

1649

1650 /* this looks like a good place for slice dispatch... */

1651 /* algorithm:

1652 * if (slice == s->macroblock_height - 1)

1653 * dispatch (both last slice & 2nd-to-last slice);

1654 * else if (slice > 0)

1655 * dispatch (slice - 1);

1656 */

1657

1658 vp3_draw_horiz_band(s, FFMIN((32 << s->chroma_y_shift) * (slice + 1) - 16,

1659 s->height - 16));

1660 }

1661

1662 /// Allocate tables for per-frame data in Vp3DecodeContext

1663 static av_cold int allocate_tables(AVCodecContext *avctx)

1664 {

1665 Vp3DecodeContext *s = avctx->priv_data;

1666 int y_fragment_count, c_fragment_count;

1667

1668 free_tables(avctx);

1669

1670 y_fragment_count = s->fragment_width[0] * s->fragment_height[0];

1671 c_fragment_count = s->fragment_width[1] * s->fragment_height[1];

1672

1673 s->superblock_coding = av_mallocz(s->superblock_count);

1674 s->all_fragments = av_mallocz_array(s->fragment_count, sizeof(Vp3Fragment));

1675

1676 s->coded_fragment_list[0] = av_mallocz_array(s->fragment_count, sizeof(int));

1677

1678 s->dct_tokens_base = av_mallocz_array(s->fragment_count,

1679 64 * sizeof(*s->dct_tokens_base));

1680 s->motion_val[0] = av_mallocz_array(y_fragment_count, sizeof(*s->motion_val[0]));

1681 s->motion_val[1] = av_mallocz_array(c_fragment_count, sizeof(*s->motion_val[1]));

1682

1683 /* work out the block mapping tables */

1684 s->superblock_fragments = av_mallocz_array(s->superblock_count, 16 * sizeof(int));

1685 s->macroblock_coding = av_mallocz(s->macroblock_count + 1);

1686

1687 if (!s->superblock_coding || !s->all_fragments ||

1688 !s->dct_tokens_base || !s->coded_fragment_list[0] ||

1689 !s->superblock_fragments || !s->macroblock_coding ||

1690 !s->motion_val[0] || !s->motion_val[1]) {

1691 vp3_decode_end(avctx);

1692 return -1;

1693 }

1694

1695 init_block_mapping(s);

1696

1697 return 0;

1698 }

1699

1700 static av_cold int init_frames(Vp3DecodeContext *s)

1701 {

1702 s->current_frame.f = av_frame_alloc();

1703 s->last_frame.f = av_frame_alloc();

1704 s->golden_frame.f = av_frame_alloc();

1705

1706 if (!s->current_frame.f || !s->last_frame.f || !s->golden_frame.f) {

1707 av_frame_free(&s->current_frame.f);

1708 av_frame_free(&s->last_frame.f);

1709 av_frame_free(&s->golden_frame.f);

1710 return AVERROR(ENOMEM);

1711 }

1712

1713 return 0;

1714 }

1715

1716 static av_cold int vp3_decode_init(AVCodecContext *avctx)

1717 {

1718 Vp3DecodeContext *s = avctx->priv_data;

1719 int i, inter, plane, ret;

1720 int c_width;

1721 int c_height;

1722 int y_fragment_count, c_fragment_count;

1723

1724 ret = init_frames(s);

1725 if (ret < 0)

1726 return ret;

1727

1728 avctx->internal->allocate_progress = 1;

1729

1730 if (avctx->codec_tag == MKTAG('V', 'P', '3', '0'))

1731 s->version = 0;

1732 else

1733 s->version = 1;

1734

1735 s->avctx = avctx;

1736 s->width = FFALIGN(avctx->coded_width, 16);

1737 s->height = FFALIGN(avctx->coded_height, 16);

1738 if (avctx->codec_id != AV_CODEC_ID_THEORA)

1739 avctx->pix_fmt = AV_PIX_FMT_YUV420P;

1740 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;

1741 ff_hpeldsp_init(&s->hdsp, avctx->flags | CODEC_FLAG_BITEXACT);

1742 ff_videodsp_init(&s->vdsp, 8);

1743 ff_vp3dsp_init(&s->vp3dsp, avctx->flags);

1744

1745 for (i = 0; i < 64; i++) {

1746 #define TRANSPOSE(x) (((x) >> 3) | (((x) & 7) << 3))

1747 s->idct_permutation[i] = TRANSPOSE(i);

1748 s->idct_scantable[i] = TRANSPOSE(ff_zigzag_direct[i]);

1749 #undef TRANSPOSE

1750 }

1751

1752 /* initialize to an impossible value which will force a recalculation

1753 * in the first frame decode */

1754 for (i = 0; i < 3; i++)

1755 s->qps[i] = -1;

1756

1757 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_x_shift, &s->chroma_y_shift);

1758

1759 s->y_superblock_width = (s->width + 31) / 32;

1760 s->y_superblock_height = (s->height + 31) / 32;

1761 s->y_superblock_count = s->y_superblock_width * s->y_superblock_height;

1762

1763 /* work out the dimensions for the C planes */

1764 c_width = s->width >> s->chroma_x_shift;

1765 c_height = s->height >> s->chroma_y_shift;

1766 s->c_superblock_width = (c_width + 31) / 32;

1767 s->c_superblock_height = (c_height + 31) / 32;

1768 s->c_superblock_count = s->c_superblock_width * s->c_superblock_height;

1769

1770 s->superblock_count = s->y_superblock_count + (s->c_superblock_count * 2);

1771 s->u_superblock_start = s->y_superblock_count;

1772 s->v_superblock_start = s->u_superblock_start + s->c_superblock_count;

1773

1774 s->macroblock_width = (s->width + 15) / 16;

1775 s->macroblock_height = (s->height + 15) / 16;

1776 s->macroblock_count = s->macroblock_width * s->macroblock_height;

1777

1778 s->fragment_width[0] = s->width / FRAGMENT_PIXELS;

1779 s->fragment_height[0] = s->height / FRAGMENT_PIXELS;

1780 s->fragment_width[1] = s->fragment_width[0] >> s->chroma_x_shift;

1781 s->fragment_height[1] = s->fragment_height[0] >> s->chroma_y_shift;

1782

1783 /* fragment count covers all 8x8 blocks for all 3 planes */

1784 y_fragment_count = s->fragment_width[0] * s->fragment_height[0];

1785 c_fragment_count = s->fragment_width[1] * s->fragment_height[1];

1786 s->fragment_count = y_fragment_count + 2 * c_fragment_count;

1787 s->fragment_start[1] = y_fragment_count;

1788 s->fragment_start[2] = y_fragment_count + c_fragment_count;

1789

1790 if (!s->theora_tables) {

1791 for (i = 0; i < 64; i++) {

1792 s->coded_dc_scale_factor[i] = vp31_dc_scale_factor[i];

1793 s->coded_ac_scale_factor[i] = vp31_ac_scale_factor[i];

1794 s->base_matrix[0][i] = vp31_intra_y_dequant[i];

1795 s->base_matrix[1][i] = vp31_intra_c_dequant[i];

1796 s->base_matrix[2][i] = vp31_inter_dequant[i];

1797 s->filter_limit_values[i] = vp31_filter_limit_values[i];

1798 }

1799

1800 for (inter = 0; inter < 2; inter++) {

1801 for (plane = 0; plane < 3; plane++) {

1802 s->qr_count[inter][plane] = 1;

1803 s->qr_size[inter][plane][0] = 63;

1804 s->qr_base[inter][plane][0] =

1805 s->qr_base[inter][plane][1] = 2 * inter + (!!plane) * !inter;

1806 }

1807 }

1808

1809 /* init VLC tables */

1810 for (i = 0; i < 16; i++) {

1811 /* DC histograms */

1812 init_vlc(&s->dc_vlc[i], 11, 32,

1813 &dc_bias[i][0][1], 4, 2,

1814 &dc_bias[i][0][0], 4, 2, 0);

1815

1816 /* group 1 AC histograms */

1817 init_vlc(&s->ac_vlc_1[i], 11, 32,

1818 &ac_bias_0[i][0][1], 4, 2,

1819 &ac_bias_0[i][0][0], 4, 2, 0);

1820

1821 /* group 2 AC histograms */

1822 init_vlc(&s->ac_vlc_2[i], 11, 32,

1823 &ac_bias_1[i][0][1], 4, 2,

1824 &ac_bias_1[i][0][0], 4, 2, 0);

1825

1826 /* group 3 AC histograms */

1827 init_vlc(&s->ac_vlc_3[i], 11, 32,

1828 &ac_bias_2[i][0][1], 4, 2,

1829 &ac_bias_2[i][0][0], 4, 2, 0);

1830

1831 /* group 4 AC histograms */

1832 init_vlc(&s->ac_vlc_4[i], 11, 32,

1833 &ac_bias_3[i][0][1], 4, 2,

1834 &ac_bias_3[i][0][0], 4, 2, 0);

1835 }

1836 } else {

1837 for (i = 0; i < 16; i++) {

1838 /* DC histograms */

1839 if (init_vlc(&s->dc_vlc[i], 11, 32,

1840 &s->huffman_table[i][0][1], 8, 4,

1841 &s->huffman_table[i][0][0], 8, 4, 0) < 0)

1842 goto vlc_fail;

1843

1844 /* group 1 AC histograms */

1845 if (init_vlc(&s->ac_vlc_1[i], 11, 32,

1846 &s->huffman_table[i + 16][0][1], 8, 4,

1847 &s->huffman_table[i + 16][0][0], 8, 4, 0) < 0)

1848 goto vlc_fail;

1849

1850 /* group 2 AC histograms */

1851 if (init_vlc(&s->ac_vlc_2[i], 11, 32,

1852 &s->huffman_table[i + 16 * 2][0][1], 8, 4,

1853 &s->huffman_table[i + 16 * 2][0][0], 8, 4, 0) < 0)

1854 goto vlc_fail;

1855

1856 /* group 3 AC histograms */

1857 if (init_vlc(&s->ac_vlc_3[i], 11, 32,

1858 &s->huffman_table[i + 16 * 3][0][1], 8, 4,

1859 &s->huffman_table[i + 16 * 3][0][0], 8, 4, 0) < 0)

1860 goto vlc_fail;

1861

1862 /* group 4 AC histograms */

1863 if (init_vlc(&s->ac_vlc_4[i], 11, 32,

1864 &s->huffman_table[i + 16 * 4][0][1], 8, 4,

1865 &s->huffman_table[i + 16 * 4][0][0], 8, 4, 0) < 0)

1866 goto vlc_fail;

1867 }

1868 }

1869

1870 init_vlc(&s->superblock_run_length_vlc, 6, 34,

1871 &superblock_run_length_vlc_table[0][1], 4, 2,

1872 &superblock_run_length_vlc_table[0][0], 4, 2, 0);

1873

1874 init_vlc(&s->fragment_run_length_vlc, 5, 30,

1875 &fragment_run_length_vlc_table[0][1], 4, 2,

1876 &fragment_run_length_vlc_table[0][0], 4, 2, 0);

1877

1878 init_vlc(&s->mode_code_vlc, 3, 8,

1879 &mode_code_vlc_table[0][1], 2, 1,

1880 &mode_code_vlc_table[0][0], 2, 1, 0);

1881

1882 init_vlc(&s->motion_vector_vlc, 6, 63,

1883 &motion_vector_vlc_table[0][1], 2, 1,

1884 &motion_vector_vlc_table[0][0], 2, 1, 0);

1885

1886 return allocate_tables(avctx);

1887

1888 vlc_fail:

1889 av_log(avctx, AV_LOG_FATAL, "Invalid huffman table\n");

1890 return -1;

1891 }

1892

1893 /// Release and shuffle frames after decode finishes

1894 static int update_frames(AVCodecContext *avctx)

1895 {

1896 Vp3DecodeContext *s = avctx->priv_data;

1897 int ret = 0;

1898

1899 /* shuffle frames (last = current) */

1900 ff_thread_release_buffer(avctx, &s->last_frame);

1901 ret = ff_thread_ref_frame(&s->last_frame, &s->current_frame);

1902 if (ret < 0)

1903 goto fail;

1904

1905 if (s->keyframe) {

1906 ff_thread_release_buffer(avctx, &s->golden_frame);

1907 ret = ff_thread_ref_frame(&s->golden_frame, &s->current_frame);

1908 }

1909

1910 fail:

1911 ff_thread_release_buffer(avctx, &s->current_frame);

1912 return ret;

1913 }

1914

1915 static int ref_frame(Vp3DecodeContext *s, ThreadFrame *dst, ThreadFrame *src)

1916 {

1917 ff_thread_release_buffer(s->avctx, dst);

1918 if (src->f->data[0])

1919 return ff_thread_ref_frame(dst, src);

1920 return 0;

1921 }

1922

1923 static int ref_frames(Vp3DecodeContext *dst, Vp3DecodeContext *src)

1924 {

1925 int ret;

1926 if ((ret = ref_frame(dst, &dst->current_frame, &src->current_frame)) < 0 ||

1927 (ret = ref_frame(dst, &dst->golden_frame, &src->golden_frame)) < 0 ||

1928 (ret = ref_frame(dst, &dst->last_frame, &src->last_frame)) < 0)

1929 return ret;

1930 return 0;

1931 }

1932

1933 static int vp3_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)

1934 {

1935 Vp3DecodeContext *s = dst->priv_data, *s1 = src->priv_data;

1936 int qps_changed = 0, i, err;

1937

1938 #define copy_fields(to, from, start_field, end_field) \

1939 memcpy(&to->start_field, &from->start_field, \

1940 (char *) &to->end_field - (char *) &to->start_field)

1941

1942 if (!s1->current_frame.f->data[0] ||

1943 s->width != s1->width || s->height != s1->height) {

1944 if (s != s1)

1945 ref_frames(s, s1);

1946 return -1;

1947 }

1948

1949 if (s != s1) {

1950 // init tables if the first frame hasn't been decoded

1951 if (!s->current_frame.f->data[0]) {

1952 int y_fragment_count, c_fragment_count;

1953 s->avctx = dst;

1954 err = allocate_tables(dst);

1955 if (err)

1956 return err;

1957 y_fragment_count = s->fragment_width[0] * s->fragment_height[0];

1958 c_fragment_count = s->fragment_width[1] * s->fragment_height[1];

1959 memcpy(s->motion_val[0], s1->motion_val[0],

1960 y_fragment_count * sizeof(*s->motion_val[0]));

1961 memcpy(s->motion_val[1], s1->motion_val[1],

1962 c_fragment_count * sizeof(*s->motion_val[1]));

1963 }

1964

1965 // copy previous frame data

1966 if ((err = ref_frames(s, s1)) < 0)

1967 return err;

1968

1969 s->keyframe = s1->keyframe;

1970

1971 // copy qscale data if necessary

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

1973 if (s->qps[i] != s1->qps[1]) {

1974 qps_changed = 1;

1975 memcpy(&s->qmat[i], &s1->qmat[i], sizeof(s->qmat[i]));

1976 }

1977 }

1978

1979 if (s->qps[0] != s1->qps[0])

1980 memcpy(&s->bounding_values_array, &s1->bounding_values_array,

1981 sizeof(s->bounding_values_array));

1982

1983 if (qps_changed)

1984 copy_fields(s, s1, qps, superblock_count);

1985 #undef copy_fields

1986 }

1987

1988 return update_frames(dst);

1989 }

1990

1991 static int vp3_decode_frame(AVCodecContext *avctx,

1992 void *data, int *got_frame,

1993 AVPacket *avpkt)

1994 {

1995 const uint8_t *buf = avpkt->data;

1996 int buf_size = avpkt->size;

1997 Vp3DecodeContext *s = avctx->priv_data;

1998 GetBitContext gb;

1999 int i, ret;

2000

2001 if ((ret = init_get_bits8(&gb, buf, buf_size)) < 0)

2002 return ret;

2003

2004 #if CONFIG_THEORA_DECODER

2005 if (s->theora && get_bits1(&gb)) {

2006 int type = get_bits(&gb, 7);

2007 skip_bits_long(&gb, 6*8); /* "theora" */

2008

2009 if (s->avctx->active_thread_type&FF_THREAD_FRAME) {

2010 av_log(avctx, AV_LOG_ERROR, "midstream reconfiguration with multithreading is unsupported, try -threads 1\n");

2011 return AVERROR_PATCHWELCOME;

2012 }

2013 if (type == 0) {

2014 vp3_decode_end(avctx);

2015 ret = theora_decode_header(avctx, &gb);

2016

2017 if (ret < 0) {

2018 vp3_decode_end(avctx);

2019 } else

2020 ret = vp3_decode_init(avctx);

2021 return ret;

2022 } else if (type == 2) {

2023 ret = theora_decode_tables(avctx, &gb);

2024 if (ret < 0) {

2025 vp3_decode_end(avctx);

2026 } else

2027 ret = vp3_decode_init(avctx);

2028 return ret;

2029 }

2030

2031 av_log(avctx, AV_LOG_ERROR,

2032 "Header packet passed to frame decoder, skipping\n");

2033 return -1;

2034 }

2035 #endif

2036

2037 s->keyframe = !get_bits1(&gb);

2038 if (!s->all_fragments) {

2039 av_log(avctx, AV_LOG_ERROR, "Data packet without prior valid headers\n");

2040 return -1;

2041 }

2042 if (!s->theora)

2043 skip_bits(&gb, 1);

2044 for (i = 0; i < 3; i++)

2045 s->last_qps[i] = s->qps[i];

2046

2047 s->nqps = 0;

2048 do {

2049 s->qps[s->nqps++] = get_bits(&gb, 6);

2050 } while (s->theora >= 0x030200 && s->nqps < 3 && get_bits1(&gb));

2051 for (i = s->nqps; i < 3; i++)

2052 s->qps[i] = -1;

2053

2054 if (s->avctx->debug & FF_DEBUG_PICT_INFO)

2055 av_log(s->avctx, AV_LOG_INFO, " VP3 %sframe #%d: Q index = %d\n",

2056 s->keyframe ? "key" : "", avctx->frame_number + 1, s->qps[0]);

2057

2058 s->skip_loop_filter = !s->filter_limit_values[s->qps[0]] ||

2059 avctx->skip_loop_filter >= (s->keyframe ? AVDISCARD_ALL

2060 : AVDISCARD_NONKEY);

2061

2062 if (s->qps[0] != s->last_qps[0])

2063 init_loop_filter(s);

2064

2065 for (i = 0; i < s->nqps; i++)

2066 // reinit all dequantizers if the first one changed, because

2067 // the DC of the first quantizer must be used for all matrices

2068 if (s->qps[i] != s->last_qps[i] || s->qps[0] != s->last_qps[0])

2069 init_dequantizer(s, i);

2070

2071 if (avctx->skip_frame >= AVDISCARD_NONKEY && !s->keyframe)

2072 return buf_size;

2073

2074 s->current_frame.f->pict_type = s->keyframe ? AV_PICTURE_TYPE_I

2075 : AV_PICTURE_TYPE_P;

2076 s->current_frame.f->key_frame = s->keyframe;

2077 if (ff_thread_get_buffer(avctx, &s->current_frame, AV_GET_BUFFER_FLAG_REF) < 0)

2078 goto error;

2079

2080 if (!s->edge_emu_buffer)

2081 s->edge_emu_buffer = av_malloc(9 * FFABS(s->current_frame.f->linesize[0]));

2082

2083 if (s->keyframe) {

2084 if (!s->theora) {

2085 skip_bits(&gb, 4); /* width code */

2086 skip_bits(&gb, 4); /* height code */

2087 if (s->version) {

2088 s->version = get_bits(&gb, 5);

2089 if (avctx->frame_number == 0)

2090 av_log(s->avctx, AV_LOG_DEBUG,

2091 "VP version: %d\n", s->version);

2092 }

2093 }

2094 if (s->version || s->theora) {

2095 if (get_bits1(&gb))

2096 av_log(s->avctx, AV_LOG_ERROR,

2097 "Warning, unsupported keyframe coding type?!\n");

2098 skip_bits(&gb, 2); /* reserved? */

2099 }

2100 } else {

2101 if (!s->golden_frame.f->data[0]) {

2102 av_log(s->avctx, AV_LOG_WARNING,

2103 "vp3: first frame not a keyframe\n");

2104

2105 s->golden_frame.f->pict_type = AV_PICTURE_TYPE_I;

2106 if (ff_thread_get_buffer(avctx, &s->golden_frame,

2107 AV_GET_BUFFER_FLAG_REF) < 0)

2108 goto error;

2109 ff_thread_release_buffer(avctx, &s->last_frame);

2110 if ((ret = ff_thread_ref_frame(&s->last_frame,

2111 &s->golden_frame)) < 0)

2112 goto error;

2113 ff_thread_report_progress(&s->last_frame, INT_MAX, 0);

2114 }

2115 }

2116

2117 memset(s->all_fragments, 0, s->fragment_count * sizeof(Vp3Fragment));

2118 ff_thread_finish_setup(avctx);

2119

2120 if (unpack_superblocks(s, &gb)) {

2121 av_log(s->avctx, AV_LOG_ERROR, "error in unpack_superblocks\n");

2122 goto error;

2123 }

2124 if (unpack_modes(s, &gb)) {

2125 av_log(s->avctx, AV_LOG_ERROR, "error in unpack_modes\n");

2126 goto error;

2127 }

2128 if (unpack_vectors(s, &gb)) {

2129 av_log(s->avctx, AV_LOG_ERROR, "error in unpack_vectors\n");

2130 goto error;

2131 }

2132 if (unpack_block_qpis(s, &gb)) {

2133 av_log(s->avctx, AV_LOG_ERROR, "error in unpack_block_qpis\n");

2134 goto error;

2135 }

2136 if (unpack_dct_coeffs(s, &gb)) {

2137 av_log(s->avctx, AV_LOG_ERROR, "error in unpack_dct_coeffs\n");

2138 goto error;

2139 }

2140

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

2142 int height = s->height >> (i && s->chroma_y_shift);

2143 if (s->flipped_image)

2144 s->data_offset[i] = 0;

2145 else

2146 s->data_offset[i] = (height - 1) * s->current_frame.f->linesize[i];

2147 }

2148

2149 s->last_slice_end = 0;

2150 for (i = 0; i < s->c_superblock_height; i++)

2151 render_slice(s, i);

2152

2153 // filter the last row

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

2155 int row = (s->height >> (3 + (i && s->chroma_y_shift))) - 1;

2156 apply_loop_filter(s, i, row, row + 1);

2157 }

2158 vp3_draw_horiz_band(s, s->height);

2159

2160 /* output frame, offset as needed */

2161 if ((ret = av_frame_ref(data, s->current_frame.f)) < 0)

2162 return ret;

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

2164 AVFrame *dst = data;

2165 int off = (s->offset_x >> (i && s->chroma_y_shift)) +

2166 (s->offset_y >> (i && s->chroma_y_shift)) * dst->linesize[i];

2167 dst->data[i] += off;

2168 }

2169 *got_frame = 1;

2170

2171 if (!HAVE_THREADS || !(s->avctx->active_thread_type & FF_THREAD_FRAME)) {

2172 ret = update_frames(avctx);

2173 if (ret < 0)

2174 return ret;

2175 }

2176

2177 return buf_size;

2178

2179 error:

2180 ff_thread_report_progress(&s->current_frame, INT_MAX, 0);

2181

2182 if (!HAVE_THREADS || !(s->avctx->active_thread_type & FF_THREAD_FRAME))

2183 av_frame_unref(s->current_frame.f);

2184

2185 return -1;

2186 }

2187

2188 static int read_huffman_tree(AVCodecContext *avctx, GetBitContext *gb)

2189 {

2190 Vp3DecodeContext *s = avctx->priv_data;

2191

2192 if (get_bits1(gb)) {

2193 int token;

2194 if (s->entries >= 32) { /* overflow */

2195 av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n");

2196 return -1;

2197 }

2198 token = get_bits(gb, 5);

2199 av_dlog(avctx, "hti %d hbits %x token %d entry : %d size %d\n",

2200 s->hti, s->hbits, token, s->entries, s->huff_code_size);

2201 s->huffman_table[s->hti][token][0] = s->hbits;

2202 s->huffman_table[s->hti][token][1] = s->huff_code_size;

2203 s->entries++;

2204 } else {

2205 if (s->huff_code_size >= 32) { /* overflow */

2206 av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n");

2207 return -1;

2208 }

2209 s->huff_code_size++;

2210 s->hbits <<= 1;

2211 if (read_huffman_tree(avctx, gb))

2212 return -1;

2213 s->hbits |= 1;

2214 if (read_huffman_tree(avctx, gb))

2215 return -1;

2216 s->hbits >>= 1;

2217 s->huff_code_size--;

2218 }

2219 return 0;

2220 }

2221

2222 static int vp3_init_thread_copy(AVCodecContext *avctx)

2223 {

2224 Vp3DecodeContext *s = avctx->priv_data;

2225

2226 s->superblock_coding = NULL;

2227 s->all_fragments = NULL;

2228 s->coded_fragment_list[0] = NULL;

2229 s->dct_tokens_base = NULL;

2230 s->superblock_fragments = NULL;

2231 s->macroblock_coding = NULL;

2232 s->motion_val[0] = NULL;

2233 s->motion_val[1] = NULL;

2234 s->edge_emu_buffer = NULL;

2235

2236 return init_frames(s);

2237 }

2238

2239 #if CONFIG_THEORA_DECODER

2240 static const enum AVPixelFormat theora_pix_fmts[4] = {

2241 AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P

2242 };

2243

2244 static int theora_decode_header(AVCodecContext *avctx, GetBitContext *gb)

2245 {

2246 Vp3DecodeContext *s = avctx->priv_data;

2247 int visible_width, visible_height, colorspace;

2248 uint8_t offset_x = 0, offset_y = 0;

2249 int ret;

2250 AVRational fps, aspect;

2251

2252 s->theora = get_bits_long(gb, 24);

2253 av_log(avctx, AV_LOG_DEBUG, "Theora bitstream version %X\n", s->theora);

2254

2255 /* 3.2.0 aka alpha3 has the same frame orientation as original vp3

2256 * but previous versions have the image flipped relative to vp3 */

2257 if (s->theora < 0x030200) {

2258 s->flipped_image = 1;

2259 av_log(avctx, AV_LOG_DEBUG,

2260 "Old (<alpha3) Theora bitstream, flipped image\n");

2261 }

2262

2263 visible_width =

2264 s->width = get_bits(gb, 16) << 4;

2265 visible_height =

2266 s->height = get_bits(gb, 16) << 4;

2267

2268 if (s->theora >= 0x030200) {

2269 visible_width = get_bits_long(gb, 24);

2270 visible_height = get_bits_long(gb, 24);

2271

2272 offset_x = get_bits(gb, 8); /* offset x */

2273 offset_y = get_bits(gb, 8); /* offset y, from bottom */

2274 }

2275

2276 /* sanity check */

2277 if (av_image_check_size(visible_width, visible_height, 0, avctx) < 0 ||

2278 visible_width + offset_x > s->width ||

2279 visible_height + offset_y > s->height) {

2280 av_log(avctx, AV_LOG_ERROR,

2281 "Invalid frame dimensions - w:%d h:%d x:%d y:%d (%dx%d).\n",

2282 visible_width, visible_height, offset_x, offset_y,

2283 s->width, s->height);

2284 return AVERROR_INVALIDDATA;

2285 }

2286

2287 fps.num = get_bits_long(gb, 32);

2288 fps.den = get_bits_long(gb, 32);

2289 if (fps.num && fps.den) {

2290 if (fps.num < 0 || fps.den < 0) {

2291 av_log(avctx, AV_LOG_ERROR, "Invalid framerate\n");

2292 return AVERROR_INVALIDDATA;

2293 }

2294 av_reduce(&avctx->framerate.den, &avctx->framerate.num,

2295 fps.den, fps.num, 1 << 30);

2296 }

2297

2298 aspect.num = get_bits_long(gb, 24);

2299 aspect.den = get_bits_long(gb, 24);

2300 if (aspect.num && aspect.den) {

2301 av_reduce(&avctx->sample_aspect_ratio.num,

2302 &avctx->sample_aspect_ratio.den,

2303 aspect.num, aspect.den, 1 << 30);

2304 ff_set_sar(avctx, avctx->sample_aspect_ratio);

2305 }

2306

2307 if (s->theora < 0x030200)

2308 skip_bits(gb, 5); /* keyframe frequency force */

2309 colorspace = get_bits(gb, 8);

2310 skip_bits(gb, 24); /* bitrate */

2311

2312 skip_bits(gb, 6); /* quality hint */

2313

2314 if (s->theora >= 0x030200) {

2315 skip_bits(gb, 5); /* keyframe frequency force */

2316 avctx->pix_fmt = theora_pix_fmts[get_bits(gb, 2)];

2317 if (avctx->pix_fmt == AV_PIX_FMT_NONE) {

2318 av_log(avctx, AV_LOG_ERROR, "Invalid pixel format\n");

2319 return AVERROR_INVALIDDATA;

2320 }

2321 skip_bits(gb, 3); /* reserved */

2322 }

2323

2324 ret = ff_set_dimensions(avctx, s->width, s->height);

2325 if (ret < 0)

2326 return ret;

2327 if (!(avctx->flags2 & CODEC_FLAG2_IGNORE_CROP)) {

2328 avctx->width = visible_width;

2329 avctx->height = visible_height;

2330 // translate offsets from theora axis ([0,0] lower left)

2331 // to normal axis ([0,0] upper left)

2332 s->offset_x = offset_x;

2333 s->offset_y = s->height - visible_height - offset_y;

2334

2335 if ((s->offset_x & 0x1F) && !(avctx->flags & CODEC_FLAG_UNALIGNED)) {

2336 s->offset_x &= ~0x1F;

2337 if (!s->offset_x_warned) {

2338 s->offset_x_warned = 1;

2339 av_log(avctx, AV_LOG_WARNING, "Reducing offset_x from %d to %d"

2340 "chroma samples to preserve alignment.\n",

2341 offset_x, s->offset_x);

2342 }

2343 }

2344 }

2345

2346 if (colorspace == 1)

2347 avctx->color_primaries = AVCOL_PRI_BT470M;

2348 else if (colorspace == 2)

2349 avctx->color_primaries = AVCOL_PRI_BT470BG;

2350

2351 if (colorspace == 1 || colorspace == 2) {

2352 avctx->colorspace = AVCOL_SPC_BT470BG;

2353 avctx->color_trc = AVCOL_TRC_BT709;

2354 }

2355

2356 return 0;

2357 }

2358

2359 static int theora_decode_tables(AVCodecContext *avctx, GetBitContext *gb)

2360 {

2361 Vp3DecodeContext *s = avctx->priv_data;

2362 int i, n, matrices, inter, plane;

2363

2364 if (s->theora >= 0x030200) {

2365 n = get_bits(gb, 3);

2366 /* loop filter limit values table */

2367 if (n)

2368 for (i = 0; i < 64; i++)

2369 s->filter_limit_values[i] = get_bits(gb, n);

2370 }

2371

2372 if (s->theora >= 0x030200)

2373 n = get_bits(gb, 4) + 1;

2374 else

2375 n = 16;

2376 /* quality threshold table */

2377 for (i = 0; i < 64; i++)

2378 s->coded_ac_scale_factor[i] = get_bits(gb, n);

2379

2380 if (s->theora >= 0x030200)

2381 n = get_bits(gb, 4) + 1;

2382 else

2383 n = 16;

2384 /* dc scale factor table */

2385 for (i = 0; i < 64; i++)

2386 s->coded_dc_scale_factor[i] = get_bits(gb, n);

2387

2388 if (s->theora >= 0x030200)

2389 matrices = get_bits(gb, 9) + 1;

2390 else

2391 matrices = 3;

2392

2393 if (matrices > 384) {

2394 av_log(avctx, AV_LOG_ERROR, "invalid number of base matrixes\n");

2395 return -1;

2396 }

2397

2398 for (n = 0; n < matrices; n++)

2399 for (i = 0; i < 64; i++)

2400 s->base_matrix[n][i] = get_bits(gb, 8);

2401

2402 for (inter = 0; inter <= 1; inter++) {

2403 for (plane = 0; plane <= 2; plane++) {

2404 int newqr = 1;

2405 if (inter || plane > 0)

2406 newqr = get_bits1(gb);

2407 if (!newqr) {

2408 int qtj, plj;

2409 if (inter && get_bits1(gb)) {

2410 qtj = 0;

2411 plj = plane;

2412 } else {

2413 qtj = (3 * inter + plane - 1) / 3;

2414 plj = (plane + 2) % 3;

2415 }

2416 s->qr_count[inter][plane] = s->qr_count[qtj][plj];

2417 memcpy(s->qr_size[inter][plane], s->qr_size[qtj][plj],

2418 sizeof(s->qr_size[0][0]));

2419 memcpy(s->qr_base[inter][plane], s->qr_base[qtj][plj],

2420 sizeof(s->qr_base[0][0]));

2421 } else {

2422 int qri = 0;

2423 int qi = 0;

2424

2425 for (;;) {

2426 i = get_bits(gb, av_log2(matrices - 1) + 1);

2427 if (i >= matrices) {

2428 av_log(avctx, AV_LOG_ERROR,

2429 "invalid base matrix index\n");

2430 return -1;

2431 }

2432 s->qr_base[inter][plane][qri] = i;

2433 if (qi >= 63)

2434 break;

2435 i = get_bits(gb, av_log2(63 - qi) + 1) + 1;

2436 s->qr_size[inter][plane][qri++] = i;

2437 qi += i;

2438 }

2439

2440 if (qi > 63) {

2441 av_log(avctx, AV_LOG_ERROR, "invalid qi %d > 63\n", qi);

2442 return -1;

2443 }

2444 s->qr_count[inter][plane] = qri;

2445 }

2446 }

2447 }

2448

2449 /* Huffman tables */

2450 for (s->hti = 0; s->hti < 80; s->hti++) {

2451 s->entries = 0;

2452 s->huff_code_size = 1;

2453 if (!get_bits1(gb)) {

2454 s->hbits = 0;

2455 if (read_huffman_tree(avctx, gb))

2456 return -1;

2457 s->hbits = 1;

2458 if (read_huffman_tree(avctx, gb))

2459 return -1;

2460 }

2461 }

2462

2463 s->theora_tables = 1;

2464

2465 return 0;

2466 }

2467

2468 static av_cold int theora_decode_init(AVCodecContext *avctx)

2469 {

2470 Vp3DecodeContext *s = avctx->priv_data;

2471 GetBitContext gb;

2472 int ptype;

2473 const uint8_t *header_start[3];

2474 int header_len[3];

2475 int i;

2476

2477 avctx->pix_fmt = AV_PIX_FMT_YUV420P;

2478

2479 s->theora = 1;

2480

2481 if (!avctx->extradata_size) {

2482 av_log(avctx, AV_LOG_ERROR, "Missing extradata!\n");

2483 return -1;

2484 }

2485

2486 if (avpriv_split_xiph_headers(avctx->extradata, avctx->extradata_size,

2487 42, header_start, header_len) < 0) {

2488 av_log(avctx, AV_LOG_ERROR, "Corrupt extradata\n");

2489 return -1;

2490 }

2491

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

2493 if (header_len[i] <= 0)

2494 continue;

2495 init_get_bits8(&gb, header_start[i], header_len[i]);

2496

2497 ptype = get_bits(&gb, 8);

2498

2499 if (!(ptype & 0x80)) {

2500 av_log(avctx, AV_LOG_ERROR, "Invalid extradata!\n");

2501 // return -1;

2502 }

2503

2504 // FIXME: Check for this as well.

2505 skip_bits_long(&gb, 6 * 8); /* "theora" */

2506

2507 switch (ptype) {

2508 case 0x80:

2509 if (theora_decode_header(avctx, &gb) < 0)

2510 return -1;

2511 break;

2512 case 0x81:

2513 // FIXME: is this needed? it breaks sometimes

2514 // theora_decode_comments(avctx, gb);

2515 break;

2516 case 0x82:

2517 if (theora_decode_tables(avctx, &gb))

2518 return -1;

2519 break;

2520 default:

2521 av_log(avctx, AV_LOG_ERROR,

2522 "Unknown Theora config packet: %d\n", ptype & ~0x80);

2523 break;

2524 }

2525 if (ptype != 0x81 && 8 * header_len[i] != get_bits_count(&gb))

2526 av_log(avctx, AV_LOG_WARNING,

2527 "%d bits left in packet %X\n",

2528 8 * header_len[i] - get_bits_count(&gb), ptype);

2529 if (s->theora < 0x030200)

2530 break;

2531 }

2532

2533 return vp3_decode_init(avctx);

2534 }

2535

2536 AVCodec ff_theora_decoder = {

2537 .name = "theora",

2538 .long_name = NULL_IF_CONFIG_SMALL("Theora"),

2539 .type = AVMEDIA_TYPE_VIDEO,

2540 .id = AV_CODEC_ID_THEORA,

2541 .priv_data_size = sizeof(Vp3DecodeContext),

2542 .init = theora_decode_init,

2543 .close = vp3_decode_end,

2544 .decode = vp3_decode_frame,

2545 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND |

2546 CODEC_CAP_FRAME_THREADS,

2547 .flush = vp3_decode_flush,

2548 .init_thread_copy = ONLY_IF_THREADS_ENABLED(vp3_init_thread_copy),

2549 .update_thread_context = ONLY_IF_THREADS_ENABLED(vp3_update_thread_context)

2550 };

2551 #endif

2552

2553 AVCodec ff_vp3_decoder = {

2554 .name = "vp3",

2555 .long_name = NULL_IF_CONFIG_SMALL("On2 VP3"),

2556 .type = AVMEDIA_TYPE_VIDEO,

2557 .id = AV_CODEC_ID_VP3,

2558 .priv_data_size = sizeof(Vp3DecodeContext),

2559 .init = vp3_decode_init,

2560 .close = vp3_decode_end,

2561 .decode = vp3_decode_frame,

2562 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND |

2563 CODEC_CAP_FRAME_THREADS,

2564 .flush = vp3_decode_flush,

2565 .init_thread_copy = ONLY_IF_THREADS_ENABLED(vp3_init_thread_copy),

2566 .update_thread_context = ONLY_IF_THREADS_ENABLED(vp3_update_thread_context),

2567 };

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