Go to the documentation of this file.
33 #include "config_components.h"
61 #define VP3_MV_VLC_BITS 6
62 #define VP4_MV_VLC_BITS 6
63 #define SUPERBLOCK_VLC_BITS 6
65 #define FRAGMENT_PIXELS 8
74 #define SB_NOT_CODED 0
75 #define SB_PARTIALLY_CODED 1
76 #define SB_FULLY_CODED 2
81 #define MAXIMUM_LONG_BIT_RUN 4129
83 #define MODE_INTER_NO_MV 0
85 #define MODE_INTER_PLUS_MV 2
86 #define MODE_INTER_LAST_MV 3
87 #define MODE_INTER_PRIOR_LAST 4
88 #define MODE_USING_GOLDEN 5
89 #define MODE_GOLDEN_MV 6
90 #define MODE_INTER_FOURMV 7
91 #define CODING_MODE_COUNT 8
140 { 0, 0 }, { 1, 0 }, { 1, 1 }, { 0, 1 },
141 { 0, 2 }, { 0, 3 }, { 1, 3 }, { 1, 2 },
142 { 2, 2 }, { 2, 3 }, { 3, 3 }, { 3, 2 },
143 { 3, 1 }, { 2, 1 }, { 2, 0 }, { 3, 0 }
172 #if CONFIG_VP4_DECODER
173 static const VLCElem *vp4_mv_vlc_table[2][7];
174 static const VLCElem *block_pattern_vlc[2];
182 #define MIN_DEQUANT_VAL 2
281 #define TOKEN_EOB(eob_run) ((eob_run) << 2)
282 #define TOKEN_ZERO_RUN(coeff, zero_run) (((coeff) * 512) + ((zero_run) << 2) + 1)
283 #define TOKEN_COEFF(coeff) (((coeff) * 4) + 2)
368 s->theora_tables = 0;
389 for (
int plane = 0; plane < 3; plane++) {
390 int sb_width = plane ?
s->c_superblock_width
391 :
s->y_superblock_width;
392 int sb_height = plane ?
s->c_superblock_height
393 :
s->y_superblock_height;
394 int frag_width =
s->fragment_width[!!plane];
395 int frag_height =
s->fragment_height[!!plane];
397 for (
int sb_y = 0; sb_y < sb_height; sb_y++)
398 for (
int sb_x = 0; sb_x < sb_width; sb_x++)
399 for (
int i = 0;
i < 16;
i++) {
403 if (x < frag_width && y < frag_height)
404 s->superblock_fragments[j++] =
s->fragment_start[plane] +
407 s->superblock_fragments[j++] = -1;
420 int ac_scale_factor =
s->coded_ac_scale_factor[
s->qps[qpi]];
422 for (
int inter = 0; inter < 2; inter++) {
423 for (
int plane = 0; plane < 3; plane++) {
424 int dc_scale_factor =
s->coded_dc_scale_factor[!!plane][
s->qps[qpi]];
425 int sum = 0, bmi, bmj, qistart, qri;
426 for (qri = 0; qri <
s->qr_count[inter][plane]; qri++) {
427 sum +=
s->qr_size[inter][plane][qri];
428 if (
s->qps[qpi] <= sum)
431 qistart = sum -
s->qr_size[inter][plane][qri];
432 bmi =
s->qr_base[inter][plane][qri];
433 bmj =
s->qr_base[inter][plane][qri + 1];
434 for (
int i = 0;
i < 64;
i++) {
435 int coeff = (2 * (sum -
s->qps[qpi]) *
s->base_matrix[bmi][
i] -
436 2 * (qistart -
s->qps[qpi]) *
s->base_matrix[bmj][
i] +
437 s->qr_size[inter][plane][qri]) /
438 (2 *
s->qr_size[inter][plane][qri]);
440 int qmin = 8 << (inter + !
i);
441 int qscale =
i ? ac_scale_factor : dc_scale_factor;
442 int qbias = (1 + inter) * 3;
443 s->qmat[qpi][inter][plane][
s->idct_permutation[
i]] =
444 (
i == 0 ||
s->version < 2) ?
av_clip((qscale *
coeff) / 100 * 4, qmin, 4096)
445 : (qscale * (
coeff - qbias) / 100 + qbias) * 4;
449 s->qmat[qpi][inter][plane][0] =
s->qmat[0][inter][plane][0];
471 const int superblock_starts[3] = {
472 0,
s->u_superblock_start,
s->v_superblock_start
475 int current_superblock = 0;
477 int num_partial_superblocks = 0;
479 int current_fragment;
480 int plane0_num_coded_frags = 0;
489 while (current_superblock < s->superblock_count &&
get_bits_left(gb) > 0) {
497 if (current_run == 34)
500 if (current_run >
s->superblock_count - current_superblock) {
502 "Invalid partially coded superblock run length\n");
506 memset(
s->superblock_coding + current_superblock,
bit, current_run);
508 current_superblock += current_run;
510 num_partial_superblocks += current_run;
515 if (num_partial_superblocks < s->superblock_count) {
516 int superblocks_decoded = 0;
518 current_superblock = 0;
522 while (superblocks_decoded < s->superblock_count - num_partial_superblocks &&
531 if (current_run == 34)
534 for (
int j = 0; j < current_run; current_superblock++) {
535 if (current_superblock >=
s->superblock_count) {
537 "Invalid fully coded superblock run length\n");
542 if (
s->superblock_coding[current_superblock] ==
SB_NOT_CODED) {
543 s->superblock_coding[current_superblock] = 2 *
bit;
547 superblocks_decoded += current_run;
553 if (num_partial_superblocks) {
564 s->total_num_coded_frags = 0;
565 memset(
s->macroblock_coding,
MODE_COPY,
s->macroblock_count);
567 s->coded_fragment_list[0] =
s->keyframe ?
s->kf_coded_fragment_list
568 :
s->nkf_coded_fragment_list;
570 for (
int plane = 0; plane < 3; plane++) {
571 int sb_start = superblock_starts[plane];
572 int sb_end = sb_start + (plane ?
s->c_superblock_count
573 :
s->y_superblock_count);
574 int num_coded_frags = 0;
577 if (
s->num_kf_coded_fragment[plane] == -1) {
578 for (
int i = sb_start;
i < sb_end;
i++) {
580 for (
int j = 0; j < 16; j++) {
582 current_fragment =
s->superblock_fragments[
i * 16 + j];
583 if (current_fragment != -1) {
584 s->coded_fragment_list[plane][num_coded_frags++] =
589 s->num_kf_coded_fragment[plane] = num_coded_frags;
591 num_coded_frags =
s->num_kf_coded_fragment[plane];
598 for (
int j = 0; j < 16; j++) {
600 current_fragment =
s->superblock_fragments[
i * 16 + j];
601 if (current_fragment != -1) {
602 int coded =
s->superblock_coding[
i];
607 if (current_run-- == 0) {
617 s->all_fragments[current_fragment].coding_method =
619 s->coded_fragment_list[plane][num_coded_frags++] =
623 s->all_fragments[current_fragment].coding_method =
631 plane0_num_coded_frags = num_coded_frags;
632 s->total_num_coded_frags += num_coded_frags;
633 for (
int i = 0;
i < 64;
i++)
634 s->num_coded_frags[plane][
i] = num_coded_frags;
636 s->coded_fragment_list[plane + 1] =
s->coded_fragment_list[plane] +
642 #define BLOCK_X (2 * mb_x + (k & 1))
643 #define BLOCK_Y (2 * mb_y + (k >> 1))
645 #if CONFIG_VP4_DECODER
657 if (v >
s->yuv_macroblock_count) {
663 skip_bits(gb, 2 + n); \
664 v += (1 << n) + get_bits(gb, n); }
665 #define thresh(n) (0x200 - (0x80 >> n))
666 #define else_if(n) else if (bits < thresh(n)) body(n)
669 }
else if (
bits < thresh(0)) {
686 static int vp4_get_block_pattern(
GetBitContext *gb,
int *next_block_pattern_table)
688 int v =
get_vlc2(gb, block_pattern_vlc[*next_block_pattern_table], 5, 1);
696 int next_block_pattern_table;
697 int bit, current_run, has_partial;
699 memset(
s->macroblock_coding,
MODE_COPY,
s->macroblock_count);
706 for (
int i = 0;
i <
s->yuv_macroblock_count;
i += current_run) {
709 current_run = vp4_get_mb_count(
s, gb);
710 if (current_run >
s->yuv_macroblock_count -
i)
712 memset(
s->superblock_coding +
i, 2 *
bit, current_run);
721 current_run = vp4_get_mb_count(
s, gb);
722 for (
int i = 0;
i <
s->yuv_macroblock_count;
i++) {
723 if (!
s->superblock_coding[
i]) {
726 current_run = vp4_get_mb_count(
s, gb);
728 s->superblock_coding[
i] =
bit;
736 next_block_pattern_table = 0;
737 for (
int plane = 0,
i = 0; plane < 3; plane++) {
738 int sb_width = plane ?
s->c_superblock_width :
s->y_superblock_width;
739 int sb_height = plane ?
s->c_superblock_height :
s->y_superblock_height;
740 int mb_width = plane ?
s->c_macroblock_width :
s->macroblock_width;
741 int mb_height = plane ?
s->c_macroblock_height :
s->macroblock_height;
742 int fragment_width =
s->fragment_width[!!plane];
743 int fragment_height =
s->fragment_height[!!plane];
745 for (
int sb_y = 0; sb_y < sb_height; sb_y++) {
746 for (
int sb_x = 0; sb_x < sb_width; sb_x++) {
747 for (
int j = 0; j < 4; j++) {
748 int mb_x = 2 * sb_x + (j >> 1);
749 int mb_y = 2 * sb_y + (j >> 1) ^ (j & 1);
750 int mb_coded, pattern, coded;
752 if (mb_x >= mb_width || mb_y >= mb_height)
755 mb_coded =
s->superblock_coding[
i++];
760 pattern = vp4_get_block_pattern(gb, &next_block_pattern_table);
764 for (
int k = 0; k < 4; k++) {
768 coded = pattern & (8 >> k);
788 int current_macroblock;
789 int current_fragment;
796 for (
int i = 0;
i <
s->fragment_count;
i++)
804 for (
int i = 0;
i < 8;
i++)
806 for (
int i = 0;
i < 8;
i++)
807 custom_mode_alphabet[
get_bits(gb, 3)] =
i;
808 alphabet = custom_mode_alphabet;
814 for (
int sb_y = 0; sb_y <
s->y_superblock_height; sb_y++) {
815 for (
int sb_x = 0; sb_x <
s->y_superblock_width; sb_x++) {
819 for (
int j = 0; j < 4; j++) {
821 int mb_x = 2 * sb_x + (j >> 1);
822 int mb_y = 2 * sb_y + (((j >> 1) + j) & 1);
823 current_macroblock = mb_y *
s->macroblock_width + mb_x;
825 if (mb_x >=
s->macroblock_width ||
826 mb_y >=
s->macroblock_height)
832 for (k = 0; k < 4; k++) {
835 if (
s->all_fragments[current_fragment].coding_method !=
MODE_COPY)
849 s->macroblock_coding[current_macroblock] = coding_mode;
850 for (k = 0; k < 4; k++) {
856 #define SET_CHROMA_MODES \
857 if (frag[s->fragment_start[1]].coding_method != MODE_COPY) \
858 frag[s->fragment_start[1]].coding_method = coding_mode; \
859 if (frag[s->fragment_start[2]].coding_method != MODE_COPY) \
860 frag[s->fragment_start[2]].coding_method = coding_mode;
862 if (
s->chroma_y_shift) {
863 frag =
s->all_fragments + mb_y *
864 s->fragment_width[1] + mb_x;
866 }
else if (
s->chroma_x_shift) {
867 frag =
s->all_fragments +
868 2 * mb_y *
s->fragment_width[1] + mb_x;
869 for (k = 0; k < 2; k++) {
871 frag +=
s->fragment_width[1];
874 for (k = 0; k < 4; k++) {
875 frag =
s->all_fragments +
890 #if CONFIG_VP4_DECODER
893 return last_motion < 0 ? -v : v;
908 int last_motion_x = 0;
909 int last_motion_y = 0;
910 int prior_last_motion_x = 0;
911 int prior_last_motion_y = 0;
912 int last_gold_motion_x = 0;
913 int last_gold_motion_y = 0;
914 int current_macroblock;
915 int current_fragment;
922 coding_mode =
s->version < 2 ?
get_bits1(gb) : 2;
926 for (
int sb_y = 0; sb_y <
s->y_superblock_height; sb_y++) {
927 for (
int sb_x = 0; sb_x <
s->y_superblock_width; sb_x++) {
931 for (
int j = 0; j < 4; j++) {
932 int mb_x = 2 * sb_x + (j >> 1);
933 int mb_y = 2 * sb_y + (((j >> 1) + j) & 1);
934 current_macroblock = mb_y *
s->macroblock_width + mb_x;
936 if (mb_x >=
s->macroblock_width ||
937 mb_y >=
s->macroblock_height ||
938 s->macroblock_coding[current_macroblock] ==
MODE_COPY)
941 switch (
s->macroblock_coding[current_macroblock]) {
943 if (coding_mode == 2) {
944 last_gold_motion_x = motion_x[0] =
vp4_get_mv(gb, 0, last_gold_motion_x);
945 last_gold_motion_y = motion_y[0] =
vp4_get_mv(gb, 1, last_gold_motion_y);
950 if (coding_mode == 0) {
955 }
else if (coding_mode == 1) {
959 motion_x[0] =
vp4_get_mv(gb, 0, last_motion_x);
960 motion_y[0] =
vp4_get_mv(gb, 1, last_motion_y);
965 prior_last_motion_x = last_motion_x;
966 prior_last_motion_y = last_motion_y;
967 last_motion_x = motion_x[0];
968 last_motion_y = motion_y[0];
974 prior_last_motion_x = last_motion_x;
975 prior_last_motion_y = last_motion_y;
979 for (
int k = 0; k < 4; k++) {
981 if (
s->all_fragments[current_fragment].coding_method !=
MODE_COPY) {
982 if (coding_mode == 0) {
987 }
else if (coding_mode == 1) {
991 motion_x[k] =
vp4_get_mv(gb, 0, prior_last_motion_x);
992 motion_y[k] =
vp4_get_mv(gb, 1, prior_last_motion_y);
994 last_motion_x = motion_x[k];
995 last_motion_y = motion_y[k];
1005 motion_x[0] = last_motion_x;
1006 motion_y[0] = last_motion_y;
1015 motion_x[0] = prior_last_motion_x;
1016 motion_y[0] = prior_last_motion_y;
1019 prior_last_motion_x = last_motion_x;
1020 prior_last_motion_y = last_motion_y;
1021 last_motion_x = motion_x[0];
1022 last_motion_y = motion_y[0];
1035 for (
int k = 0; k < 4; k++) {
1039 s->motion_val[0][current_fragment][0] = motion_x[k];
1040 s->motion_val[0][current_fragment][1] = motion_y[k];
1042 s->motion_val[0][current_fragment][0] = motion_x[0];
1043 s->motion_val[0][current_fragment][1] = motion_y[0];
1047 if (
s->chroma_y_shift) {
1049 motion_x[0] =
RSHIFT(motion_x[0] + motion_x[1] +
1050 motion_x[2] + motion_x[3], 2);
1051 motion_y[0] =
RSHIFT(motion_y[0] + motion_y[1] +
1052 motion_y[2] + motion_y[3], 2);
1054 if (
s->version <= 2) {
1055 motion_x[0] = (motion_x[0] >> 1) | (motion_x[0] & 1);
1056 motion_y[0] = (motion_y[0] >> 1) | (motion_y[0] & 1);
1058 frag = mb_y *
s->fragment_width[1] + mb_x;
1059 s->motion_val[1][frag][0] = motion_x[0];
1060 s->motion_val[1][frag][1] = motion_y[0];
1061 }
else if (
s->chroma_x_shift) {
1063 motion_x[0] =
RSHIFT(motion_x[0] + motion_x[1], 1);
1064 motion_y[0] =
RSHIFT(motion_y[0] + motion_y[1], 1);
1065 motion_x[1] =
RSHIFT(motion_x[2] + motion_x[3], 1);
1066 motion_y[1] =
RSHIFT(motion_y[2] + motion_y[3], 1);
1068 motion_x[1] = motion_x[0];
1069 motion_y[1] = motion_y[0];
1071 if (
s->version <= 2) {
1072 motion_x[0] = (motion_x[0] >> 1) | (motion_x[0] & 1);
1073 motion_x[1] = (motion_x[1] >> 1) | (motion_x[1] & 1);
1075 frag = 2 * mb_y *
s->fragment_width[1] + mb_x;
1076 for (
int k = 0; k < 2; k++) {
1077 s->motion_val[1][frag][0] = motion_x[k];
1078 s->motion_val[1][frag][1] = motion_y[k];
1079 frag +=
s->fragment_width[1];
1082 for (
int k = 0; k < 4; k++) {
1085 s->motion_val[1][frag][0] = motion_x[k];
1086 s->motion_val[1][frag][1] = motion_y[k];
1088 s->motion_val[1][frag][0] = motion_x[0];
1089 s->motion_val[1][frag][1] = motion_y[0];
1102 int num_blocks =
s->total_num_coded_frags;
1104 for (
int qpi = 0; qpi <
s->nqps - 1 && num_blocks > 0; qpi++) {
1105 int i = 0, blocks_decoded = 0, num_blocks_at_qpi = 0;
1106 int bit, run_length;
1119 if (run_length == 34)
1121 blocks_decoded += run_length;
1124 num_blocks_at_qpi += run_length;
1126 for (
int j = 0; j < run_length;
i++) {
1127 if (
i >=
s->total_num_coded_frags)
1130 if (
s->all_fragments[
s->coded_fragment_list[0][
i]].qpi == qpi) {
1131 s->all_fragments[
s->coded_fragment_list[0][
i]].qpi +=
bit;
1135 }
while (blocks_decoded < num_blocks &&
get_bits_left(gb) > 0);
1137 num_blocks -= num_blocks_at_qpi;
1153 int bits_to_get, zero_run;
1157 bits_to_get =
get_bits(gb, bits_to_get);
1180 const VLCElem *vlc_table,
int coeff_index,
1190 int num_coeffs =
s->num_coded_frags[plane][coeff_index];
1191 int16_t *dct_tokens =
s->dct_tokens[plane][coeff_index];
1194 const int *coded_fragment_list =
s->coded_fragment_list[plane];
1197 if (num_coeffs < 0) {
1199 "Invalid number of coefficients at level %d\n", coeff_index);
1203 if (eob_run > num_coeffs) {
1205 blocks_ended = num_coeffs;
1206 eob_run -= num_coeffs;
1209 blocks_ended = eob_run;
1215 dct_tokens[j++] = blocks_ended << 2;
1219 token =
get_vlc2(gb, vlc_table, 11, 3);
1221 if ((
unsigned) token <= 6
U) {
1228 if (eob_run > num_coeffs - coeff_i) {
1229 dct_tokens[j++] =
TOKEN_EOB(num_coeffs - coeff_i);
1230 blocks_ended += num_coeffs - coeff_i;
1231 eob_run -= num_coeffs - coeff_i;
1232 coeff_i = num_coeffs;
1235 blocks_ended += eob_run;
1239 }
else if (token >= 0) {
1250 all_fragments[coded_fragment_list[coeff_i]].
dc =
coeff;
1255 if (coeff_index + zero_run > 64) {
1257 "Invalid zero run of %d with %d coeffs left\n",
1258 zero_run, 64 - coeff_index);
1259 zero_run = 64 - coeff_index;
1264 for (
int i = coeff_index + 1;
i <= coeff_index + zero_run;
i++)
1265 s->num_coded_frags[plane][
i]--;
1273 if (blocks_ended >
s->num_coded_frags[plane][coeff_index])
1279 for (
int i = coeff_index + 1;
i < 64;
i++)
1280 s->num_coded_frags[plane][
i] -= blocks_ended;
1284 s->dct_tokens[plane + 1][coeff_index] = dct_tokens + j;
1285 else if (coeff_index < 63)
1286 s->dct_tokens[0][coeff_index + 1] = dct_tokens + j;
1294 int fragment_height);
1306 int residual_eob_run = 0;
1307 const VLCElem *y_tables[64], *c_tables[64];
1309 s->dct_tokens[0][0] =
s->dct_tokens_base;
1320 0, residual_eob_run);
1321 if (residual_eob_run < 0)
1322 return residual_eob_run;
1331 1, residual_eob_run);
1332 if (residual_eob_run < 0)
1333 return residual_eob_run;
1335 2, residual_eob_run);
1336 if (residual_eob_run < 0)
1337 return residual_eob_run;
1342 s->fragment_width[1],
s->fragment_height[1]);
1344 s->fragment_width[1],
s->fragment_height[1]);
1354 for (
int i = 1;
i <= 5;
i++) {
1359 for (
int i = 6;
i <= 14;
i++) {
1364 for (
int i = 15;
i <= 27;
i++) {
1369 for (
int i = 28;
i <= 63;
i++) {
1376 for (
int i = 1;
i <= 63;
i++) {
1378 0, residual_eob_run);
1379 if (residual_eob_run < 0)
1380 return residual_eob_run;
1383 1, residual_eob_run);
1384 if (residual_eob_run < 0)
1385 return residual_eob_run;
1387 2, residual_eob_run);
1388 if (residual_eob_run < 0)
1389 return residual_eob_run;
1395 #if CONFIG_VP4_DECODER
1404 int plane,
int eob_tracker[64],
int fragment)
1412 while (!eob_tracker[coeff_i]) {
1419 if ((
unsigned) token <= 6
U) {
1421 *
s->dct_tokens[plane][coeff_i]++ =
TOKEN_EOB(0);
1422 eob_tracker[coeff_i] = eob_run - 1;
1424 }
else if (token >= 0) {
1428 if (coeff_i + zero_run > 64) {
1430 "Invalid zero run of %d with %d coeffs left\n",
1431 zero_run, 64 - coeff_i);
1432 zero_run = 64 - coeff_i;
1435 coeff_i += zero_run;
1450 *
s->dct_tokens[plane][coeff_i]++ =
TOKEN_EOB(0);
1451 eob_tracker[coeff_i]--;
1463 for (
int i = 0;
i < 4;
i++)
1464 dc_pred[0][
i + 1] =
s->dc_pred_row[sb_x * 4 +
i];
1466 for (
int j = 1; j < 5; j++)
1467 for (
int i = 0;
i < 4;
i++)
1468 vp4_dc_predictor_reset(&dc_pred[j][
i + 1]);
1473 for (
int i = 0;
i < 4;
i++)
1474 s->dc_pred_row[sb_x * 4 +
i] = dc_pred[4][
i + 1];
1476 for (
int i = 1;
i < 5;
i++)
1477 dc_pred[
i][0] = dc_pred[
i][4];
1487 dc += dc_pred[-6].
dc;
1492 dc += dc_pred[6].
dc;
1496 if (count != 2 && dc_pred[-1].
type ==
type) {
1497 dc += dc_pred[-1].
dc;
1501 if (count != 2 && dc_pred[1].
type ==
type) {
1502 dc += dc_pred[1].
dc;
1507 return count == 2 ?
dc / 2 : last_dc[
type];
1512 int16_t *
base =
s->dct_tokens_base;
1513 for (
int plane = 0; plane < 3; plane++) {
1514 for (
int i = 0;
i < 64;
i++) {
1515 s->dct_tokens[plane][
i] =
base;
1516 base +=
s->fragment_width[!!plane] *
s->fragment_height[!!plane];
1529 int eob_tracker[64];
1548 for (
int i = 1;
i <= 5;
i++) {
1553 for (
int i = 6;
i <= 14;
i++) {
1558 for (
int i = 15;
i <= 27;
i++) {
1563 for (
int i = 28;
i <= 63;
i++) {
1569 vp4_set_tokens_base(
s);
1571 memset(last_dc, 0,
sizeof(last_dc));
1574 memset(eob_tracker, 0,
sizeof(eob_tracker));
1577 for (
int i = 0;
i <
s->fragment_width[!!plane];
i++)
1578 vp4_dc_predictor_reset(&
s->dc_pred_row[
i]);
1580 for (
int j = 0; j < 6; j++)
1581 for (
int i = 0;
i < 6;
i++)
1582 vp4_dc_predictor_reset(&dc_pred[j][
i]);
1584 for (
int sb_y = 0; sb_y * 4 <
s->fragment_height[!!plane]; sb_y++) {
1585 for (
int sb_x = 0; sb_x *4 <
s->fragment_width[!!plane]; sb_x++) {
1586 vp4_dc_pred_before(
s, dc_pred, sb_x);
1587 for (
int j = 0; j < 16; j++) {
1590 int x = 4 * sb_x + hx;
1591 int y = 4 * sb_y + hy;
1595 if (x >=
s->fragment_width[!!plane] || y >=
s->fragment_height[!!plane])
1598 fragment =
s->fragment_start[plane] + y *
s->fragment_width[!!plane] + x;
1603 if (vp4_unpack_vlcs(
s, gb,
tables[!!plane], plane, eob_tracker,
fragment) < 0)
1609 vp4_dc_pred(
s, this_dc_pred, last_dc, dc_block_type, plane);
1611 this_dc_pred->
type = dc_block_type,
1612 this_dc_pred->
dc = last_dc[dc_block_type] =
s->all_fragments[
fragment].dc;
1614 vp4_dc_pred_after(
s, dc_pred, sb_x);
1619 vp4_set_tokens_base(
s);
1630 #define COMPATIBLE_FRAME(x) \
1631 (compatible_frame[s->all_fragments[x].coding_method] == current_frame_type)
1632 #define DC_COEFF(u) s->all_fragments[u].dc
1637 int fragment_height)
1644 int i = first_fragment;
1649 int vl, vul, vu, vur;
1661 static const int predictor_transform[16][4] = {
1675 { -104, 116, 0, 116 },
1677 { -104, 116, 0, 116 }
1686 static const unsigned char compatible_frame[9] = {
1697 int current_frame_type;
1713 for (
int y = 0; y < fragment_height; y++) {
1715 for (
int x = 0; x < fragment_width; x++,
i++) {
1718 if (
s->all_fragments[
i].coding_method !=
MODE_COPY) {
1719 current_frame_type =
1720 compatible_frame[
s->all_fragments[
i].coding_method];
1730 u =
i - fragment_width;
1735 ul =
i - fragment_width - 1;
1740 if (x + 1 < fragment_width) {
1741 ur =
i - fragment_width + 1;
1751 predicted_dc = last_dc[current_frame_type];
1755 (predictor_transform[
transform][0] * vul) +
1756 (predictor_transform[
transform][1] * vu) +
1757 (predictor_transform[
transform][2] * vur) +
1758 (predictor_transform[
transform][3] * vl);
1760 predicted_dc /= 128;
1765 if (
FFABS(predicted_dc - vu) > 128)
1767 else if (
FFABS(predicted_dc - vl) > 128)
1769 else if (
FFABS(predicted_dc - vul) > 128)
1777 last_dc[current_frame_type] =
DC_COEFF(
i);
1784 int ystart,
int yend)
1786 int *bounding_values =
s->bounding_values_array + 127;
1788 int width =
s->fragment_width[!!plane];
1789 int height =
s->fragment_height[!!plane];
1791 ptrdiff_t
stride =
s->current_frame.f->linesize[plane];
1792 uint8_t *plane_data =
s->current_frame.f->data[plane];
1793 if (!
s->flipped_image)
1795 plane_data +=
s->data_offset[plane] + 8 * ystart *
stride;
1797 for (
int y = ystart; y < yend; y++) {
1798 for (
int x = 0; x <
width; x++) {
1806 s->vp3dsp.h_loop_filter(
1808 stride, bounding_values);
1813 s->vp3dsp.v_loop_filter(
1815 stride, bounding_values);
1821 if ((x <
width - 1) &&
1823 s->vp3dsp.h_loop_filter(
1824 plane_data + 8 * x + 8,
1825 stride, bounding_values);
1833 s->vp3dsp.v_loop_filter(
1834 plane_data + 8 * x + 8 *
stride,
1835 stride, bounding_values);
1841 plane_data += 8 *
stride;
1850 int plane,
int inter, int16_t
block[64])
1852 const int16_t *dequantizer =
s->qmat[frag->
qpi][inter][plane];
1853 const uint8_t *
perm =
s->idct_scantable;
1857 int token = *
s->dct_tokens[plane][
i];
1858 switch (token & 3) {
1861 s->dct_tokens[plane][
i]++;
1863 *
s->dct_tokens[plane][
i] = token & ~3;
1866 s->dct_tokens[plane][
i]++;
1867 i += (token >> 2) & 0x7f;
1877 s->dct_tokens[plane][
i++]++;
1887 block[0] = frag->
dc *
s->qmat[0][inter][plane][0];
1900 int y_flipped =
s->flipped_image ?
s->height - y : y;
1906 y_flipped ==
s->height ? INT_MAX
1910 if (!
s->avctx->draw_horiz_band)
1913 h = y -
s->last_slice_end;
1914 s->last_slice_end = y;
1917 if (!
s->flipped_image)
1918 y =
s->height - y -
h;
1920 cy = y >>
s->chroma_y_shift;
1921 offset[0] =
s->current_frame.f->linesize[0] * y;
1922 offset[1] =
s->current_frame.f->linesize[1] * cy;
1923 offset[2] =
s->current_frame.f->linesize[2] * cy;
1928 s->avctx->draw_horiz_band(
s->avctx,
s->current_frame.f,
offset, y, 3,
h);
1936 int motion_y,
int y)
1940 int border = motion_y & 1;
1948 ref_row = y + (motion_y >> 1);
1949 ref_row =
FFMAX(
FFABS(ref_row), ref_row + 8 + border);
1954 #if CONFIG_VP4_DECODER
1958 static int vp4_mc_loop_filter(
Vp3DecodeContext *
s,
int plane,
int motion_x,
int motion_y,
int bx,
int by,
1959 const uint8_t *motion_source, ptrdiff_t
stride,
1960 int src_x,
int src_y, uint8_t *
temp)
1962 int motion_shift = plane ? 4 : 2;
1963 int subpel_mask = plane ? 3 : 1;
1964 int *bounding_values =
s->bounding_values_array + 127;
1968 int x_subpel, y_subpel;
1969 int x_offset, y_offset;
1971 int block_width = plane ? 8 : 16;
1972 int plane_width =
s->width >> (plane &&
s->chroma_x_shift);
1973 int plane_height =
s->height >> (plane &&
s->chroma_y_shift);
1975 #define loop_stride 12
1976 uint8_t
loop[12 * loop_stride];
1979 x = 8 * bx + motion_x / motion_shift;
1980 y = 8 * by + motion_y / motion_shift;
1982 x_subpel = motion_x & subpel_mask;
1983 y_subpel = motion_y & subpel_mask;
1985 if (x_subpel || y_subpel) {
1995 x2 = x + block_width;
1996 y2 = y + block_width;
1998 if (x2 < 0 || x2 >= plane_width || y2 < 0 || y2 >= plane_height)
2001 x_offset = (-(x + 2) & 7) + 2;
2002 y_offset = (-(y + 2) & 7) + 2;
2004 av_assert1(!(x_offset > 8 + x_subpel && y_offset > 8 + y_subpel));
2006 s->vdsp.emulated_edge_mc(
loop, motion_source -
stride - 1,
2008 12, 12, src_x - 1, src_y - 1,
2012 if (x_offset <= 8 + x_subpel)
2015 if (y_offset <= 8 + y_subpel)
2023 if (!x_offset && !y_offset)
2026 s->vdsp.emulated_edge_mc(
loop, motion_source -
stride - 1,
2028 12, 12, src_x - 1, src_y - 1,
2032 #define safe_loop_filter(name, ptr, stride, bounding_values) \
2033 if ((uintptr_t)(ptr) & 7) \
2034 s->vp3dsp.name##_unaligned(ptr, stride, bounding_values); \
2036 s->vp3dsp.name(ptr, stride, bounding_values);
2039 safe_loop_filter(h_loop_filter,
loop + loop_stride + x_offset + 1, loop_stride, bounding_values);
2042 safe_loop_filter(v_loop_filter,
loop + (y_offset + 1)*loop_stride + 1, loop_stride, bounding_values);
2045 for (
int i = 0;
i < 9;
i++)
2058 int16_t *
block =
s->block;
2059 int motion_x = 0xdeadbeef, motion_y = 0xdeadbeef;
2064 const AVFrame *last_frame =
s->last_frame.f ?
2065 s->last_frame.f :
s->current_frame.f;
2066 const AVFrame *golden_frame =
s->golden_frame.f ?
2067 s->golden_frame.f :
s->current_frame.f;
2068 int motion_halfpel_index;
2071 if (slice >=
s->c_superblock_height)
2074 for (
int plane = 0; plane < 3; plane++) {
2076 s->data_offset[plane];
2077 const uint8_t *last_plane = last_frame->
data[plane] +
2078 s->data_offset[plane];
2079 const uint8_t *golden_plane = golden_frame->
data[plane] +
2080 s->data_offset[plane];
2081 ptrdiff_t
stride =
s->current_frame.f->linesize[plane];
2082 int plane_width =
s->width >> (plane &&
s->chroma_x_shift);
2083 int plane_height =
s->height >> (plane &&
s->chroma_y_shift);
2084 const int8_t (*motion_val)[2] =
s->motion_val[!!plane];
2086 int sb_y = slice << (!plane &&
s->chroma_y_shift);
2087 int slice_height = sb_y + 1 + (!plane &&
s->chroma_y_shift);
2088 int slice_width = plane ?
s->c_superblock_width
2089 :
s->y_superblock_width;
2091 int fragment_width =
s->fragment_width[!!plane];
2092 int fragment_height =
s->fragment_height[!!plane];
2093 int fragment_start =
s->fragment_start[plane];
2095 int do_await = !plane && HAVE_THREADS &&
2098 if (!
s->flipped_image)
2104 for (; sb_y < slice_height; sb_y++) {
2106 for (
int sb_x = 0; sb_x < slice_width; sb_x++) {
2108 for (
int j = 0; j < 16; j++) {
2111 int fragment = y * fragment_width + x;
2116 if (x >= fragment_width || y >= fragment_height)
2119 first_pixel = 8 * y *
stride + 8 * x;
2125 (16 * y) >>
s->chroma_y_shift);
2128 if (
s->all_fragments[
i].coding_method !=
MODE_COPY) {
2129 const uint8_t *motion_source;
2132 motion_source = golden_plane;
2134 motion_source = last_plane;
2136 motion_source += first_pixel;
2137 motion_halfpel_index = 0;
2141 if ((
s->all_fragments[
i].coding_method >
MODE_INTRA) &&
2144 int standard_mc = 1;
2145 motion_x = motion_val[
fragment][0];
2146 motion_y = motion_val[
fragment][1];
2147 #if CONFIG_VP4_DECODER
2148 if (plane &&
s->version >= 2) {
2149 motion_x = (motion_x >> 1) | (motion_x & 1);
2150 motion_y = (motion_y >> 1) | (motion_y & 1);
2154 src_x = (motion_x >> 1) + 8 * x;
2155 src_y = (motion_y >> 1) + 8 * y;
2157 motion_halfpel_index = motion_x & 0x01;
2158 motion_source += (motion_x >> 1);
2160 motion_halfpel_index |= (motion_y & 0x01) << 1;
2161 motion_source += ((motion_y >> 1) *
stride);
2163 #if CONFIG_VP4_DECODER
2164 if (
s->version >= 2) {
2165 uint8_t *
temp =
s->edge_emu_buffer;
2168 if (vp4_mc_loop_filter(
s, plane, motion_val[
fragment][0], motion_val[
fragment][1], x, y, motion_source,
stride, src_x, src_y,
temp)) {
2169 motion_source =
temp;
2175 if (standard_mc && (
2176 src_x < 0 || src_y < 0 ||
2177 src_x + 9 >= plane_width ||
2178 src_y + 9 >= plane_height)) {
2179 uint8_t *
temp =
s->edge_emu_buffer;
2183 s->vdsp.emulated_edge_mc(
temp, motion_source,
2188 motion_source =
temp;
2199 if (motion_halfpel_index != 3) {
2200 s->hdsp.put_no_rnd_pixels_tab[1][motion_halfpel_index](
2202 motion_source,
stride, 8);
2206 int d = (motion_x ^ motion_y) >> 31;
2209 motion_source +
stride + 1 +
d,
2235 s->hdsp.put_pixels_tab[1][0](
2237 last_plane + first_pixel,
2244 if (
s->version < 2 && !
s->skip_loop_filter)
2246 FFMIN(4 * sb_y + 3, fragment_height - 1));
2284 #if CONFIG_VP4_DECODER
2285 for (
int j = 0; j < 2; j++)
2286 for (
int i = 0;
i < 7;
i++) {
2287 vp4_mv_vlc_table[j][
i] =
2295 for (
int i = 0;
i < 2;
i++) {
2296 block_pattern_vlc[
i] =
2308 int y_fragment_count, c_fragment_count;
2312 y_fragment_count =
s->fragment_width[0] *
s->fragment_height[0];
2313 c_fragment_count =
s->fragment_width[1] *
s->fragment_height[1];
2316 s->superblock_coding =
av_mallocz(
FFMAX(
s->superblock_count,
s->yuv_macroblock_count));
2317 s->all_fragments =
av_calloc(
s->fragment_count,
sizeof(*
s->all_fragments));
2319 s-> kf_coded_fragment_list =
av_calloc(
s->fragment_count,
sizeof(
int));
2320 s->nkf_coded_fragment_list =
av_calloc(
s->fragment_count,
sizeof(
int));
2321 memset(
s-> num_kf_coded_fragment, -1,
sizeof(
s-> num_kf_coded_fragment));
2324 64 *
sizeof(*
s->dct_tokens_base));
2325 s->motion_val[0] =
av_calloc(y_fragment_count,
sizeof(*
s->motion_val[0]));
2326 s->motion_val[1] =
av_calloc(c_fragment_count,
sizeof(*
s->motion_val[1]));
2329 s->superblock_fragments =
av_calloc(
s->superblock_count, 16 *
sizeof(
int));
2330 s->macroblock_coding =
av_mallocz(
s->macroblock_count + 1);
2332 s->dc_pred_row =
av_malloc_array(
s->y_superblock_width * 4,
sizeof(*
s->dc_pred_row));
2334 if (!
s->superblock_coding || !
s->all_fragments ||
2335 !
s->dct_tokens_base || !
s->kf_coded_fragment_list ||
2336 !
s->nkf_coded_fragment_list ||
2337 !
s->superblock_fragments || !
s->macroblock_coding ||
2339 !
s->motion_val[0] || !
s->motion_val[1]) {
2364 int y_fragment_count, c_fragment_count;
2368 #if !CONFIG_VP4_DECODER
2389 for (
int i = 0;
i < 64;
i++) {
2390 #define TRANSPOSE(x) (((x) >> 3) | (((x) & 7) << 3))
2398 for (
int i = 0;
i < 3;
i++)
2405 s->y_superblock_width = (
s->width + 31) / 32;
2406 s->y_superblock_height = (
s->height + 31) / 32;
2407 s->y_superblock_count =
s->y_superblock_width *
s->y_superblock_height;
2410 c_width =
s->width >>
s->chroma_x_shift;
2411 c_height =
s->height >>
s->chroma_y_shift;
2412 s->c_superblock_width = (c_width + 31) / 32;
2413 s->c_superblock_height = (c_height + 31) / 32;
2414 s->c_superblock_count =
s->c_superblock_width *
s->c_superblock_height;
2416 s->superblock_count =
s->y_superblock_count + (
s->c_superblock_count * 2);
2417 s->u_superblock_start =
s->y_superblock_count;
2418 s->v_superblock_start =
s->u_superblock_start +
s->c_superblock_count;
2420 s->macroblock_width = (
s->width + 15) / 16;
2421 s->macroblock_height = (
s->height + 15) / 16;
2422 s->macroblock_count =
s->macroblock_width *
s->macroblock_height;
2423 s->c_macroblock_width = (c_width + 15) / 16;
2424 s->c_macroblock_height = (c_height + 15) / 16;
2425 s->c_macroblock_count =
s->c_macroblock_width *
s->c_macroblock_height;
2426 s->yuv_macroblock_count =
s->macroblock_count + 2 *
s->c_macroblock_count;
2430 s->fragment_width[1] =
s->fragment_width[0] >>
s->chroma_x_shift;
2431 s->fragment_height[1] =
s->fragment_height[0] >>
s->chroma_y_shift;
2434 y_fragment_count =
s->fragment_width[0] *
s->fragment_height[0];
2435 c_fragment_count =
s->fragment_width[1] *
s->fragment_height[1];
2436 s->fragment_count = y_fragment_count + 2 * c_fragment_count;
2437 s->fragment_start[1] = y_fragment_count;
2438 s->fragment_start[2] = y_fragment_count + c_fragment_count;
2440 if (!
s->theora_tables) {
2441 for (
int i = 0;
i < 64;
i++) {
2451 for (
int inter = 0; inter < 2; inter++) {
2452 for (
int plane = 0; plane < 3; plane++) {
2453 s->qr_count[inter][plane] = 1;
2454 s->qr_size[inter][plane][0] = 63;
2455 s->qr_base[inter][plane][0] =
2456 s->qr_base[inter][plane][1] = 2 * inter + (!!plane) * !inter;
2467 s->coeff_vlc = vlcs;
2469 if (!
s->theora_tables) {
2470 const uint8_t (*bias_tabs)[32][2];
2476 &bias_tabs[
i][0][1], 2,
2477 &bias_tabs[
i][0][0], 2, 1,
2488 &
tab->entries[0].len,
sizeof(*
tab->entries),
2489 &
tab->entries[0].sym,
sizeof(*
tab->entries), 1,
2528 int qps_changed = 0;
2543 for (
int i = 0;
i < 3;
i++) {
2544 if (
s->qps[
i] != s1->
qps[1]) {
2546 memcpy(&
s->qmat[
i], &s1->
qmat[
i],
sizeof(
s->qmat[
i]));
2550 if (
s->qps[0] != s1->
qps[0])
2552 sizeof(
s->bounding_values_array));
2555 memcpy(
s->qps, s1->
qps,
sizeof(
s->qps));
2556 memcpy(
s->last_qps, s1->
last_qps,
sizeof(
s->last_qps));
2569 const uint8_t *buf = avpkt->
data;
2570 int buf_size = avpkt->
size;
2578 #if CONFIG_THEORA_DECODER
2584 av_log(avctx,
AV_LOG_ERROR,
"midstream reconfiguration with multithreading is unsupported, try -threads 1\n");
2598 }
else if (
type == 2) {
2611 "Header packet passed to frame decoder, skipping\n");
2617 if (!
s->all_fragments) {
2623 for (
int i = 0;
i < 3;
i++)
2624 s->last_qps[
i] =
s->qps[
i];
2629 }
while (
s->theora >= 0x030200 &&
s->nqps < 3 &&
get_bits1(&gb));
2630 for (
int i =
s->nqps;
i < 3;
i++)
2635 s->keyframe ?
"key" :
"", avctx->frame_num + 1,
s->qps[0]);
2637 s->skip_loop_filter = !
s->filter_limit_values[
s->qps[0]] ||
2641 if (
s->qps[0] !=
s->last_qps[0])
2644 for (
int i = 0;
i <
s->nqps;
i++)
2647 if (
s->qps[
i] !=
s->last_qps[
i] ||
s->qps[0] !=
s->last_qps[0])
2668 if (!
s->edge_emu_buffer) {
2669 s->edge_emu_buffer =
av_malloc(9 *
FFABS(
s->current_frame.f->linesize[0]));
2670 if (!
s->edge_emu_buffer) {
2682 #if !CONFIG_VP4_DECODER
2689 if (avctx->frame_num == 0)
2691 "VP version: %d\n",
s->version);
2694 if (
s->version ||
s->theora) {
2697 "Warning, unsupported keyframe coding type?!\n");
2700 #if CONFIG_VP4_DECODER
2701 if (
s->version >= 2) {
2702 int mb_height, mb_width;
2703 int mb_width_mul, mb_width_div, mb_height_mul, mb_height_div;
2707 if (mb_height !=
s->macroblock_height ||
2708 mb_width !=
s->macroblock_width)
2715 if (mb_width_mul != 1 || mb_width_div != 1 || mb_height_mul != 1 || mb_height_div != 1)
2724 if (!
s->golden_frame.f) {
2726 "vp3: first frame not a keyframe\n");
2738 memset(
s->all_fragments, 0,
s->fragment_count *
sizeof(
Vp3Fragment));
2740 if (
s->version < 2) {
2745 #if CONFIG_VP4_DECODER
2747 if ((
ret = vp4_unpack_macroblocks(
s, &gb)) < 0) {
2766 if (
s->version < 2) {
2771 #if CONFIG_VP4_DECODER
2773 if ((
ret = vp4_unpack_dct_coeffs(
s, &gb)) < 0) {
2780 for (
int i = 0;
i < 3;
i++) {
2781 int height =
s->height >> (
i &&
s->chroma_y_shift);
2782 if (
s->flipped_image)
2783 s->data_offset[
i] = 0;
2785 s->data_offset[
i] = (
height - 1) *
s->current_frame.f->linesize[
i];
2788 s->last_slice_end = 0;
2789 for (
int i = 0;
i <
s->c_superblock_height;
i++)
2794 for (
int i = 0;
i < 3;
i++) {
2795 int row = (
s->height >> (3 + (
i &&
s->chroma_y_shift))) - 1;
2804 frame->crop_left =
s->offset_x;
2805 frame->crop_right = avctx->coded_width - avctx->width -
s->offset_x;
2806 frame->crop_top =
s->offset_y;
2807 frame->crop_bottom = avctx->coded_height - avctx->height -
s->offset_y;
2835 ff_dlog(avctx,
"code length %d, curr entry %d, token %d\n",
2853 #if CONFIG_THEORA_DECODER
2861 int visible_width, visible_height, colorspace;
2862 uint8_t offset_x = 0, offset_y = 0;
2869 s->theora_header = 0;
2879 if (
s->theora < 0x030200) {
2880 s->flipped_image = 1;
2882 "Old (<alpha3) Theora bitstream, flipped image\n");
2890 if (
s->theora >= 0x030200) {
2900 visible_width + offset_x >
s->width ||
2901 visible_height + offset_y >
s->height ||
2905 "Invalid frame dimensions - w:%d h:%d x:%d y:%d (%dx%d).\n",
2906 visible_width, visible_height, offset_x, offset_y,
2907 s->width,
s->height);
2913 if (fps.
num && fps.
den) {
2914 if (fps.
num < 0 || fps.
den < 0) {
2919 fps.
den, fps.
num, 1 << 30);
2924 if (aspect.
num && aspect.
den) {
2927 aspect.
num, aspect.
den, 1 << 30);
2931 if (
s->theora < 0x030200)
2938 if (
s->theora >= 0x030200) {
2955 avctx->
width = visible_width;
2956 avctx->
height = visible_height;
2959 s->offset_x = offset_x;
2960 s->offset_y =
s->height - visible_height - offset_y;
2963 if (colorspace == 1)
2965 else if (colorspace == 2)
2968 if (colorspace == 1 || colorspace == 2) {
2973 s->theora_header = 1;
2980 int n, matrices,
ret;
2982 if (!
s->theora_header)
2985 if (
s->theora >= 0x030200) {
2989 for (
int i = 0;
i < 64;
i++)
2993 if (
s->theora >= 0x030200)
2998 for (
int i = 0;
i < 64;
i++)
2999 s->coded_ac_scale_factor[
i] =
get_bits(gb, n);
3001 if (
s->theora >= 0x030200)
3006 for (
int i = 0;
i < 64;
i++)
3007 s->coded_dc_scale_factor[0][
i] =
3008 s->coded_dc_scale_factor[1][
i] =
get_bits(gb, n);
3010 if (
s->theora >= 0x030200)
3015 if (matrices > 384) {
3020 for (
int j = 0; j < matrices; j++)
3021 for (
int i = 0;
i < 64;
i++)
3024 for (
int inter = 0; inter <= 1; inter++) {
3025 for (
int plane = 0; plane <= 2; plane++) {
3027 if (inter || plane > 0)
3035 qtj = (3 * inter + plane - 1) / 3;
3036 plj = (plane + 2) % 3;
3038 s->qr_count[inter][plane] =
s->qr_count[qtj][plj];
3039 memcpy(
s->qr_size[inter][plane],
s->qr_size[qtj][plj],
3040 sizeof(
s->qr_size[0][0]));
3041 memcpy(
s->qr_base[inter][plane],
s->qr_base[qtj][plj],
3042 sizeof(
s->qr_base[0][0]));
3049 if (
i >= matrices) {
3051 "invalid base matrix index\n");
3054 s->qr_base[inter][plane][qri] =
i;
3058 s->qr_size[inter][plane][qri++] =
i;
3066 s->qr_count[inter][plane] = qri;
3073 s->huffman_table[
i].nb_entries = 0;
3078 s->theora_tables = 1;
3088 const uint8_t *header_start[3];
3102 42, header_start, header_len) < 0) {
3107 for (
int i = 0;
i < 3;
i++) {
3108 if (header_len[
i] <= 0)
3116 if (!(ptype & 0x80)) {
3139 "Unknown Theora config packet: %d\n", ptype & ~0x80);
3144 "%d bits left in packet %X\n",
3146 if (
s->theora < 0x030200)
3159 .
init = theora_decode_init,
3189 #if CONFIG_VP4_DECODER
static void error(const char *err)
static const uint16_t vp4_ac_scale_factor[64]
void ff_progress_frame_report(ProgressFrame *f, int n)
Notify later decoding threads when part of their reference frame is ready.
static av_cold int allocate_tables(AVCodecContext *avctx)
Allocate tables for per-frame data in Vp3DecodeContext.
static int vp3_dequant(Vp3DecodeContext *s, const Vp3Fragment *frag, int plane, int inter, int16_t block[64])
Pull DCT tokens from the 64 levels to decode and dequant the coefficients for the next block in codin...
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
#define AV_LOG_WARNING
Something somehow does not look correct.
AVPixelFormat
Pixel format.
int ff_vlc_init_from_lengths(VLC *vlc, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags, void *logctx)
Build VLC decoding tables suitable for use with get_vlc2()
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
static int get_bits_left(GetBitContext *gb)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
static int vp4_get_mv(GetBitContext *gb, int axis, int last_motion)
static void vp3_decode_flush(AVCodecContext *avctx)
enum AVColorSpace colorspace
YUV colorspace type.
static const uint8_t zero_run_base[32]
#define MODE_INTER_PRIOR_LAST
#define u(width, name, range_min, range_max)
uint8_t idct_scantable[64]
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
static const uint8_t mode_code_vlc_len[8]
static void * ff_refstruct_alloc_ext(size_t size, unsigned flags, void *opaque, void(*free_cb)(FFRefStructOpaque opaque, void *obj))
A wrapper around ff_refstruct_alloc_ext_c() for the common case of a non-const qualified opaque.
static VLCElem superblock_run_length_vlc[88]
static int read_huffman_tree(HuffTable *huff, GetBitContext *gb, int length, AVCodecContext *avctx)
This structure describes decoded (raw) audio or video data.
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
void ff_vp3dsp_set_bounding_values(int *bounding_values_array, int filter_limit)
const FFCodec ff_vp3_decoder
int ff_progress_frame_get_buffer(AVCodecContext *avctx, ProgressFrame *f, int flags)
This function sets up the ProgressFrame, i.e.
Vp3Fragment * all_fragments
static VLCElem mode_code_vlc[24+2108 *CONFIG_VP4_DECODER]
uint8_t filter_limit_values[64]
static VLCElem fragment_run_length_vlc[56]
static VLCElem motion_vector_vlc[112]
RefStruct is an API for creating reference-counted objects with minimal overhead.
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
static int unpack_superblocks(Vp3DecodeContext *s, GetBitContext *gb)
static void render_slice(Vp3DecodeContext *s, int slice)
const VLCElem * vlc_tabs[80]
#define FF_DEBUG_PICT_INFO
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static VLCElem vlc_tables[VLC_TABLES_SIZE]
#define AV_CODEC_FLAG2_IGNORE_CROP
Discard cropping information from SPS.
#define bit(string, value)
int bounding_values_array[256+2]
static void skip_bits(GetBitContext *s, int n)
int is_copy
When using frame-threaded decoding, this field is set for the first worker thread (e....
int * superblock_fragments
@ AVCOL_SPC_BT470BG
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
ProgressFrame golden_frame
static int get_coeff(GetBitContext *gb, int token, int16_t *coeff)
AVCodec p
The public AVCodec.
static int ref_frame(VVCFrame *dst, const VVCFrame *src)
static const uint8_t vp4_mv_vlc[2][7][63][2]
#define CODING_MODE_COUNT
static const struct twinvq_data tab
Writing a table generator This documentation is preliminary Parts of the API are not good and should be changed Basic concepts A table generator consists of two *_tablegen c and *_tablegen h The h file will provide the variable declarations and initialization code for the tables
int flags
AV_CODEC_FLAG_*.
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
#define MODE_INTER_LAST_MV
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
int num_kf_coded_fragment[3]
#define TOKEN_ZERO_RUN(coeff, zero_run)
static const uint8_t vp4_pred_block_type_map[8]
#define FF_CODEC_CAP_USES_PROGRESSFRAMES
The decoder might make use of the ProgressFrame API.
static void await_reference_row(Vp3DecodeContext *s, const Vp3Fragment *fragment, int motion_y, int y)
Wait for the reference frame of the current fragment.
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
static int ff_thread_once(char *control, void(*routine)(void))
static const uint8_t motion_vector_vlc_table[63][2]
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define FF_ARRAY_ELEMS(a)
static av_cold void free_vlc_tables(FFRefStructOpaque unused, void *obj)
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
static int theora_decode_tables(AVCodecContext *avctx, GetBitContext *gb)
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
static const uint8_t hilbert_offset[16][2]
For static VLCs, the number of bits can often be hardcoded at each get_vlc2() callsite.
#define FF_CODEC_DECODE_CB(func)
static void init_loop_filter(Vp3DecodeContext *s)
static const uint8_t vp4_mv_table_selector[32]
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
static const int8_t transform[32][32]
static int init_block_mapping(Vp3DecodeContext *s)
This function sets up all of the various blocks mappings: superblocks <-> fragments,...
#define SB_PARTIALLY_CODED
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
void ff_progress_frame_unref(ProgressFrame *f)
Give up a reference to the underlying frame contained in a ProgressFrame and reset the ProgressFrame,...
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before ff_progress_frame_await() has been called on them. reget_buffer() and buffer age optimizations no longer work. *The contents of buffers must not be written to after ff_progress_frame_report() has been called on them. This includes draw_edges(). Porting codecs to frame threading
static void reverse_dc_prediction(Vp3DecodeContext *s, int first_fragment, int fragment_width, int fragment_height)
static int unpack_dct_coeffs(Vp3DecodeContext *s, GetBitContext *gb)
static const int ModeAlphabet[6][CODING_MODE_COUNT]
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
#define CODEC_LONG_NAME(str)
@ AVCOL_PRI_BT470BG
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
#define MODE_USING_GOLDEN
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
uint8_t idct_permutation[64]
static void init_dequantizer(Vp3DecodeContext *s, int qpi)
#define MODE_INTER_FOURMV
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
@ AVDISCARD_ALL
discard all
static const int16_t *const coeff_tables[32]
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Used to store optimal huffman encoding results.
static int unpack_modes(Vp3DecodeContext *s, GetBitContext *gb)
Rational number (pair of numerator and denominator).
struct AVCodecInternal * internal
Private context used for internal data.
void ff_vp3dsp_h_loop_filter_12(uint8_t *first_pixel, ptrdiff_t stride, int *bounding_values)
static int theora_decode_header(AVCodecContext *avctx, GetBitContext *gb)
@ AV_PICTURE_TYPE_I
Intra.
static unsigned int get_bits1(GetBitContext *s)
static const uint8_t fragment_run_length_vlc_len[30]
static const uint8_t vp4_bias[5 *16][32][2]
int ff_set_sar(AVCodecContext *avctx, AVRational sar)
Check that the provided sample aspect ratio is valid and set it on the codec context.
#define TOKEN_COEFF(coeff)
static const uint8_t vp4_y_dc_scale_factor[64]
#define UPDATE_THREAD_CONTEXT(func)
CoeffVLCs * coeff_vlc
The first 16 of the following VLCs are for the dc coefficients; the others are four groups of 16 VLCs...
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
static const uint16_t vp31_ac_scale_factor[64]
uint8_t qr_size[2][3][64]
static const uint8_t vp31_intra_y_dequant[64]
void ff_vp3dsp_v_loop_filter_12(uint8_t *first_pixel, ptrdiff_t stride, int *bounding_values)
int total_num_coded_frags
@ AVDISCARD_NONKEY
discard all frames except keyframes
int flags2
AV_CODEC_FLAG2_*.
int(* init)(AVBSFContext *ctx)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
static const int8_t fixed_motion_vector_table[64]
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
#define DECLARE_ALIGNED(n, t, v)
static int unpack_vectors(Vp3DecodeContext *s, GetBitContext *gb)
const FFCodec ff_vp4_decoder
static void update_frames(AVCodecContext *avctx)
Release and shuffle frames after decode finishes.
#define FF_CODEC_CAP_EXPORTS_CROPPING
The decoder sets the cropping fields in the output frames manually.
#define AV_NUM_DATA_POINTERS
static const struct @252 eob_run_table[7]
int16_t * dct_tokens[3][64]
This is a list of all tokens in bitstream order.
uint16_t coded_dc_scale_factor[2][64]
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
unsigned char * macroblock_coding
#define AV_LOG_INFO
Standard information.
@ AVCOL_TRC_BT709
also ITU-R BT1361
#define FF_THREAD_FRAME
Decode more than one frame at once.
int * nkf_coded_fragment_list
static void apply_loop_filter(Vp3DecodeContext *s, int plane, int ystart, int yend)
av_cold void ff_vp3dsp_init(VP3DSPContext *c, int flags)
#define i(width, name, range_min, range_max)
uint8_t * edge_emu_buffer
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
#define av_malloc_array(a, b)
static int vp3_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
static const uint8_t superblock_run_length_vlc_lens[34]
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
const uint8_t ff_mjpeg_std_chrominance_quant_tbl[64]
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
#define SUPERBLOCK_VLC_BITS
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
const char * name
Name of the codec implementation.
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
ProgressFrame current_frame
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
void * av_calloc(size_t nmemb, size_t size)
int * coded_fragment_list[3]
const uint8_t ff_zigzag_direct[64]
@ AVCOL_PRI_BT470M
also FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
void ff_vlc_free(VLC *vlc)
#define FFSWAP(type, a, b)
static av_cold void free_tables(AVCodecContext *avctx)
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
static int unpack_vlcs(Vp3DecodeContext *s, GetBitContext *gb, const VLCElem *vlc_table, int coeff_index, int plane, int eob_run)
#define MODE_INTER_PLUS_MV
int num_coded_frags[3][64]
number of blocks that contain DCT coefficients at the given level or higher
void ff_refstruct_replace(void *dstp, const void *src)
Ensure *dstp refers to the same object as src.
static const uint8_t vp4_block_pattern_table_selector[14]
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call ff_thread_finish_setup() afterwards. If some code can 't be moved
void ff_progress_frame_replace(ProgressFrame *dst, const ProgressFrame *src)
Do nothing if dst and src already refer to the same AVFrame; otherwise unreference dst and if src is ...
const FFCodec ff_theora_decoder
static const uint8_t vp4_filter_limit_values[64]
static const VLCElem * coeff_vlc[2][8][4]
main external API structure.
static void vp3_draw_horiz_band(Vp3DecodeContext *s, int y)
called when all pixels up to row y are complete
@ AVCHROMA_LOC_CENTER
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
static const uint8_t vp4_generic_dequant[64]
static const uint8_t zero_run_get_bits[32]
uint32_t coded_ac_scale_factor[64]
static void output_plane(const Plane *plane, int buf_sel, uint8_t *dst, ptrdiff_t dst_pitch, int dst_height)
Convert and output the current plane.
static const uint8_t vp31_inter_dequant[64]
static void body(uint32_t ABCD[4], const uint8_t *src, size_t nblocks)
static const uint8_t vp4_block_pattern_vlc[2][14][2]
int avpriv_split_xiph_headers(const uint8_t *extradata, int extradata_size, int first_header_size, const uint8_t *header_start[3], int header_len[3])
Split a single extradata buffer into the three headers that most Xiph codecs use.
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
const av_cold VLCElem * ff_vlc_init_tables_from_lengths(VLCInitState *state, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags)
unsigned char * superblock_coding
#define COMPATIBLE_FRAME(x)
#define AVERROR_DECODER_NOT_FOUND
Decoder not found.
int coded_width
Bitstream width / height, may be different from width/height e.g.
@ AV_PICTURE_TYPE_P
Predicted.
static const VLCElem * ff_vlc_init_tables(VLCInitState *state, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, int flags)
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
#define avpriv_request_sample(...)
static const uint8_t vp3_bias[5 *16][32][2]
static int get_eob_run(GetBitContext *gb, int token)
#define VLC_INIT_STATIC_TABLE_FROM_LENGTHS(vlc_table, nb_bits, nb_codes, lens, lens_wrap, syms, syms_wrap, syms_size, offset, flags)
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
HuffTable huffman_table[5 *16]
The ProgressFrame structure.
#define VLC_INIT_STATE(_table)
static const uint8_t vp31_filter_limit_values[64]
This structure stores compressed data.
static av_cold int vp3_decode_init(AVCodecContext *avctx)
uint8_t base_matrix[384][64]
static const uint8_t vp31_dc_scale_factor[64]
int width
picture width / height.
int * kf_coded_fragment_list
#define AV_CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
static int unpack_block_qpis(Vp3DecodeContext *s, GetBitContext *gb)
uint16_t qr_base[2][3][64]
static av_cold int vp3_decode_end(AVCodecContext *avctx)
The exact code depends on how similar the blocks are and how related they are to the block
static const double coeff[2][5]
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define MKTAG(a, b, c, d)
static const uint8_t vp4_uv_dc_scale_factor[64]
#define MAXIMUM_LONG_BIT_RUN
static av_cold void init_tables_once(void)
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
int8_t(*[2] motion_val)[2]
VP4Predictor * dc_pred_row
static const uint8_t coeff_get_bits[32]
int16_t * dct_tokens_base
void ff_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
int16_t qmat[3][2][3][64]
qmat[qpi][is_inter][plane]
#define TOKEN_EOB(eob_run)