49 #define FRAGMENT_PIXELS 8 58 #define SB_NOT_CODED 0 59 #define SB_PARTIALLY_CODED 1 60 #define SB_FULLY_CODED 2 65 #define MAXIMUM_LONG_BIT_RUN 4129 67 #define MODE_INTER_NO_MV 0 69 #define MODE_INTER_PLUS_MV 2 70 #define MODE_INTER_LAST_MV 3 71 #define MODE_INTER_PRIOR_LAST 4 72 #define MODE_USING_GOLDEN 5 73 #define MODE_GOLDEN_MV 6 74 #define MODE_INTER_FOURMV 7 75 #define CODING_MODE_COUNT 8 120 { 0, 0 }, { 1, 0 }, { 1, 1 }, { 0, 1 },
121 { 0, 2 }, { 0, 3 }, { 1, 3 }, { 1, 2 },
122 { 2, 2 }, { 2, 3 }, { 3, 3 }, { 3, 2 },
123 { 3, 1 }, { 2, 1 }, { 2, 0 }, { 3, 0 }
126 #define MIN_DEQUANT_VAL 2 168 int fragment_width[2];
169 int fragment_height[2];
172 int fragment_start[3];
175 int8_t (*motion_val[2])[2];
178 uint16_t coded_dc_scale_factor[64];
179 uint32_t coded_ac_scale_factor[64];
183 uint16_t qr_base[2][3][64];
202 int16_t *dct_tokens[3][64];
204 #define TOKEN_EOB(eob_run) ((eob_run) << 2) 205 #define TOKEN_ZERO_RUN(coeff, zero_run) (((coeff) << 9) + ((zero_run) << 2) + 1) 206 #define TOKEN_COEFF(coeff) (((coeff) << 2) + 2) 212 int num_coded_frags[3][64];
217 int *coded_fragment_list[3];
251 uint32_t huffman_table[80][32][2];
297 for (i = 0; i < 16; i++) {
322 int sb_x, sb_y, plane;
325 for (plane = 0; plane < 3; plane++) {
333 for (sb_y = 0; sb_y < sb_height; sb_y++)
334 for (sb_x = 0; sb_x < sb_width; sb_x++)
335 for (i = 0; i < 16; i++) {
337 y = 4 * sb_y + hilbert_offset[i][1];
339 if (x < frag_width && y < frag_height)
358 int i, plane, inter, qri, bmi, bmj, qistart;
360 for (inter = 0; inter < 2; inter++) {
361 for (plane = 0; plane < 3; plane++) {
363 for (qri = 0; qri < s->
qr_count[inter][plane]; qri++) {
364 sum += s->
qr_size[inter][plane][qri];
365 if (s->
qps[qpi] <= sum)
368 qistart = sum - s->
qr_size[inter][plane][qri];
369 bmi = s->
qr_base[inter][plane][qri];
370 bmj = s->
qr_base[inter][plane][qri + 1];
371 for (i = 0; i < 64; i++) {
374 s->
qr_size[inter][plane][qri]) /
375 (2 * s->
qr_size[inter][plane][qri]);
377 int qmin = 8 << (inter + !i);
378 int qscale = i ? ac_scale_factor : dc_scale_factor;
381 av_clip((qscale * coeff) / 100 * 4, qmin, 4096);
385 s->
qmat[
qpi][inter][plane][0] = s->
qmat[0][inter][plane][0];
404 assert(filter_limit < 128);
408 for (x = 0; x < filter_limit; x++) {
409 bounding_values[-x] = -x;
410 bounding_values[x] = x;
412 for (x = value = filter_limit; x < 128 && value; x++, value--) {
413 bounding_values[ x] = value;
414 bounding_values[-x] = -value;
417 bounding_values[128] = value;
418 bounding_values[129] = bounding_values[130] = filter_limit * 0x02020202;
427 int superblock_starts[3] = {
431 int current_superblock = 0;
433 int num_partial_superblocks = 0;
436 int current_fragment;
446 while (current_superblock < s->superblock_count &&
get_bits_left(gb) > 0) {
454 if (current_run == 34)
459 "Invalid partially coded superblock run length\n");
465 current_superblock += current_run;
467 num_partial_superblocks += current_run;
472 if (num_partial_superblocks < s->superblock_count) {
473 int superblocks_decoded = 0;
475 current_superblock = 0;
479 while (superblocks_decoded < s->superblock_count - num_partial_superblocks &&
488 if (current_run == 34)
491 for (j = 0; j < current_run; current_superblock++) {
494 "Invalid fully coded superblock run length\n");
504 superblocks_decoded += current_run;
510 if (num_partial_superblocks) {
524 for (plane = 0; plane < 3; plane++) {
525 int sb_start = superblock_starts[plane];
528 int num_coded_frags = 0;
530 for (i = sb_start; i < sb_end && get_bits_left(gb) > 0; i++) {
532 for (j = 0; j < 16; j++) {
535 if (current_fragment != -1) {
541 if (current_run-- == 0) {
564 for (i = 0; i < 64; i++)
579 int i, j, k, sb_x, sb_y;
581 int current_macroblock;
582 int current_fragment;
597 for (i = 0; i < 8; i++)
599 for (i = 0; i < 8; i++)
600 custom_mode_alphabet[
get_bits(gb, 3)] = i;
601 alphabet = custom_mode_alphabet;
612 for (j = 0; j < 4; j++) {
613 int mb_x = 2 * sb_x + (j >> 1);
614 int mb_y = 2 * sb_y + (((j >> 1) + j) & 1);
621 #define BLOCK_X (2 * mb_x + (k & 1)) 622 #define BLOCK_Y (2 * mb_y + (k >> 1)) 626 for (k = 0; k < 4; k++) {
644 for (k = 0; k < 4; k++) {
650 #define SET_CHROMA_MODES \ 651 if (frag[s->fragment_start[1]].coding_method != MODE_COPY) \ 652 frag[s->fragment_start[1]].coding_method = coding_mode; \ 653 if (frag[s->fragment_start[2]].coding_method != MODE_COPY) \ 654 frag[s->fragment_start[2]].coding_method = coding_mode; 663 for (k = 0; k < 2; k++) {
668 for (k = 0; k < 4; k++) {
688 int j, k, sb_x, sb_y;
692 int last_motion_x = 0;
693 int last_motion_y = 0;
694 int prior_last_motion_x = 0;
695 int prior_last_motion_y = 0;
696 int current_macroblock;
697 int current_fragment;
713 for (j = 0; j < 4; j++) {
714 int mb_x = 2 * sb_x + (j >> 1);
715 int mb_y = 2 * sb_y + (((j >> 1) + j) & 1);
727 if (coding_mode == 0) {
737 prior_last_motion_x = last_motion_x;
738 prior_last_motion_y = last_motion_y;
739 last_motion_x = motion_x[0];
740 last_motion_y = motion_y[0];
746 prior_last_motion_x = last_motion_x;
747 prior_last_motion_y = last_motion_y;
751 for (k = 0; k < 4; k++) {
754 if (coding_mode == 0) {
761 last_motion_x = motion_x[k];
762 last_motion_y = motion_y[k];
772 motion_x[0] = last_motion_x;
773 motion_y[0] = last_motion_y;
782 motion_x[0] = prior_last_motion_x;
783 motion_y[0] = prior_last_motion_y;
786 prior_last_motion_x = last_motion_x;
787 prior_last_motion_y = last_motion_y;
788 last_motion_x = motion_x[0];
789 last_motion_y = motion_y[0];
802 for (k = 0; k < 4; k++) {
806 s->
motion_val[0][current_fragment][0] = motion_x[k];
807 s->
motion_val[0][current_fragment][1] = motion_y[k];
809 s->
motion_val[0][current_fragment][0] = motion_x[0];
810 s->
motion_val[0][current_fragment][1] = motion_y[0];
816 motion_x[0] =
RSHIFT(motion_x[0] + motion_x[1] +
817 motion_x[2] + motion_x[3], 2);
818 motion_y[0] =
RSHIFT(motion_y[0] + motion_y[1] +
819 motion_y[2] + motion_y[3], 2);
821 motion_x[0] = (motion_x[0] >> 1) | (motion_x[0] & 1);
822 motion_y[0] = (motion_y[0] >> 1) | (motion_y[0] & 1);
828 motion_x[0] =
RSHIFT(motion_x[0] + motion_x[1], 1);
829 motion_y[0] =
RSHIFT(motion_y[0] + motion_y[1], 1);
830 motion_x[1] =
RSHIFT(motion_x[2] + motion_x[3], 1);
831 motion_y[1] =
RSHIFT(motion_y[2] + motion_y[3], 1);
833 motion_x[1] = motion_x[0];
834 motion_y[1] = motion_y[0];
836 motion_x[0] = (motion_x[0] >> 1) | (motion_x[0] & 1);
837 motion_x[1] = (motion_x[1] >> 1) | (motion_x[1] & 1);
840 for (k = 0; k < 2; k++) {
846 for (k = 0; k < 4; k++) {
866 int qpi, i, j, bit, run_length, blocks_decoded, num_blocks_at_qpi;
869 for (qpi = 0; qpi < s->
nqps - 1 && num_blocks > 0; qpi++) {
870 i = blocks_decoded = num_blocks_at_qpi = 0;
882 if (run_length == 34)
884 blocks_decoded += run_length;
887 num_blocks_at_qpi += run_length;
889 for (j = 0; j < run_length; i++) {
898 }
while (blocks_decoded < num_blocks &&
get_bits_left(gb) > 0);
900 num_blocks -= num_blocks_at_qpi;
919 VLC *table,
int coeff_index,
931 int16_t *dct_tokens = s->
dct_tokens[plane][coeff_index];
940 "Invalid number of coefficents at level %d\n", coeff_index);
942 if (eob_run > num_coeffs) {
944 blocks_ended = num_coeffs;
945 eob_run -= num_coeffs;
948 blocks_ended = eob_run;
954 dct_tokens[j++] = blocks_ended << 2;
958 token =
get_vlc2(gb, vlc_table, 11, 3);
960 if ((
unsigned) token <= 6
U) {
967 if (eob_run > num_coeffs - coeff_i) {
968 dct_tokens[j++] =
TOKEN_EOB(num_coeffs - coeff_i);
969 blocks_ended += num_coeffs - coeff_i;
970 eob_run -= num_coeffs - coeff_i;
971 coeff_i = num_coeffs;
974 blocks_ended += eob_run;
978 }
else if (token >= 0) {
981 bits_to_get =
get_bits(gb, bits_to_get);
996 all_fragments[coded_fragment_list[coeff_i]].
dc = coeff;
1001 if (coeff_index + zero_run > 64) {
1003 "Invalid zero run of %d with %d coeffs left\n",
1004 zero_run, 64 - coeff_index);
1005 zero_run = 64 - coeff_index;
1010 for (i = coeff_index + 1; i <= coeff_index + zero_run; i++)
1025 for (i = coeff_index + 1; i < 64; i++)
1030 s->
dct_tokens[plane + 1][coeff_index] = dct_tokens + j;
1031 else if (coeff_index < 63)
1032 s->
dct_tokens[0][coeff_index + 1] = dct_tokens + j;
1040 int fragment_height);
1052 int residual_eob_run = 0;
1064 0, residual_eob_run);
1065 if (residual_eob_run < 0)
1066 return residual_eob_run;
1073 1, residual_eob_run);
1074 if (residual_eob_run < 0)
1075 return residual_eob_run;
1077 2, residual_eob_run);
1078 if (residual_eob_run < 0)
1079 return residual_eob_run;
1094 for (i = 1; i <= 5; i++) {
1095 y_tables[i] = &s->
ac_vlc_1[ac_y_table];
1096 c_tables[i] = &s->
ac_vlc_1[ac_c_table];
1098 for (i = 6; i <= 14; i++) {
1099 y_tables[i] = &s->
ac_vlc_2[ac_y_table];
1100 c_tables[i] = &s->
ac_vlc_2[ac_c_table];
1102 for (i = 15; i <= 27; i++) {
1103 y_tables[i] = &s->
ac_vlc_3[ac_y_table];
1104 c_tables[i] = &s->
ac_vlc_3[ac_c_table];
1106 for (i = 28; i <= 63; i++) {
1107 y_tables[i] = &s->
ac_vlc_4[ac_y_table];
1108 c_tables[i] = &s->
ac_vlc_4[ac_c_table];
1112 for (i = 1; i <= 63; i++) {
1113 residual_eob_run =
unpack_vlcs(s, gb, y_tables[i], i,
1114 0, residual_eob_run);
1115 if (residual_eob_run < 0)
1116 return residual_eob_run;
1118 residual_eob_run =
unpack_vlcs(s, gb, c_tables[i], i,
1119 1, residual_eob_run);
1120 if (residual_eob_run < 0)
1121 return residual_eob_run;
1122 residual_eob_run =
unpack_vlcs(s, gb, c_tables[i], i,
1123 2, residual_eob_run);
1124 if (residual_eob_run < 0)
1125 return residual_eob_run;
1136 #define COMPATIBLE_FRAME(x) \ 1137 (compatible_frame[s->all_fragments[x].coding_method] == current_frame_type) 1138 #define DC_COEFF(u) s->all_fragments[u].dc 1143 int fragment_height)
1151 int i = first_fragment;
1156 int vl, vul, vu, vur;
1168 static const int predictor_transform[16][4] = {
1182 { -104, 116, 0, 116 },
1184 { -104, 116, 0, 116 }
1193 static const unsigned char compatible_frame[9] = {
1204 int current_frame_type;
1220 for (y = 0; y < fragment_height; y++) {
1222 for (x = 0; x < fragment_width; x++, i++) {
1226 current_frame_type =
1237 u = i - fragment_width;
1242 ul = i - fragment_width - 1;
1247 if (x + 1 < fragment_width) {
1248 ur = i - fragment_width + 1;
1255 if (transform == 0) {
1258 predicted_dc = last_dc[current_frame_type];
1262 (predictor_transform[
transform][0] * vul) +
1263 (predictor_transform[transform][1] * vu) +
1264 (predictor_transform[
transform][2] * vur) +
1265 (predictor_transform[transform][3] * vl);
1267 predicted_dc /= 128;
1271 if ((transform == 15) || (transform == 13)) {
1272 if (
FFABS(predicted_dc - vu) > 128)
1274 else if (
FFABS(predicted_dc - vl) > 128)
1276 else if (
FFABS(predicted_dc - vul) > 128)
1284 last_dc[current_frame_type] =
DC_COEFF(i);
1291 int ystart,
int yend)
1305 for (y = ystart; y < yend; y++) {
1306 for (x = 0; x <
width; x++) {
1316 stride, bounding_values);
1323 stride, bounding_values);
1329 if ((x < width - 1) &&
1332 plane_data + 8 * x + 8,
1333 stride, bounding_values);
1339 if ((y < height - 1) &&
1342 plane_data + 8 * x + 8 * stride,
1343 stride, bounding_values);
1349 plane_data += 8 *
stride;
1358 int plane,
int inter, int16_t
block[64])
1360 int16_t *dequantizer = s->
qmat[frag->
qpi][inter][plane];
1366 switch (token & 3) {
1375 i += (token >> 2) & 0x7f;
1380 block[perm[i]] = (token >> 9) * dequantizer[perm[i]];
1384 block[perm[i]] = (token >> 2) * dequantizer[perm[i]];
1395 block[0] = frag->
dc * s->
qmat[0][inter][plane][0];
1445 int motion_y,
int y)
1449 int border = motion_y & 1;
1457 ref_row = y + (motion_y >> 1);
1458 ref_row =
FFMAX(
FFABS(ref_row), ref_row + 8 + border);
1469 int x, y, i, j, fragment;
1471 int motion_x = 0xdeadbeef, motion_y = 0xdeadbeef;
1472 int motion_halfpel_index;
1474 int plane, first_pixel;
1479 for (plane = 0; plane < 3; plane++) {
1489 int8_t(*motion_val)[2] = s->
motion_val[!!plane];
1509 for (; sb_y < slice_height; sb_y++) {
1511 for (sb_x = 0; sb_x < slice_width; sb_x++) {
1513 for (j = 0; j < 16; j++) {
1515 y = 4 * sb_y + hilbert_offset[j][1];
1516 fragment = y * fragment_width + x;
1518 i = fragment_start + fragment;
1521 if (x >= fragment_width || y >= fragment_height)
1524 first_pixel = 8 * y * stride + 8 * x;
1529 motion_val[fragment][1],
1536 motion_source = golden_plane;
1538 motion_source = last_plane;
1540 motion_source += first_pixel;
1541 motion_halfpel_index = 0;
1548 motion_x = motion_val[fragment][0];
1549 motion_y = motion_val[fragment][1];
1551 src_x = (motion_x >> 1) + 8 * x;
1552 src_y = (motion_y >> 1) + 8 * y;
1554 motion_halfpel_index = motion_x & 0x01;
1555 motion_source += (motion_x >> 1);
1557 motion_halfpel_index |= (motion_y & 0x01) << 1;
1558 motion_source += ((motion_y >> 1) * stride);
1560 if (src_x < 0 || src_y < 0 ||
1561 src_x + 9 >= plane_width ||
1562 src_y + 9 >= plane_height) {
1572 motion_source = temp;
1583 if (motion_halfpel_index != 3) {
1585 output_plane + first_pixel,
1586 motion_source,
stride, 8);
1590 int d = (motion_x ^ motion_y) >> 31;
1593 motion_source + stride + 1 + d,
1626 output_plane + first_pixel,
1627 last_plane + first_pixel,
1636 FFMIN(4 * sb_y + 3, fragment_height - 1));
1656 int y_fragment_count, c_fragment_count;
1707 int i, inter, plane, ret;
1710 int y_fragment_count, c_fragment_count;
1733 for (i = 0; i < 64; i++) {
1734 #define TRANSPOSE(x) (x >> 3) | ((x & 7) << 3) 1742 for (i = 0; i < 3; i++)
1780 for (i = 0; i < 64; i++) {
1789 for (inter = 0; inter < 2; inter++) {
1790 for (plane = 0; plane < 3; plane++) {
1792 s->
qr_size[inter][plane][0] = 63;
1794 s->
qr_base[inter][plane][1] = 2 * inter + (!!plane) * !inter;
1799 for (i = 0; i < 16; i++) {
1826 for (i = 0; i < 16; i++) {
1907 if (src->
f->
data[0])
1925 int qps_changed = 0, i, err;
1927 #define copy_fields(to, from, start_field, end_field) \ 1928 memcpy(&to->start_field, &from->start_field, \ 1929 (char *) &to->end_field - (char *) &to->start_field) 1931 if (!s1->current_frame.f->data[0] ||
1932 s->
width != s1->width || s->
height != s1->height) {
1941 int y_fragment_count, c_fragment_count;
1949 y_fragment_count *
sizeof(*s->
motion_val[0]));
1951 c_fragment_count *
sizeof(*s->
motion_val[1]));
1961 for (i = 0; i < 3; i++) {
1962 if (s->
qps[i] != s1->qps[1]) {
1964 memcpy(&s->
qmat[i], &s1->qmat[i],
sizeof(s->
qmat[i]));
1968 if (s->
qps[0] != s1->qps[0])
1981 void *
data,
int *got_frame,
1985 int buf_size = avpkt->
size;
1994 "Header packet passed to frame decoder, skipping\n");
2001 for (i = 0; i < 3; i++)
2008 for (i = s->
nqps; i < 3; i++)
2013 s->
keyframe ?
"key" :
"", avctx->frame_number + 1, s->
qps[0]);
2022 for (i = 0; i < s->
nqps; i++)
2047 if (avctx->frame_number == 0)
2049 "VP version: %d\n", s->
version);
2055 "Warning, unsupported keyframe coding type?!\n");
2061 "vp3: first frame not a keyframe\n");
2101 for (i = 0; i < 3; i++) {
2114 for (i = 0; i < 3; i++) {
2152 av_dlog(avctx,
"hti %d hbits %x token %d entry : %d size %d\n",
2192 #if CONFIG_THEORA_DECODER 2200 int visible_width, visible_height,
colorspace;
2201 int offset_x = 0, offset_y = 0;
2210 if (s->
theora < 0x030200) {
2213 "Old (<alpha3) Theora bitstream, flipped image\n");
2221 if (s->
theora >= 0x030200) {
2231 if (fps.
num && fps.
den) {
2232 if (fps.
num < 0 || fps.
den < 0) {
2237 fps.
den, fps.
num, 1 << 30);
2242 if (aspect.
num && aspect.
den) {
2245 aspect.
num, aspect.
den, 1 << 30);
2249 if (s->
theora < 0x030200)
2256 if (s->
theora >= 0x030200) {
2264 if (visible_width <= s->
width && visible_width > s->
width - 16 &&
2265 visible_height <= s->
height && visible_height > s->
height - 16 &&
2266 !offset_x && (offset_y == s->
height - visible_height))
2273 if (colorspace == 1)
2275 else if (colorspace == 2)
2278 if (colorspace == 1 || colorspace == 2) {
2289 int i, n, matrices, inter, plane;
2291 if (s->
theora >= 0x030200) {
2295 for (i = 0; i < 64; i++)
2299 if (s->
theora >= 0x030200)
2304 for (i = 0; i < 64; i++)
2307 if (s->
theora >= 0x030200)
2312 for (i = 0; i < 64; i++)
2315 if (s->
theora >= 0x030200)
2320 if (matrices > 384) {
2325 for (n = 0; n < matrices; n++)
2326 for (i = 0; i < 64; i++)
2329 for (inter = 0; inter <= 1; inter++) {
2330 for (plane = 0; plane <= 2; plane++) {
2332 if (inter || plane > 0)
2340 qtj = (3 * inter + plane - 1) / 3;
2341 plj = (plane + 2) % 3;
2354 if (i >= matrices) {
2356 "invalid base matrix index\n");
2359 s->
qr_base[inter][plane][qri] = i;
2363 s->
qr_size[inter][plane][qri++] = i;
2377 for (s->
hti = 0; s->
hti < 80; s->
hti++) {
2412 42, header_start, header_len) < 0) {
2417 for (i = 0; i < 3; i++) {
2418 if (header_len[i] <= 0)
2424 if (!(ptype & 0x80)) {
2434 theora_decode_header(avctx, &gb);
2441 if (theora_decode_tables(avctx, &gb))
2446 "Unknown Theora config packet: %d\n", ptype & ~0x80);
2451 "%d bits left in packet %X\n",
2453 if (s->
theora < 0x030200)
2466 .
init = theora_decode_init,
static const int16_t vp31_intra_y_dequant[64]
uint8_t idct_scantable[64]
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
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)
#define TOKEN_EOB(eob_run)
static void render_slice(Vp3DecodeContext *s, int slice)
int bounding_values_array[256+2]
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.
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)
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 MODE_INTER_PLUS_MV
static av_cold int init_frames(Vp3DecodeContext *s)
#define DECLARE_ALIGNED(n, t, v)
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)
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
static av_cold int vp3_decode_init(AVCodecContext *avctx)
static int unpack_superblocks(Vp3DecodeContext *s, GetBitContext *gb)
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)
void ff_thread_await_progress(ThreadFrame *f, int n, int field)
Wait for earlier decoding threads to finish reference pictures.
int * superblock_fragments
VLC superblock_run_length_vlc
static const uint32_t vp31_ac_scale_factor[64]
#define MAXIMUM_LONG_BIT_RUN
static const int motion_vector_table[63]
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)
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
void(* idct_add)(uint8_t *dest, int line_size, int16_t *block)
av_dlog(ac->avr, "%d samples - audio_convert: %s to %s (%s)\, len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic ? ac->func_descr_generic :ac->func_descr)
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
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
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...
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 vp3_decode_flush(AVCodecContext *avctx)
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
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.
#define CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
void ff_thread_finish_setup(AVCodecContext *avctx)
If the codec defines update_thread_context(), call this when they are ready for the next thread to st...
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 int16_t vp31_inter_dequant[64]
static const uint16_t ac_bias_1[16][32][2]
static int ref_frames(Vp3DecodeContext *dst, Vp3DecodeContext *src)
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]
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static void output_plane(const Plane *plane, int buf_sel, uint8_t *dst, int dst_pitch, int dst_height)
Convert and output the current plane.
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
int is_copy
Whether the parent AVCodecContext is a copy of the context which had init() called on it...
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
#define CODING_MODE_COUNT
static const int zero_run_base[32]
#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.
void av_log(void *avcl, int level, const char *fmt,...)
const char * name
Name of the codec implementation.
static const int ModeAlphabet[6][CODING_MODE_COUNT]
static const int16_t vp31_intra_c_dequant[64]
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 int coeff_get_bits[32]
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
static const int16_t *const coeff_tables[32]
void(* idct_put)(uint8_t *dest, int line_size, int16_t *block)
unsigned char * macroblock_coding
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
enum AVPictureType pict_type
Picture type of the frame.
#define FF_THREAD_FRAME
Decode more than one frame at once.
#define CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
VLC fragment_run_length_vlc
int width
picture width / height.
#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.
void(* emulated_edge_mc)(uint8_t *buf, const uint8_t *src, ptrdiff_t buf_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...
uint8_t * edge_emu_buffer
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
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]
int total_num_coded_frags
if(ac->has_optimized_func)
static void apply_loop_filter(Vp3DecodeContext *s, int plane, int ystart, int yend)
static const int8_t transform[32][32]
#define AV_LOG_INFO
Standard information.
Libavcodec external API header.
static const uint16_t ac_bias_0[16][32][2]
void(* h_loop_filter)(uint8_t *src, int stride, int *bounding_values)
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.
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 void close(AVCodecParserContext *s)
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)
static void skip_bits(GetBitContext *s, int n)
enum AVColorSpace colorspace
YUV colorspace type.
rational number numerator/denominator
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
op_pixels_func put_no_rnd_pixels_tab[2][4]
Halfpel motion compensation with no rounding (a+b)>>1.
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
const uint8_t ff_zigzag_direct[64]
int avpriv_split_xiph_headers(uint8_t *extradata, int extradata_size, int first_header_size, uint8_t *header_start[3], int header_len[3])
Split a single extradata buffer into the three headers that most Xiph codecs use. ...
int num_coded_frags[3][64]
number of blocks that contain DCT coefficients at the given level or higher
#define TOKEN_COEFF(coeff)
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.
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
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
#define copy_fields(to, from, start_field, end_field)
int * coded_fragment_list[3]
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
unsigned char * superblock_coding
common internal api header.
#define CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
#define CODEC_FLAG_GRAY
Only decode/encode grayscale.
int16_t * dct_tokens_base
static int ref_frame(Vp3DecodeContext *s, ThreadFrame *dst, ThreadFrame *src)
static av_cold void flush(AVCodecContext *avctx)
Flush (reset) the frame ID after seeking.
static const int eob_run_get_bits[7]
FF_ENABLE_DEPRECATION_WARNINGS 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.
static int vp3_init_thread_copy(AVCodecContext *avctx)
static const int16_t vp31_dc_scale_factor[64]
uint16_t coded_dc_scale_factor[64]
static av_cold int init(AVCodecParserContext *s)
Core video DSP helper functions.
uint8_t base_matrix[384][64]
static int unpack_block_qpis(Vp3DecodeContext *s, GetBitContext *gb)
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
#define MODE_INTER_PRIOR_LAST
void(* v_loop_filter)(uint8_t *src, int stride, int *bounding_values)
static const int eob_run_base[7]
void(* idct_dc_add)(uint8_t *dest, int line_size, int16_t *block)
static int vp3_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
#define MODE_INTER_LAST_MV
enum AVColorSpace colorspace
static const int zero_run_get_bits[32]
av_cold void ff_vp3dsp_init(VP3DSPContext *c, int flags)
static const uint8_t vp31_filter_limit_values[64]
#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.
uint32_t coded_ac_scale_factor[64]
int8_t(*[2] motion_val)[2]