76 if (prefer_delayed_free) {
84 }
else if (can_direct_free) {
96 int prefer_delayed_free,
int can_direct_free,
int free_mem)
102 for (i = 0; i < 5; i++)
175 for (i = 0; i < 4; i++)
178 for (i = 0; i < 4; i++)
182 for (i = 0; i < 3; i++)
191 for (i = 0; i < 4; i++) {
224 if (buf_size - size < 0)
248 for (i = 0; i < 4; i++) {
312 int header_size, hscale, vscale, i, j, k, l, m, ret;
319 header_size =
AV_RL24(buf) >> 5;
331 if (header_size > buf_size - 7*s->
keyframe) {
337 if (
AV_RL24(buf) != 0x2a019d) {
341 width =
AV_RL16(buf+3) & 0x3fff;
342 height =
AV_RL16(buf+5) & 0x3fff;
343 hscale = buf[4] >> 6;
344 vscale = buf[6] >> 6;
348 if (hscale || vscale)
352 for (i = 0; i < 4; i++)
353 for (j = 0; j < 16; j++)
365 buf_size -= header_size;
412 for (i = 0; i < 4; i++)
413 for (j = 0; j < 8; j++)
414 for (k = 0; k < 3; k++)
431 for (i = 0; i < 4; i++)
434 for (i = 0; i < 3; i++)
438 for (i = 0; i < 2; i++)
439 for (j = 0; j < 19; j++)
463 for (i = 0; i < 3; i++)
465 for (i = 9; i > 3; i--)
507 *mbsplits_cur, *firstidx;
517 top_mv = top_mb->
bmv;
534 for (n = 0; n < num; n++) {
536 uint32_t left, above;
540 left =
AV_RN32A(&left_mv[mbsplits_left[k + 3]]);
542 left =
AV_RN32A(&cur_mv[mbsplits_cur[k - 1]]);
544 above =
AV_RN32A(&top_mv[mbsplits_top[k + 12]]);
546 above =
AV_RN32A(&cur_mv[mbsplits_cur[k - 4]]);
575 enum { CNT_ZERO, CNT_NEAREST, CNT_NEAR, CNT_SPLITMV };
576 enum { VP8_EDGE_TOP, VP8_EDGE_LEFT, VP8_EDGE_TOPLEFT };
598 #define MV_EDGE_CHECK(n)\
600 VP8Macroblock *edge = mb_edge[n];\
601 int edge_ref = edge->ref_frame;\
602 if (edge_ref != VP56_FRAME_CURRENT) {\
603 uint32_t mv = AV_RN32A(&edge->mv);\
605 if (cur_sign_bias != sign_bias[edge_ref]) {\
608 mv = ((mv&0x7fff7fff) + 0x00010001) ^ (mv&0x80008000);\
610 if (!n || mv != AV_RN32A(&near_mv[idx]))\
611 AV_WN32A(&near_mv[++idx], mv);\
612 cnt[idx] += 1 + (n != 2);\
614 cnt[CNT_ZERO] += 1 + (n != 2);\
627 if (cnt[CNT_SPLITMV] &&
AV_RN32A(&near_mv[1 + VP8_EDGE_TOP]) ==
AV_RN32A(&near_mv[1 + VP8_EDGE_TOPLEFT]))
628 cnt[CNT_NEAREST] += 1;
631 if (cnt[CNT_NEAR] > cnt[CNT_NEAREST]) {
633 FFSWAP(
VP56mv, near_mv[CNT_NEAREST], near_mv[CNT_NEAR]);
640 clamp_mv(s, &mb->
mv, &near_mv[CNT_ZERO + (cnt[CNT_NEAREST] >= cnt[CNT_ZERO])]);
670 int mb_x,
int keyframe,
int layout)
686 for (y = 0; y < 4; y++) {
687 for (x = 0; x < 4; x++) {
691 left[y] = top[x] = *intra4x4;
697 for (i = 0; i < 16; i++)
711 *segment = ref ? *ref : *segment;
757 #ifndef decode_block_coeffs_internal
769 int i,
uint8_t *token_prob, int16_t qmul[2])
782 token_prob = probs[i][0];
788 token_prob = probs[i+1][1];
808 int cat = (a<<1) + b;
809 coeff = 3 + (8<<cat);
813 token_prob = probs[i+1][2];
837 int i,
int zero_nhood, int16_t qmul[2])
839 uint8_t *token_prob = probs[i][zero_nhood];
849 int i, x, y, luma_start = 0, luma_ctx = 3;
850 int nnz_pred, nnz, nnz_total = 0;
855 nnz_pred = t_nnz[8] + l_nnz[8];
860 l_nnz[8] = t_nnz[8] = !!nnz;
874 for (y = 0; y < 4; y++)
875 for (x = 0; x < 4; x++) {
876 nnz_pred = l_nnz[y] + t_nnz[x];
881 t_nnz[x] = l_nnz[y] = !!nnz;
888 for (i = 4; i < 6; i++)
889 for (y = 0; y < 2; y++)
890 for (x = 0; x < 2; x++) {
891 nnz_pred = l_nnz[i+2*y] + t_nnz[i+2*x];
895 t_nnz[i+2*x] = l_nnz[i+2*y] = !!nnz;
908 int linesize,
int uvlinesize,
int simple)
912 AV_COPY64(top_border+16, src_cb + 7*uvlinesize);
913 AV_COPY64(top_border+24, src_cr + 7*uvlinesize);
919 int linesize,
int uvlinesize,
int mb_x,
int mb_y,
int mb_width,
920 int simple,
int xchg)
922 uint8_t *top_border_m1 = top_border-32;
924 src_cb -= uvlinesize;
925 src_cr -= uvlinesize;
927 #define XCHG(a,b,xchg) do { \
928 if (xchg) AV_SWAP64(b,a); \
929 else AV_COPY64(b,a); \
932 XCHG(top_border_m1+8, src_y-8, xchg);
933 XCHG(top_border, src_y, xchg);
934 XCHG(top_border+8, src_y+8, 1);
935 if (mb_x < mb_width-1)
936 XCHG(top_border+32, src_y+16, 1);
940 if (!simple || !mb_y) {
941 XCHG(top_border_m1+16, src_cb-8, xchg);
942 XCHG(top_border_m1+24, src_cr-8, xchg);
943 XCHG(top_border+16, src_cb, 1);
944 XCHG(top_border+24, src_cr, 1);
1009 if (!mb_x && mb_y) {
1043 int x, y, mode, nnz;
1063 uint8_t tr_top[4] = { 127, 127, 127, 127 };
1073 tr = tr_right[-1]*0x01010101u;
1080 for (y = 0; y < 4; y++) {
1082 for (x = 0; x < 4; x++) {
1090 topright = tr_right;
1095 dst = copy_dst + 12;
1099 AV_WN32A(copy_dst+4, 127
U * 0x01010101U);
1105 copy_dst[3] = ptr[4*x-s->
linesize-1];
1112 copy_dst[35] = 129
U;
1114 copy_dst[11] = ptr[4*x -1];
1115 copy_dst[19] = ptr[4*x+s->
linesize -1];
1116 copy_dst[27] = ptr[4*x+s->
linesize*2-1];
1117 copy_dst[35] = ptr[4*x+s->
linesize*3-1];
1123 s->
hpc.
pred4x4[mode](dst, topright, linesize);
1161 { 0, 1, 2, 1, 2, 1, 2, 1 },
1163 { 0, 3, 5, 3, 5, 3, 5, 3 },
1164 { 0, 2, 3, 2, 3, 2, 3, 2 },
1186 int x_off,
int y_off,
int block_w,
int block_h,
1194 int mx = (mv->
x << 1)&7, mx_idx =
subpel_idx[0][mx];
1195 int my = (mv->
y << 1)&7, my_idx =
subpel_idx[0][my];
1197 x_off += mv->
x >> 2;
1198 y_off += mv->
y >> 2;
1202 src += y_off * linesize + x_off;
1203 if (x_off < mx_idx || x_off >= width - block_w -
subpel_idx[2][mx] ||
1204 y_off < my_idx || y_off >= height - block_h -
subpel_idx[2][my]) {
1207 x_off - mx_idx, y_off - my_idx, width, height);
1210 mc_func[my_idx][mx_idx](dst, linesize, src, linesize, block_h, mx, my);
1213 mc_func[0][0](dst, linesize, src + y_off * linesize + x_off, linesize, block_h, 0, 0);
1237 int block_w,
int block_h,
int width,
int height,
int linesize,
1246 x_off += mv->
x >> 3;
1247 y_off += mv->
y >> 3;
1250 src1 += y_off * linesize + x_off;
1251 src2 += y_off * linesize + x_off;
1253 if (x_off < mx_idx || x_off >= width - block_w -
subpel_idx[2][mx] ||
1254 y_off < my_idx || y_off >= height - block_h -
subpel_idx[2][my]) {
1257 x_off - mx_idx, y_off - my_idx, width, height);
1259 mc_func[my_idx][mx_idx](dst1, linesize, src1, linesize, block_h, mx, my);
1263 x_off - mx_idx, y_off - my_idx, width, height);
1265 mc_func[my_idx][mx_idx](dst2, linesize, src2, linesize, block_h, mx, my);
1267 mc_func[my_idx][mx_idx](dst1, linesize, src1, linesize, block_h, mx, my);
1268 mc_func[my_idx][mx_idx](dst2, linesize, src2, linesize, block_h, mx, my);
1272 mc_func[0][0](dst1, linesize, src1 + y_off * linesize + x_off, linesize, block_h, 0, 0);
1273 mc_func[0][0](dst2, linesize, src2 + y_off * linesize + x_off, linesize, block_h, 0, 0);
1279 AVFrame *ref_frame,
int x_off,
int y_off,
1280 int bx_off,
int by_off,
1281 int block_w,
int block_h,
1288 ref_frame, mv, x_off + bx_off, y_off + by_off,
1289 block_w, block_h, width, height, s->
linesize,
1297 x_off >>= 1; y_off >>= 1;
1298 bx_off >>= 1; by_off >>= 1;
1299 width >>= 1; height >>= 1;
1300 block_w >>= 1; block_h >>= 1;
1302 dst[2] + by_off * s->
uvlinesize + bx_off, ref_frame,
1303 &uvmv, x_off + bx_off, y_off + by_off,
1304 block_w, block_h, width, height, s->
uvlinesize,
1313 if (s->
ref_count[ref-1] > (mb_xy >> 5)) {
1314 int x_off = mb_x << 4, y_off = mb_y << 4;
1315 int mx = (mb->
mv.
x>>2) + x_off + 8;
1316 int my = (mb->
mv.
y>>2) + y_off;
1323 off= (mx>>1) + ((my>>1) + (mb_x&7))*s->
uvlinesize + 64;
1335 int x_off = mb_x << 4, y_off = mb_y << 4;
1343 0, 0, 16, 16, width,
height, &mb->
mv);
1350 for (y = 0; y < 4; y++) {
1351 for (x = 0; x < 4; x++) {
1354 4*x + x_off, 4*y + y_off, 4, 4,
1361 x_off >>= 1; y_off >>= 1; width >>= 1;
height >>= 1;
1362 for (y = 0; y < 2; y++) {
1363 for (x = 0; x < 2; x++) {
1364 uvmv.
x = mb->
bmv[ 2*y * 4 + 2*x ].
x +
1365 mb->
bmv[ 2*y * 4 + 2*x+1].
x +
1366 mb->
bmv[(2*y+1) * 4 + 2*x ].x +
1367 mb->
bmv[(2*y+1) * 4 + 2*x+1].
x;
1368 uvmv.
y = mb->
bmv[ 2*y * 4 + 2*x ].
y +
1369 mb->
bmv[ 2*y * 4 + 2*x+1].
y +
1370 mb->
bmv[(2*y+1) * 4 + 2*x ].y +
1371 mb->
bmv[(2*y+1) * 4 + 2*x+1].
y;
1372 uvmv.
x = (uvmv.
x + 2 + (uvmv.
x >> (
INT_BIT-1))) >> 2;
1373 uvmv.
y = (uvmv.
y + 2 + (uvmv.
y >> (
INT_BIT-1))) >> 2;
1379 dst[2] + 4*y*s->
uvlinesize + x*4, ref, &uvmv,
1380 4*x + x_off, 4*y + y_off, 4, 4,
1389 0, 0, 16, 8, width,
height, &bmv[0]);
1391 0, 8, 16, 8, width,
height, &bmv[1]);
1395 0, 0, 8, 16, width,
height, &bmv[0]);
1397 8, 0, 8, 16, width,
height, &bmv[1]);
1401 0, 0, 8, 8, width,
height, &bmv[0]);
1403 8, 0, 8, 8, width,
height, &bmv[1]);
1405 0, 8, 8, 8, width,
height, &bmv[2]);
1407 8, 8, 8, 8, width,
height, &bmv[3]);
1419 for (y = 0; y < 4; y++) {
1422 if (nnz4&~0x01010101) {
1423 for (x = 0; x < 4; x++) {
1440 for (ch = 0; ch < 2; ch++) {
1444 if (nnz4&~0x01010101) {
1445 for (y = 0; y < 2; y++) {
1446 for (x = 0; x < 2; x++) {
1453 goto chroma_idct_end;
1467 int interior_limit, filter_level;
1481 filter_level = av_clip_uintp2(filter_level, 6);
1483 interior_limit = filter_level;
1488 interior_limit =
FFMAX(interior_limit, 1);
1497 int mbedge_lim, bedge_lim, hev_thresh;
1503 static const uint8_t hev_thresh_lut[2][64] = {
1504 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
1505 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1506 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1508 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
1509 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1510 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1517 bedge_lim = 2*filter_level + inner_limit;
1518 mbedge_lim = bedge_lim + 4;
1520 hev_thresh = hev_thresh_lut[s->
keyframe][filter_level];
1524 mbedge_lim, inner_limit, hev_thresh);
1526 mbedge_lim, inner_limit, hev_thresh);
1531 inner_limit, hev_thresh);
1533 inner_limit, hev_thresh);
1535 inner_limit, hev_thresh);
1537 uvlinesize, bedge_lim,
1538 inner_limit, hev_thresh);
1543 mbedge_lim, inner_limit, hev_thresh);
1545 mbedge_lim, inner_limit, hev_thresh);
1550 linesize, bedge_lim,
1551 inner_limit, hev_thresh);
1553 linesize, bedge_lim,
1554 inner_limit, hev_thresh);
1556 linesize, bedge_lim,
1557 inner_limit, hev_thresh);
1559 dst[2] + 4 * uvlinesize,
1560 uvlinesize, bedge_lim,
1561 inner_limit, hev_thresh);
1567 int mbedge_lim, bedge_lim;
1576 bedge_lim = 2*filter_level + inner_limit;
1577 mbedge_lim = bedge_lim + 4;
1604 #define MARGIN (16 << 2)
1613 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1621 for (mb_x = 0; mb_x < s->
mb_width; mb_x++, mb_xy++, mb++) {
1635 #define check_thread_pos(td, otd, mb_x_check, mb_y_check)\
1637 int tmp = (mb_y_check << 16) | (mb_x_check & 0xFFFF);\
1638 if (otd->thread_mb_pos < tmp) {\
1639 pthread_mutex_lock(&otd->lock);\
1640 td->wait_mb_pos = tmp;\
1642 if (otd->thread_mb_pos >= tmp)\
1644 pthread_cond_wait(&otd->cond, &otd->lock);\
1646 td->wait_mb_pos = INT_MAX;\
1647 pthread_mutex_unlock(&otd->lock);\
1651 #define update_pos(td, mb_y, mb_x)\
1653 int pos = (mb_y << 16) | (mb_x & 0xFFFF);\
1654 int sliced_threading = (avctx->active_thread_type == FF_THREAD_SLICE) && (num_jobs > 1);\
1655 int is_null = (next_td == NULL) || (prev_td == NULL);\
1656 int pos_check = (is_null) ? 1 :\
1657 (next_td != td && pos >= next_td->wait_mb_pos) ||\
1658 (prev_td != td && pos >= prev_td->wait_mb_pos);\
1659 td->thread_mb_pos = pos;\
1660 if (sliced_threading && pos_check) {\
1661 pthread_mutex_lock(&td->lock);\
1662 pthread_cond_broadcast(&td->cond);\
1663 pthread_mutex_unlock(&td->lock);\
1667 #define check_thread_pos(td, otd, mb_x_check, mb_y_check)
1668 #define update_pos(td, mb_y, mb_x)
1672 int jobnr,
int threadnr)
1677 int i, y, mb_x, mb_xy = mb_y*s->
mb_width;
1687 if (mb_y == 0) prev_td = td;
1688 else prev_td = &s->
thread_data[(jobnr + num_jobs - 1)%num_jobs];
1689 if (mb_y == s->
mb_height-1) next_td = td;
1690 else next_td = &s->
thread_data[(jobnr + 1)%num_jobs];
1695 memset(mb - 1, 0,
sizeof(*mb));
1702 for (i = 0; i < 3; i++)
1703 for (y = 0; y < 16>>!!i; y++)
1704 dst[i][y*curframe->
linesize[i]-1] = 129;
1713 for (mb_x = 0; mb_x < s->
mb_width; mb_x++, mb_xy++, mb++) {
1715 if (prev_td != td) {
1716 if (threadnr != 0) {
1728 prev_frame && prev_frame->ref_index[0] ? prev_frame->ref_index[0] + mb_xy :
NULL, 0);
1758 if (s->
deblock_filter && num_jobs != 1 && threadnr == num_jobs-1) {
1782 int jobnr,
int threadnr)
1801 if (mb_y == 0) prev_td = td;
1802 else prev_td = &s->
thread_data[(jobnr + num_jobs - 1)%num_jobs];
1803 if (mb_y == s->
mb_height-1) next_td = td;
1804 else next_td = &s->
thread_data[(jobnr + 1)%num_jobs];
1806 for (mb_x = 0; mb_x < s->
mb_width; mb_x++, mb++) {
1808 if (prev_td != td) {
1816 if (num_jobs == 1) {
1836 int jobnr,
int threadnr)
1844 for (mb_y = jobnr; mb_y < s->
mb_height; mb_y += num_jobs) {
1866 int ret, i, referenced, num_jobs;
1891 for (i = 0; i < 5; i++)
1893 &s->
frames[i] != prev_frame &&
1900 for (i = 0; i < 5; i++)
1901 if (&s->
frames[i] != prev_frame &&
1912 if (curframe->data[0])
1928 curframe->reference = referenced ? 3 : 0;
1954 s->
linesize = curframe->linesize[0];
2050 #define REBASE(pic) \
2051 pic ? pic - &s_src->frames[0] + &s->frames[0] : NULL
2065 s->
prob[0] = s_src->
prob[!s_src->update_probabilities];