51 #define FRAGMENT_PIXELS 8 60 #define SB_NOT_CODED 0 61 #define SB_PARTIALLY_CODED 1 62 #define SB_FULLY_CODED 2 67 #define MAXIMUM_LONG_BIT_RUN 4129 69 #define MODE_INTER_NO_MV 0 71 #define MODE_INTER_PLUS_MV 2 72 #define MODE_INTER_LAST_MV 3 73 #define MODE_INTER_PRIOR_LAST 4 74 #define MODE_USING_GOLDEN 5 75 #define MODE_GOLDEN_MV 6 76 #define MODE_INTER_FOURMV 7 77 #define CODING_MODE_COUNT 8 126 { 0, 0 }, { 1, 0 }, { 1, 1 }, { 0, 1 },
127 { 0, 2 }, { 0, 3 }, { 1, 3 }, { 1, 2 },
128 { 2, 2 }, { 2, 3 }, { 3, 3 }, { 3, 2 },
129 { 3, 1 }, { 2, 1 }, { 2, 0 }, { 3, 0 }
156 #define MIN_DEQUANT_VAL 2 202 int fragment_width[2];
203 int fragment_height[2];
206 int fragment_start[3];
212 int8_t (*motion_val[2])[2];
215 uint16_t coded_dc_scale_factor[2][64];
216 uint32_t coded_ac_scale_factor[64];
220 uint16_t qr_base[2][3][64];
239 int16_t *dct_tokens[3][64];
241 #define TOKEN_EOB(eob_run) ((eob_run) << 2) 242 #define TOKEN_ZERO_RUN(coeff, zero_run) (((coeff) * 512) + ((zero_run) << 2) + 1) 243 #define TOKEN_COEFF(coeff) (((coeff) * 4) + 2) 249 int num_coded_frags[3][64];
254 int *coded_fragment_list[3];
258 int num_kf_coded_fragment[3];
353 for (i = 0; i < 16; i++) {
366 for (j = 0; j < 2; j++)
367 for (i = 0; i < 7; i++)
370 for (i = 0; i < 2; i++)
384 int sb_x, sb_y,
plane;
387 for (plane = 0; plane < 3; plane++) {
395 for (sb_y = 0; sb_y < sb_height; sb_y++)
396 for (sb_x = 0; sb_x < sb_width; sb_x++)
397 for (i = 0; i < 16; i++) {
399 y = 4 * sb_y + hilbert_offset[
i][1];
401 if (x < frag_width && y < frag_height)
419 int i,
plane, inter, qri, bmi, bmj, qistart;
421 for (inter = 0; inter < 2; inter++) {
422 for (plane = 0; plane < 3; plane++) {
427 if (s->
qps[qpi] <= sum)
433 for (i = 0; i < 64; i++) {
437 (2 * s->
qr_size[inter][plane][qri]);
439 int qmin = 8 << (inter + !
i);
440 int qscale = i ? ac_scale_factor : dc_scale_factor;
441 int qbias = (1 + inter) * 3;
443 (i == 0 || s->
version < 2) ? av_clip((qscale * coeff) / 100 * 4, qmin, 4096)
444 : (qscale * (coeff - qbias) / 100 + qbias) * 4;
470 int superblock_starts[3] = {
474 int current_superblock = 0;
476 int num_partial_superblocks = 0;
479 int current_fragment;
481 int plane0_num_coded_frags = 0;
490 while (current_superblock < s->superblock_count &&
get_bits_left(gb) > 0) {
498 if (current_run == 34)
503 "Invalid partially coded superblock run length\n");
509 current_superblock += current_run;
511 num_partial_superblocks += current_run;
516 if (num_partial_superblocks < s->superblock_count) {
517 int superblocks_decoded = 0;
519 current_superblock = 0;
523 while (superblocks_decoded < s->superblock_count - num_partial_superblocks &&
532 if (current_run == 34)
535 for (j = 0; j < current_run; current_superblock++) {
538 "Invalid fully coded superblock run length\n");
548 superblocks_decoded += current_run;
554 if (num_partial_superblocks) {
571 for (plane = 0; plane < 3; plane++) {
572 int sb_start = superblock_starts[
plane];
575 int num_coded_frags = 0;
579 for (i = sb_start; i < sb_end; i++) {
581 for (j = 0; j < 16; j++) {
584 if (current_fragment != -1) {
594 for (i = sb_start; i < sb_end && get_bits_left(gb) > 0; i++) {
599 for (j = 0; j < 16; j++) {
602 if (current_fragment != -1) {
608 if (current_run-- == 0) {
632 plane0_num_coded_frags = num_coded_frags;
634 for (i = 0; i < 64; i++)
643 #define BLOCK_X (2 * mb_x + (k & 1)) 644 #define BLOCK_Y (2 * mb_y + (k >> 1)) 646 #if CONFIG_VP4_DECODER 655 while ((bits =
show_bits(gb, 9)) == 0x1ff) {
664 skip_bits(gb, 2 + n); \ 665 v += (1 << n) + get_bits(gb, n); } 666 #define thresh(n) (0x200 - (0x80 >> n)) 667 #define else_if(n) else if (bits < thresh(n)) body(n) 670 }
else if (bits < thresh(0)) {
692 *next_block_pattern_table = 0;
702 int next_block_pattern_table;
703 int bit, current_run, has_partial;
715 current_run = vp4_get_mb_count(s, gb);
727 current_run = vp4_get_mb_count(s, gb);
732 current_run = vp4_get_mb_count(s, gb);
742 next_block_pattern_table = 0;
744 for (plane = 0; plane < 3; plane++) {
753 for (sb_y = 0; sb_y < sb_height; sb_y++) {
754 for (sb_x = 0; sb_x < sb_width; sb_x++) {
755 for (j = 0; j < 4; j++) {
756 int mb_x = 2 * sb_x + (j >> 1);
757 int mb_y = 2 * sb_y + (j >> 1) ^ (j & 1);
758 int mb_coded, pattern, coded;
760 if (mb_x >= mb_width || mb_y >= mb_height)
768 pattern = vp4_get_block_pattern(s, gb, &next_block_pattern_table);
772 for (k = 0; k < 4; k++) {
776 coded = pattern & (8 >> k);
795 int i, j, k, sb_x, sb_y;
797 int current_macroblock;
798 int current_fragment;
813 for (i = 0; i < 8; i++)
815 for (i = 0; i < 8; i++)
816 custom_mode_alphabet[
get_bits(gb, 3)] =
i;
817 alphabet = custom_mode_alphabet;
828 for (j = 0; j < 4; j++) {
829 int mb_x = 2 * sb_x + (j >> 1);
830 int mb_y = 2 * sb_y + (((j >> 1) + j) & 1);
840 for (k = 0; k < 4; k++) {
858 for (k = 0; k < 4; k++) {
864 #define SET_CHROMA_MODES \ 865 if (frag[s->fragment_start[1]].coding_method != MODE_COPY) \ 866 frag[s->fragment_start[1]].coding_method = coding_mode; \ 867 if (frag[s->fragment_start[2]].coding_method != MODE_COPY) \ 868 frag[s->fragment_start[2]].coding_method = coding_mode; 877 for (k = 0; k < 2; k++) {
882 for (k = 0; k < 4; k++) {
899 return last_motion < 0 ? -v : v;
908 int j, k, sb_x, sb_y;
912 int last_motion_x = 0;
913 int last_motion_y = 0;
914 int prior_last_motion_x = 0;
915 int prior_last_motion_y = 0;
916 int last_gold_motion_x = 0;
917 int last_gold_motion_y = 0;
918 int current_macroblock;
919 int current_fragment;
935 for (j = 0; j < 4; j++) {
936 int mb_x = 2 * sb_x + (j >> 1);
937 int mb_y = 2 * sb_y + (((j >> 1) + j) & 1);
947 if (coding_mode == 2) {
948 last_gold_motion_x = motion_x[0] =
vp4_get_mv(s, gb, 0, last_gold_motion_x);
949 last_gold_motion_y = motion_y[0] =
vp4_get_mv(s, gb, 1, last_gold_motion_y);
954 if (coding_mode == 0) {
957 }
else if (coding_mode == 1) {
961 motion_x[0] =
vp4_get_mv(s, gb, 0, last_motion_x);
962 motion_y[0] =
vp4_get_mv(s, gb, 1, last_motion_y);
967 prior_last_motion_x = last_motion_x;
968 prior_last_motion_y = last_motion_y;
969 last_motion_x = motion_x[0];
970 last_motion_y = motion_y[0];
976 prior_last_motion_x = last_motion_x;
977 prior_last_motion_y = last_motion_y;
981 for (k = 0; k < 4; k++) {
984 if (coding_mode == 0) {
987 }
else if (coding_mode == 1) {
991 motion_x[k] =
vp4_get_mv(s, gb, 0, prior_last_motion_x);
992 motion_y[k] =
vp4_get_mv(s, 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 (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];
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);
1055 motion_x[0] = (motion_x[0] >> 1) | (motion_x[0] & 1);
1056 motion_y[0] = (motion_y[0] >> 1) | (motion_y[0] & 1);
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];
1072 motion_x[0] = (motion_x[0] >> 1) | (motion_x[0] & 1);
1073 motion_x[1] = (motion_x[1] >> 1) | (motion_x[1] & 1);
1076 for (k = 0; k < 2; k++) {
1082 for (k = 0; k < 4; k++) {
1102 int qpi,
i, j,
bit, run_length, blocks_decoded, num_blocks_at_qpi;
1105 for (qpi = 0; qpi < s->
nqps - 1 && num_blocks > 0; qpi++) {
1106 i = blocks_decoded = num_blocks_at_qpi = 0;
1118 if (run_length == 34)
1120 blocks_decoded += run_length;
1123 num_blocks_at_qpi += run_length;
1125 for (j = 0; j < run_length; i++) {
1134 }
while (blocks_decoded < num_blocks &&
get_bits_left(gb) > 0);
1136 num_blocks -= num_blocks_at_qpi;
1152 int bits_to_get, zero_run;
1156 bits_to_get =
get_bits(gb, bits_to_get);
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) {
1240 zero_run =
get_coeff(gb, token, &coeff);
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 (i = coeff_index + 1; i <= coeff_index + zero_run; i++)
1279 for (i = coeff_index + 1; i < 64; i++)
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;
1321 0, residual_eob_run);
1322 if (residual_eob_run < 0)
1323 return residual_eob_run;
1332 1, residual_eob_run);
1333 if (residual_eob_run < 0)
1334 return residual_eob_run;
1336 2, residual_eob_run);
1337 if (residual_eob_run < 0)
1338 return residual_eob_run;
1355 for (i = 1; i <= 5; i++) {
1359 for (i = 6; i <= 14; i++) {
1363 for (i = 15; i <= 27; i++) {
1367 for (i = 28; i <= 63; i++) {
1373 for (i = 1; i <= 63; i++) {
1374 residual_eob_run =
unpack_vlcs(s, gb, y_tables[i], i,
1375 0, residual_eob_run);
1376 if (residual_eob_run < 0)
1377 return residual_eob_run;
1379 residual_eob_run =
unpack_vlcs(s, gb, c_tables[i], i,
1380 1, residual_eob_run);
1381 if (residual_eob_run < 0)
1382 return residual_eob_run;
1383 residual_eob_run =
unpack_vlcs(s, gb, c_tables[i], i,
1384 2, residual_eob_run);
1385 if (residual_eob_run < 0)
1386 return residual_eob_run;
1392 #if CONFIG_VP4_DECODER 1409 while (!eob_tracker[coeff_i]) {
1416 if ((
unsigned) token <= 6
U) {
1419 eob_tracker[coeff_i] = eob_run - 1;
1421 }
else if (token >= 0) {
1422 zero_run =
get_coeff(gb, token, &coeff);
1425 if (coeff_i + zero_run > 64) {
1427 "Invalid zero run of %d with %d coeffs left\n",
1428 zero_run, 64 - coeff_i);
1429 zero_run = 64 - coeff_i;
1432 coeff_i += zero_run;
1448 eob_tracker[coeff_i]--;
1462 for (i = 0; i < 4; i++)
1465 for (j = 1; j < 5; j++)
1466 for (i = 0; i < 4; i++)
1467 vp4_dc_predictor_reset(&dc_pred[j][i + 1]);
1474 for (i = 0; i < 4; i++)
1477 for (i = 1; i < 5; i++)
1478 dc_pred[i][0] = dc_pred[i][4];
1488 dc += dc_pred[-6].
dc;
1493 dc += dc_pred[6].
dc;
1497 if (count != 2 && dc_pred[-1].
type ==
type) {
1498 dc += dc_pred[-1].
dc;
1502 if (count != 2 && dc_pred[1].
type ==
type) {
1503 dc += dc_pred[1].
dc;
1508 return count == 2 ? dc / 2 : last_dc[
type];
1515 for (plane = 0; plane < 3; plane++) {
1516 for (i = 0; i < 64; i++) {
1531 int plane, sb_y, sb_x;
1532 int eob_tracker[64];
1548 tables[0][0] = &s->
dc_vlc[dc_y_table];
1549 tables[1][0] = &s->
dc_vlc[dc_c_table];
1550 for (i = 1; i <= 5; i++) {
1551 tables[0][
i] = &s->
ac_vlc_1[ac_y_table];
1552 tables[1][
i] = &s->
ac_vlc_1[ac_c_table];
1554 for (i = 6; i <= 14; i++) {
1555 tables[0][
i] = &s->
ac_vlc_2[ac_y_table];
1556 tables[1][
i] = &s->
ac_vlc_2[ac_c_table];
1558 for (i = 15; i <= 27; i++) {
1559 tables[0][
i] = &s->
ac_vlc_3[ac_y_table];
1560 tables[1][
i] = &s->
ac_vlc_3[ac_c_table];
1562 for (i = 28; i <= 63; i++) {
1563 tables[0][
i] = &s->
ac_vlc_4[ac_y_table];
1564 tables[1][
i] = &s->
ac_vlc_4[ac_c_table];
1567 vp4_set_tokens_base(s);
1569 memset(last_dc, 0,
sizeof(last_dc));
1572 memset(eob_tracker, 0,
sizeof(eob_tracker));
1578 for (j = 0; j < 6; j++)
1579 for (i = 0; i < 6; i++)
1580 vp4_dc_predictor_reset(&dc_pred[j][i]);
1584 vp4_dc_pred_before(s, dc_pred, sb_x);
1585 for (j = 0; j < 16; j++) {
1588 int x = 4 * sb_x + hx;
1589 int y = 4 * sb_y + hy;
1601 if (vp4_unpack_vlcs(s, gb, tables[!!plane], plane, eob_tracker, fragment) < 0)
1607 vp4_dc_pred(s, this_dc_pred, last_dc, dc_block_type, plane);
1609 this_dc_pred->
type = dc_block_type,
1612 vp4_dc_pred_after(s, dc_pred, sb_x);
1617 vp4_set_tokens_base(s);
1628 #define COMPATIBLE_FRAME(x) \ 1629 (compatible_frame[s->all_fragments[x].coding_method] == current_frame_type) 1630 #define DC_COEFF(u) s->all_fragments[u].dc 1635 int fragment_height)
1643 int i = first_fragment;
1648 int vl, vul, vu, vur;
1660 static const int predictor_transform[16][4] = {
1674 { -104, 116, 0, 116 },
1676 { -104, 116, 0, 116 }
1685 static const unsigned char compatible_frame[9] = {
1696 int current_frame_type;
1712 for (y = 0; y < fragment_height; y++) {
1714 for (x = 0; x < fragment_width; x++, i++) {
1718 current_frame_type =
1729 u = i - fragment_width;
1734 ul = i - fragment_width - 1;
1739 if (x + 1 < fragment_width) {
1740 ur = i - fragment_width + 1;
1747 if (transform == 0) {
1750 predicted_dc = last_dc[current_frame_type];
1754 (predictor_transform[
transform][0] * vul) +
1755 (predictor_transform[transform][1] * vu) +
1756 (predictor_transform[
transform][2] * vur) +
1757 (predictor_transform[transform][3] * vl);
1759 predicted_dc /= 128;
1763 if ((transform == 15) || (transform == 13)) {
1764 if (
FFABS(predicted_dc - vu) > 128)
1766 else if (
FFABS(predicted_dc - vl) > 128)
1768 else if (
FFABS(predicted_dc - vul) > 128)
1776 last_dc[current_frame_type] =
DC_COEFF(i);
1783 int ystart,
int yend)
1797 for (y = ystart; y < yend; y++) {
1798 for (x = 0; x <
width; x++) {
1808 stride, bounding_values);
1815 stride, bounding_values);
1821 if ((x < width - 1) &&
1824 plane_data + 8 * x + 8,
1825 stride, bounding_values);
1831 if ((y < height - 1) &&
1834 plane_data + 8 * x + 8 * stride,
1835 stride, bounding_values);
1841 plane_data += 8 *
stride;
1852 int16_t *dequantizer = s->
qmat[frag->
qpi][inter][
plane];
1858 switch (token & 3) {
1867 i += (token >> 2) & 0x7f;
1872 block[perm[
i]] = (token >> 9) * dequantizer[perm[i]];
1876 block[perm[
i]] = (token >> 2) * dequantizer[perm[i]];
1887 block[0] = frag->
dc * s->
qmat[0][inter][
plane][0];
1906 y_flipped == s->
height ? INT_MAX
1937 int motion_y,
int y)
1941 int border = motion_y & 1;
1949 ref_row = y + (motion_y >> 1);
1950 ref_row =
FFMAX(
FFABS(ref_row), ref_row + 8 + border);
1955 #if CONFIG_VP4_DECODER 1959 static int vp4_mc_loop_filter(
Vp3DecodeContext *s,
int plane,
int motion_x,
int motion_y,
int bx,
int by,
1962 int motion_shift =
plane ? 4 : 2;
1963 int subpel_mask =
plane ? 3 : 1;
1969 int x_subpel, y_subpel;
1970 int x_offset, y_offset;
1972 int block_width =
plane ? 8 : 16;
1976 #define loop_stride 12 1980 x = 8 * bx + motion_x / motion_shift;
1981 y = 8 * by + motion_y / motion_shift;
1983 x_subpel = motion_x & subpel_mask;
1984 y_subpel = motion_y & subpel_mask;
1986 if (x_subpel || y_subpel) {
1996 x2 = x + block_width;
1997 y2 = y + block_width;
1999 if (x2 < 0 || x2 >= plane_width || y2 < 0 || y2 >= plane_height)
2002 x_offset = (-(x + 2) & 7) + 2;
2003 y_offset = (-(y + 2) & 7) + 2;
2005 if (x_offset > 8 + x_subpel && y_offset > 8 + y_subpel)
2010 12, 12, src_x - 1, src_y - 1,
2014 if (x_offset <= 8 + x_subpel)
2017 if (y_offset <= 8 + y_subpel)
2025 if (!x_offset && !y_offset)
2030 12, 12, src_x - 1, src_y - 1,
2034 #define safe_loop_filter(name, ptr, stride, bounding_values) \ 2035 if ((uintptr_t)(ptr) & 7) \ 2036 s->vp3dsp.name##_unaligned(ptr, stride, bounding_values); \ 2038 s->vp3dsp.name(ptr, stride, bounding_values); 2041 safe_loop_filter(h_loop_filter, loop + loop_stride + x_offset + 1, loop_stride, bounding_values);
2044 safe_loop_filter(v_loop_filter, loop + (y_offset + 1)*loop_stride + 1, loop_stride, bounding_values);
2047 for (i = 0; i < 9; i++)
2048 memcpy(temp + i*
stride, loop + (i + 1) * loop_stride + 1, 9);
2062 int motion_x = 0xdeadbeef, motion_y = 0xdeadbeef;
2063 int motion_halfpel_index;
2065 int plane, first_pixel;
2070 for (plane = 0; plane < 3; plane++) {
2091 int do_await = !plane && HAVE_THREADS &&
2100 for (; sb_y < slice_height; sb_y++) {
2102 for (sb_x = 0; sb_x < slice_width; sb_x++) {
2104 for (j = 0; j < 16; j++) {
2106 y = 4 * sb_y + hilbert_offset[j][1];
2107 fragment = y * fragment_width + x;
2109 i = fragment_start + fragment;
2112 if (x >= fragment_width || y >= fragment_height)
2115 first_pixel = 8 * y * stride + 8 * x;
2120 motion_val[fragment][1],
2127 motion_source = golden_plane;
2129 motion_source = last_plane;
2131 motion_source += first_pixel;
2132 motion_halfpel_index = 0;
2139 int standard_mc = 1;
2140 motion_x = motion_val[fragment][0];
2141 motion_y = motion_val[fragment][1];
2142 #if CONFIG_VP4_DECODER 2143 if (plane && s->
version >= 2) {
2144 motion_x = (motion_x >> 1) | (motion_x & 1);
2145 motion_y = (motion_y >> 1) | (motion_y & 1);
2149 src_x = (motion_x >> 1) + 8 * x;
2150 src_y = (motion_y >> 1) + 8 * y;
2152 motion_halfpel_index = motion_x & 0x01;
2153 motion_source += (motion_x >> 1);
2155 motion_halfpel_index |= (motion_y & 0x01) << 1;
2156 motion_source += ((motion_y >> 1) * stride);
2158 #if CONFIG_VP4_DECODER 2163 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)) {
2164 motion_source =
temp;
2170 if (standard_mc && (
2171 src_x < 0 || src_y < 0 ||
2172 src_x + 9 >= plane_width ||
2173 src_y + 9 >= plane_height)) {
2183 motion_source =
temp;
2194 if (motion_halfpel_index != 3) {
2196 output_plane + first_pixel,
2197 motion_source,
stride, 8);
2201 int d = (motion_x ^ motion_y) >> 31;
2204 motion_source + stride + 1 + d,
2231 output_plane + first_pixel,
2232 last_plane + first_pixel,
2241 FFMIN(4 * sb_y + 3, fragment_height - 1));
2261 int y_fragment_count, c_fragment_count;
2274 memset(s-> num_kf_coded_fragment, -1,
sizeof(s-> num_kf_coded_fragment));
2324 int y_fragment_count, c_fragment_count;
2325 #if CONFIG_VP4_DECODER 2352 for (i = 0; i < 64; i++) {
2353 #define TRANSPOSE(x) (((x) >> 3) | (((x) & 7) << 3)) 2361 for (i = 0; i < 3; i++)
2404 for (i = 0; i < 64; i++) {
2414 for (inter = 0; inter < 2; inter++) {
2415 for (plane = 0; plane < 3; plane++) {
2425 for (i = 0; i < 16; i++) {
2451 #if CONFIG_VP4_DECODER 2453 for (i = 0; i < 16; i++) {
2482 for (i = 0; i < 16; i++) {
2531 #if CONFIG_VP4_DECODER 2532 for (j = 0; j < 2; j++)
2533 for (i = 0; i < 7; i++)
2539 for (i = 0; i < 2; i++)
2578 if (src->
f->
data[0])
2596 int qps_changed = 0,
i, err;
2598 #define copy_fields(to, from, start_field, end_field) \ 2599 memcpy(&to->start_field, &from->start_field, \ 2600 (char *) &to->end_field - (char *) &to->start_field) 2602 if (!
s1->current_frame.f->data[0] ||
2614 int y_fragment_count, c_fragment_count;
2622 y_fragment_count *
sizeof(*s->
motion_val[0]));
2624 c_fragment_count *
sizeof(*s->
motion_val[1]));
2628 if ((err = ref_frames(s,
s1)) < 0)
2634 for (
i = 0;
i < 3;
i++) {
2635 if (s->
qps[
i] !=
s1->qps[1]) {
2641 if (s->
qps[0] !=
s1->qps[0])
2655 void *
data,
int *got_frame,
2660 int buf_size = avpkt->
size;
2668 #if CONFIG_THEORA_DECODER 2674 av_log(avctx,
AV_LOG_ERROR,
"midstream reconfiguration with multithreading is unsupported, try -threads 1\n");
2688 }
else if (type == 2) {
2701 "Header packet passed to frame decoder, skipping\n");
2713 for (i = 0; i < 3; i++)
2725 s->
keyframe ?
"key" :
"", avctx->frame_number + 1, s->
qps[0]);
2758 if (avctx->frame_number == 0)
2760 "VP version: %d\n", s->
version);
2766 "Warning, unsupported keyframe coding type?!\n");
2769 #if CONFIG_VP4_DECODER 2771 int mb_height, mb_width;
2772 int mb_width_mul, mb_width_div, mb_height_mul, mb_height_div;
2784 if (mb_width_mul != 1 || mb_width_div != 1 || mb_height_mul != 1 || mb_height_div != 1)
2795 "vp3: first frame not a keyframe\n");
2817 #if CONFIG_VP4_DECODER 2819 if (vp4_unpack_macroblocks(s, &gb)) {
2843 #if CONFIG_VP4_DECODER 2845 if (vp4_unpack_dct_coeffs(s, &gb)) {
2852 for (
i = 0;
i < 3;
i++) {
2866 for (
i = 0;
i < 3;
i++) {
2877 frame->crop_right = avctx->coded_width - avctx->width - s->
offset_x;
2879 frame->crop_bottom = avctx->coded_height - avctx->height - s->
offset_y;
2911 ff_dlog(avctx,
"hti %d hbits %x token %d entry : %d size %d\n",
2942 s-> kf_coded_fragment_list=
NULL;
2956 #if CONFIG_THEORA_DECODER 2964 int visible_width, visible_height, colorspace;
2965 uint8_t offset_x = 0, offset_y = 0;
2979 if (s->
theora < 0x030200) {
2982 "Old (<alpha3) Theora bitstream, flipped image\n");
2990 if (s->
theora >= 0x030200) {
3000 visible_width + offset_x > s->
width ||
3001 visible_height + offset_y > s->
height) {
3003 "Invalid frame dimensions - w:%d h:%d x:%d y:%d (%dx%d).\n",
3004 visible_width, visible_height, offset_x, offset_y,
3011 if (fps.
num && fps.
den) {
3012 if (fps.
num < 0 || fps.
den < 0) {
3017 fps.
den, fps.
num, 1 << 30);
3022 if (aspect.
num && aspect.
den) {
3025 aspect.
num, aspect.
den, 1 << 30);
3029 if (s->
theora < 0x030200)
3036 if (s->
theora >= 0x030200) {
3051 avctx->
width = visible_width;
3052 avctx->
height = visible_height;
3059 if (colorspace == 1)
3061 else if (colorspace == 2)
3064 if (colorspace == 1 || colorspace == 2) {
3076 int i,
n, matrices, inter,
plane;
3081 if (s->
theora >= 0x030200) {
3085 for (i = 0; i < 64; i++)
3089 if (s->
theora >= 0x030200)
3094 for (i = 0; i < 64; i++)
3097 if (s->
theora >= 0x030200)
3102 for (i = 0; i < 64; i++)
3106 if (s->
theora >= 0x030200)
3111 if (matrices > 384) {
3116 for (n = 0; n < matrices; n++)
3117 for (i = 0; i < 64; i++)
3120 for (inter = 0; inter <= 1; inter++) {
3121 for (plane = 0; plane <= 2; plane++) {
3123 if (inter || plane > 0)
3131 qtj = (3 * inter + plane - 1) / 3;
3132 plj = (plane + 2) % 3;
3145 if (i >= matrices) {
3147 "invalid base matrix index\n");
3168 for (s->
hti = 0; s->
hti < 80; s->
hti++) {
3191 const uint8_t *header_start[3];
3206 42, header_start, header_len) < 0) {
3211 for (i = 0; i < 3; i++) {
3212 if (header_len[i] <= 0)
3220 if (!(ptype & 0x80)) {
3243 "Unknown Theora config packet: %d\n", ptype & ~0x80);
3248 "%d bits left in packet %X\n",
3250 if (s->
theora < 0x030200)
3263 .
init = theora_decode_init,
3291 #if CONFIG_VP4_DECODER
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
uint8_t idct_scantable[64]
discard all frames except keyframes
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define AV_NUM_DATA_POINTERS
int16_t qmat[3][2][3][64]
qmat[qpi][is_inter][plane]
static int init_block_mapping(Vp3DecodeContext *s)
This function sets up all of the various blocks mappings: superblocks <-> fragments, macroblocks <-> fragments, superblocks <-> macroblocks.
#define copy_fields(s, e)
This structure describes decoded (raw) audio or video data.
#define TOKEN_EOB(eob_run)
static void render_slice(Vp3DecodeContext *s, int slice)
static const uint16_t vp4_dc_bias[16][32][2]
ptrdiff_t const GLvoid * data
static void flush(AVCodecContext *avctx)
int bounding_values_array[256+2]
int coded_width
Bitstream width / height, may be different from width/height e.g.
void(* put_no_rnd_pixels_l2)(uint8_t *dst, const uint8_t *a, const uint8_t *b, ptrdiff_t stride, int h)
Copy 8xH pixels from source to destination buffer using a bilinear filter with no rounding (i...
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
#define AV_LOG_WARNING
Something somehow does not look correct.
static int get_coeff(GetBitContext *gb, int token, int16_t *coeff)
uint16_t qr_base[2][3][64]
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 void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
static av_cold int init(AVCodecContext *avctx)
static int theora_decode_tables(AVCodecContext *avctx, GetBitContext *gb)
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 have add an init_thread_copy() which re-allocates them for other threads.Add AV_CODEC_CAP_FRAME_THREADS to the codec capabilities.There will be very little speed gain at this point but it should work.If there are inter-frame dependencies
static const uint16_t fragment_run_length_vlc_table[30][2]
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601 ...
#define avpriv_request_sample(...)
#define MODE_INTER_PLUS_MV
static av_cold int init_frames(Vp3DecodeContext *s)
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
static int unpack_modes(Vp3DecodeContext *s, GetBitContext *gb)
static const uint8_t zero_run_base[32]
void(* v_loop_filter)(uint8_t *src, ptrdiff_t stride, int *bounding_values)
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
static av_cold int vp3_decode_init(AVCodecContext *avctx)
static const uint8_t coeff_get_bits[32]
int num_kf_coded_fragment[3]
static int theora_decode_header(AVCodecContext *avctx, GetBitContext *gb)
static int unpack_superblocks(Vp3DecodeContext *s, GetBitContext *gb)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
static const uint16_t vp4_ac_scale_factor[64]
static void reverse_dc_prediction(Vp3DecodeContext *s, int first_fragment, int fragment_width, int fragment_height)
static av_cold int vp3_decode_end(AVCodecContext *avctx)
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_thread_await_progress() 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_thread_report_progress() has been called on them.This includes draw_edges().Porting codecs to frame threading
static const uint16_t vp4_ac_bias_0[16][32][2]
int * superblock_fragments
VLC superblock_run_length_vlc
#define MAXIMUM_LONG_BIT_RUN
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
static const uint16_t ac_bias_3[16][32][2]
void(* draw_horiz_band)(struct AVCodecContext *s, const AVFrame *src, int offset[AV_NUM_DATA_POINTERS], int y, int type, int height)
If non NULL, 'draw_horiz_band' is called by the libavcodec decoder to draw a horizontal band...
static const uint16_t dc_bias[16][32][2]
Vp3Fragment * all_fragments
static void init_loop_filter(Vp3DecodeContext *s)
#define COMPATIBLE_FRAME(x)
void(* emulated_edge_mc)(uint8_t *dst, const uint8_t *src, ptrdiff_t dst_linesize, ptrdiff_t src_linesize, int block_w, int block_h, int src_x, int src_y, int w, int h)
Copy a rectangular area of samples to a temporary buffer and replicate the border samples...
The exact code depends on how similar the blocks are and how related they are to the block
static int unpack_vectors(Vp3DecodeContext *s, GetBitContext *gb)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
#define TOKEN_ZERO_RUN(coeff, zero_run)
#define FF_DEBUG_PICT_INFO
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
static int vp3_dequant(Vp3DecodeContext *s, 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 av_cold int end(AVCodecContext *avctx)
static int FUNC() huffman_table(CodedBitstreamContext *ctx, RWContext *rw, JPEGRawHuffmanTable *current)
Multithreading support functions.
uint8_t idct_permutation[64]
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
static void init_dequantizer(Vp3DecodeContext *s, int qpi)
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
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.
#define u(width, name, range_min, range_max)
static void vp3_decode_flush(AVCodecContext *avctx)
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
uint8_t filter_limit_values[64]
static int get_bits_count(const GetBitContext *s)
int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
int ff_set_sar(AVCodecContext *avctx, AVRational sar)
Check that the provided sample aspect ratio is valid and set it on the codec context.
bitstream reader API header.
static const uint8_t vp31_intra_c_dequant[64]
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
static const uint8_t mode_code_vlc_table[8][2]
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
static int unpack_dct_coeffs(Vp3DecodeContext *s, GetBitContext *gb)
static const uint16_t table[]
static void body(uint32_t ABCD[4], const uint8_t *src, int nblocks)
static const uint16_t ac_bias_1[16][32][2]
static const uint8_t vp4_pred_block_type_map[8]
static int get_bits_left(GetBitContext *gb)
static int vp3_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
static const uint8_t motion_vector_vlc_table[63][2]
also FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
#define i(width, name, range_min, range_max)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define AV_CODEC_FLAG2_IGNORE_CROP
Discard cropping information from SPS.
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
int is_copy
Whether the parent AVCodecContext is a copy of the context which had init() called on it...
static const struct @185 eob_run_table[7]
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
#define CODING_MODE_COUNT
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.
void(* idct_add)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
int active_thread_type
Which multithreading methods are in use by the codec.
static const int8_t fixed_motion_vector_table[64]
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
int flags
AV_CODEC_FLAG_*.
void(* h_loop_filter)(uint8_t *src, ptrdiff_t stride, int *bounding_values)
AVCodec ff_theora_decoder
static av_cold void free_tables(AVCodecContext *avctx)
const char * name
Name of the codec implementation.
uint16_t coded_dc_scale_factor[2][64]
static const int ModeAlphabet[6][CODING_MODE_COUNT]
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
#define FF_CODEC_CAP_EXPORTS_CROPPING
The decoder sets the cropping fields in the output frames manually.
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
static const int16_t *const coeff_tables[32]
unsigned char * macroblock_coding
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...
#define AV_CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
enum AVPictureType pict_type
Picture type of the frame.
static const uint8_t vp31_intra_y_dequant[64]
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
#define FF_THREAD_FRAME
Decode more than one frame at once.
VLC fragment_run_length_vlc
int width
picture width / height.
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
#define SB_PARTIALLY_CODED
static int unpack_vlcs(Vp3DecodeContext *s, GetBitContext *gb, VLC *table, int coeff_index, int plane, int eob_run)
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
uint8_t * edge_emu_buffer
static const uint8_t vp4_mv_table_selector[32]
static const uint16_t vp4_ac_bias_3[16][32][2]
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
static const uint16_t vp31_ac_scale_factor[64]
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 const int8_t motion_vector_table[63]
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
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. ...
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
static const uint16_t ac_bias_2[16][32][2]
static const uint8_t hilbert_offset[16][2]
static const uint8_t vp4_y_dc_scale_factor[64]
void ff_vp3dsp_h_loop_filter_12(uint8_t *first_pixel, ptrdiff_t stride, int *bounding_values)
static void error(const char *err)
int total_num_coded_frags
void(* idct_dc_add)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
static void apply_loop_filter(Vp3DecodeContext *s, int plane, int ystart, int yend)
static const int8_t transform[32][32]
static const uint8_t vp4_filter_limit_values[64]
#define AV_LOG_INFO
Standard information.
static const uint8_t vp4_block_pattern_table_selector[14]
Libavcodec external API header.
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 have add an so the codec calls ff_thread_report set AVCodecInternal allocate_progress The frames must then be freed with ff_thread_release_buffer().Otherwise leave it at zero and decode directly into the user-supplied frames.Call ff_thread_report_progress() after some part of the current picture has decoded.A good place to put this is where draw_horiz_band() is called-add this if it isn't called anywhere
static const uint16_t ac_bias_0[16][32][2]
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
int16_t * dct_tokens[3][64]
This is a list of all tokens in bitstream order.
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
ThreadFrame current_frame
main external API structure.
static const uint8_t vp4_generic_dequant[64]
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
uint8_t qr_size[2][3][64]
op_pixels_func put_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
static av_cold int allocate_tables(AVCodecContext *avctx)
Allocate tables for per-frame data in Vp3DecodeContext.
static unsigned int get_bits1(GetBitContext *s)
op_pixels_func put_no_rnd_pixels_tab[4][4]
Halfpel motion compensation with no rounding (a+b)>>1.
static void skip_bits(GetBitContext *s, int n)
enum AVColorSpace colorspace
YUV colorspace type.
Rational number (pair of numerator and denominator).
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
int * nkf_coded_fragment_list
const uint8_t ff_zigzag_direct[64]
int num_coded_frags[3][64]
number of blocks that contain DCT coefficients at the given level or higher
#define TOKEN_COEFF(coeff)
static int vp4_get_mv(Vp3DecodeContext *s, GetBitContext *gb, int axis, int last_motion)
static VLC_TYPE vlc_tables[VLC_TABLES_SIZE][2]
static const uint8_t vp31_dc_scale_factor[64]
int allocate_progress
Whether to allocate progress for frame threading.
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
static int read_huffman_tree(AVCodecContext *avctx, GetBitContext *gb)
static int update_frames(AVCodecContext *avctx)
Release and shuffle frames after decode finishes.
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
static const uint16_t superblock_run_length_vlc_table[34][2]
#define MODE_USING_GOLDEN
uint32_t huffman_table[80][32][2]
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
#define MODE_INTER_FOURMV
static const uint8_t vp4_uv_dc_scale_factor[64]
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static const uint8_t vp4_block_pattern_vlc[2][14][2]
static int theora_header(AVFormatContext *s, int idx)
static const uint16_t vp4_ac_bias_2[16][32][2]
void ff_vp3dsp_v_loop_filter_12(uint8_t *first_pixel, ptrdiff_t stride, int *bounding_values)
int * coded_fragment_list[3]
GLint GLenum GLboolean GLsizei stride
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
static const uint8_t vp31_inter_dequant[64]
unsigned char * superblock_coding
common internal api header.
int16_t * dct_tokens_base
#define bit(string, value)
static int get_eob_run(GetBitContext *gb, int token)
static const uint16_t vp4_ac_bias_1[16][32][2]
Core video DSP helper functions.
uint8_t base_matrix[384][64]
void ff_vp3dsp_set_bounding_values(int *bounding_values_array, int filter_limit)
static int unpack_block_qpis(Vp3DecodeContext *s, GetBitContext *gb)
int * kf_coded_fragment_list
static void await_reference_row(Vp3DecodeContext *s, Vp3Fragment *fragment, int motion_y, int y)
Wait for the reference frame of the current fragment.
struct AVCodecInternal * internal
Private context used for internal data.
VLC_TYPE(* table)[2]
code, bits
int key_frame
1 -> keyframe, 0-> not
static const double coeff[2][5]
int flags2
AV_CODEC_FLAG2_*.
#define MODE_INTER_PRIOR_LAST
VP4Predictor * dc_pred_row
static const uint16_t vp4_mv_vlc[2][7][63][2]
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
#define MODE_INTER_LAST_MV
#define av_malloc_array(a, b)
void(* idct_put)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
av_cold void ff_vp3dsp_init(VP3DSPContext *c, int flags)
static const uint8_t vp31_filter_limit_values[64]
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
#define MKTAG(a, b, c, d)
AVPixelFormat
Pixel format.
This structure stores compressed data.
static void vp3_draw_horiz_band(Vp3DecodeContext *s, int y)
called when all pixels up to row y are complete
void ff_free_vlc(VLC *vlc)
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
uint32_t coded_ac_scale_factor[64]
static const uint8_t zero_run_get_bits[32]
void * av_mallocz_array(size_t nmemb, size_t size)
int8_t(*[2] motion_val)[2]