2 * VP9 compatible video decoder
4 * Copyright (C) 2013 Ronald S. Bultje <rsbultje gmail com>
5 * Copyright (C) 2013 Clément Bœsch <u pkh me>
7 * This file is part of FFmpeg.
9 * FFmpeg is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * FFmpeg is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with FFmpeg; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30 static av_always_inline void clamp_mv(VP56mv *dst, const VP56mv *src,
33 dst->x = av_clip(src->x, td->min_mv.x, td->max_mv.x);
34 dst->y = av_clip(src->y, td->min_mv.y, td->max_mv.y);
37 static void find_ref_mvs(VP9TileData *td,
38 VP56mv *pmv, int ref, int z, int idx, int sb)
40 static const int8_t mv_ref_blk_off[N_BS_SIZES][8][2] = {
41 [BS_64x64] = { { 3, -1 }, { -1, 3 }, { 4, -1 }, { -1, 4 },
42 { -1, -1 }, { 0, -1 }, { -1, 0 }, { 6, -1 } },
43 [BS_64x32] = { { 0, -1 }, { -1, 0 }, { 4, -1 }, { -1, 2 },
44 { -1, -1 }, { 0, -3 }, { -3, 0 }, { 2, -1 } },
45 [BS_32x64] = { { -1, 0 }, { 0, -1 }, { -1, 4 }, { 2, -1 },
46 { -1, -1 }, { -3, 0 }, { 0, -3 }, { -1, 2 } },
47 [BS_32x32] = { { 1, -1 }, { -1, 1 }, { 2, -1 }, { -1, 2 },
48 { -1, -1 }, { 0, -3 }, { -3, 0 }, { -3, -3 } },
49 [BS_32x16] = { { 0, -1 }, { -1, 0 }, { 2, -1 }, { -1, -1 },
50 { -1, 1 }, { 0, -3 }, { -3, 0 }, { -3, -3 } },
51 [BS_16x32] = { { -1, 0 }, { 0, -1 }, { -1, 2 }, { -1, -1 },
52 { 1, -1 }, { -3, 0 }, { 0, -3 }, { -3, -3 } },
53 [BS_16x16] = { { 0, -1 }, { -1, 0 }, { 1, -1 }, { -1, 1 },
54 { -1, -1 }, { 0, -3 }, { -3, 0 }, { -3, -3 } },
55 [BS_16x8] = { { 0, -1 }, { -1, 0 }, { 1, -1 }, { -1, -1 },
56 { 0, -2 }, { -2, 0 }, { -2, -1 }, { -1, -2 } },
57 [BS_8x16] = { { -1, 0 }, { 0, -1 }, { -1, 1 }, { -1, -1 },
58 { -2, 0 }, { 0, -2 }, { -1, -2 }, { -2, -1 } },
59 [BS_8x8] = { { 0, -1 }, { -1, 0 }, { -1, -1 }, { 0, -2 },
60 { -2, 0 }, { -1, -2 }, { -2, -1 }, { -2, -2 } },
61 [BS_8x4] = { { 0, -1 }, { -1, 0 }, { -1, -1 }, { 0, -2 },
62 { -2, 0 }, { -1, -2 }, { -2, -1 }, { -2, -2 } },
63 [BS_4x8] = { { 0, -1 }, { -1, 0 }, { -1, -1 }, { 0, -2 },
64 { -2, 0 }, { -1, -2 }, { -2, -1 }, { -2, -2 } },
65 [BS_4x4] = { { 0, -1 }, { -1, 0 }, { -1, -1 }, { 0, -2 },
66 { -2, 0 }, { -1, -2 }, { -2, -1 }, { -2, -2 } },
68 VP9Context *s = td->s;
70 int row = td->row, col = td->col, row7 = td->row7;
71 const int8_t (*p)[2] = mv_ref_blk_off[b->bs];
72 #define INVALID_MV 0x80008000U
73 uint32_t mem = INVALID_MV, mem_sub8x8 = INVALID_MV;
76 #define RETURN_DIRECT_MV(mv) \
78 uint32_t m = AV_RN32A(&mv); \
82 } else if (mem == INVALID_MV) { \
84 } else if (m != mem) { \
91 if (sb == 2 || sb == 1) {
92 RETURN_DIRECT_MV(b->mv[0][z]);
94 RETURN_DIRECT_MV(b->mv[2][z]);
95 RETURN_DIRECT_MV(b->mv[1][z]);
96 RETURN_DIRECT_MV(b->mv[0][z]);
99 #define RETURN_MV(mv) \
104 av_assert2(idx == 1); \
105 av_assert2(mem != INVALID_MV); \
106 if (mem_sub8x8 == INVALID_MV) { \
107 clamp_mv(&tmp, &mv, td); \
108 m = AV_RN32A(&tmp); \
113 mem_sub8x8 = AV_RN32A(&mv); \
114 } else if (mem_sub8x8 != AV_RN32A(&mv)) { \
115 clamp_mv(&tmp, &mv, td); \
116 m = AV_RN32A(&tmp); \
120 /* BUG I'm pretty sure this isn't the intention */ \
126 uint32_t m = AV_RN32A(&mv); \
128 clamp_mv(pmv, &mv, td); \
130 } else if (mem == INVALID_MV) { \
132 } else if (m != mem) { \
133 clamp_mv(pmv, &mv, td); \
140 VP9mvrefPair *mv = &s->s.frames[CUR_FRAME].mv[(row - 1) * s->sb_cols * 8 + col];
141 if (mv->ref[0] == ref)
142 RETURN_MV(s->above_mv_ctx[2 * col + (sb & 1)][0]);
143 else if (mv->ref[1] == ref)
144 RETURN_MV(s->above_mv_ctx[2 * col + (sb & 1)][1]);
146 if (col > td->tile_col_start) {
147 VP9mvrefPair *mv = &s->s.frames[CUR_FRAME].mv[row * s->sb_cols * 8 + col - 1];
148 if (mv->ref[0] == ref)
149 RETURN_MV(td->left_mv_ctx[2 * row7 + (sb >> 1)][0]);
150 else if (mv->ref[1] == ref)
151 RETURN_MV(td->left_mv_ctx[2 * row7 + (sb >> 1)][1]);
158 // previously coded MVs in this neighborhood, using same reference frame
160 int c = p[i][0] + col, r = p[i][1] + row;
162 if (c >= td->tile_col_start && c < s->cols &&
163 r >= 0 && r < s->rows) {
164 VP9mvrefPair *mv = &s->s.frames[CUR_FRAME].mv[r * s->sb_cols * 8 + c];
166 if (mv->ref[0] == ref)
167 RETURN_MV(mv->mv[0]);
168 else if (mv->ref[1] == ref)
169 RETURN_MV(mv->mv[1]);
173 // MV at this position in previous frame, using same reference frame
174 if (s->s.h.use_last_frame_mvs) {
175 VP9mvrefPair *mv = &s->s.frames[REF_FRAME_MVPAIR].mv[row * s->sb_cols * 8 + col];
177 if (!s->s.frames[REF_FRAME_MVPAIR].uses_2pass)
178 ff_thread_await_progress(&s->s.frames[REF_FRAME_MVPAIR].tf, row >> 3, 0);
179 if (mv->ref[0] == ref)
180 RETURN_MV(mv->mv[0]);
181 else if (mv->ref[1] == ref)
182 RETURN_MV(mv->mv[1]);
185 #define RETURN_SCALE_MV(mv, scale) \
188 VP56mv mv_temp = { -mv.x, -mv.y }; \
189 RETURN_MV(mv_temp); \
195 // previously coded MVs in this neighborhood, using different reference frame
196 for (i = 0; i < 8; i++) {
197 int c = p[i][0] + col, r = p[i][1] + row;
199 if (c >= td->tile_col_start && c < s->cols && r >= 0 && r < s->rows) {
200 VP9mvrefPair *mv = &s->s.frames[CUR_FRAME].mv[r * s->sb_cols * 8 + c];
202 if (mv->ref[0] != ref && mv->ref[0] >= 0)
203 RETURN_SCALE_MV(mv->mv[0],
204 s->s.h.signbias[mv->ref[0]] != s->s.h.signbias[ref]);
205 if (mv->ref[1] != ref && mv->ref[1] >= 0 &&
206 // BUG - libvpx has this condition regardless of whether
207 // we used the first ref MV and pre-scaling
208 AV_RN32A(&mv->mv[0]) != AV_RN32A(&mv->mv[1])) {
209 RETURN_SCALE_MV(mv->mv[1], s->s.h.signbias[mv->ref[1]] != s->s.h.signbias[ref]);
214 // MV at this position in previous frame, using different reference frame
215 if (s->s.h.use_last_frame_mvs) {
216 VP9mvrefPair *mv = &s->s.frames[REF_FRAME_MVPAIR].mv[row * s->sb_cols * 8 + col];
218 // no need to await_progress, because we already did that above
219 if (mv->ref[0] != ref && mv->ref[0] >= 0)
220 RETURN_SCALE_MV(mv->mv[0], s->s.h.signbias[mv->ref[0]] != s->s.h.signbias[ref]);
221 if (mv->ref[1] != ref && mv->ref[1] >= 0 &&
222 // BUG - libvpx has this condition regardless of whether
223 // we used the first ref MV and pre-scaling
224 AV_RN32A(&mv->mv[0]) != AV_RN32A(&mv->mv[1])) {
225 RETURN_SCALE_MV(mv->mv[1], s->s.h.signbias[mv->ref[1]] != s->s.h.signbias[ref]);
230 clamp_mv(pmv, pmv, td);
233 #undef RETURN_SCALE_MV
236 static av_always_inline int read_mv_component(VP9TileData *td, int idx, int hp)
238 VP9Context *s = td->s;
239 int bit, sign = vp56_rac_get_prob(td->c, s->prob.p.mv_comp[idx].sign);
240 int n, c = vp8_rac_get_tree(td->c, ff_vp9_mv_class_tree,
241 s->prob.p.mv_comp[idx].classes);
243 td->counts.mv_comp[idx].sign[sign]++;
244 td->counts.mv_comp[idx].classes[c]++;
248 for (n = 0, m = 0; m < c; m++) {
249 bit = vp56_rac_get_prob(td->c, s->prob.p.mv_comp[idx].bits[m]);
251 td->counts.mv_comp[idx].bits[m][bit]++;
254 bit = vp8_rac_get_tree(td->c, ff_vp9_mv_fp_tree,
255 s->prob.p.mv_comp[idx].fp);
257 td->counts.mv_comp[idx].fp[bit]++;
259 bit = vp56_rac_get_prob(td->c, s->prob.p.mv_comp[idx].hp);
260 td->counts.mv_comp[idx].hp[bit]++;
264 // bug in libvpx - we count for bw entropy purposes even if the
266 td->counts.mv_comp[idx].hp[1]++;
270 n = vp56_rac_get_prob(td->c, s->prob.p.mv_comp[idx].class0);
271 td->counts.mv_comp[idx].class0[n]++;
272 bit = vp8_rac_get_tree(td->c, ff_vp9_mv_fp_tree,
273 s->prob.p.mv_comp[idx].class0_fp[n]);
274 td->counts.mv_comp[idx].class0_fp[n][bit]++;
275 n = (n << 3) | (bit << 1);
277 bit = vp56_rac_get_prob(td->c, s->prob.p.mv_comp[idx].class0_hp);
278 td->counts.mv_comp[idx].class0_hp[bit]++;
282 // bug in libvpx - we count for bw entropy purposes even if the
284 td->counts.mv_comp[idx].class0_hp[1]++;
288 return sign ? -(n + 1) : (n + 1);
291 void ff_vp9_fill_mv(VP9TileData *td, VP56mv *mv, int mode, int sb)
293 VP9Context *s = td->s;
296 if (mode == ZEROMV) {
301 // FIXME cache this value and reuse for other subblocks
302 find_ref_mvs(td, &mv[0], b->ref[0], 0, mode == NEARMV,
303 mode == NEWMV ? -1 : sb);
304 // FIXME maybe move this code into find_ref_mvs()
305 if ((mode == NEWMV || sb == -1) &&
306 !(hp = s->s.h.highprecisionmvs &&
307 abs(mv[0].x) < 64 && abs(mv[0].y) < 64)) {
322 enum MVJoint j = vp8_rac_get_tree(td->c, ff_vp9_mv_joint_tree,
325 td->counts.mv_joint[j]++;
327 mv[0].y += read_mv_component(td, 0, hp);
329 mv[0].x += read_mv_component(td, 1, hp);
333 // FIXME cache this value and reuse for other subblocks
334 find_ref_mvs(td, &mv[1], b->ref[1], 1, mode == NEARMV,
335 mode == NEWMV ? -1 : sb);
336 if ((mode == NEWMV || sb == -1) &&
337 !(hp = s->s.h.highprecisionmvs &&
338 abs(mv[1].x) < 64 && abs(mv[1].y) < 64)) {
353 enum MVJoint j = vp8_rac_get_tree(td->c, ff_vp9_mv_joint_tree,
356 td->counts.mv_joint[j]++;
358 mv[1].y += read_mv_component(td, 0, hp);
360 mv[1].x += read_mv_component(td, 1, hp);