66 if (prefer_delayed_free) {
74 }
else if (can_direct_free) {
86 int prefer_delayed_free,
int can_direct_free,
int free_mem)
92 for (i = 0; i < 5; i++)
149 for (i = 0; i < 4; i++)
152 for (i = 0; i < 4; i++)
156 for (i = 0; i < 3; i++)
165 for (i = 0; i < 4; i++)
174 const uint8_t *
sizes = buf;
186 if (buf_size - size < 0)
210 for (i = 0; i < 4; i++) {
273 int header_size, hscale, vscale, i, j, k, l, m, ret;
280 header_size =
AV_RL24(buf) >> 5;
292 if (header_size > buf_size - 7*s->
keyframe) {
298 if (
AV_RL24(buf) != 0x2a019d) {
302 width =
AV_RL16(buf+3) & 0x3fff;
303 height =
AV_RL16(buf+5) & 0x3fff;
304 hscale = buf[4] >> 6;
305 vscale = buf[6] >> 6;
309 if (hscale || vscale)
313 for (i = 0; i < 4; i++)
314 for (j = 0; j < 16; j++)
331 buf_size -= header_size;
372 for (i = 0; i < 4; i++)
373 for (j = 0; j < 8; j++)
374 for (k = 0; k < 3; k++)
391 for (i = 0; i < 4; i++)
394 for (i = 0; i < 3; i++)
398 for (i = 0; i < 2; i++)
399 for (j = 0; j < 19; j++)
423 for (i = 0; i < 3; i++)
425 for (i = 9; i > 3; i--)
431 const uint8_t *ps = p+2;
467 *mbsplits_cur, *firstidx;
487 for (n = 0; n < num; n++) {
489 uint32_t left, above;
490 const uint8_t *submv_prob;
493 left =
AV_RN32A(&left_mv[mbsplits_left[k + 3]]);
495 left =
AV_RN32A(&cur_mv[mbsplits_cur[k - 1]]);
497 above =
AV_RN32A(&top_mv[mbsplits_top[k + 12]]);
499 above =
AV_RN32A(&cur_mv[mbsplits_cur[k - 4]]);
528 enum { CNT_ZERO, CNT_NEAREST, CNT_NEAR, CNT_SPLITMV };
529 enum { VP8_EDGE_TOP, VP8_EDGE_LEFT, VP8_EDGE_TOPLEFT };
534 uint8_t cnt[4] = { 0 };
542 #define MV_EDGE_CHECK(n)\
544 VP8Macroblock *edge = mb_edge[n];\
545 int edge_ref = edge->ref_frame;\
546 if (edge_ref != VP56_FRAME_CURRENT) {\
547 uint32_t mv = AV_RN32A(&edge->mv);\
549 if (cur_sign_bias != sign_bias[edge_ref]) {\
552 mv = ((mv&0x7fff7fff) + 0x00010001) ^ (mv&0x80008000);\
554 if (!n || mv != AV_RN32A(&near_mv[idx]))\
555 AV_WN32A(&near_mv[++idx], mv);\
556 cnt[idx] += 1 + (n != 2);\
558 cnt[CNT_ZERO] += 1 + (n != 2);\
571 if (cnt[CNT_SPLITMV] &&
AV_RN32A(&near_mv[1 + VP8_EDGE_TOP]) ==
AV_RN32A(&near_mv[1 + VP8_EDGE_TOPLEFT]))
572 cnt[CNT_NEAREST] += 1;
575 if (cnt[CNT_NEAR] > cnt[CNT_NEAREST]) {
576 FFSWAP(uint8_t, cnt[CNT_NEAREST], cnt[CNT_NEAR]);
577 FFSWAP(
VP56mv, near_mv[CNT_NEAREST], near_mv[CNT_NEAR]);
584 clamp_mv(s, &mb->
mv, &near_mv[CNT_ZERO + (cnt[CNT_NEAREST] >= cnt[CNT_ZERO])]);
614 int mb_x,
int keyframe)
621 for (y = 0; y < 4; y++) {
622 for (x = 0; x < 4; x++) {
626 left[y] = top[x] = *intra4x4;
632 for (i = 0; i < 16; i++)
645 *segment = ref ? *ref : *segment;
688 #ifndef decode_block_coeffs_internal
700 int i, uint8_t *token_prob, int16_t qmul[2])
712 token_prob = probs[i][0];
718 token_prob = probs[i+1][1];
738 int cat = (a<<1) + b;
739 coeff = 3 + (8<<cat);
743 token_prob = probs[i+1][2];
766 int i,
int zero_nhood, int16_t qmul[2])
768 uint8_t *token_prob = probs[i][zero_nhood];
776 uint8_t t_nnz[9], uint8_t l_nnz[9])
778 int i, x, y, luma_start = 0, luma_ctx = 3;
779 int nnz_pred, nnz, nnz_total = 0;
784 nnz_pred = t_nnz[8] + l_nnz[8];
789 l_nnz[8] = t_nnz[8] = !!nnz;
803 for (y = 0; y < 4; y++)
804 for (x = 0; x < 4; x++) {
805 nnz_pred = l_nnz[y] + t_nnz[x];
810 t_nnz[x] = l_nnz[y] = !!nnz;
817 for (i = 4; i < 6; i++)
818 for (y = 0; y < 2; y++)
819 for (x = 0; x < 2; x++) {
820 nnz_pred = l_nnz[i+2*y] + t_nnz[i+2*x];
824 t_nnz[i+2*x] = l_nnz[i+2*y] = !!nnz;
836 void backup_mb_border(uint8_t *top_border, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr,
837 int linesize,
int uvlinesize,
int simple)
841 AV_COPY64(top_border+16, src_cb + 7*uvlinesize);
842 AV_COPY64(top_border+24, src_cr + 7*uvlinesize);
847 void xchg_mb_border(uint8_t *top_border, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr,
848 int linesize,
int uvlinesize,
int mb_x,
int mb_y,
int mb_width,
849 int simple,
int xchg)
851 uint8_t *top_border_m1 = top_border-32;
853 src_cb -= uvlinesize;
854 src_cr -= uvlinesize;
856 #define XCHG(a,b,xchg) do { \
857 if (xchg) AV_SWAP64(b,a); \
858 else AV_COPY64(b,a); \
861 XCHG(top_border_m1+8, src_y-8, xchg);
862 XCHG(top_border, src_y, xchg);
863 XCHG(top_border+8, src_y+8, 1);
864 if (mb_x < mb_width-1)
865 XCHG(top_border+32, src_y+16, 1);
869 if (!simple || !mb_y) {
870 XCHG(top_border_m1+16, src_cb-8, xchg);
871 XCHG(top_border_m1+24, src_cr-8, xchg);
872 XCHG(top_border+16, src_cb, 1);
873 XCHG(top_border+24, src_cr, 1);
990 uint8_t *ptr = dst[0];
992 uint8_t tr_top[4] = { 127, 127, 127, 127 };
996 uint8_t *tr_right = ptr - s->
linesize + 16;
1002 tr = tr_right[-1]*0x01010101u;
1003 tr_right = (uint8_t *)&tr;
1009 for (y = 0; y < 4; y++) {
1010 uint8_t *topright = ptr + 4 - s->
linesize;
1011 for (x = 0; x < 4; x++) {
1013 uint8_t *dst = ptr+4*x;
1019 topright = tr_right;
1024 dst = copy_dst + 12;
1028 AV_WN32A(copy_dst+4, 127
U * 0x01010101U);
1034 copy_dst[3] = ptr[4*x-s->
linesize-1];
1041 copy_dst[35] = 129
U;
1043 copy_dst[11] = ptr[4*x -1];
1044 copy_dst[19] = ptr[4*x+s->
linesize -1];
1045 copy_dst[27] = ptr[4*x+s->
linesize*2-1];
1046 copy_dst[35] = ptr[4*x+s->
linesize*3-1];
1052 s->
hpc.
pred4x4[mode](dst, topright, linesize);
1090 { 0, 1, 2, 1, 2, 1, 2, 1 },
1092 { 0, 3, 5, 3, 5, 3, 5, 3 },
1093 { 0, 2, 3, 2, 3, 2, 3, 2 },
1114 int x_off,
int y_off,
int block_w,
int block_h,
1118 uint8_t *src = ref->
data[0];
1122 int mx = (mv->
x << 1)&7, mx_idx =
subpel_idx[0][mx];
1123 int my = (mv->
y << 1)&7, my_idx =
subpel_idx[0][my];
1125 x_off += mv->
x >> 2;
1126 y_off += mv->
y >> 2;
1130 src += y_off * linesize + x_off;
1131 if (x_off < mx_idx || x_off >= width - block_w -
subpel_idx[2][mx] ||
1132 y_off < my_idx || y_off >= height - block_h -
subpel_idx[2][my]) {
1135 x_off - mx_idx, y_off - my_idx, width, height);
1138 mc_func[my_idx][mx_idx](dst, linesize, src, linesize, block_h, mx, my);
1141 mc_func[0][0](dst, linesize, src + y_off * linesize + x_off, linesize, block_h, 0, 0);
1164 const VP56mv *
mv,
int x_off,
int y_off,
1165 int block_w,
int block_h,
int width,
int height,
int linesize,
1168 uint8_t *src1 = ref->
data[1], *src2 = ref->
data[2];
1174 x_off += mv->
x >> 3;
1175 y_off += mv->
y >> 3;
1178 src1 += y_off * linesize + x_off;
1179 src2 += y_off * linesize + x_off;
1181 if (x_off < mx_idx || x_off >= width - block_w -
subpel_idx[2][mx] ||
1182 y_off < my_idx || y_off >= height - block_h -
subpel_idx[2][my]) {
1185 x_off - mx_idx, y_off - my_idx, width, height);
1187 mc_func[my_idx][mx_idx](dst1, linesize, src1, linesize, block_h, mx, my);
1191 x_off - mx_idx, y_off - my_idx, width, height);
1193 mc_func[my_idx][mx_idx](dst2, linesize, src2, linesize, block_h, mx, my);
1195 mc_func[my_idx][mx_idx](dst1, linesize, src1, linesize, block_h, mx, my);
1196 mc_func[my_idx][mx_idx](dst2, linesize, src2, linesize, block_h, mx, my);
1200 mc_func[0][0](dst1, linesize, src1 + y_off * linesize + x_off, linesize, block_h, 0, 0);
1201 mc_func[0][0](dst2, linesize, src2 + y_off * linesize + x_off, linesize, block_h, 0, 0);
1207 AVFrame *ref_frame,
int x_off,
int y_off,
1208 int bx_off,
int by_off,
1209 int block_w,
int block_h,
1216 ref_frame, mv, x_off + bx_off, y_off + by_off,
1217 block_w, block_h, width, height, s->
linesize,
1225 x_off >>= 1; y_off >>= 1;
1226 bx_off >>= 1; by_off >>= 1;
1227 width >>= 1; height >>= 1;
1228 block_w >>= 1; block_h >>= 1;
1230 dst[2] + by_off * s->
uvlinesize + bx_off, ref_frame,
1231 &uvmv, x_off + bx_off, y_off + by_off,
1232 block_w, block_h, width, height, s->
uvlinesize,
1241 if (s->
ref_count[ref-1] > (mb_xy >> 5)) {
1242 int x_off = mb_x << 4, y_off = mb_y << 4;
1243 int mx = (mb->
mv.
x>>2) + x_off + 8;
1244 int my = (mb->
mv.
y>>2) + y_off;
1251 off= (mx>>1) + ((my>>1) + (mb_x&7))*s->
uvlinesize + 64;
1263 int x_off = mb_x << 4, y_off = mb_y << 4;
1271 0, 0, 16, 16, width,
height, &mb->
mv);
1278 for (y = 0; y < 4; y++) {
1279 for (x = 0; x < 4; x++) {
1282 4*x + x_off, 4*y + y_off, 4, 4,
1289 x_off >>= 1; y_off >>= 1; width >>= 1;
height >>= 1;
1290 for (y = 0; y < 2; y++) {
1291 for (x = 0; x < 2; x++) {
1292 uvmv.
x = mb->
bmv[ 2*y * 4 + 2*x ].
x +
1293 mb->
bmv[ 2*y * 4 + 2*x+1].
x +
1294 mb->
bmv[(2*y+1) * 4 + 2*x ].x +
1295 mb->
bmv[(2*y+1) * 4 + 2*x+1].
x;
1296 uvmv.
y = mb->
bmv[ 2*y * 4 + 2*x ].
y +
1297 mb->
bmv[ 2*y * 4 + 2*x+1].
y +
1298 mb->
bmv[(2*y+1) * 4 + 2*x ].y +
1299 mb->
bmv[(2*y+1) * 4 + 2*x+1].
y;
1300 uvmv.
x = (uvmv.
x + 2 + (uvmv.
x >> (
INT_BIT-1))) >> 2;
1301 uvmv.
y = (uvmv.
y + 2 + (uvmv.
y >> (
INT_BIT-1))) >> 2;
1307 dst[2] + 4*y*s->
uvlinesize + x*4, ref, &uvmv,
1308 4*x + x_off, 4*y + y_off, 4, 4,
1317 0, 0, 16, 8, width,
height, &bmv[0]);
1319 0, 8, 16, 8, width,
height, &bmv[1]);
1323 0, 0, 8, 16, width,
height, &bmv[0]);
1325 8, 0, 8, 16, width,
height, &bmv[1]);
1329 0, 0, 8, 8, width,
height, &bmv[0]);
1331 8, 0, 8, 8, width,
height, &bmv[1]);
1333 0, 8, 8, 8, width,
height, &bmv[2]);
1335 8, 8, 8, 8, width,
height, &bmv[3]);
1345 uint8_t *y_dst = dst[0];
1346 for (y = 0; y < 4; y++) {
1349 if (nnz4&~0x01010101) {
1350 for (x = 0; x < 4; x++) {
1351 if ((uint8_t)nnz4 == 1)
1353 else if((uint8_t)nnz4 > 1)
1367 for (ch = 0; ch < 2; ch++) {
1370 uint8_t *ch_dst = dst[1+ch];
1371 if (nnz4&~0x01010101) {
1372 for (y = 0; y < 2; y++) {
1373 for (x = 0; x < 2; x++) {
1374 if ((uint8_t)nnz4 == 1)
1376 else if((uint8_t)nnz4 > 1)
1380 goto chroma_idct_end;
1394 int interior_limit, filter_level;
1408 filter_level = av_clip_uintp2(filter_level, 6);
1410 interior_limit = filter_level;
1415 interior_limit =
FFMAX(interior_limit, 1);
1424 int mbedge_lim, bedge_lim, hev_thresh;
1430 static const uint8_t hev_thresh_lut[2][64] = {
1431 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
1432 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1433 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1435 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
1436 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1437 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1444 bedge_lim = 2*filter_level + inner_limit;
1445 mbedge_lim = bedge_lim + 4;
1447 hev_thresh = hev_thresh_lut[s->
keyframe][filter_level];
1451 mbedge_lim, inner_limit, hev_thresh);
1453 mbedge_lim, inner_limit, hev_thresh);
1458 inner_limit, hev_thresh);
1460 inner_limit, hev_thresh);
1462 inner_limit, hev_thresh);
1464 uvlinesize, bedge_lim,
1465 inner_limit, hev_thresh);
1470 mbedge_lim, inner_limit, hev_thresh);
1472 mbedge_lim, inner_limit, hev_thresh);
1477 linesize, bedge_lim,
1478 inner_limit, hev_thresh);
1480 linesize, bedge_lim,
1481 inner_limit, hev_thresh);
1483 linesize, bedge_lim,
1484 inner_limit, hev_thresh);
1486 dst[2] + 4 * uvlinesize,
1487 uvlinesize, bedge_lim,
1488 inner_limit, hev_thresh);
1494 int mbedge_lim, bedge_lim;
1503 bedge_lim = 2*filter_level + inner_limit;
1504 mbedge_lim = bedge_lim + 4;
1533 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1545 uint8_t *dst = curframe->
data[0] + 16*mb_y*s->
linesize;
1548 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1567 int ret, mb_x, mb_y, i, y, referenced;
1591 for (i = 0; i < 5; i++)
1593 &s->
frames[i] != prev_frame &&
1600 for (i = 0; i < 5; i++)
1601 if (&s->
frames[i] != prev_frame &&
1612 if (curframe->data[0])
1617 curframe->reference = referenced ? 3 : 0;
1653 s->
linesize = curframe->linesize[0];
1673 #define MARGIN (16 << 2)
1677 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1682 curframe->data[0] + 16*mb_y*s->
linesize,
1687 memset(mb - 1, 0,
sizeof(*mb));
1693 for (i = 0; i < 3; i++)
1694 for (y = 0; y < 16>>!!i; y++)
1695 dst[i][y*curframe->linesize[i]-1] = 129;
1705 for (mb_x = 0; mb_x < s->
mb_width; mb_x++, mb_xy++, mb++) {
1710 decode_mb_mode(s, mb, mb_x, mb_y, curframe->ref_index[0] + mb_xy,
1808 #define REBASE(pic) \
1809 pic ? pic - &s_src->frames[0] + &s->frames[0] : NULL
1821 s->
prob[0] = s_src->
prob[!s_src->update_probabilities];