lavc/vp9: split into vp9{block,data,mvs}
[ffmpeg.git] / libavcodec / vp9mvs.c
1 /*
2  * VP9 compatible video decoder
3  *
4  * Copyright (C) 2013 Ronald S. Bultje <rsbultje gmail com>
5  * Copyright (C) 2013 Clément Bœsch <u pkh me>
6  *
7  * This file is part of FFmpeg.
8  *
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.
13  *
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.
18  *
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
22  */
23
24 #include "internal.h"
25 #include "vp56.h"
26 #include "vp9.h"
27 #include "vp9data.h"
28
29 static av_always_inline void clamp_mv(VP56mv *dst, const VP56mv *src,
30                                       VP9Context *s)
31 {
32     dst->x = av_clip(src->x, s->min_mv.x, s->max_mv.x);
33     dst->y = av_clip(src->y, s->min_mv.y, s->max_mv.y);
34 }
35
36 static void find_ref_mvs(VP9Context *s,
37                          VP56mv *pmv, int ref, int z, int idx, int sb)
38 {
39     static const int8_t mv_ref_blk_off[N_BS_SIZES][8][2] = {
40         [BS_64x64] = {{  3, -1 }, { -1,  3 }, {  4, -1 }, { -1,  4 },
41                       { -1, -1 }, {  0, -1 }, { -1,  0 }, {  6, -1 }},
42         [BS_64x32] = {{  0, -1 }, { -1,  0 }, {  4, -1 }, { -1,  2 },
43                       { -1, -1 }, {  0, -3 }, { -3,  0 }, {  2, -1 }},
44         [BS_32x64] = {{ -1,  0 }, {  0, -1 }, { -1,  4 }, {  2, -1 },
45                       { -1, -1 }, { -3,  0 }, {  0, -3 }, { -1,  2 }},
46         [BS_32x32] = {{  1, -1 }, { -1,  1 }, {  2, -1 }, { -1,  2 },
47                       { -1, -1 }, {  0, -3 }, { -3,  0 }, { -3, -3 }},
48         [BS_32x16] = {{  0, -1 }, { -1,  0 }, {  2, -1 }, { -1, -1 },
49                       { -1,  1 }, {  0, -3 }, { -3,  0 }, { -3, -3 }},
50         [BS_16x32] = {{ -1,  0 }, {  0, -1 }, { -1,  2 }, { -1, -1 },
51                       {  1, -1 }, { -3,  0 }, {  0, -3 }, { -3, -3 }},
52         [BS_16x16] = {{  0, -1 }, { -1,  0 }, {  1, -1 }, { -1,  1 },
53                       { -1, -1 }, {  0, -3 }, { -3,  0 }, { -3, -3 }},
54         [BS_16x8]  = {{  0, -1 }, { -1,  0 }, {  1, -1 }, { -1, -1 },
55                       {  0, -2 }, { -2,  0 }, { -2, -1 }, { -1, -2 }},
56         [BS_8x16]  = {{ -1,  0 }, {  0, -1 }, { -1,  1 }, { -1, -1 },
57                       { -2,  0 }, {  0, -2 }, { -1, -2 }, { -2, -1 }},
58         [BS_8x8]   = {{  0, -1 }, { -1,  0 }, { -1, -1 }, {  0, -2 },
59                       { -2,  0 }, { -1, -2 }, { -2, -1 }, { -2, -2 }},
60         [BS_8x4]   = {{  0, -1 }, { -1,  0 }, { -1, -1 }, {  0, -2 },
61                       { -2,  0 }, { -1, -2 }, { -2, -1 }, { -2, -2 }},
62         [BS_4x8]   = {{  0, -1 }, { -1,  0 }, { -1, -1 }, {  0, -2 },
63                       { -2,  0 }, { -1, -2 }, { -2, -1 }, { -2, -2 }},
64         [BS_4x4]   = {{  0, -1 }, { -1,  0 }, { -1, -1 }, {  0, -2 },
65                       { -2,  0 }, { -1, -2 }, { -2, -1 }, { -2, -2 }},
66     };
67     VP9Block *b = s->b;
68     int row = s->row, col = s->col, row7 = s->row7;
69     const int8_t (*p)[2] = mv_ref_blk_off[b->bs];
70 #define INVALID_MV 0x80008000U
71     uint32_t mem = INVALID_MV, mem_sub8x8 = INVALID_MV;
72     int i;
73
74 #define RETURN_DIRECT_MV(mv) \
75     do { \
76         uint32_t m = AV_RN32A(&mv); \
77         if (!idx) { \
78             AV_WN32A(pmv, m); \
79             return; \
80         } else if (mem == INVALID_MV) { \
81             mem = m; \
82         } else if (m != mem) { \
83             AV_WN32A(pmv, m); \
84             return; \
85         } \
86     } while (0)
87
88     if (sb >= 0) {
89         if (sb == 2 || sb == 1) {
90             RETURN_DIRECT_MV(b->mv[0][z]);
91         } else if (sb == 3) {
92             RETURN_DIRECT_MV(b->mv[2][z]);
93             RETURN_DIRECT_MV(b->mv[1][z]);
94             RETURN_DIRECT_MV(b->mv[0][z]);
95         }
96
97 #define RETURN_MV(mv) \
98     do { \
99         if (sb > 0) { \
100             VP56mv tmp; \
101             uint32_t m; \
102             av_assert2(idx == 1); \
103             av_assert2(mem != INVALID_MV); \
104             if (mem_sub8x8 == INVALID_MV) { \
105                 clamp_mv(&tmp, &mv, s); \
106                 m = AV_RN32A(&tmp); \
107                 if (m != mem) { \
108                     AV_WN32A(pmv, m); \
109                     return; \
110                 } \
111                 mem_sub8x8 = AV_RN32A(&mv); \
112             } else if (mem_sub8x8 != AV_RN32A(&mv)) { \
113                 clamp_mv(&tmp, &mv, s); \
114                 m = AV_RN32A(&tmp); \
115                 if (m != mem) { \
116                     AV_WN32A(pmv, m); \
117                 } else { \
118                     /* BUG I'm pretty sure this isn't the intention */ \
119                     AV_WN32A(pmv, 0); \
120                 } \
121                 return; \
122             } \
123         } else { \
124             uint32_t m = AV_RN32A(&mv); \
125             if (!idx) { \
126                 clamp_mv(pmv, &mv, s); \
127                 return; \
128             } else if (mem == INVALID_MV) { \
129                 mem = m; \
130             } else if (m != mem) { \
131                 clamp_mv(pmv, &mv, s); \
132                 return; \
133             } \
134         } \
135     } while (0)
136
137         if (row > 0) {
138             struct VP9mvrefPair *mv = &s->s.frames[CUR_FRAME].mv[(row - 1) * s->sb_cols * 8 + col];
139             if (mv->ref[0] == ref) {
140                 RETURN_MV(s->above_mv_ctx[2 * col + (sb & 1)][0]);
141             } else if (mv->ref[1] == ref) {
142                 RETURN_MV(s->above_mv_ctx[2 * col + (sb & 1)][1]);
143             }
144         }
145         if (col > s->tile_col_start) {
146             struct VP9mvrefPair *mv = &s->s.frames[CUR_FRAME].mv[row * s->sb_cols * 8 + col - 1];
147             if (mv->ref[0] == ref) {
148                 RETURN_MV(s->left_mv_ctx[2 * row7 + (sb >> 1)][0]);
149             } else if (mv->ref[1] == ref) {
150                 RETURN_MV(s->left_mv_ctx[2 * row7 + (sb >> 1)][1]);
151             }
152         }
153         i = 2;
154     } else {
155         i = 0;
156     }
157
158     // previously coded MVs in this neighbourhood, using same reference frame
159     for (; i < 8; i++) {
160         int c = p[i][0] + col, r = p[i][1] + row;
161
162         if (c >= s->tile_col_start && c < s->cols && r >= 0 && r < s->rows) {
163             struct VP9mvrefPair *mv = &s->s.frames[CUR_FRAME].mv[r * s->sb_cols * 8 + c];
164
165             if (mv->ref[0] == ref) {
166                 RETURN_MV(mv->mv[0]);
167             } else if (mv->ref[1] == ref) {
168                 RETURN_MV(mv->mv[1]);
169             }
170         }
171     }
172
173     // MV at this position in previous frame, using same reference frame
174     if (s->s.h.use_last_frame_mvs) {
175         struct VP9mvrefPair *mv = &s->s.frames[REF_FRAME_MVPAIR].mv[row * s->sb_cols * 8 + col];
176
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]);
183         }
184     }
185
186 #define RETURN_SCALE_MV(mv, scale) \
187     do { \
188         if (scale) { \
189             VP56mv mv_temp = { -mv.x, -mv.y }; \
190             RETURN_MV(mv_temp); \
191         } else { \
192             RETURN_MV(mv); \
193         } \
194     } while (0)
195
196     // previously coded MVs in this neighbourhood, using different reference frame
197     for (i = 0; i < 8; i++) {
198         int c = p[i][0] + col, r = p[i][1] + row;
199
200         if (c >= s->tile_col_start && c < s->cols && r >= 0 && r < s->rows) {
201             struct VP9mvrefPair *mv = &s->s.frames[CUR_FRAME].mv[r * s->sb_cols * 8 + c];
202
203             if (mv->ref[0] != ref && mv->ref[0] >= 0) {
204                 RETURN_SCALE_MV(mv->mv[0], s->s.h.signbias[mv->ref[0]] != s->s.h.signbias[ref]);
205             }
206             if (mv->ref[1] != ref && mv->ref[1] >= 0 &&
207                 // BUG - libvpx has this condition regardless of whether
208                 // we used the first ref MV and pre-scaling
209                 AV_RN32A(&mv->mv[0]) != AV_RN32A(&mv->mv[1])) {
210                 RETURN_SCALE_MV(mv->mv[1], s->s.h.signbias[mv->ref[1]] != s->s.h.signbias[ref]);
211             }
212         }
213     }
214
215     // MV at this position in previous frame, using different reference frame
216     if (s->s.h.use_last_frame_mvs) {
217         struct VP9mvrefPair *mv = &s->s.frames[REF_FRAME_MVPAIR].mv[row * s->sb_cols * 8 + col];
218
219         // no need to await_progress, because we already did that above
220         if (mv->ref[0] != ref && mv->ref[0] >= 0) {
221             RETURN_SCALE_MV(mv->mv[0], s->s.h.signbias[mv->ref[0]] != s->s.h.signbias[ref]);
222         }
223         if (mv->ref[1] != ref && mv->ref[1] >= 0 &&
224             // BUG - libvpx has this condition regardless of whether
225             // we used the first ref MV and pre-scaling
226             AV_RN32A(&mv->mv[0]) != AV_RN32A(&mv->mv[1])) {
227             RETURN_SCALE_MV(mv->mv[1], s->s.h.signbias[mv->ref[1]] != s->s.h.signbias[ref]);
228         }
229     }
230
231     AV_ZERO32(pmv);
232     clamp_mv(pmv, pmv, s);
233 #undef INVALID_MV
234 #undef RETURN_MV
235 #undef RETURN_SCALE_MV
236 }
237
238 static av_always_inline int read_mv_component(VP9Context *s, int idx, int hp)
239 {
240     int bit, sign = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].sign);
241     int n, c = vp8_rac_get_tree(&s->c, ff_vp9_mv_class_tree,
242                                 s->prob.p.mv_comp[idx].classes);
243
244     s->counts.mv_comp[idx].sign[sign]++;
245     s->counts.mv_comp[idx].classes[c]++;
246     if (c) {
247         int m;
248
249         for (n = 0, m = 0; m < c; m++) {
250             bit = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].bits[m]);
251             n |= bit << m;
252             s->counts.mv_comp[idx].bits[m][bit]++;
253         }
254         n <<= 3;
255         bit = vp8_rac_get_tree(&s->c, ff_vp9_mv_fp_tree, s->prob.p.mv_comp[idx].fp);
256         n |= bit << 1;
257         s->counts.mv_comp[idx].fp[bit]++;
258         if (hp) {
259             bit = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].hp);
260             s->counts.mv_comp[idx].hp[bit]++;
261             n |= bit;
262         } else {
263             n |= 1;
264             // bug in libvpx - we count for bw entropy purposes even if the
265             // bit wasn't coded
266             s->counts.mv_comp[idx].hp[1]++;
267         }
268         n += 8 << c;
269     } else {
270         n = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].class0);
271         s->counts.mv_comp[idx].class0[n]++;
272         bit = vp8_rac_get_tree(&s->c, ff_vp9_mv_fp_tree,
273                                s->prob.p.mv_comp[idx].class0_fp[n]);
274         s->counts.mv_comp[idx].class0_fp[n][bit]++;
275         n = (n << 3) | (bit << 1);
276         if (hp) {
277             bit = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].class0_hp);
278             s->counts.mv_comp[idx].class0_hp[bit]++;
279             n |= bit;
280         } else {
281             n |= 1;
282             // bug in libvpx - we count for bw entropy purposes even if the
283             // bit wasn't coded
284             s->counts.mv_comp[idx].class0_hp[1]++;
285         }
286     }
287
288     return sign ? -(n + 1) : (n + 1);
289 }
290
291 void ff_vp9_fill_mv(VP9Context *s, VP56mv *mv, int mode, int sb)
292 {
293     VP9Block *b = s->b;
294
295     if (mode == ZEROMV) {
296         AV_ZERO64(mv);
297     } else {
298         int hp;
299
300         // FIXME cache this value and reuse for other subblocks
301         find_ref_mvs(s, &mv[0], b->ref[0], 0, mode == NEARMV,
302                      mode == NEWMV ? -1 : sb);
303         // FIXME maybe move this code into find_ref_mvs()
304         if ((mode == NEWMV || sb == -1) &&
305             !(hp = s->s.h.highprecisionmvs && abs(mv[0].x) < 64 && abs(mv[0].y) < 64)) {
306             if (mv[0].y & 1) {
307                 if (mv[0].y < 0)
308                     mv[0].y++;
309                 else
310                     mv[0].y--;
311             }
312             if (mv[0].x & 1) {
313                 if (mv[0].x < 0)
314                     mv[0].x++;
315                 else
316                     mv[0].x--;
317             }
318         }
319         if (mode == NEWMV) {
320             enum MVJoint j = vp8_rac_get_tree(&s->c, ff_vp9_mv_joint_tree,
321                                               s->prob.p.mv_joint);
322
323             s->counts.mv_joint[j]++;
324             if (j >= MV_JOINT_V)
325                 mv[0].y += read_mv_component(s, 0, hp);
326             if (j & 1)
327                 mv[0].x += read_mv_component(s, 1, hp);
328         }
329
330         if (b->comp) {
331             // FIXME cache this value and reuse for other subblocks
332             find_ref_mvs(s, &mv[1], b->ref[1], 1, mode == NEARMV,
333                          mode == NEWMV ? -1 : sb);
334             if ((mode == NEWMV || sb == -1) &&
335                 !(hp = s->s.h.highprecisionmvs && abs(mv[1].x) < 64 && abs(mv[1].y) < 64)) {
336                 if (mv[1].y & 1) {
337                     if (mv[1].y < 0)
338                         mv[1].y++;
339                     else
340                         mv[1].y--;
341                 }
342                 if (mv[1].x & 1) {
343                     if (mv[1].x < 0)
344                         mv[1].x++;
345                     else
346                         mv[1].x--;
347                 }
348             }
349             if (mode == NEWMV) {
350                 enum MVJoint j = vp8_rac_get_tree(&s->c, ff_vp9_mv_joint_tree,
351                                                   s->prob.p.mv_joint);
352
353                 s->counts.mv_joint[j]++;
354                 if (j >= MV_JOINT_V)
355                     mv[1].y += read_mv_component(s, 0, hp);
356                 if (j & 1)
357                     mv[1].x += read_mv_component(s, 1, hp);
358             }
359         }
360     }
361 }