40 #if CONFIG_VP7_DECODER && CONFIG_VP8_DECODER
41 #define VPX(vp7, f) (vp7 ? vp7_ ## f : vp8_ ## f)
42 #elif CONFIG_VP7_DECODER
43 #define VPX(vp7, f) vp7_ ## f
44 #else // CONFIG_VP8_DECODER
45 #define VPX(vp7, f) vp8_ ## f
87 #if CONFIG_VP8_DECODER
130 for (i = 0; i < 5; i++)
224 for (i = 0; i < 4; i++)
227 for (i = 0; i < 4; i++)
231 for (i = 0; i < 3; i++)
240 for (i = 0; i < 4; i++) {
273 if (buf_size - size < 0)
316 for (i = 0; i < 4; i++) {
369 for (i = 0; i < 4; i++)
370 for (j = 0; j < 16; j++)
380 for (i = 0; i < 4; i++)
381 for (j = 0; j < 8; j++)
382 for (k = 0; k < 3; k++)
391 #define VP7_MVC_SIZE 17
392 #define VP8_MVC_SIZE 19
401 for (i = 0; i < 4; i++)
404 for (i = 0; i < 3; i++)
408 for (i = 0; i < 2; i++)
409 for (j = 0; j < mvc_size; j++)
429 for (j = 1; j < 3; j++) {
430 for (i = 0; i < height / 2; i++)
437 const uint8_t *src,
int src_linesize,
442 for (j = 0; j <
height; j++) {
443 for (i = 0; i <
width; i++) {
444 uint8_t y = src[j * src_linesize + i];
445 dst[j * dst_linesize + i] = av_clip_uint8(y + ((y * beta) >> 8) + alpha);
456 if (!s->
keyframe && (alpha || beta)) {
483 width, height, alpha, beta);
492 int part1_size, hscale, vscale, i, j,
ret;
496 s->
profile = (buf[0] >> 1) & 7;
504 part1_size =
AV_RL24(buf) >> 4;
506 if (buf_size < 4 - s->
profile + part1_size) {
518 buf_size -= part1_size;
526 if (hscale || vscale)
535 for (i = 0; i < 2; i++)
547 for (i = 0; i < 4; i++) {
552 for (j = 0; j < 3; j++)
557 for (j = 0; j < 4; j++)
611 for (i = 1; i < 16; i++)
638 int header_size, hscale, vscale,
ret;
650 header_size =
AV_RL24(buf) >> 5;
664 if (header_size > buf_size - 7 * s->
keyframe) {
670 if (
AV_RL24(buf) != 0x2a019d) {
672 "Invalid start code 0x%x\n",
AV_RL24(buf));
675 width =
AV_RL16(buf + 3) & 0x3fff;
676 height =
AV_RL16(buf + 5) & 0x3fff;
677 hscale = buf[4] >> 6;
678 vscale = buf[6] >> 6;
682 if (hscale || vscale)
699 buf_size -= header_size;
765 dst->
x = av_clip(src->
x, av_clip(s->
mv_min.
x, INT16_MIN, INT16_MAX),
766 av_clip(s->
mv_max.
x, INT16_MIN, INT16_MAX));
767 dst->
y = av_clip(src->
y, av_clip(s->
mv_min.
y, INT16_MIN, INT16_MAX),
768 av_clip(s->
mv_max.
y, INT16_MIN, INT16_MAX));
781 for (i = 0; i < 3; i++)
783 for (i = (vp7 ? 7 : 9); i > 3; i--)
838 const uint8_t *mbsplits_top, *mbsplits_cur, *firstidx;
848 top_mv = top_mb->
bmv;
864 for (n = 0; n < num; n++) {
866 uint32_t left, above;
870 left =
AV_RN32A(&left_mv[mbsplits_left[k + 3]]);
872 left =
AV_RN32A(&cur_mv[mbsplits_cur[k - 1]]);
874 above =
AV_RN32A(&top_mv[mbsplits_top[k + 12]]);
876 above =
AV_RN32A(&cur_mv[mbsplits_cur[k - 4]]);
913 int xoffset,
int yoffset,
int boundary,
914 int *edge_x,
int *edge_y)
916 int vwidth = mb_width + 1;
917 int new = (mb_y + yoffset) * vwidth + mb_x + xoffset;
918 if (
new < boundary ||
new % vwidth == vwidth - 1)
920 *edge_y =
new / vwidth;
921 *edge_x =
new % vwidth;
932 int mb_x,
int mb_y,
int layout)
935 enum { CNT_ZERO, CNT_NEAREST, CNT_NEAR };
936 enum { VP8_EDGE_TOP, VP8_EDGE_LEFT, VP8_EDGE_TOPLEFT };
960 if (
AV_RN32A(&near_mv[CNT_NEAREST])) {
961 if (mv ==
AV_RN32A(&near_mv[CNT_NEAREST])) {
963 }
else if (
AV_RN32A(&near_mv[CNT_NEAR])) {
964 if (mv !=
AV_RN32A(&near_mv[CNT_NEAR]))
972 AV_WN32A(&near_mv[CNT_NEAREST], mv);
993 if (cnt[CNT_NEAREST] > cnt[CNT_NEAR])
994 AV_WN32A(&mb->
mv, cnt[CNT_ZERO] > cnt[CNT_NEAREST] ? 0 :
AV_RN32A(&near_mv[CNT_NEAREST]));
1004 mb->
bmv[0] = mb->
mv;
1007 mb->
mv = near_mv[CNT_NEAR];
1008 mb->
bmv[0] = mb->
mv;
1011 mb->
mv = near_mv[CNT_NEAREST];
1012 mb->
bmv[0] = mb->
mv;
1017 mb->
bmv[0] = mb->
mv;
1023 int mb_x,
int mb_y,
int layout)
1028 enum { CNT_ZERO, CNT_NEAREST, CNT_NEAR, CNT_SPLITMV };
1029 enum { VP8_EDGE_TOP, VP8_EDGE_LEFT, VP8_EDGE_TOPLEFT };
1038 mb_edge[0] = mb + 2;
1039 mb_edge[2] = mb + 1;
1050 #define MV_EDGE_CHECK(n) \
1052 VP8Macroblock *edge = mb_edge[n]; \
1053 int edge_ref = edge->ref_frame; \
1054 if (edge_ref != VP56_FRAME_CURRENT) { \
1055 uint32_t mv = AV_RN32A(&edge->mv); \
1057 if (cur_sign_bias != sign_bias[edge_ref]) { \
1060 mv = ((mv & 0x7fff7fff) + \
1061 0x00010001) ^ (mv & 0x80008000); \
1063 if (!n || mv != AV_RN32A(&near_mv[idx])) \
1064 AV_WN32A(&near_mv[++idx], mv); \
1065 cnt[idx] += 1 + (n != 2); \
1067 cnt[CNT_ZERO] += 1 + (n != 2); \
1080 if (cnt[CNT_SPLITMV] &&
1081 AV_RN32A(&near_mv[1 + VP8_EDGE_TOP]) ==
AV_RN32A(&near_mv[1 + VP8_EDGE_TOPLEFT]))
1082 cnt[CNT_NEAREST] += 1;
1085 if (cnt[CNT_NEAR] > cnt[CNT_NEAREST]) {
1087 FFSWAP(
VP56mv, near_mv[CNT_NEAREST], near_mv[CNT_NEAR]);
1093 clamp_mv(s, &mb->
mv, &near_mv[CNT_ZERO + (cnt[CNT_NEAREST] >= cnt[CNT_ZERO])]);
1104 mb->
bmv[0] = mb->
mv;
1108 mb->
bmv[0] = mb->
mv;
1112 mb->
bmv[0] = mb->
mv;
1117 mb->
bmv[0] = mb->
mv;
1123 int mb_x,
int keyframe,
int layout)
1139 for (y = 0; y < 4; y++) {
1140 for (x = 0; x < 4; x++) {
1144 left[
y] = top[x] = *intra4x4;
1150 for (i = 0; i < 16; i++)
1161 const char *vp7_feature_name[] = {
"q-index",
1163 "partial-golden-update",
1168 for (i = 0; i < 4; i++) {
1174 "Feature %s present in macroblock (value 0x%x)\n",
1183 *segment = ref ? *ref : *segment;
1250 int i,
uint8_t *token_prob, int16_t qmul[2],
1251 const uint8_t scan[16],
int vp7)
1265 token_prob = probs[i][0];
1273 token_prob = probs[i + 1][1];
1293 int cat = (a << 1) + b;
1294 coeff = 3 + (8 << cat);
1298 token_prob = probs[i + 1][2];
1310 int16_t
dc = block[0];
1319 block[0] = pred[0] =
dc;
1324 block[0] = pred[0] =
dc;
1338 token_prob, qmul, scan,
IS_VP7);
1341 #ifndef vp8_decode_block_coeffs_internal
1369 int i,
int zero_nhood, int16_t qmul[2],
1370 const uint8_t scan[16],
int vp7)
1372 uint8_t *token_prob = probs[i][zero_nhood];
1376 token_prob, qmul, scan)
1386 int i, x,
y, luma_start = 0, luma_ctx = 3;
1387 int nnz_pred, nnz, nnz_total = 0;
1392 nnz_pred = t_nnz[8] + l_nnz[8];
1398 l_nnz[8] = t_nnz[8] = !!nnz;
1418 for (y = 0; y < 4; y++)
1419 for (x = 0; x < 4; x++) {
1420 nnz_pred = l_nnz[
y] + t_nnz[x];
1423 luma_start, nnz_pred,
1429 t_nnz[x] = l_nnz[
y] = !!nnz;
1436 for (i = 4; i < 6; i++)
1437 for (y = 0; y < 2; y++)
1438 for (x = 0; x < 2; x++) {
1439 nnz_pred = l_nnz[i + 2 *
y] + t_nnz[i + 2 * x];
1445 t_nnz[i + 2 * x] = l_nnz[i + 2 *
y] = !!nnz;
1459 int linesize,
int uvlinesize,
int simple)
1461 AV_COPY128(top_border, src_y + 15 * linesize);
1463 AV_COPY64(top_border + 16, src_cb + 7 * uvlinesize);
1464 AV_COPY64(top_border + 24, src_cr + 7 * uvlinesize);
1470 uint8_t *src_cr,
int linesize,
int uvlinesize,
int mb_x,
1471 int mb_y,
int mb_width,
int simple,
int xchg)
1473 uint8_t *top_border_m1 = top_border - 32;
1475 src_cb -= uvlinesize;
1476 src_cr -= uvlinesize;
1478 #define XCHG(a, b, xchg) \
1486 XCHG(top_border_m1 + 8, src_y - 8, xchg);
1487 XCHG(top_border, src_y, xchg);
1488 XCHG(top_border + 8, src_y + 8, 1);
1489 if (mb_x < mb_width - 1)
1490 XCHG(top_border + 32, src_y + 16, 1);
1494 if (!simple || !mb_y) {
1495 XCHG(top_border_m1 + 16, src_cb - 8, xchg);
1496 XCHG(top_border_m1 + 24, src_cr - 8, xchg);
1497 XCHG(top_border + 16, src_cb, 1);
1498 XCHG(top_border + 24, src_cr, 1);
1548 int *copy_buf,
int vp7)
1552 if (!mb_x && mb_y) {
1586 int x,
y,
mode, nnz;
1602 const uint8_t lo = is_vp7 ? 128 : 127;
1603 const uint8_t hi = is_vp7 ? 128 : 129;
1604 uint8_t tr_top[4] = { lo, lo, lo, lo };
1612 if (mb_y && mb_x == s->
mb_width - 1) {
1613 tr = tr_right[-1] * 0x01010101
u;
1620 for (y = 0; y < 4; y++) {
1622 for (x = 0; x < 4; x++) {
1627 if ((y == 0 || x == 3) && mb_y == 0) {
1630 topright = tr_right;
1633 mb_y + y, ©, is_vp7);
1635 dst = copy_dst + 12;
1639 AV_WN32A(copy_dst + 4, lo * 0x01010101U);
1645 copy_dst[3] = ptr[4 * x - s->
linesize - 1];
1654 copy_dst[11] = ptr[4 * x - 1];
1655 copy_dst[19] = ptr[4 * x + s->
linesize - 1];
1656 copy_dst[27] = ptr[4 * x + s->
linesize * 2 - 1];
1657 copy_dst[35] = ptr[4 * x + s->
linesize * 3 - 1];
1686 mb_x, mb_y, is_vp7);
1697 { 0, 1, 2, 1, 2, 1, 2, 1 },
1699 { 0, 3, 5, 3, 5, 3, 5, 3 },
1700 { 0, 2, 3, 2, 3, 2, 3, 2 },
1722 int x_off,
int y_off,
int block_w,
int block_h,
1729 int src_linesize = linesize;
1731 int mx = (mv->
x << 1) & 7, mx_idx = subpel_idx[0][mx];
1732 int my = (mv->
y << 1) & 7, my_idx = subpel_idx[0][my];
1734 x_off += mv->
x >> 2;
1735 y_off += mv->
y >> 2;
1739 src += y_off * linesize + x_off;
1740 if (x_off < mx_idx || x_off >= width - block_w - subpel_idx[2][mx] ||
1741 y_off < my_idx || y_off >= height - block_h - subpel_idx[2][my]) {
1743 src - my_idx * linesize - mx_idx,
1745 block_w + subpel_idx[1][mx],
1746 block_h + subpel_idx[1][my],
1747 x_off - mx_idx, y_off - my_idx,
1752 mc_func[my_idx][mx_idx](dst, linesize,
src, src_linesize, block_h, mx, my);
1755 mc_func[0][0](dst, linesize, src + y_off * linesize + x_off,
1756 linesize, block_h, 0, 0);
1780 int x_off,
int y_off,
int block_w,
int block_h,
1787 int mx = mv->
x & 7, mx_idx = subpel_idx[0][mx];
1788 int my = mv->
y & 7, my_idx = subpel_idx[0][my];
1790 x_off += mv->
x >> 3;
1791 y_off += mv->
y >> 3;
1794 src1 += y_off * linesize + x_off;
1795 src2 += y_off * linesize + x_off;
1797 if (x_off < mx_idx || x_off >= width - block_w - subpel_idx[2][mx] ||
1798 y_off < my_idx || y_off >= height - block_h - subpel_idx[2][my]) {
1800 src1 - my_idx * linesize - mx_idx,
1802 block_w + subpel_idx[1][mx],
1803 block_h + subpel_idx[1][my],
1804 x_off - mx_idx, y_off - my_idx, width, height);
1806 mc_func[my_idx][mx_idx](dst1, linesize, src1,
EDGE_EMU_LINESIZE, block_h, mx, my);
1809 src2 - my_idx * linesize - mx_idx,
1810 EDGE_EMU_LINESIZE, linesize,
1811 block_w + subpel_idx[1][mx],
1812 block_h + subpel_idx[1][my],
1813 x_off - mx_idx, y_off - my_idx, width, height);
1815 mc_func[my_idx][mx_idx](dst2, linesize, src2,
EDGE_EMU_LINESIZE, block_h, mx, my);
1817 mc_func[my_idx][mx_idx](dst1, linesize, src1, linesize, block_h, mx, my);
1818 mc_func[my_idx][mx_idx](dst2, linesize, src2, linesize, block_h, mx, my);
1822 mc_func[0][0](dst1, linesize, src1 + y_off * linesize + x_off, linesize, block_h, 0, 0);
1823 mc_func[0][0](dst2, linesize, src2 + y_off * linesize + x_off, linesize, block_h, 0, 0);
1830 int bx_off,
int by_off,
int block_w,
int block_h,
1837 ref_frame, mv, x_off + bx_off, y_off + by_off,
1838 block_w, block_h, width, height, s->
linesize,
1857 dst[2] + by_off * s->
uvlinesize + bx_off, ref_frame,
1858 &uvmv, x_off + bx_off, y_off + by_off,
1859 block_w, block_h, width, height, s->
uvlinesize,
1870 if (s->
ref_count[ref - 1] > (mb_xy >> 5)) {
1871 int x_off = mb_x << 4, y_off = mb_y << 4;
1872 int mx = (mb->
mv.
x >> 2) + x_off + 8;
1873 int my = (mb->
mv.
y >> 2) + y_off;
1875 int off = mx + (my + (mb_x & 3) * 4) * s->
linesize + 64;
1880 off = (mx >> 1) + ((my >> 1) + (mb_x & 7)) * s->
uvlinesize + 64;
1892 int x_off = mb_x << 4, y_off = mb_y << 4;
1900 0, 0, 16, 16, width,
height, &mb->
mv);
1907 for (y = 0; y < 4; y++) {
1908 for (x = 0; x < 4; x++) {
1910 ref, &bmv[4 * y + x],
1911 4 * x + x_off, 4 * y + y_off, 4, 4,
1922 for (y = 0; y < 2; y++) {
1923 for (x = 0; x < 2; x++) {
1924 uvmv.
x = mb->
bmv[2 * y * 4 + 2 * x ].
x +
1925 mb->
bmv[2 * y * 4 + 2 * x + 1].
x +
1926 mb->
bmv[(2 * y + 1) * 4 + 2 * x ].x +
1927 mb->
bmv[(2 * y + 1) * 4 + 2 * x + 1].
x;
1928 uvmv.
y = mb->
bmv[2 * y * 4 + 2 * x ].
y +
1929 mb->
bmv[2 * y * 4 + 2 * x + 1].
y +
1930 mb->
bmv[(2 * y + 1) * 4 + 2 * x ].y +
1931 mb->
bmv[(2 * y + 1) * 4 + 2 * x + 1].
y;
1940 &uvmv, 4 * x + x_off, 4 * y + y_off, 4, 4,
1949 0, 0, 16, 8, width,
height, &bmv[0]);
1951 0, 8, 16, 8, width,
height, &bmv[1]);
1955 0, 0, 8, 16, width,
height, &bmv[0]);
1957 8, 0, 8, 16, width,
height, &bmv[1]);
1961 0, 0, 8, 8, width,
height, &bmv[0]);
1963 8, 0, 8, 8, width,
height, &bmv[1]);
1965 0, 8, 8, 8, width,
height, &bmv[2]);
1967 8, 8, 8, 8, width,
height, &bmv[3]);
1979 for (y = 0; y < 4; y++) {
1982 if (nnz4 & ~0x01010101) {
1983 for (x = 0; x < 4; x++) {
2004 for (ch = 0; ch < 2; ch++) {
2007 uint8_t *ch_dst = dst[1 + ch];
2008 if (nnz4 & ~0x01010101) {
2009 for (y = 0; y < 2; y++) {
2010 for (x = 0; x < 2; x++) {
2013 td->
block[4 + ch][(y << 1) + x],
2017 td->
block[4 + ch][(y << 1) + x],
2021 goto chroma_idct_end;
2038 int interior_limit, filter_level;
2052 filter_level = av_clip_uintp2(filter_level, 6);
2054 interior_limit = filter_level;
2059 interior_limit =
FFMAX(interior_limit, 1);
2069 int mb_x,
int mb_y,
int is_vp7)
2071 int mbedge_lim, bedge_lim_y, bedge_lim_uv, hev_thresh;
2077 static const uint8_t hev_thresh_lut[2][64] = {
2078 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
2079 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2080 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
2082 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
2083 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2084 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2092 bedge_lim_y = filter_level;
2093 bedge_lim_uv = filter_level * 2;
2094 mbedge_lim = filter_level + 2;
2097 bedge_lim_uv = filter_level * 2 + inner_limit;
2098 mbedge_lim = bedge_lim_y + 4;
2101 hev_thresh = hev_thresh_lut[s->
keyframe][filter_level];
2105 mbedge_lim, inner_limit, hev_thresh);
2107 mbedge_lim, inner_limit, hev_thresh);
2110 #define H_LOOP_FILTER_16Y_INNER(cond) \
2111 if (cond && inner_filter) { \
2112 s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0] + 4, linesize, \
2113 bedge_lim_y, inner_limit, \
2115 s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0] + 8, linesize, \
2116 bedge_lim_y, inner_limit, \
2118 s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0] + 12, linesize, \
2119 bedge_lim_y, inner_limit, \
2121 s->vp8dsp.vp8_h_loop_filter8uv_inner(dst[1] + 4, dst[2] + 4, \
2122 uvlinesize, bedge_lim_uv, \
2123 inner_limit, hev_thresh); \
2130 mbedge_lim, inner_limit, hev_thresh);
2132 mbedge_lim, inner_limit, hev_thresh);
2137 linesize, bedge_lim_y,
2138 inner_limit, hev_thresh);
2140 linesize, bedge_lim_y,
2141 inner_limit, hev_thresh);
2143 linesize, bedge_lim_y,
2144 inner_limit, hev_thresh);
2146 dst[2] + 4 * uvlinesize,
2147 uvlinesize, bedge_lim_uv,
2148 inner_limit, hev_thresh);
2158 int mbedge_lim, bedge_lim;
2167 bedge_lim = 2 * filter_level + inner_limit;
2168 mbedge_lim = bedge_lim + 4;
2187 #define MARGIN (16 << 2)
2197 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
2199 ((s->
mb_width + 1) * (mb_y + 1) + 1);
2206 for (mb_x = 0; mb_x < s->
mb_width; mb_x++, mb_xy++, mb++) {
2211 prev_frame && prev_frame->
seg_map ?
2234 #define check_thread_pos(td, otd, mb_x_check, mb_y_check) \
2236 int tmp = (mb_y_check << 16) | (mb_x_check & 0xFFFF); \
2237 if (otd->thread_mb_pos < tmp) { \
2238 pthread_mutex_lock(&otd->lock); \
2239 td->wait_mb_pos = tmp; \
2241 if (otd->thread_mb_pos >= tmp) \
2243 pthread_cond_wait(&otd->cond, &otd->lock); \
2245 td->wait_mb_pos = INT_MAX; \
2246 pthread_mutex_unlock(&otd->lock); \
2250 #define update_pos(td, mb_y, mb_x) \
2252 int pos = (mb_y << 16) | (mb_x & 0xFFFF); \
2253 int sliced_threading = (avctx->active_thread_type == FF_THREAD_SLICE) && \
2255 int is_null = !next_td || !prev_td; \
2256 int pos_check = (is_null) ? 1 \
2257 : (next_td != td && \
2258 pos >= next_td->wait_mb_pos) || \
2260 pos >= prev_td->wait_mb_pos); \
2261 td->thread_mb_pos = pos; \
2262 if (sliced_threading && pos_check) { \
2263 pthread_mutex_lock(&td->lock); \
2264 pthread_cond_broadcast(&td->cond); \
2265 pthread_mutex_unlock(&td->lock); \
2269 #define check_thread_pos(td, otd, mb_x_check, mb_y_check)
2270 #define update_pos(td, mb_y, mb_x)
2274 int jobnr,
int threadnr,
int is_vp7)
2279 int mb_x, mb_xy = mb_y * s->
mb_width;
2292 prev_td = &s->
thread_data[(jobnr + num_jobs - 1) % num_jobs];
2296 next_td = &s->
thread_data[(jobnr + 1) % num_jobs];
2306 memset(mb - 1, 0,
sizeof(*mb));
2310 if (!is_vp7 || mb_y == 0)
2316 for (mb_x = 0; mb_x < s->
mb_width; mb_x++, mb_xy++, mb++) {
2318 if (prev_td != td) {
2319 if (threadnr != 0) {
2321 mb_x + (is_vp7 ? 2 : 1),
2322 mb_y - (is_vp7 ? 2 : 1));
2325 mb_x + (is_vp7 ? 2 : 1) + s->
mb_width + 3,
2326 mb_y - (is_vp7 ? 2 : 1));
2333 dst[2] - dst[1], 2);
2337 prev_frame && prev_frame->seg_map ?
2338 prev_frame->seg_map->data + mb_xy :
NULL, 0, is_vp7);
2369 if (s->
deblock_filter && num_jobs != 1 && threadnr == num_jobs - 1) {
2395 int jobnr,
int threadnr)
2401 int jobnr,
int threadnr)
2407 int jobnr,
int threadnr,
int is_vp7)
2429 prev_td = &s->
thread_data[(jobnr + num_jobs - 1) % num_jobs];
2433 next_td = &s->
thread_data[(jobnr + 1) % num_jobs];
2435 for (mb_x = 0; mb_x < s->
mb_width; mb_x++, mb++) {
2439 (mb_x + 1) + (s->
mb_width + 3), mb_y - 1);
2444 if (num_jobs == 1) {
2456 filter_mb(s, dst, f, mb_x, mb_y, is_vp7);
2466 int jobnr,
int threadnr)
2472 int jobnr,
int threadnr)
2479 int threadnr,
int is_vp7)
2488 for (mb_y = jobnr; mb_y < s->
mb_height; mb_y += num_jobs) {
2508 int jobnr,
int threadnr)
2514 int jobnr,
int threadnr)
2525 int ret, i, referenced, num_jobs;
2554 for (i = 0; i < 5; i++)
2556 &s->
frames[i] != prev_frame &&
2579 "Discarding interframe without a prior keyframe!\n");
2584 curframe->tf.f->key_frame = s->
keyframe;
2611 s->
linesize = curframe->tf.f->linesize[0];
2684 #if CONFIG_VP7_DECODER
2755 #if CONFIG_VP7_DECODER
2767 #if CONFIG_VP8_DECODER
2783 #define REBASE(pic) ((pic) ? (pic) - &s_src->frames[0] + &s->frames[0] : NULL)
2798 s->
prob[0] = s_src->
prob[!s_src->update_probabilities];
2804 if (s_src->frames[i].tf.f->data[0]) {
2805 int ret = vp8_ref_frame(s, &s->
frames[i], &s_src->frames[i]);
2811 s->
framep[0] = REBASE(s_src->next_framep[0]);
2812 s->
framep[1] = REBASE(s_src->next_framep[1]);
2813 s->
framep[2] = REBASE(s_src->next_framep[2]);
2814 s->
framep[3] = REBASE(s_src->next_framep[3]);
2820 #if CONFIG_VP7_DECODER
2827 .
init = vp7_decode_init,
2829 .
decode = vp7_decode_frame,
2835 #if CONFIG_VP8_DECODER