GCC Code Coverage Report | |||||||||||||||||||||
|
|||||||||||||||||||||
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 |
} |
Generated by: GCOVR (Version 4.2) |