27 #include "libavutil/imgutils.h"
79 #if CONFIG_VP8_DECODER
122 for (i = 0; i < 5; i++)
209 for (i = 0; i < 4; i++)
212 for (i = 0; i < 4; i++)
216 for (i = 0; i < 3; i++)
225 for (i = 0; i < 4; i++) {
258 if (buf_size - size < 0)
301 for (i = 0; i < 4; i++) {
354 for (i = 0; i < 4; i++)
355 for (j = 0; j < 16; j++)
365 for (i = 0; i < 4; i++)
366 for (j = 0; j < 8; j++)
367 for (k = 0; k < 3; k++)
376 #define VP7_MVC_SIZE 17
377 #define VP8_MVC_SIZE 19
386 for (i = 0; i < 4; i++)
389 for (i = 0; i < 3; i++)
393 for (i = 0; i < 2; i++)
394 for (j = 0; j < mvc_size; j++)
414 for (j = 1; j < 3; j++) {
415 for (i = 0; i < height / 2; i++)
427 for (j = 0; j <
height; j++) {
428 for (i = 0; i <
width; i++) {
429 uint8_t y = src[j * linesize + i];
430 dst[j * linesize + i] = av_clip_uint8(y + ((y * beta) >> 8) + alpha);
441 if (!s->
keyframe && (alpha || beta)) {
464 width, height, dst->
linesize[0], alpha, beta);
473 int part1_size, hscale, vscale, i, j, ret;
477 s->
profile = (buf[0] >> 1) & 7;
485 part1_size =
AV_RL24(buf) >> 4;
494 buf_size -= part1_size;
502 if (hscale || vscale)
511 for (i = 0; i < 2; i++)
523 for (i = 0; i < 4; i++) {
528 for (j = 0; j < 3; j++)
533 for (j = 0; j < 4; j++)
587 for (i = 1; i < 16; i++)
614 int header_size, hscale, vscale, ret;
621 header_size =
AV_RL24(buf) >> 5;
635 if (header_size > buf_size - 7 * s->
keyframe) {
641 if (
AV_RL24(buf) != 0x2a019d) {
643 "Invalid start code 0x%x\n",
AV_RL24(buf));
646 width =
AV_RL16(buf + 3) & 0x3fff;
647 height =
AV_RL16(buf + 5) & 0x3fff;
648 hscale = buf[4] >> 6;
649 vscale = buf[6] >> 6;
653 if (hscale || vscale)
670 buf_size -= header_size;
748 for (i = 0; i < 3; i++)
750 for (i = (vp7 ? 7 : 9); i > 3; i--)
795 const uint8_t *mbsplits_top, *mbsplits_cur, *firstidx;
805 top_mv = top_mb->
bmv;
821 for (n = 0; n < num; n++) {
823 uint32_t left, above;
827 left =
AV_RN32A(&left_mv[mbsplits_left[k + 3]]);
829 left =
AV_RN32A(&cur_mv[mbsplits_cur[k - 1]]);
831 above =
AV_RN32A(&top_mv[mbsplits_top[k + 12]]);
833 above =
AV_RN32A(&cur_mv[mbsplits_cur[k - 4]]);
870 int xoffset,
int yoffset,
int boundary,
871 int *edge_x,
int *edge_y)
873 int vwidth = mb_width + 1;
874 int new = (mb_y + yoffset) * vwidth + mb_x + xoffset;
875 if (
new < boundary ||
new % vwidth == vwidth - 1)
877 *edge_y =
new / vwidth;
878 *edge_x =
new % vwidth;
889 int mb_x,
int mb_y,
int layout)
892 enum { CNT_ZERO, CNT_NEAREST, CNT_NEAR };
893 enum { VP8_EDGE_TOP, VP8_EDGE_LEFT, VP8_EDGE_TOPLEFT };
917 if (
AV_RN32A(&near_mv[CNT_NEAREST])) {
918 if (mv ==
AV_RN32A(&near_mv[CNT_NEAREST])) {
920 }
else if (
AV_RN32A(&near_mv[CNT_NEAR])) {
921 if (mv !=
AV_RN32A(&near_mv[CNT_NEAR]))
929 AV_WN32A(&near_mv[CNT_NEAREST], mv);
950 if (cnt[CNT_NEAREST] > cnt[CNT_NEAR])
951 AV_WN32A(&mb->
mv, cnt[CNT_ZERO] > cnt[CNT_NEAREST] ? 0 :
AV_RN32A(&near_mv[CNT_NEAREST]));
964 mb->
mv = near_mv[CNT_NEAR];
968 mb->
mv = near_mv[CNT_NEAREST];
980 int mb_x,
int mb_y,
int layout)
985 enum { CNT_ZERO, CNT_NEAREST, CNT_NEAR, CNT_SPLITMV };
986 enum { VP8_EDGE_TOP, VP8_EDGE_LEFT, VP8_EDGE_TOPLEFT };
1007 #define MV_EDGE_CHECK(n) \
1009 VP8Macroblock *edge = mb_edge[n]; \
1010 int edge_ref = edge->ref_frame; \
1011 if (edge_ref != VP56_FRAME_CURRENT) { \
1012 uint32_t mv = AV_RN32A(&edge->mv); \
1014 if (cur_sign_bias != sign_bias[edge_ref]) { \
1017 mv = ((mv & 0x7fff7fff) + \
1018 0x00010001) ^ (mv & 0x80008000); \
1020 if (!n || mv != AV_RN32A(&near_mv[idx])) \
1021 AV_WN32A(&near_mv[++idx], mv); \
1022 cnt[idx] += 1 + (n != 2); \
1024 cnt[CNT_ZERO] += 1 + (n != 2); \
1037 if (cnt[CNT_SPLITMV] &&
1038 AV_RN32A(&near_mv[1 + VP8_EDGE_TOP]) ==
AV_RN32A(&near_mv[1 + VP8_EDGE_TOPLEFT]))
1039 cnt[CNT_NEAREST] += 1;
1042 if (cnt[CNT_NEAR] > cnt[CNT_NEAREST]) {
1044 FFSWAP(
VP56mv, near_mv[CNT_NEAREST], near_mv[CNT_NEAR]);
1050 clamp_mv(s, &mb->
mv, &near_mv[CNT_ZERO + (cnt[CNT_NEAREST] >= cnt[CNT_ZERO])]);
1061 mb->
bmv[0] = mb->
mv;
1065 mb->
bmv[0] = mb->
mv;
1069 mb->
bmv[0] = mb->
mv;
1074 mb->
bmv[0] = mb->
mv;
1080 int mb_x,
int keyframe,
int layout)
1096 for (y = 0; y < 4; y++) {
1097 for (x = 0; x < 4; x++) {
1101 left[y] = top[x] = *intra4x4;
1107 for (i = 0; i < 16; i++)
1118 const char *vp7_feature_name[] = {
"q-index",
1120 "partial-golden-update",
1125 for (i = 0; i < 4; i++) {
1131 "Feature %s present in macroblock (value 0x%x)\n",
1139 *segment = ref ? *ref : *segment;
1206 int i,
uint8_t *token_prob, int16_t qmul[2],
1207 const uint8_t scan[16],
int vp7)
1221 token_prob = probs[i][0];
1229 token_prob = probs[i + 1][1];
1249 int cat = (a << 1) + b;
1250 coeff = 3 + (8 << cat);
1254 token_prob = probs[i + 1][2];
1256 block[scan[i]] = (
vp8_rac_get(&c) ? -coeff : coeff) * qmul[!!i];
1266 int16_t
dc = block[0];
1275 block[0] = pred[0] =
dc;
1280 block[0] = pred[0] =
dc;
1294 token_prob, qmul, scan,
IS_VP7);
1297 #ifndef vp8_decode_block_coeffs_internal
1324 int i,
int zero_nhood, int16_t qmul[2],
1325 const uint8_t scan[16],
int vp7)
1327 uint8_t *token_prob = probs[i][zero_nhood];
1331 token_prob, qmul, scan)
1341 int i, x, y, luma_start = 0, luma_ctx = 3;
1342 int nnz_pred, nnz, nnz_total = 0;
1347 nnz_pred = t_nnz[8] + l_nnz[8];
1353 l_nnz[8] = t_nnz[8] = !!nnz;
1373 for (y = 0; y < 4; y++)
1374 for (x = 0; x < 4; x++) {
1375 nnz_pred = l_nnz[y] + t_nnz[x];
1378 luma_start, nnz_pred,
1384 t_nnz[x] = l_nnz[y] = !!nnz;
1391 for (i = 4; i < 6; i++)
1392 for (y = 0; y < 2; y++)
1393 for (x = 0; x < 2; x++) {
1394 nnz_pred = l_nnz[i + 2 * y] + t_nnz[i + 2 * x];
1400 t_nnz[i + 2 * x] = l_nnz[i + 2 * y] = !!nnz;
1414 int linesize,
int uvlinesize,
int simple)
1416 AV_COPY128(top_border, src_y + 15 * linesize);
1418 AV_COPY64(top_border + 16, src_cb + 7 * uvlinesize);
1419 AV_COPY64(top_border + 24, src_cr + 7 * uvlinesize);
1425 uint8_t *src_cr,
int linesize,
int uvlinesize,
int mb_x,
1426 int mb_y,
int mb_width,
int simple,
int xchg)
1428 uint8_t *top_border_m1 = top_border - 32;
1430 src_cb -= uvlinesize;
1431 src_cr -= uvlinesize;
1433 #define XCHG(a, b, xchg) \
1441 XCHG(top_border_m1 + 8, src_y - 8, xchg);
1442 XCHG(top_border, src_y, xchg);
1443 XCHG(top_border + 8, src_y + 8, 1);
1444 if (mb_x < mb_width - 1)
1445 XCHG(top_border + 32, src_y + 16, 1);
1449 if (!simple || !mb_y) {
1450 XCHG(top_border_m1 + 16, src_cb - 8, xchg);
1451 XCHG(top_border_m1 + 24, src_cr - 8, xchg);
1452 XCHG(top_border + 16, src_cb, 1);
1453 XCHG(top_border + 24, src_cr, 1);
1503 int *copy_buf,
int vp7)
1507 if (!mb_x && mb_y) {
1541 int x, y, mode, nnz;
1557 const uint8_t lo = is_vp7 ? 128 : 127;
1558 const uint8_t hi = is_vp7 ? 128 : 129;
1559 uint8_t tr_top[4] = { lo, lo, lo, lo };
1567 if (mb_y && mb_x == s->
mb_width - 1) {
1568 tr = tr_right[-1] * 0x01010101u;
1575 for (y = 0; y < 4; y++) {
1577 for (x = 0; x < 4; x++) {
1582 if ((y == 0 || x == 3) && mb_y == 0) {
1585 topright = tr_right;
1588 mb_y + y, ©, is_vp7);
1590 dst = copy_dst + 12;
1594 AV_WN32A(copy_dst + 4, lo * 0x01010101U);
1600 copy_dst[3] = ptr[4 * x - s->
linesize - 1];
1609 copy_dst[11] = ptr[4 * x - 1];
1610 copy_dst[19] = ptr[4 * x + s->
linesize - 1];
1611 copy_dst[27] = ptr[4 * x + s->
linesize * 2 - 1];
1612 copy_dst[35] = ptr[4 * x + s->
linesize * 3 - 1];
1615 s->
hpc.
pred4x4[mode](dst, topright, linesize);
1641 mb_x, mb_y, is_vp7);
1652 { 0, 1, 2, 1, 2, 1, 2, 1 },
1654 { 0, 3, 5, 3, 5, 3, 5, 3 },
1655 { 0, 2, 3, 2, 3, 2, 3, 2 },
1677 int x_off,
int y_off,
int block_w,
int block_h,
1684 int src_linesize = linesize;
1686 int mx = (mv->
x << 1) & 7, mx_idx = subpel_idx[0][mx];
1687 int my = (mv->
y << 1) & 7, my_idx = subpel_idx[0][my];
1689 x_off += mv->
x >> 2;
1690 y_off += mv->
y >> 2;
1694 src += y_off * linesize + x_off;
1695 if (x_off < mx_idx || x_off >= width - block_w - subpel_idx[2][mx] ||
1696 y_off < my_idx || y_off >= height - block_h - subpel_idx[2][my]) {
1698 src - my_idx * linesize - mx_idx,
1700 block_w + subpel_idx[1][mx],
1701 block_h + subpel_idx[1][my],
1702 x_off - mx_idx, y_off - my_idx,
1707 mc_func[my_idx][mx_idx](dst, linesize, src, src_linesize, block_h, mx, my);
1710 mc_func[0][0](dst, linesize, src + y_off * linesize + x_off,
1711 linesize, block_h, 0, 0);
1735 int x_off,
int y_off,
int block_w,
int block_h,
1742 int mx = mv->
x & 7, mx_idx = subpel_idx[0][mx];
1743 int my = mv->
y & 7, my_idx = subpel_idx[0][my];
1745 x_off += mv->
x >> 3;
1746 y_off += mv->
y >> 3;
1749 src1 += y_off * linesize + x_off;
1750 src2 += y_off * linesize + x_off;
1752 if (x_off < mx_idx || x_off >= width - block_w - subpel_idx[2][mx] ||
1753 y_off < my_idx || y_off >= height - block_h - subpel_idx[2][my]) {
1755 src1 - my_idx * linesize - mx_idx,
1757 block_w + subpel_idx[1][mx], block_h + subpel_idx[1][my],
1758 x_off - mx_idx, y_off - my_idx, width, height);
1760 mc_func[my_idx][mx_idx](dst1, linesize, src1,
EDGE_EMU_LINESIZE, block_h, mx, my);
1763 src2 - my_idx * linesize - mx_idx,
1764 EDGE_EMU_LINESIZE, linesize,
1765 block_w + subpel_idx[1][mx], block_h + subpel_idx[1][my],
1766 x_off - mx_idx, y_off - my_idx, width, height);
1768 mc_func[my_idx][mx_idx](dst2, linesize, src2,
EDGE_EMU_LINESIZE, block_h, mx, my);
1770 mc_func[my_idx][mx_idx](dst1, linesize, src1, linesize, block_h, mx, my);
1771 mc_func[my_idx][mx_idx](dst2, linesize, src2, linesize, block_h, mx, my);
1775 mc_func[0][0](dst1, linesize, src1 + y_off * linesize + x_off, linesize, block_h, 0, 0);
1776 mc_func[0][0](dst2, linesize, src2 + y_off * linesize + x_off, linesize, block_h, 0, 0);
1783 int bx_off,
int by_off,
int block_w,
int block_h,
1790 ref_frame, mv, x_off + bx_off, y_off + by_off,
1791 block_w, block_h, width, height, s->
linesize,
1810 dst[2] + by_off * s->
uvlinesize + bx_off, ref_frame,
1811 &uvmv, x_off + bx_off, y_off + by_off,
1812 block_w, block_h, width, height, s->
uvlinesize,
1823 if (s->
ref_count[ref - 1] > (mb_xy >> 5)) {
1824 int x_off = mb_x << 4, y_off = mb_y << 4;
1825 int mx = (mb->
mv.
x >> 2) + x_off + 8;
1826 int my = (mb->
mv.
y >> 2) + y_off;
1828 int off = mx + (my + (mb_x & 3) * 4) * s->
linesize + 64;
1833 off = (mx >> 1) + ((my >> 1) + (mb_x & 7)) * s->
uvlinesize + 64;
1845 int x_off = mb_x << 4, y_off = mb_y << 4;
1853 0, 0, 16, 16, width,
height, &mb->
mv);
1860 for (y = 0; y < 4; y++) {
1861 for (x = 0; x < 4; x++) {
1863 ref, &bmv[4 * y + x],
1864 4 * x + x_off, 4 * y + y_off, 4, 4,
1875 for (y = 0; y < 2; y++) {
1876 for (x = 0; x < 2; x++) {
1877 uvmv.
x = mb->
bmv[2 * y * 4 + 2 * x ].
x +
1878 mb->
bmv[2 * y * 4 + 2 * x + 1].
x +
1879 mb->
bmv[(2 * y + 1) * 4 + 2 * x ].x +
1880 mb->
bmv[(2 * y + 1) * 4 + 2 * x + 1].
x;
1881 uvmv.
y = mb->
bmv[2 * y * 4 + 2 * x ].
y +
1882 mb->
bmv[2 * y * 4 + 2 * x + 1].
y +
1883 mb->
bmv[(2 * y + 1) * 4 + 2 * x ].y +
1884 mb->
bmv[(2 * y + 1) * 4 + 2 * x + 1].
y;
1885 uvmv.
x = (uvmv.
x + 2 + (uvmv.
x >> (
INT_BIT - 1))) >> 2;
1886 uvmv.
y = (uvmv.
y + 2 + (uvmv.
y >> (
INT_BIT - 1))) >> 2;
1893 &uvmv, 4 * x + x_off, 4 * y + y_off, 4, 4,
1902 0, 0, 16, 8, width,
height, &bmv[0]);
1904 0, 8, 16, 8, width,
height, &bmv[1]);
1908 0, 0, 8, 16, width,
height, &bmv[0]);
1910 8, 0, 8, 16, width,
height, &bmv[1]);
1914 0, 0, 8, 8, width,
height, &bmv[0]);
1916 8, 0, 8, 8, width,
height, &bmv[1]);
1918 0, 8, 8, 8, width,
height, &bmv[2]);
1920 8, 8, 8, 8, width,
height, &bmv[3]);
1932 for (y = 0; y < 4; y++) {
1935 if (nnz4 & ~0x01010101) {
1936 for (x = 0; x < 4; x++) {
1957 for (ch = 0; ch < 2; ch++) {
1960 uint8_t *ch_dst = dst[1 + ch];
1961 if (nnz4 & ~0x01010101) {
1962 for (y = 0; y < 2; y++) {
1963 for (x = 0; x < 2; x++) {
1966 td->
block[4 + ch][(y << 1) + x],
1970 td->
block[4 + ch][(y << 1) + x],
1974 goto chroma_idct_end;
1991 int interior_limit, filter_level;
2005 filter_level = av_clip_uintp2(filter_level, 6);
2007 interior_limit = filter_level;
2012 interior_limit =
FFMAX(interior_limit, 1);
2022 int mb_x,
int mb_y,
int is_vp7)
2024 int mbedge_lim, bedge_lim_y, bedge_lim_uv, hev_thresh;
2030 static const uint8_t hev_thresh_lut[2][64] = {
2031 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
2032 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2033 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
2035 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
2036 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2037 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2045 bedge_lim_y = filter_level;
2046 bedge_lim_uv = filter_level * 2;
2047 mbedge_lim = filter_level + 2;
2050 bedge_lim_uv = filter_level * 2 + inner_limit;
2051 mbedge_lim = bedge_lim_y + 4;
2054 hev_thresh = hev_thresh_lut[s->
keyframe][filter_level];
2058 mbedge_lim, inner_limit, hev_thresh);
2060 mbedge_lim, inner_limit, hev_thresh);
2063 #define H_LOOP_FILTER_16Y_INNER(cond) \
2064 if (cond && inner_filter) { \
2065 s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0] + 4, linesize, \
2066 bedge_lim_y, inner_limit, \
2068 s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0] + 8, linesize, \
2069 bedge_lim_y, inner_limit, \
2071 s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0] + 12, linesize, \
2072 bedge_lim_y, inner_limit, \
2074 s->vp8dsp.vp8_h_loop_filter8uv_inner(dst[1] + 4, dst[2] + 4, \
2075 uvlinesize, bedge_lim_uv, \
2076 inner_limit, hev_thresh); \
2083 mbedge_lim, inner_limit, hev_thresh);
2085 mbedge_lim, inner_limit, hev_thresh);
2090 linesize, bedge_lim_y,
2091 inner_limit, hev_thresh);
2093 linesize, bedge_lim_y,
2094 inner_limit, hev_thresh);
2096 linesize, bedge_lim_y,
2097 inner_limit, hev_thresh);
2099 dst[2] + 4 * uvlinesize,
2100 uvlinesize, bedge_lim_uv,
2101 inner_limit, hev_thresh);
2111 int mbedge_lim, bedge_lim;
2120 bedge_lim = 2 * filter_level + inner_limit;
2121 mbedge_lim = bedge_lim + 4;
2140 #define MARGIN (16 << 2)
2150 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
2152 ((s->
mb_width + 1) * (mb_y + 1) + 1);
2159 for (mb_x = 0; mb_x < s->
mb_width; mb_x++, mb_xy++, mb++) {
2164 prev_frame && prev_frame->
seg_map ?
2187 #define check_thread_pos(td, otd, mb_x_check, mb_y_check) \
2189 int tmp = (mb_y_check << 16) | (mb_x_check & 0xFFFF); \
2190 if (otd->thread_mb_pos < tmp) { \
2191 pthread_mutex_lock(&otd->lock); \
2192 td->wait_mb_pos = tmp; \
2194 if (otd->thread_mb_pos >= tmp) \
2196 pthread_cond_wait(&otd->cond, &otd->lock); \
2198 td->wait_mb_pos = INT_MAX; \
2199 pthread_mutex_unlock(&otd->lock); \
2203 #define update_pos(td, mb_y, mb_x) \
2205 int pos = (mb_y << 16) | (mb_x & 0xFFFF); \
2206 int sliced_threading = (avctx->active_thread_type == FF_THREAD_SLICE) && \
2208 int is_null = !next_td || !prev_td; \
2209 int pos_check = (is_null) ? 1 \
2210 : (next_td != td && \
2211 pos >= next_td->wait_mb_pos) || \
2213 pos >= prev_td->wait_mb_pos); \
2214 td->thread_mb_pos = pos; \
2215 if (sliced_threading && pos_check) { \
2216 pthread_mutex_lock(&td->lock); \
2217 pthread_cond_broadcast(&td->cond); \
2218 pthread_mutex_unlock(&td->lock); \
2222 #define check_thread_pos(td, otd, mb_x_check, mb_y_check)
2223 #define update_pos(td, mb_y, mb_x)
2227 int jobnr,
int threadnr,
int is_vp7)
2232 int mb_x, mb_xy = mb_y * s->
mb_width;
2245 prev_td = &s->
thread_data[(jobnr + num_jobs - 1) % num_jobs];
2249 next_td = &s->
thread_data[(jobnr + 1) % num_jobs];
2259 memset(mb - 1, 0,
sizeof(*mb));
2263 if (!is_vp7 || mb_y == 0)
2269 for (mb_x = 0; mb_x < s->
mb_width; mb_x++, mb_xy++, mb++) {
2271 if (prev_td != td) {
2272 if (threadnr != 0) {
2274 mb_x + (is_vp7 ? 2 : 1),
2275 mb_y - (is_vp7 ? 2 : 1));
2278 mb_x + (is_vp7 ? 2 : 1) + s->
mb_width + 3,
2279 mb_y - (is_vp7 ? 2 : 1));
2286 dst[2] - dst[1], 2);
2290 prev_frame && prev_frame->seg_map ?
2291 prev_frame->seg_map->data + mb_xy :
NULL, 0, is_vp7);
2322 if (s->
deblock_filter && num_jobs != 1 && threadnr == num_jobs - 1) {
2348 int jobnr,
int threadnr,
int is_vp7)
2370 prev_td = &s->
thread_data[(jobnr + num_jobs - 1) % num_jobs];
2374 next_td = &s->
thread_data[(jobnr + 1) % num_jobs];
2376 for (mb_x = 0; mb_x < s->
mb_width; mb_x++, mb++) {
2380 (mb_x + 1) + (s->
mb_width + 3), mb_y - 1);
2385 if (num_jobs == 1) {
2397 filter_mb(s, dst, f, mb_x, mb_y, is_vp7);
2408 int threadnr,
int is_vp7)
2417 for (mb_y = jobnr; mb_y < s->
mb_height; mb_y += num_jobs) {
2437 int jobnr,
int threadnr)
2443 int jobnr,
int threadnr)
2454 int ret, i, referenced, num_jobs;
2483 for (i = 0; i < 5; i++)
2485 &s->
frames[i] != prev_frame &&
2501 "Discarding interframe without a prior keyframe!\n");
2506 curframe->tf.f->key_frame = s->
keyframe;
2534 s->
linesize = curframe->tf.f->linesize[0];
2607 #if CONFIG_VP7_DECODER
2670 #if CONFIG_VP7_DECODER
2682 #if CONFIG_VP8_DECODER
2698 #define REBASE(pic) pic ? pic - &s_src->frames[0] + &s->frames[0] : NULL
2713 s->
prob[0] = s_src->
prob[!s_src->update_probabilities];
2719 if (s_src->frames[i].tf.f->data[0]) {
2720 int ret = vp8_ref_frame(s, &s->
frames[i], &s_src->frames[i]);
2726 s->
framep[0] = REBASE(s_src->next_framep[0]);
2727 s->
framep[1] = REBASE(s_src->next_framep[1]);
2728 s->
framep[2] = REBASE(s_src->next_framep[2]);
2729 s->
framep[3] = REBASE(s_src->next_framep[3]);
2735 #if CONFIG_VP7_DECODER
2742 .
init = vp7_decode_init,
2744 .
decode = vp7_decode_frame,
2750 #if CONFIG_VP8_DECODER
static void get_quants(VP8Context *s)
VP8Macroblock * macroblocks
static const uint8_t vp8_dc_qlookup[VP8_MAX_QUANT+1]
static av_always_inline void intra_predict(VP8Context *s, VP8ThreadData *td, uint8_t *dst[3], VP8Macroblock *mb, int mb_x, int mb_y, int is_vp7)
static const uint8_t vp8_submv_prob[5][3]
static const uint16_t vp7_ydc_qlookup[]
discard all frames except keyframes
void(* vp8_idct_dc_add)(uint8_t *dst, int16_t block[16], ptrdiff_t stride)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static const uint8_t vp7_mv_default_prob[2][17]
(only used in prediction) no split MVs
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
void ff_vp7dsp_init(VP8DSPContext *c)
static void update_lf_deltas(VP8Context *s)
This structure describes decoded (raw) audio or video data.
static const uint8_t vp7_pred4x4_mode[]
int8_t sign_bias[4]
one state [0, 1] per ref frame type
static av_unused void pthread_cond_init(pthread_cond_t *cond, const void *unused_attr)
int coded_width
Bitstream width / height, may be different from width/height e.g.
static av_always_inline int inter_predict_dc(int16_t block[16], int16_t pred[2])
#define AV_LOG_WARNING
Something somehow does not look correct.
void(* vp8_idct_dc_add4y)(uint8_t *dst, int16_t block[4][16], ptrdiff_t stride)
#define VP7_MV_PRED_COUNT
static av_always_inline int vp8_rac_get_tree(VP56RangeCoder *c, const int8_t(*tree)[2], const uint8_t *probs)
uint8_t feature_value[4][4]
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.
uint8_t * intra4x4_pred_mode_top
static VP56Frame ref_to_update(VP8Context *s, int update, VP56Frame ref)
Determine which buffers golden and altref should be updated with after this frame.
static int vp7_decode_block_coeffs_internal(VP56RangeCoder *r, int16_t block[16], uint8_t probs[16][3][NUM_DCT_TOKENS-1], int i, uint8_t *token_prob, int16_t qmul[2], const uint8_t scan[16])
uint8_t token[4][16][3][NUM_DCT_TOKENS-1]
static void vp8_decode_flush(AVCodecContext *avctx)
vp8_mc_func put_vp8_bilinear_pixels_tab[3][3][3]
#define DECLARE_ALIGNED(n, t, v)
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
void(* vp8_v_loop_filter8uv_inner)(uint8_t *dstU, uint8_t *dstV, ptrdiff_t stride, int flim_E, int flim_I, int hev_thresh)
static const int8_t vp8_pred8x8c_tree[3][2]
static const uint16_t vp7_y2dc_qlookup[]
struct VP8Context::@71 qmat[4]
Macroblocks can have one of 4 different quants in a frame when segmentation is enabled.
static void copy_luma(AVFrame *dst, AVFrame *src, int width, int height)
void(* prefetch)(uint8_t *buf, ptrdiff_t stride, int h)
Prefetch memory into cache (if supported by hardware).
void ff_thread_await_progress(ThreadFrame *f, int n, int field)
Wait for earlier decoding threads to finish reference pictures.
int update_probabilities
If this flag is not set, all the probability updates are discarded after this frame is decoded...
static void vp8_filter_mb_row(AVCodecContext *avctx, void *tdata, int jobnr, int threadnr, int is_vp7)
static int vp8_decode_block_coeffs_internal(VP56RangeCoder *r, int16_t block[16], uint8_t probs[16][3][NUM_DCT_TOKENS-1], int i, uint8_t *token_prob, int16_t qmul[2])
static const uint8_t zigzag_scan[16]
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
vp8_mc_func put_vp8_epel_pixels_tab[3][3][3]
first dimension: width>>3, height is assumed equal to width second dimension: 0 if no vertical interp...
static av_always_inline const uint8_t * get_submv_prob(uint32_t left, uint32_t top, int is_vp7)
void av_freep(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
static const uint8_t vp8_pred8x8c_prob_inter[3]
static av_always_inline int decode_block_coeffs(VP56RangeCoder *c, int16_t block[16], uint8_t probs[16][3][NUM_DCT_TOKENS-1], int i, int zero_nhood, int16_t qmul[2], const uint8_t scan[16], int vp7)
static const uint8_t vp8_mbsplits[5][16]
enum AVDiscard skip_frame
static const int8_t vp8_pred16x16_tree_intra[4][2]
static int read_mv_component(VP56RangeCoder *c, const uint8_t *p, int vp7)
Motion vector coding, 17.1.
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
struct VP8Context::@72 lf_delta
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
int update_golden
VP56_FRAME_NONE if not updated, or which frame to copy if so.
uint8_t intra4x4_pred_mode_top[4]
static av_always_inline void xchg_mb_border(uint8_t *top_border, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int mb_x, int mb_y, int mb_width, int simple, int xchg)
static int vp7_update_dimensions(VP8Context *s, int width, int height)
int fade_present
Fade bit present in bitstream (VP7)
static av_always_inline void vp7_decode_mvs(VP8Context *s, VP8Macroblock *mb, int mb_x, int mb_y, int layout)
static VP8Frame * vp8_find_free_buffer(VP8Context *s)
static av_always_inline int check_intra_pred4x4_mode_emuedge(int mode, int mb_x, int mb_y, int *copy_buf, int vp7)
void(* vp8_luma_dc_wht_dc)(int16_t block[4][4][16], int16_t dc[16])
void(* vp8_idct_dc_add4uv)(uint8_t *dst, int16_t block[4][16], ptrdiff_t stride)
Multithreading support functions.
int ff_vp8_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
const char * name
Name of the codec implementation.
static const uint8_t vp8_mv_update_prob[2][19]
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
void(* pred8x8[4+3+4])(uint8_t *src, ptrdiff_t stride)
int update_last
update VP56_FRAME_PREVIOUS with the current one
struct AVCodecInternal * internal
Private context used for internal data.
int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
static void copy(LZOContext *c, int cnt)
Copies bytes from input to output buffer with checking.
static void parse_segment_info(VP8Context *s)
int num_coeff_partitions
All coefficients are contained in separate arith coding contexts.
static const uint8_t vp8_token_default_probs[4][8][3][NUM_DCT_TOKENS-1]
vp8_mc_func put_pixels_tab[3][3][3]
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...
void(* pred4x4[9+3+3])(uint8_t *src, const uint8_t *topright, ptrdiff_t stride)
void(* vp8_v_loop_filter8uv)(uint8_t *dstU, uint8_t *dstV, ptrdiff_t stride, int flim_E, int flim_I, int hev_thresh)
uint8_t feature_index_prob[4][3]
uint8_t intra4x4_pred_mode_mb[16]
static av_always_inline int vp78_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt, int is_vp7)
uint8_t intra4x4_pred_mode_left[4]
#define VERT_VP8_PRED
for VP8, VERT_PRED is the average of
av_cold void ff_vp78dsp_init(VP8DSPContext *dsp)
static const VP56mv * get_bmv_ptr(const VP8Macroblock *mb, int subblock)
static const uint8_t vp8_mbsplit_count[4]
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static const int8_t vp8_coeff_band_indexes[8][10]
static const uint8_t vp8_pred4x4_mode[]
static av_always_inline void prefetch_motion(VP8Context *s, VP8Macroblock *mb, int mb_x, int mb_y, int mb_xy, int ref)
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
static const uint8_t vp8_dct_cat2_prob[]
static const uint8_t vp8_mv_default_prob[2][19]
static const int sizes[][2]
static int vp8_decode_frame_header(VP8Context *s, const uint8_t *buf, int buf_size)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
static av_always_inline int check_tm_pred8x8_mode(int mode, int mb_x, int mb_y, int vp7)
static int pthread_mutex_init(pthread_mutex_t *m, void *attr)
static int vp8_decode_mb_row_sliced(AVCodecContext *avctx, void *tdata, int jobnr, int threadnr)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
int active_thread_type
Which multithreading methods are in use by the codec.
void(* vp8_idct_add)(uint8_t *dst, int16_t block[16], ptrdiff_t stride)
VP8 compatible video decoder.
static const uint8_t vp8_mbfirstidx[4][16]
#define EDGE_EMU_LINESIZE
uint16_t inter_dc_pred[2][2]
Interframe DC prediction (VP7) [0] VP56_FRAME_PREVIOUS [1] VP56_FRAME_GOLDEN.
VP8Macroblock * macroblocks_base
static av_always_inline void vp8_mc_part(VP8Context *s, VP8ThreadData *td, uint8_t *dst[3], ThreadFrame *ref_frame, int x_off, int y_off, int bx_off, int by_off, int block_w, int block_h, int width, int height, VP56mv *mv)
static const uint8_t vp8_pred4x4_prob_inter[9]
uint8_t edge_emu_buffer[21 *EDGE_EMU_LINESIZE]
static av_always_inline int decode_block_coeffs_internal(VP56RangeCoder *r, int16_t block[16], uint8_t probs[16][3][NUM_DCT_TOKENS-1], int i, uint8_t *token_prob, int16_t qmul[2], const uint8_t scan[16], int vp7)
static const int vp7_mode_contexts[31][4]
static void vp7_get_quants(VP8Context *s)
Libavcodec external API header.
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
static const uint8_t vp8_pred16x16_prob_inter[4]
useful rectangle filling function
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
static int pthread_mutex_destroy(pthread_mutex_t *m)
static av_unused void pthread_cond_destroy(pthread_cond_t *cond)
uint8_t * data
The data buffer.
#define H_LOOP_FILTER_16Y_INNER(cond)
uint8_t feature_present_prob[4]
static av_always_inline void vp8_mc_chroma(VP8Context *s, VP8ThreadData *td, uint8_t *dst1, uint8_t *dst2, ThreadFrame *ref, const VP56mv *mv, int x_off, int y_off, int block_w, int block_h, int width, int height, ptrdiff_t linesize, vp8_mc_func mc_func[3][3])
chroma MC function
static av_unused int vp8_rac_get_sint(VP56RangeCoder *c, int bits)
int width
picture width / height.
int8_t ref[4]
filter strength adjustment for macroblocks that reference: [0] - intra / VP56_FRAME_CURRENT [1] - VP5...
static av_cold int vp8_init_frames(VP8Context *s)
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...
static void free_buffers(VP8Context *s)
#define check_thread_pos(td, otd, mb_x_check, mb_y_check)
#define FF_ARRAY_ELEMS(a)
static av_unused int vp8_rac_get_uint(VP56RangeCoder *c, int bits)
int16_t luma_dc_qmul[2]
luma dc-only block quant
static const uint8_t vp8_pred4x4_prob_intra[10][10][9]
uint8_t(* top_border)[16+8+8]
static av_always_inline void filter_level_for_mb(VP8Context *s, VP8Macroblock *mb, VP8FilterStrength *f, int is_vp7)
static const int8_t vp7_feature_index_tree[4][2]
static const uint8_t vp7_feature_value_size[2][4]
#define vp56_rac_get_prob
static void vp8_decode_flush_impl(AVCodecContext *avctx, int free_mem)
static av_always_inline void decode_mb_coeffs(VP8Context *s, VP8ThreadData *td, VP56RangeCoder *c, VP8Macroblock *mb, uint8_t t_nnz[9], uint8_t l_nnz[9], int is_vp7)
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
av_cold void ff_h264_pred_init(H264PredContext *h, int codec_id, const int bit_depth, const int chroma_format_idc)
Set the intra prediction function pointers.
static void vp8_decode_mv_mb_modes(AVCodecContext *avctx, VP8Frame *cur_frame, VP8Frame *prev_frame)
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
if(ac->has_optimized_func)
static const float pred[4]
static int vp7_decode_mb_row_sliced(AVCodecContext *avctx, void *tdata, int jobnr, int threadnr)
static const int8_t mv[256][2]
static void vp7_decode_mv_mb_modes(AVCodecContext *avctx, VP8Frame *cur_frame, VP8Frame *prev_frame)
static av_always_inline int check_intra_pred8x8_mode_emuedge(int mode, int mb_x, int mb_y, int vp7)
static av_always_inline int vp56_rac_get_prob_branchy(VP56RangeCoder *c, int prob)
static av_always_inline void inter_predict(VP8Context *s, VP8ThreadData *td, uint8_t *dst[3], VP8Macroblock *mb, int mb_x, int mb_y)
Apply motion vectors to prediction buffer, chapter 18.
static const uint8_t vp8_pred8x8c_prob_intra[3]
void(* vp8_mc_func)(uint8_t *dst, ptrdiff_t dstStride, uint8_t *src, ptrdiff_t srcStride, int h, int x, int y)
void(* vp8_v_loop_filter16y)(uint8_t *dst, ptrdiff_t stride, int flim_E, int flim_I, int hev_thresh)
static void vp8_release_frame(VP8Context *s, VP8Frame *f)
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
static const uint16_t vp7_yac_qlookup[]
main external API structure.
static void close(AVCodecParserContext *s)
#define FF_THREAD_FRAME
Decode more than one frame at once.
static int vp7_fade_frame(VP8Context *s, VP56RangeCoder *c)
VP8Frame * next_framep[4]
int mb_layout
This describes the macroblock memory layout.
uint8_t left_nnz[9]
For coeff decode, we need to know whether the above block had non-zero coefficients.
static const uint8_t vp8_mbsplit_prob[3]
VP56RangeCoder c
header context, includes mb modes and motion vectors
void(* pred16x16[4+3+2])(uint8_t *src, ptrdiff_t stride)
VP56RangeCoder coeff_partition[8]
static const int8_t vp8_pred16x16_tree_inter[4][2]
static int setup_partitions(VP8Context *s, const uint8_t *buf, int buf_size)
AVBufferRef * av_buffer_allocz(int size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
static int vp8_update_dimensions(VP8Context *s, int width, int height)
VP8FilterStrength * filter_strength
static av_always_inline void clamp_mv(VP8Context *s, VP56mv *dst, const VP56mv *src)
static av_always_inline int check_dc_pred8x8_mode(int mode, int mb_x, int mb_y)
static void vp78_update_probability_tables(VP8Context *s)
static const int8_t vp8_pred4x4_tree[9][2]
uint8_t enabled
whether each mb can have a different strength based on mode/ref
static av_always_inline void idct_mb(VP8Context *s, VP8ThreadData *td, uint8_t *dst[3], VP8Macroblock *mb)
static void vp78_update_pred16x16_pred8x8_mvc_probabilities(VP8Context *s, int mvc_size)
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
static const uint8_t subpel_idx[3][8]
static void update_refs(VP8Context *s)
static av_always_inline int vp8_rac_get_coeff(VP56RangeCoder *c, const uint8_t *prob)
static const uint8_t vp8_coeff_band[16]
void(* vp8_h_loop_filter8uv)(uint8_t *dstU, uint8_t *dstV, ptrdiff_t stride, int flim_E, int flim_I, int hev_thresh)
int allocate_progress
Whether to allocate progress for frame threading.
static const uint16_t vp8_ac_qlookup[VP8_MAX_QUANT+1]
static const uint8_t vp8_pred16x16_prob_intra[4]
static const int8_t vp8_segmentid_tree[][2]
static av_always_inline void decode_intra4x4_modes(VP8Context *s, VP56RangeCoder *c, VP8Macroblock *mb, int mb_x, int keyframe, int layout)
void ff_vp56_init_range_decoder(VP56RangeCoder *c, const uint8_t *buf, int buf_size)
av_cold int ff_vp8_decode_init(AVCodecContext *avctx)
uint8_t feature_enabled[4]
Macroblock features (VP7)
int8_t mode[VP8_MVMODE_SPLIT+1]
filter strength adjustment for the following macroblock modes: [0-3] - i16x16 (always zero) [4] - i4x...
2 8x16 blocks (horizontal)
av_cold int ff_vp8_decode_free(AVCodecContext *avctx)
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_dlog(ac->avr,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> dc
static av_always_inline void backup_mb_border(uint8_t *top_border, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int simple)
struct VP8Context::@70 filter
void(* vp8_luma_dc_wht)(int16_t block[4][4][16], int16_t dc[16])
void(* vp8_v_loop_filter_simple)(uint8_t *dst, ptrdiff_t stride, int flim)
struct VP8Context::@69 segmentation
Base parameters for segmentation, i.e.
discard all non reference
struct VP8Context::@73 prob[2]
These are all of the updatable probabilities for binary decisions.
void(* vp8_h_loop_filter_simple)(uint8_t *dst, ptrdiff_t stride, int flim)
static av_always_inline void vp78_decode_mv_mb_modes(AVCodecContext *avctx, VP8Frame *curframe, VP8Frame *prev_frame, int is_vp7)
static av_always_inline void decode_mb_mode(VP8Context *s, VP8Macroblock *mb, int mb_x, int mb_y, uint8_t *segment, uint8_t *ref, int layout, int is_vp7)
#define FFSWAP(type, a, b)
#define CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
common internal api header.
void(* vp8_v_loop_filter16y_inner)(uint8_t *dst, ptrdiff_t stride, int flim_E, int flim_I, int hev_thresh)
#define CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
static int ref_frame(Vp3DecodeContext *s, ThreadFrame *dst, ThreadFrame *src)
static void vp8_decode_mb_row_no_filter(AVCodecContext *avctx, void *tdata, int jobnr, int threadnr, int is_vp7)
static av_cold void flush(AVCodecContext *avctx)
Flush (reset) the frame ID after seeking.
static int vp8_alloc_frame(VP8Context *s, VP8Frame *f, int ref)
enum AVDiscard skip_loop_filter
static av_always_inline int vp8_rac_get(VP56RangeCoder *c)
static av_always_inline int decode_splitmvs(VP8Context *s, VP56RangeCoder *c, VP8Macroblock *mb, int layout, int is_vp7)
Split motion vector prediction, 16.4.
static av_cold int init(AVCodecParserContext *s)
static const SiprModeParam modes[MODE_COUNT]
static av_always_inline int check_tm_pred4x4_mode(int mode, int mb_x, int mb_y, int vp7)
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
static int vp7_calculate_mb_offset(int mb_x, int mb_y, int mb_width, int xoffset, int yoffset, int boundary, int *edge_x, int *edge_y)
The vp7 reference decoder uses a padding macroblock column (added to right edge of the frame) to guar...
int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)
The codec may call this to execute several independent things.
#define update_pos(td, mb_y, mb_x)
#define HOR_VP8_PRED
unaveraged version of HOR_PRED, see
static av_always_inline int update_dimensions(VP8Context *s, int width, int height, int is_vp7)
static av_always_inline int vp78_decode_mb_row_sliced(AVCodecContext *avctx, void *tdata, int jobnr, int threadnr, int is_vp7)
static av_unused int vp8_rac_get_nn(VP56RangeCoder *c)
static void fade(uint8_t *dst, uint8_t *src, int width, int height, int linesize, int alpha, int beta)
static av_always_inline void vp8_mc_luma(VP8Context *s, VP8ThreadData *td, uint8_t *dst, ThreadFrame *ref, const VP56mv *mv, int x_off, int y_off, int block_w, int block_h, int width, int height, ptrdiff_t linesize, vp8_mc_func mc_func[3][3])
luma MC function
static const uint8_t vp8_token_update_probs[4][8][3][NUM_DCT_TOKENS-1]
static av_always_inline void filter_mb(VP8Context *s, uint8_t *dst[3], VP8FilterStrength *f, int mb_x, int mb_y, int is_vp7)
int8_t filter_level[4]
base loop filter level
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
static const int vp8_mode_contexts[6][4]
static const uint8_t vp8_dct_cat1_prob[]
void(* vp8_h_loop_filter16y)(uint8_t *dst, ptrdiff_t stride, int flim_E, int flim_I, int hev_thresh)
static av_always_inline void vp8_decode_mvs(VP8Context *s, VP8Macroblock *mb, int mb_x, int mb_y, int layout)
uint8_t non_zero_count_cache[6][4]
This is the index plus one of the last non-zero coeff for each of the blocks in the current macrobloc...
void ff_vp8dsp_init(VP8DSPContext *c)
static void vp78_reset_probability_tables(VP8Context *s)
This structure stores compressed data.
static int vp7_decode_frame_header(VP8Context *s, const uint8_t *buf, int buf_size)
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
const uint8_t *const ff_vp8_dct_cat_prob[]
VP8ThreadData * thread_data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static av_always_inline void filter_mb_simple(VP8Context *s, uint8_t *dst, VP8FilterStrength *f, int mb_x, int mb_y)
void * av_mallocz(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
static const VP7MVPred vp7_mv_pred[VP7_MV_PRED_COUNT]
static const uint16_t vp7_y2ac_qlookup[]
static const uint8_t vp7_submv_prob[3]
static av_always_inline int vp78_decode_init(AVCodecContext *avctx, int is_vp7)