GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/vp9mvs.c Lines: 150 150 100.0 %
Date: 2020-09-25 14:59:26 Branches: 340 432 78.7 %

Line Branch Exec Source
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
#include "vp9dec.h"
29
30
610499
static av_always_inline void clamp_mv(VP56mv *dst, const VP56mv *src,
31
                                      VP9TileData *td)
32
{
33
610499
    dst->x = av_clip(src->x, td->min_mv.x, td->max_mv.x);
34
610499
    dst->y = av_clip(src->y, td->min_mv.y, td->max_mv.y);
35
610499
}
36
37
629638
static void find_ref_mvs(VP9TileData *td,
38
                         VP56mv *pmv, int ref, int z, int idx, int sb)
39
{
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 } },
67
    };
68
629638
    VP9Context *s = td->s;
69
629638
    VP9Block *b = td->b;
70
629638
    int row = td->row, col = td->col, row7 = td->row7;
71
629638
    const int8_t (*p)[2] = mv_ref_blk_off[b->bs];
72
#define INVALID_MV 0x80008000U
73
629638
    uint32_t mem = INVALID_MV, mem_sub8x8 = INVALID_MV;
74
    int i;
75
76
#define RETURN_DIRECT_MV(mv)                    \
77
    do {                                        \
78
        uint32_t m = AV_RN32A(&mv);             \
79
        if (!idx) {                             \
80
            AV_WN32A(pmv, m);                   \
81
            return;                             \
82
        } else if (mem == INVALID_MV) {         \
83
            mem = m;                            \
84
        } else if (m != mem) {                  \
85
            AV_WN32A(pmv, m);                   \
86
            return;                             \
87
        }                                       \
88
    } while (0)
89
90
629638
    if (sb >= 0) {
91

71719
        if (sb == 2 || sb == 1) {
92

33364
            RETURN_DIRECT_MV(b->mv[0][z]);
93
38355
        } else if (sb == 3) {
94

9994
            RETURN_DIRECT_MV(b->mv[2][z]);
95

3598
            RETURN_DIRECT_MV(b->mv[1][z]);
96

596
            RETURN_DIRECT_MV(b->mv[0][z]);
97
        }
98
99
#define RETURN_MV(mv)                                                  \
100
    do {                                                               \
101
        if (sb > 0) {                                                  \
102
            VP56mv tmp;                                                \
103
            uint32_t m;                                                \
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);                                    \
109
                if (m != mem) {                                        \
110
                    AV_WN32A(pmv, m);                                  \
111
                    return;                                            \
112
                }                                                      \
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);                                    \
117
                if (m != mem) {                                        \
118
                    AV_WN32A(pmv, m);                                  \
119
                } else {                                               \
120
                    /* BUG I'm pretty sure this isn't the intention */ \
121
                    AV_WN32A(pmv, 0);                                  \
122
                }                                                      \
123
                return;                                                \
124
            }                                                          \
125
        } else {                                                       \
126
            uint32_t m = AV_RN32A(&mv);                                \
127
            if (!idx) {                                                \
128
                clamp_mv(pmv, &mv, td);                                \
129
                return;                                                \
130
            } else if (mem == INVALID_MV) {                            \
131
                mem = m;                                               \
132
            } else if (m != mem) {                                     \
133
                clamp_mv(pmv, &mv, td);                                \
134
                return;                                                \
135
            }                                                          \
136
        }                                                              \
137
    } while (0)
138
139
47728
        if (row > 0) {
140
37408
            VP9mvrefPair *mv = &s->s.frames[CUR_FRAME].mv[(row - 1) * s->sb_cols * 8 + col];
141
37408
            if (mv->ref[0] == ref)
142




32790
                RETURN_MV(s->above_mv_ctx[2 * col + (sb & 1)][0]);
143
4618
            else if (mv->ref[1] == ref)
144




677
                RETURN_MV(s->above_mv_ctx[2 * col + (sb & 1)][1]);
145
        }
146
25899
        if (col > td->tile_col_start) {
147
25241
            VP9mvrefPair *mv = &s->s.frames[CUR_FRAME].mv[row * s->sb_cols * 8 + col - 1];
148
25241
            if (mv->ref[0] == ref)
149




22765
                RETURN_MV(td->left_mv_ctx[2 * row7 + (sb >> 1)][0]);
150
2476
            else if (mv->ref[1] == ref)
151




363
                RETURN_MV(td->left_mv_ctx[2 * row7 + (sb >> 1)][1]);
152
        }
153
5616
        i = 2;
154
    } else {
155
557919
        i = 0;
156
    }
157
158
    // previously coded MVs in this neighborhood, using same reference frame
159
986772
    for (; i < 8; i++) {
160
963971
        int c = p[i][0] + col, r = p[i][1] + row;
161
162

963971
        if (c >= td->tile_col_start && c < s->cols &&
163
878874
            r >= 0 && r < s->rows) {
164
878852
            VP9mvrefPair *mv = &s->s.frames[CUR_FRAME].mv[r * s->sb_cols * 8 + c];
165
166
878852
            if (mv->ref[0] == ref)
167




650180
                RETURN_MV(mv->mv[0]);
168
228672
            else if (mv->ref[1] == ref)
169




36239
                RETURN_MV(mv->mv[1]);
170
        }
171
    }
172
173
    // MV at this position in previous frame, using same reference frame
174
22801
    if (s->s.h.use_last_frame_mvs) {
175
21751
        VP9mvrefPair *mv = &s->s.frames[REF_FRAME_MVPAIR].mv[row * s->sb_cols * 8 + col];
176
177
21751
        if (!s->s.frames[REF_FRAME_MVPAIR].uses_2pass)
178
21751
            ff_thread_await_progress(&s->s.frames[REF_FRAME_MVPAIR].tf, row >> 3, 0);
179
21751
        if (mv->ref[0] == ref)
180




9486
            RETURN_MV(mv->mv[0]);
181
12265
        else if (mv->ref[1] == ref)
182




296
            RETURN_MV(mv->mv[1]);
183
    }
184
185
#define RETURN_SCALE_MV(mv, scale)              \
186
    do {                                        \
187
        if (scale) {                            \
188
            VP56mv mv_temp = { -mv.x, -mv.y };  \
189
            RETURN_MV(mv_temp);                 \
190
        } else {                                \
191
            RETURN_MV(mv);                      \
192
        }                                       \
193
    } while (0)
194
195
    // previously coded MVs in this neighborhood, using different reference frame
196
41238
    for (i = 0; i < 8; i++) {
197
38386
        int c = p[i][0] + col, r = p[i][1] + row;
198
199


38386
        if (c >= td->tile_col_start && c < s->cols && r >= 0 && r < s->rows) {
200
23724
            VP9mvrefPair *mv = &s->s.frames[CUR_FRAME].mv[r * s->sb_cols * 8 + c];
201
202

23724
            if (mv->ref[0] != ref && mv->ref[0] >= 0)
203








12406
                RETURN_SCALE_MV(mv->mv[0],
204
                                s->s.h.signbias[mv->ref[0]] != s->s.h.signbias[ref]);
205

13067
            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
134
                AV_RN32A(&mv->mv[0]) != AV_RN32A(&mv->mv[1])) {
209








92
                RETURN_SCALE_MV(mv->mv[1], s->s.h.signbias[mv->ref[1]] != s->s.h.signbias[ref]);
210
            }
211
        }
212
    }
213
214
    // MV at this position in previous frame, using different reference frame
215
2852
    if (s->s.h.use_last_frame_mvs) {
216
2650
        VP9mvrefPair *mv = &s->s.frames[REF_FRAME_MVPAIR].mv[row * s->sb_cols * 8 + col];
217
218
        // no need to await_progress, because we already did that above
219

2650
        if (mv->ref[0] != ref && mv->ref[0] >= 0)
220








1497
            RETURN_SCALE_MV(mv->mv[0], s->s.h.signbias[mv->ref[0]] != s->s.h.signbias[ref]);
221

1232
        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
5
            AV_RN32A(&mv->mv[0]) != AV_RN32A(&mv->mv[1])) {
225








5
            RETURN_SCALE_MV(mv->mv[1], s->s.h.signbias[mv->ref[1]] != s->s.h.signbias[ref]);
226
        }
227
    }
228
229
1430
    AV_ZERO32(pmv);
230
1430
    clamp_mv(pmv, pmv, td);
231
#undef INVALID_MV
232
#undef RETURN_MV
233
#undef RETURN_SCALE_MV
234
}
235
236
418761
static av_always_inline int read_mv_component(VP9TileData *td, int idx, int hp)
237
{
238
418761
    VP9Context *s = td->s;
239
418761
    int bit, sign = vp56_rac_get_prob(td->c, s->prob.p.mv_comp[idx].sign);
240
418761
    int n, c = vp8_rac_get_tree(td->c, ff_vp9_mv_class_tree,
241
418761
                                s->prob.p.mv_comp[idx].classes);
242
243
418761
    td->counts.mv_comp[idx].sign[sign]++;
244
418761
    td->counts.mv_comp[idx].classes[c]++;
245
418761
    if (c) {
246
        int m;
247
248
155253
        for (n = 0, m = 0; m < c; m++) {
249
102271
            bit = vp56_rac_get_prob(td->c, s->prob.p.mv_comp[idx].bits[m]);
250
102271
            n |= bit << m;
251
102271
            td->counts.mv_comp[idx].bits[m][bit]++;
252
        }
253
52982
        n <<= 3;
254
52982
        bit = vp8_rac_get_tree(td->c, ff_vp9_mv_fp_tree,
255
52982
                               s->prob.p.mv_comp[idx].fp);
256
52982
        n  |= bit << 1;
257
52982
        td->counts.mv_comp[idx].fp[bit]++;
258
52982
        if (hp) {
259
28467
            bit = vp56_rac_get_prob(td->c, s->prob.p.mv_comp[idx].hp);
260
28467
            td->counts.mv_comp[idx].hp[bit]++;
261
28467
            n |= bit;
262
        } else {
263
24515
            n |= 1;
264
            // bug in libvpx - we count for bw entropy purposes even if the
265
            // bit wasn't coded
266
24515
            td->counts.mv_comp[idx].hp[1]++;
267
        }
268
52982
        n += 8 << c;
269
    } else {
270
365779
        n = vp56_rac_get_prob(td->c, s->prob.p.mv_comp[idx].class0);
271
365779
        td->counts.mv_comp[idx].class0[n]++;
272
365779
        bit = vp8_rac_get_tree(td->c, ff_vp9_mv_fp_tree,
273
365779
                               s->prob.p.mv_comp[idx].class0_fp[n]);
274
365779
        td->counts.mv_comp[idx].class0_fp[n][bit]++;
275
365779
        n = (n << 3) | (bit << 1);
276
365779
        if (hp) {
277
190893
            bit = vp56_rac_get_prob(td->c, s->prob.p.mv_comp[idx].class0_hp);
278
190893
            td->counts.mv_comp[idx].class0_hp[bit]++;
279
190893
            n |= bit;
280
        } else {
281
174886
            n |= 1;
282
            // bug in libvpx - we count for bw entropy purposes even if the
283
            // bit wasn't coded
284
174886
            td->counts.mv_comp[idx].class0_hp[1]++;
285
        }
286
    }
287
288
418761
    return sign ? -(n + 1) : (n + 1);
289
}
290
291
612526
void ff_vp9_fill_mv(VP9TileData *td, VP56mv *mv, int mode, int sb)
292
{
293
612526
    VP9Context *s = td->s;
294
612526
    VP9Block *b = td->b;
295
296
612526
    if (mode == ZEROMV) {
297
10887
        AV_ZERO64(mv);
298
    } else {
299
        int hp;
300
301
        // FIXME cache this value and reuse for other subblocks
302
601639
        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

601639
        if ((mode == NEWMV || sb == -1) &&
306
531330
            !(hp = s->s.h.highprecisionmvs &&
307

531330
              abs(mv[0].x) < 64 && abs(mv[0].y) < 64)) {
308
246465
            if (mv[0].y & 1) {
309
1747
                if (mv[0].y < 0)
310
734
                    mv[0].y++;
311
                else
312
1013
                    mv[0].y--;
313
            }
314
246465
            if (mv[0].x & 1) {
315
2198
                if (mv[0].x < 0)
316
767
                    mv[0].x++;
317
                else
318
1431
                    mv[0].x--;
319
            }
320
        }
321
601639
        if (mode == NEWMV) {
322
533544
            enum MVJoint j = vp8_rac_get_tree(td->c, ff_vp9_mv_joint_tree,
323
266772
                                              s->prob.p.mv_joint);
324
325
266772
            td->counts.mv_joint[j]++;
326
266772
            if (j >= MV_JOINT_V)
327
221012
                mv[0].y += read_mv_component(td, 0, hp);
328
266772
            if (j & 1)
329
177279
                mv[0].x += read_mv_component(td, 1, hp);
330
        }
331
332
601639
        if (b->comp) {
333
            // FIXME cache this value and reuse for other subblocks
334
27999
            find_ref_mvs(td, &mv[1], b->ref[1], 1, mode == NEARMV,
335
                         mode == NEWMV ? -1 : sb);
336

27999
            if ((mode == NEWMV || sb == -1) &&
337
26589
                !(hp = s->s.h.highprecisionmvs &&
338

26589
                  abs(mv[1].x) < 64 && abs(mv[1].y) < 64)) {
339
17957
                if (mv[1].y & 1) {
340
80
                    if (mv[1].y < 0)
341
30
                        mv[1].y++;
342
                    else
343
50
                        mv[1].y--;
344
                }
345
17957
                if (mv[1].x & 1) {
346
64
                    if (mv[1].x < 0)
347
54
                        mv[1].x++;
348
                    else
349
10
                        mv[1].x--;
350
                }
351
            }
352
27999
            if (mode == NEWMV) {
353
26738
                enum MVJoint j = vp8_rac_get_tree(td->c, ff_vp9_mv_joint_tree,
354
13369
                                                  s->prob.p.mv_joint);
355
356
13369
                td->counts.mv_joint[j]++;
357
13369
                if (j >= MV_JOINT_V)
358
10926
                    mv[1].y += read_mv_component(td, 0, hp);
359
13369
                if (j & 1)
360
9544
                    mv[1].x += read_mv_component(td, 1, hp);
361
            }
362
        }
363
    }
364
612526
}