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];
static void get_quants(VP8Context *s)
static void vp8_decode_flush_impl(AVCodecContext *avctx, int prefer_delayed_free, int can_direct_free, int free_mem)
VP8Macroblock * macroblocks
static const uint8_t vp8_dc_qlookup[VP8_MAX_QUANT+1]
static const uint8_t vp8_submv_prob[5][3]
static int decode_frame_header(VP8Context *s, const uint8_t *buf, int buf_size)
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
void(* prefetch)(uint8_t *buf, ptrdiff_t stride, int h)
Prefetch memory into cache (if supported by hardware).
static void vp8_release_frame(VP8Context *s, AVFrame *f, int prefer_delayed_free, int can_direct_free)
(only used in prediction) no split MVs
static void update_lf_deltas(VP8Context *s)
This structure describes decoded (raw) audio or video data.
int8_t sign_bias[4]
one state [0, 1] per ref frame type
int coded_width
Bitstream width / height, may be different from width/height.
static av_always_inline int vp8_rac_get_tree(VP56RangeCoder *c, const int8_t(*tree)[2], const uint8_t *probs)
static int vp8_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
static av_always_inline void vp8_mc_chroma(VP8Context *s, VP8ThreadData *td, uint8_t *dst1, uint8_t *dst2, AVFrame *ref, const VP56mv *mv, int x_off, int y_off, int block_w, int block_h, int width, int height, int linesize, vp8_mc_func mc_func[3][3])
chroma MC function
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.
void(* vp8_v_loop_filter16y)(uint8_t *dst, ptrdiff_t stride, int flim_E, int flim_I, int hev_thresh)
static void release_queued_segmaps(VP8Context *s, int is_close)
uint8_t token[4][16][3][NUM_DCT_TOKENS-1]
void avcodec_set_dimensions(AVCodecContext *s, int width, int height)
static av_always_inline int check_intra_pred4x4_mode_emuedge(int mode, int mb_x, int mb_y, int *copy_buf)
static void vp8_decode_flush(AVCodecContext *avctx)
vp8_mc_func put_vp8_bilinear_pixels_tab[3][3][3]
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
static const int8_t vp8_pred8x8c_tree[3][2]
static av_always_inline int check_intra_pred8x8_mode(int mode, int mb_x, int mb_y)
int update_probabilities
If this flag is not set, all the probability updates are discarded after this frame is decoded...
static av_always_inline void filter_level_for_mb(VP8Context *s, VP8Macroblock *mb, VP8FilterStrength *f)
static const uint8_t zigzag_scan[16]
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...
void av_freep(void *arg)
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 const uint8_t vp8_mbsplits[5][16]
enum AVDiscard skip_frame
static const int8_t vp8_pred16x16_tree_intra[4][2]
static av_always_inline void decode_mvs(VP8Context *s, VP8Macroblock *mb, int mb_x, int mb_y, int layout)
void(* emulated_edge_mc)(uint8_t *buf, const uint8_t *src, ptrdiff_t 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 int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
struct VP8Context::@62 filter
int update_golden
VP56_FRAME_NONE if not updated, or which frame to copy if so.
#define FFSWAP(type, a, b)
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)
struct VP8DecoderContext VP8Context
static void pthread_cond_init(pthread_cond_t *cond, const void *unused_attr)
#define TM_VP8_PRED
"True Motion", used instead of plane
av_cold void ff_vp8dsp_init(VP8DSPContext *dsp)
struct VP8Context::@61 segmentation
Base parameters for segmentation, i.e.
#define DIAG_DOWN_LEFT_PRED
void(* vp8_h_loop_filter8uv_inner)(uint8_t *dstU, uint8_t *dstV, ptrdiff_t stride, int flim_E, int flim_I, int hev_thresh)
static const uint8_t vp8_mv_update_prob[2][19]
void(* pred8x8[4+3+4])(uint8_t *src, ptrdiff_t stride)
int update_last
update VP56_FRAME_PREVIOUS with the current one
static int update_dimensions(VP8Context *s, int width, int height)
static av_always_inline int decode_block_coeffs(VP56RangeCoder *c, DCTELEM block[16], uint8_t probs[16][3][NUM_DCT_TOKENS-1], int i, int zero_nhood, int16_t qmul[2])
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(* pred4x4[9+3+3])(uint8_t *src, const uint8_t *topright, ptrdiff_t stride)
uint8_t intra4x4_pred_mode_mb[16]
static int init(AVCodecParserContext *s)
uint8_t intra4x4_pred_mode_left[4]
#define VERT_VP8_PRED
for VP8, VERT_PRED is the average of
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 vp8_mbsplit_count[4]
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 const int8_t vp8_coeff_band_indexes[8][10]
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
static const uint8_t vp8_pred4x4_mode[]
void(* vp8_idct_dc_add)(uint8_t *dst, DCTELEM block[16], ptrdiff_t stride)
static av_always_inline void prefetch_motion(VP8Context *s, VP8Macroblock *mb, int mb_x, int mb_y, int mb_xy, int ref)
void(* vp8_luma_dc_wht)(DCTELEM block[4][4][16], DCTELEM dc[16])
static const uint8_t vp8_dct_cat2_prob[]
Multithreading support functions.
static const uint8_t vp8_mv_default_prob[2][19]
static void vp8_decode_mb_row_no_filter(AVCodecContext *avctx, void *tdata, int jobnr, int threadnr)
static const int sizes[][2]
int is_copy
Whether the parent AVCodecContext is a copy of the context which had init() called on it...
void(* vp8_h_loop_filter8uv)(uint8_t *dstU, uint8_t *dstV, ptrdiff_t stride, int flim_E, int flim_I, int hev_thresh)
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. ...
int active_thread_type
Which multithreading methods are in use by the codec.
VP8 compatible video decoder.
void(* vp8_v_loop_filter8uv)(uint8_t *dstU, uint8_t *dstV, ptrdiff_t stride, int flim_E, int flim_I, int hev_thresh)
static const uint8_t vp8_mbfirstidx[4][16]
void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
void av_log(void *avcl, int level, const char *fmt,...)
const char * name
Name of the codec implementation.
VP8Macroblock * macroblocks_base
static av_always_inline void vp8_mc_part(VP8Context *s, VP8ThreadData *td, uint8_t *dst[3], AVFrame *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]
#define CODEC_FLAG_EMU_EDGE
static void vp8_filter_mb_row(AVCodecContext *avctx, void *tdata, int jobnr, int threadnr)
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])
static int decode_block_coeffs_internal(VP56RangeCoder *r, DCTELEM block[16], uint8_t probs[16][3][NUM_DCT_TOKENS-1], int i, uint8_t *token_prob, int16_t qmul[2])
static av_always_inline void vp8_mc_luma(VP8Context *s, VP8ThreadData *td, uint8_t *dst, AVFrame *ref, const VP56mv *mv, int x_off, int y_off, int block_w, int block_h, int width, int height, int linesize, vp8_mc_func mc_func[3][3])
luma MC function
#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]
struct VP8Context::@65 prob[2]
These are all of the updatable probabilities for binary decisions.
useful rectangle filling function
static int pthread_mutex_destroy(pthread_mutex_t *m)
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
static int read_mv_component(VP56RangeCoder *c, const uint8_t *p)
Motion vector coding, 17.1.
static int vp8_alloc_frame(VP8Context *s, AVFrame *f)
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...
#define CODEC_CAP_FRAME_THREADS
static void free_buffers(VP8Context *s)
#define check_thread_pos(td, otd, mb_x_check, mb_y_check)
static void vp8_decode_mv_mb_modes(AVCodecContext *avctx, AVFrame *curframe, AVFrame *prev_frame)
struct VP8Context::@63 qmat[4]
Macroblocks can have one of 4 different quants in a frame when segmentation is enabled.
static av_unused int vp8_rac_get_uint(VP56RangeCoder *c, int bits)
void(* vp8_mc_func)(uint8_t *dst, ptrdiff_t dstStride, uint8_t *src, ptrdiff_t srcStride, int h, int x, int y)
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]
uint8_t * edge_emu_buffer
#define vp56_rac_get_prob
static av_always_inline void filter_mb(VP8Context *s, uint8_t *dst[3], VP8FilterStrength *f, int mb_x, int mb_y)
#define VERT_PRED
Prediction types.
#define DIAG_DOWN_RIGHT_PRED
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
static const int8_t mv[256][2]
static av_always_inline int vp56_rac_get_prob_branchy(VP56RangeCoder *c, int prob)
void(* vp8_v_loop_filter8uv_inner)(uint8_t *dstU, uint8_t *dstV, ptrdiff_t stride, int flim_E, int flim_I, int hev_thresh)
void(* vp8_h_loop_filter_simple)(uint8_t *dst, ptrdiff_t stride, int flim)
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 ff_thread_await_progress(AVFrame *f, int n, int field)
Wait for earlier decoding threads to finish reference pictures.
int linesize[AV_NUM_DATA_POINTERS]
Size, in bytes, of the data for each picture/channel plane.
static void pthread_cond_destroy(pthread_cond_t *cond)
main external API structure.
static void close(AVCodecParserContext *s)
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)
#define FF_ARRAY_ELEMS(a)
VP8FilterStrength * filter_strength
void av_log_missing_feature(void *avc, const char *feature, int want_sample)
Log a generic warning message about a missing feature.
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 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)
void(* vp8_luma_dc_wht_dc)(DCTELEM block[4][4][16], DCTELEM dc[16])
int8_t * ref_index[2]
motion reference frame index the order in which these are stored can depend on the codec...
static const uint8_t subpel_idx[3][8]
void(* vp8_idct_dc_add4y)(uint8_t *dst, DCTELEM block[4][16], ptrdiff_t stride)
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]
uint8_t * segmentation_maps[5]
A list of segmentation_map buffers that are to be free()'ed in the next decoding iteration.
static const uint16_t vp8_ac_qlookup[VP8_MAX_QUANT+1]
static av_cold int vp8_decode_init(AVCodecContext *avctx)
static const uint8_t vp8_pred16x16_prob_intra[4]
static const int8_t vp8_segmentid_tree[][2]
#define CODEC_CAP_SLICE_THREADS
static av_always_inline void decode_intra4x4_modes(VP8Context *s, VP56RangeCoder *c, VP8Macroblock *mb, int mb_x, int keyframe, int layout)
void(* vp8_h_loop_filter16y_inner)(uint8_t *dst, ptrdiff_t stride, int flim_E, int flim_I, int hev_thresh)
void(* vp8_idct_add)(uint8_t *dst, DCTELEM block[16], ptrdiff_t stride)
void ff_vp56_init_range_decoder(VP56RangeCoder *c, const uint8_t *buf, int buf_size)
#define DECLARE_ALIGNED(n, t, v)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
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)
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)
discard all non reference
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
void(* vp8_v_loop_filter_simple)(uint8_t *dst, ptrdiff_t stride, int flim)
common internal api header.
static av_cold void flush(AVCodecContext *avctx)
Flush (reset) the frame ID after seeking.
#define AVERROR_INVALIDDATA
static av_cold int vp8_decode_init_thread_copy(AVCodecContext *avctx)
static av_always_inline int check_tm_pred4x4_mode(int mode, int mb_x, int mb_y)
enum AVDiscard skip_loop_filter
static av_always_inline int vp8_rac_get(VP56RangeCoder *c)
static const SiprModeParam modes[MODE_COUNT]
static av_always_inline int check_intra_pred8x8_mode_emuedge(int mode, int mb_x, int mb_y)
void(* vp8_h_loop_filter16y)(uint8_t *dst, ptrdiff_t stride, int flim_E, int flim_I, int hev_thresh)
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)
struct AVCodecInternal * internal
Private context used for internal data.
static av_always_inline void intra_predict(VP8Context *s, VP8ThreadData *td, uint8_t *dst[3], VP8Macroblock *mb, int mb_x, int mb_y)
#define HOR_VP8_PRED
unaveraged version of HOR_PRED, see
void(* vp8_idct_dc_add4uv)(uint8_t *dst, DCTELEM block[4][16], ptrdiff_t stride)
static av_always_inline int decode_splitmvs(VP8Context *s, VP56RangeCoder *c, VP8Macroblock *mb, int layout)
Split motion vector prediction, 16.4.
static av_always_inline int check_tm_pred8x8_mode(int mode, int mb_x, int mb_y)
static av_unused int vp8_rac_get_nn(VP56RangeCoder *c)
void(* vp8_v_loop_filter16y_inner)(uint8_t *dst, ptrdiff_t stride, int flim_E, int flim_I, int hev_thresh)
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)
static const uint8_t vp8_token_update_probs[4][8][3][NUM_DCT_TOKENS-1]
int8_t filter_level[4]
base loop filter level
static const int vp8_mode_contexts[6][4]
static int vp8_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
static const uint8_t vp8_dct_cat1_prob[]
void ff_thread_report_progress(AVFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f)
Wrapper around get_buffer() for frame-multithreaded codecs.
static av_always_inline const uint8_t * get_submv_prob(uint32_t left, uint32_t top)
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...
This structure stores compressed data.
const uint8_t *const ff_vp8_dct_cat_prob[]
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
VP8ThreadData * thread_data
void ff_thread_release_buffer(AVCodecContext *avctx, AVFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
static av_always_inline void filter_mb_simple(VP8Context *s, uint8_t *dst, VP8FilterStrength *f, int mb_x, int mb_y)
struct VP8Context::@64 lf_delta
static av_cold int vp8_decode_free(AVCodecContext *avctx)
if(!(ptr_align%ac->ptr_align)&&samples_align >=aligned_len)