FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/vp8.c
Date: 2025-06-01 09:29:47
Exec Total Coverage
Lines: 1372 1603 85.6%
Functions: 77 84 91.7%
Branches: 817 1159 70.5%
Line Branch Exec Source
1 /*
2 * VP7/VP8 compatible video decoder
3 *
4 * Copyright (C) 2010 David Conrad
5 * Copyright (C) 2010 Ronald S. Bultje
6 * Copyright (C) 2010 Fiona Glaser
7 * Copyright (C) 2012 Daniel Kang
8 * Copyright (C) 2014 Peter Ross
9 *
10 * This file is part of FFmpeg.
11 *
12 * FFmpeg is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Lesser General Public
14 * License as published by the Free Software Foundation; either
15 * version 2.1 of the License, or (at your option) any later version.
16 *
17 * FFmpeg is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * Lesser General Public License for more details.
21 *
22 * You should have received a copy of the GNU Lesser General Public
23 * License along with FFmpeg; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 */
26
27 #include "config_components.h"
28
29 #include "libavutil/mem.h"
30 #include "libavutil/mem_internal.h"
31
32 #include "avcodec.h"
33 #include "codec_internal.h"
34 #include "decode.h"
35 #include "hwaccel_internal.h"
36 #include "hwconfig.h"
37 #include "mathops.h"
38 #include "progressframe.h"
39 #include "libavutil/refstruct.h"
40 #include "thread.h"
41 #include "vp8.h"
42 #include "vp89_rac.h"
43 #include "vp8data.h"
44 #include "vpx_rac.h"
45
46 #if ARCH_ARM
47 # include "arm/vp8.h"
48 #endif
49
50 // fixme: add 1 bit to all the calls to this?
51 6134 static int vp8_rac_get_sint(VPXRangeCoder *c, int bits)
52 {
53 int v;
54
55
2/2
✓ Branch 1 taken 5385 times.
✓ Branch 2 taken 749 times.
 6134 if (!vp89_rac_get(c))
56 5385 return 0;
57
58 749 v = vp89_rac_get_uint(c, bits);
59
60
2/2
✓ Branch 1 taken 98 times.
✓ Branch 2 taken 651 times.
 749 if (vp89_rac_get(c))
61 98 v = -v;
62
63 749 return v;
64 }
65
66 306 static int vp8_rac_get_nn(VPXRangeCoder *c)
67 {
68 306 int v = vp89_rac_get_uint(c, 7) << 1;
69 306 return v + !v;
70 }
71
72 // DCTextra
73 48615 static int vp8_rac_get_coeff(VPXRangeCoder *c, const uint8_t *prob)
74 {
75 48615 int v = 0;
76
77 do {
78 185502 v = (v<<1) + vpx_rac_get_prob(c, *prob++);
79
2/2
✓ Branch 0 taken 136887 times.
✓ Branch 1 taken 48615 times.
 185502 } while (*prob);
80
81 48615 return v;
82 }
83
84 78 static void free_buffers(VP8Context *s)
85 {
86 int i;
87
2/2
✓ Branch 0 taken 39 times.
✓ Branch 1 taken 39 times.
 78 if (s->thread_data)
88
2/2
✓ Branch 0 taken 312 times.
✓ Branch 1 taken 39 times.
 351 for (i = 0; i < MAX_THREADS; i++) {
89 #if HAVE_THREADS
90 312 pthread_cond_destroy(&s->thread_data[i].cond);
91 312 pthread_mutex_destroy(&s->thread_data[i].lock);
92 #endif
93 312 av_freep(&s->thread_data[i].filter_strength);
94 }
95 78 av_freep(&s->thread_data);
96 78 av_freep(&s->macroblocks_base);
97 78 av_freep(&s->intra4x4_pred_mode_top);
98 78 av_freep(&s->top_nnz);
99 78 av_freep(&s->top_border);
100
101 78 s->macroblocks = NULL;
102 78 }
103
104 1149 static int vp8_alloc_frame(VP8Context *s, VP8Frame *f, int ref)
105 {
106 1149 int ret = ff_progress_frame_get_buffer(s->avctx, &f->tf,
107 ref ? AV_GET_BUFFER_FLAG_REF : 0);
108
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1149 times.
 1149 if (ret < 0)
109 ✗ return ret;
110 1149 f->seg_map = av_refstruct_allocz(s->mb_width * s->mb_height);
111
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1149 times.
 1149 if (!f->seg_map) {
112 ✗ ret = AVERROR(ENOMEM);
113 ✗ goto fail;
114 }
115 1149 ret = ff_hwaccel_frame_priv_alloc(s->avctx, &f->hwaccel_picture_private);
116
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1149 times.
 1149 if (ret < 0)
117 ✗ goto fail;
118
119 1149 return 0;
120
121 ✗ fail:
122 ✗ av_refstruct_unref(&f->seg_map);
123 ✗ ff_progress_frame_unref(&f->tf);
124 ✗ return ret;
125 }
126
127 1424 static void vp8_release_frame(VP8Frame *f)
128 {
129 1424 av_refstruct_unref(&f->seg_map);
130 1424 av_refstruct_unref(&f->hwaccel_picture_private);
131 1424 ff_progress_frame_unref(&f->tf);
132 1424 }
133
134 78 static av_cold void vp8_decode_flush_impl(AVCodecContext *avctx, int free_mem)
135 {
136 78 VP8Context *s = avctx->priv_data;
137 int i;
138
139
2/2
✓ Branch 0 taken 390 times.
✓ Branch 1 taken 78 times.
 468 for (i = 0; i < FF_ARRAY_ELEMS(s->frames); i++)
140 390 vp8_release_frame(&s->frames[i]);
141 78 memset(s->framep, 0, sizeof(s->framep));
142
143
1/2
✓ Branch 0 taken 78 times.
✗ Branch 1 not taken.
 78 if (free_mem)
144 78 free_buffers(s);
145
146
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 78 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 78 if (FF_HW_HAS_CB(avctx, flush))
147 ✗ FF_HW_SIMPLE_CALL(avctx, flush);
148 78 }
149
150 ✗ static av_cold void vp8_decode_flush(AVCodecContext *avctx)
151 {
152 ✗ vp8_decode_flush_impl(avctx, 0);
153 ✗ }
154
155 1149 static VP8Frame *vp8_find_free_buffer(VP8Context *s)
156 {
157 1149 VP8Frame *frame = NULL;
158 int i;
159
160 // find a free buffer
161
1/2
✓ Branch 0 taken 2807 times.
✗ Branch 1 not taken.
 2807 for (i = 0; i < 5; i++)
162
2/2
✓ Branch 0 taken 2212 times.
✓ Branch 1 taken 595 times.
 2807 if (&s->frames[i] != s->framep[VP8_FRAME_CURRENT] &&
163
2/2
✓ Branch 0 taken 2211 times.
✓ Branch 1 taken 1 times.
 2212 &s->frames[i] != s->framep[VP8_FRAME_PREVIOUS] &&
164
2/2
✓ Branch 0 taken 1607 times.
✓ Branch 1 taken 604 times.
 2211 &s->frames[i] != s->framep[VP8_FRAME_GOLDEN] &&
165
2/2
✓ Branch 0 taken 1149 times.
✓ Branch 1 taken 458 times.
 1607 &s->frames[i] != s->framep[VP8_FRAME_ALTREF]) {
166 1149 frame = &s->frames[i];
167 1149 break;
168 }
169
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1149 times.
 1149 if (i == 5) {
170 ✗ av_log(s->avctx, AV_LOG_FATAL, "Ran out of free frames!\n");
171 ✗ abort();
172 }
173
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1149 times.
 1149 if (frame->tf.f)
174 ✗ vp8_release_frame(frame);
175
176 1149 return frame;
177 }
178
179 21 static enum AVPixelFormat get_pixel_format(VP8Context *s)
180 {
181 21 enum AVPixelFormat pix_fmts[] = {
182 #if CONFIG_VP8_VAAPI_HWACCEL
183 AV_PIX_FMT_VAAPI,
184 #endif
185 #if CONFIG_VP8_NVDEC_HWACCEL
186 AV_PIX_FMT_CUDA,
187 #endif
188 AV_PIX_FMT_YUV420P,
189 AV_PIX_FMT_NONE,
190 };
191
192 21 return ff_get_format(s->avctx, pix_fmts);
193 }
194
195 static av_always_inline
196 39 int update_dimensions(VP8Context *s, int width, int height, int is_vp7)
197 {
198 39 AVCodecContext *avctx = s->avctx;
199 39 int i, ret, dim_reset = 0;
200
201
7/8
✓ Branch 0 taken 29 times.
✓ Branch 1 taken 10 times.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 24 times.
✓ Branch 4 taken 5 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 24 times.
✓ Branch 7 taken 5 times.
 39 if (width != s->avctx->width || ((width+15)/16 != s->mb_width || (height+15)/16 != s->mb_height) && s->macroblocks_base ||
202
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24 times.
 24 height != s->avctx->height) {
203 15 vp8_decode_flush_impl(s->avctx, 1);
204
205 15 ret = ff_set_dimensions(s->avctx, width, height);
206
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
 15 if (ret < 0)
207 ✗ return ret;
208
209 15 dim_reset = (s->macroblocks_base != NULL);
210 }
211
212
3/4
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 28 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 11 times.
 39 if ((s->pix_fmt == AV_PIX_FMT_NONE || dim_reset) &&
213
4/4
✓ Branch 0 taken 22 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 21 times.
✓ Branch 3 taken 1 times.
 28 !s->actually_webp && !is_vp7) {
214 21 s->pix_fmt = get_pixel_format(s);
215
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 21 times.
 21 if (s->pix_fmt < 0)
216 ✗ return AVERROR(EINVAL);
217 21 avctx->pix_fmt = s->pix_fmt;
218 }
219
220 39 s->mb_width = (s->avctx->coded_width + 15) / 16;
221 39 s->mb_height = (s->avctx->coded_height + 15) / 16;
222
223
3/4
✓ Branch 0 taken 38 times.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 38 times.
 39 s->mb_layout = is_vp7 || avctx->active_thread_type == FF_THREAD_SLICE &&
224 ✗ avctx->thread_count > 1;
225
2/2
✓ Branch 0 taken 38 times.
✓ Branch 1 taken 1 times.
 39 if (!s->mb_layout) { // Frame threading and one thread
226 38 s->macroblocks_base = av_mallocz((s->mb_width + s->mb_height * 2 + 1) *
227 sizeof(*s->macroblocks));
228 38 s->intra4x4_pred_mode_top = av_mallocz(s->mb_width * 4);
229 } else // Sliced threading
230 1 s->macroblocks_base = av_mallocz((s->mb_width + 2) * (s->mb_height + 2) *
231 sizeof(*s->macroblocks));
232 39 s->top_nnz = av_mallocz(s->mb_width * sizeof(*s->top_nnz));
233 39 s->top_border = av_mallocz((s->mb_width + 1) * sizeof(*s->top_border));
234 39 s->thread_data = av_mallocz(MAX_THREADS * sizeof(VP8ThreadData));
235
236
3/6
✓ Branch 0 taken 39 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 39 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 39 times.
✗ Branch 5 not taken.
 39 if (!s->macroblocks_base || !s->top_nnz || !s->top_border ||
237
4/6
✓ Branch 0 taken 39 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 38 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 1 times.
 39 !s->thread_data || (!s->intra4x4_pred_mode_top && !s->mb_layout)) {
238 ✗ free_buffers(s);
239 ✗ return AVERROR(ENOMEM);
240 }
241
242
2/2
✓ Branch 0 taken 312 times.
✓ Branch 1 taken 39 times.
 351 for (i = 0; i < MAX_THREADS; i++) {
243 624 s->thread_data[i].filter_strength =
244 312 av_mallocz(s->mb_width * sizeof(*s->thread_data[0].filter_strength));
245
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 312 times.
 312 if (!s->thread_data[i].filter_strength) {
246 ✗ free_buffers(s);
247 ✗ return AVERROR(ENOMEM);
248 }
249 #if HAVE_THREADS
250 312 ret = pthread_mutex_init(&s->thread_data[i].lock, NULL);
251
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 312 times.
 312 if (ret) {
252 ✗ free_buffers(s);
253 ✗ return AVERROR(ret);
254 }
255 312 ret = pthread_cond_init(&s->thread_data[i].cond, NULL);
256
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 312 times.
 312 if (ret) {
257 ✗ free_buffers(s);
258 ✗ return AVERROR(ret);
259 }
260 #endif
261 }
262
263 39 s->macroblocks = s->macroblocks_base + 1;
264
265 39 return 0;
266 }
267
268 1 static int vp7_update_dimensions(VP8Context *s, int width, int height)
269 {
270 1 return update_dimensions(s, width, height, IS_VP7);
271 }
272
273 38 static int vp8_update_dimensions(VP8Context *s, int width, int height)
274 {
275 38 return update_dimensions(s, width, height, IS_VP8);
276 }
277
278
279 433 static void parse_segment_info(VP8Context *s)
280 {
281 433 VPXRangeCoder *c = &s->c;
282 int i;
283
284 433 s->segmentation.update_map = vp89_rac_get(c);
285 433 s->segmentation.update_feature_data = vp89_rac_get(c);
286
287
2/2
✓ Branch 0 taken 68 times.
✓ Branch 1 taken 365 times.
 433 if (s->segmentation.update_feature_data) {
288 68 s->segmentation.absolute_vals = vp89_rac_get(c);
289
290
2/2
✓ Branch 0 taken 272 times.
✓ Branch 1 taken 68 times.
 340 for (i = 0; i < 4; i++)
291 272 s->segmentation.base_quant[i] = vp8_rac_get_sint(c, 7);
292
293
2/2
✓ Branch 0 taken 272 times.
✓ Branch 1 taken 68 times.
 340 for (i = 0; i < 4; i++)
294 272 s->segmentation.filter_level[i] = vp8_rac_get_sint(c, 6);
295 }
296
2/2
✓ Branch 0 taken 68 times.
✓ Branch 1 taken 365 times.
 433 if (s->segmentation.update_map)
297
2/2
✓ Branch 0 taken 204 times.
✓ Branch 1 taken 68 times.
 272 for (i = 0; i < 3; i++)
298
2/2
✓ Branch 1 taken 24 times.
✓ Branch 2 taken 180 times.
 204 s->prob->segmentid[i] = vp89_rac_get(c) ? vp89_rac_get_uint(c, 8) : 255;
299 433 }
300
301 44 static void update_lf_deltas(VP8Context *s)
302 {
303 44 VPXRangeCoder *c = &s->c;
304 int i;
305
306
2/2
✓ Branch 0 taken 176 times.
✓ Branch 1 taken 44 times.
 220 for (i = 0; i < 4; i++) {
307
2/2
✓ Branch 1 taken 132 times.
✓ Branch 2 taken 44 times.
 176 if (vp89_rac_get(c)) {
308 132 s->lf_delta.ref[i] = vp89_rac_get_uint(c, 6);
309
310
2/2
✓ Branch 1 taken 88 times.
✓ Branch 2 taken 44 times.
 132 if (vp89_rac_get(c))
311 88 s->lf_delta.ref[i] = -s->lf_delta.ref[i];
312 }
313 }
314
315
2/2
✓ Branch 0 taken 176 times.
✓ Branch 1 taken 44 times.
 220 for (i = MODE_I4x4; i <= VP8_MVMODE_SPLIT; i++) {
316
1/2
✓ Branch 1 taken 176 times.
✗ Branch 2 not taken.
 176 if (vp89_rac_get(c)) {
317 176 s->lf_delta.mode[i] = vp89_rac_get_uint(c, 6);
318
319
2/2
✓ Branch 1 taken 44 times.
✓ Branch 2 taken 132 times.
 176 if (vp89_rac_get(c))
320 44 s->lf_delta.mode[i] = -s->lf_delta.mode[i];
321 }
322 }
323 44 }
324
325 1118 static int setup_partitions(VP8Context *s, const uint8_t *buf, int buf_size)
326 {
327 1118 const uint8_t *sizes = buf;
328 int i;
329 int ret;
330
331 1118 s->num_coeff_partitions = 1 << vp89_rac_get_uint(&s->c, 2);
332
333 1118 buf += 3 * (s->num_coeff_partitions - 1);
334 1118 buf_size -= 3 * (s->num_coeff_partitions - 1);
335
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1118 times.
 1118 if (buf_size < 0)
336 ✗ return -1;
337
338
2/2
✓ Branch 0 taken 339 times.
✓ Branch 1 taken 1118 times.
 1457 for (i = 0; i < s->num_coeff_partitions - 1; i++) {
339 339 int size = AV_RL24(sizes + 3 * i);
340
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 339 times.
 339 if (buf_size - size < 0)
341 ✗ return -1;
342 339 s->coeff_partition_size[i] = size;
343
344 339 ret = ff_vpx_init_range_decoder(&s->coeff_partition[i], buf, size);
345
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 339 times.
 339 if (ret < 0)
346 ✗ return ret;
347 339 buf += size;
348 339 buf_size -= size;
349 }
350
351 1118 s->coeff_partition_size[i] = buf_size;
352
353 1118 return ff_vpx_init_range_decoder(&s->coeff_partition[i], buf, buf_size);
354 }
355
356 31 static void vp7_get_quants(VP8Context *s)
357 {
358 31 VPXRangeCoder *c = &s->c;
359
360 31 int yac_qi = vp89_rac_get_uint(c, 7);
361
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 31 times.
 31 int ydc_qi = vp89_rac_get(c) ? vp89_rac_get_uint(c, 7) : yac_qi;
362
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 31 times.
 31 int y2dc_qi = vp89_rac_get(c) ? vp89_rac_get_uint(c, 7) : yac_qi;
363
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 31 times.
 31 int y2ac_qi = vp89_rac_get(c) ? vp89_rac_get_uint(c, 7) : yac_qi;
364
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 31 times.
 31 int uvdc_qi = vp89_rac_get(c) ? vp89_rac_get_uint(c, 7) : yac_qi;
365
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 31 times.
 31 int uvac_qi = vp89_rac_get(c) ? vp89_rac_get_uint(c, 7) : yac_qi;
366
367 31 s->qmat[0].luma_qmul[0] = vp7_ydc_qlookup[ydc_qi];
368 31 s->qmat[0].luma_qmul[1] = vp7_yac_qlookup[yac_qi];
369 31 s->qmat[0].luma_dc_qmul[0] = vp7_y2dc_qlookup[y2dc_qi];
370 31 s->qmat[0].luma_dc_qmul[1] = vp7_y2ac_qlookup[y2ac_qi];
371 31 s->qmat[0].chroma_qmul[0] = FFMIN(vp7_ydc_qlookup[uvdc_qi], 132);
372 31 s->qmat[0].chroma_qmul[1] = vp7_yac_qlookup[uvac_qi];
373 31 }
374
375 1118 static void vp8_get_quants(VP8Context *s)
376 {
377 1118 VPXRangeCoder *c = &s->c;
378 int i, base_qi;
379
380 1118 s->quant.yac_qi = vp89_rac_get_uint(c, 7);
381 1118 s->quant.ydc_delta = vp8_rac_get_sint(c, 4);
382 1118 s->quant.y2dc_delta = vp8_rac_get_sint(c, 4);
383 1118 s->quant.y2ac_delta = vp8_rac_get_sint(c, 4);
384 1118 s->quant.uvdc_delta = vp8_rac_get_sint(c, 4);
385 1118 s->quant.uvac_delta = vp8_rac_get_sint(c, 4);
386
387
2/2
✓ Branch 0 taken 4472 times.
✓ Branch 1 taken 1118 times.
 5590 for (i = 0; i < 4; i++) {
388
2/2
✓ Branch 0 taken 1732 times.
✓ Branch 1 taken 2740 times.
 4472 if (s->segmentation.enabled) {
389 1732 base_qi = s->segmentation.base_quant[i];
390
2/2
✓ Branch 0 taken 1608 times.
✓ Branch 1 taken 124 times.
 1732 if (!s->segmentation.absolute_vals)
391 1608 base_qi += s->quant.yac_qi;
392 } else
393 2740 base_qi = s->quant.yac_qi;
394
395 4472 s->qmat[i].luma_qmul[0] = vp8_dc_qlookup[av_clip_uintp2(base_qi + s->quant.ydc_delta, 7)];
396 4472 s->qmat[i].luma_qmul[1] = vp8_ac_qlookup[av_clip_uintp2(base_qi, 7)];
397 4472 s->qmat[i].luma_dc_qmul[0] = vp8_dc_qlookup[av_clip_uintp2(base_qi + s->quant.y2dc_delta, 7)] * 2;
398 /* 101581>>16 is equivalent to 155/100 */
399 4472 s->qmat[i].luma_dc_qmul[1] = vp8_ac_qlookup[av_clip_uintp2(base_qi + s->quant.y2ac_delta, 7)] * 101581 >> 16;
400 4472 s->qmat[i].chroma_qmul[0] = vp8_dc_qlookup[av_clip_uintp2(base_qi + s->quant.uvdc_delta, 7)];
401 4472 s->qmat[i].chroma_qmul[1] = vp8_ac_qlookup[av_clip_uintp2(base_qi + s->quant.uvac_delta, 7)];
402
403 4472 s->qmat[i].luma_dc_qmul[1] = FFMAX(s->qmat[i].luma_dc_qmul[1], 8);
404 4472 s->qmat[i].chroma_qmul[0] = FFMIN(s->qmat[i].chroma_qmul[0], 132);
405 }
406 1118 }
407
408 /**
409 * Determine which buffers golden and altref should be updated with after this frame.
410 * The spec isn't clear here, so I'm going by my understanding of what libvpx does
411 *
412 * Intra frames update all 3 references
413 * Inter frames update VP8_FRAME_PREVIOUS if the update_last flag is set
414 * If the update (golden|altref) flag is set, it's updated with the current frame
415 * if update_last is set, and VP8_FRAME_PREVIOUS otherwise.
416 * If the flag is not set, the number read means:
417 * 0: no update
418 * 1: VP8_FRAME_PREVIOUS
419 * 2: update golden with altref, or update altref with golden
420 */
421 2136 static VP8FrameType ref_to_update(VP8Context *s, int update, VP8FrameType ref)
422 {
423 2136 VPXRangeCoder *c = &s->c;
424
425
2/2
✓ Branch 0 taken 90 times.
✓ Branch 1 taken 2046 times.
 2136 if (update)
426 90 return VP8_FRAME_CURRENT;
427
428
3/3
✓ Branch 1 taken 31 times.
✓ Branch 2 taken 84 times.
✓ Branch 3 taken 1931 times.
 2046 switch (vp89_rac_get_uint(c, 2)) {
429 31 case 1:
430 31 return VP8_FRAME_PREVIOUS;
431 84 case 2:
432
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 81 times.
 84 return (ref == VP8_FRAME_GOLDEN) ? VP8_FRAME_ALTREF : VP8_FRAME_GOLDEN;
433 }
434 1931 return VP8_FRAME_NONE;
435 }
436
437 51 static void vp78_reset_probability_tables(VP8Context *s)
438 {
439 int i, j;
440
2/2
✓ Branch 0 taken 204 times.
✓ Branch 1 taken 51 times.
 255 for (i = 0; i < 4; i++)
441
2/2
✓ Branch 0 taken 3264 times.
✓ Branch 1 taken 204 times.
 3468 for (j = 0; j < 16; j++)
442 3264 memcpy(s->prob->token[i][j], vp8_token_default_probs[i][vp8_coeff_band[j]],
443 sizeof(s->prob->token[i][j]));
444 51 }
445
446 1149 static void vp78_update_probability_tables(VP8Context *s)
447 {
448 1149 VPXRangeCoder *c = &s->c;
449 int i, j, k, l, m;
450
451
2/2
✓ Branch 0 taken 4596 times.
✓ Branch 1 taken 1149 times.
 5745 for (i = 0; i < 4; i++)
452
2/2
✓ Branch 0 taken 36768 times.
✓ Branch 1 taken 4596 times.
 41364 for (j = 0; j < 8; j++)
453
2/2
✓ Branch 0 taken 110304 times.
✓ Branch 1 taken 36768 times.
 147072 for (k = 0; k < 3; k++)
454
2/2
✓ Branch 0 taken 1213344 times.
✓ Branch 1 taken 110304 times.
 1323648 for (l = 0; l < NUM_DCT_TOKENS-1; l++)
455
2/2
✓ Branch 1 taken 7627 times.
✓ Branch 2 taken 1205717 times.
 1213344 if (vpx_rac_get_prob_branchy(c, ff_vp8_token_update_probs[i][j][k][l])) {
456 7627 int prob = vp89_rac_get_uint(c, 8);
457
2/2
✓ Branch 0 taken 17675 times.
✓ Branch 1 taken 7627 times.
 25302 for (m = 0; vp8_coeff_band_indexes[j][m] >= 0; m++)
458 17675 s->prob->token[i][vp8_coeff_band_indexes[j][m]][k][l] = prob;
459 }
460 1149 }
461
462 #define VP7_MVC_SIZE 17
463 #define VP8_MVC_SIZE 19
464
465 1098 static void vp78_update_pred16x16_pred8x8_mvc_probabilities(VP8Context *s,
466 int mvc_size)
467 {
468 1098 VPXRangeCoder *c = &s->c;
469 int i, j;
470
471
2/2
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 1096 times.
 1098 if (vp89_rac_get(c))
472
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 2 times.
 10 for (i = 0; i < 4; i++)
473 8 s->prob->pred16x16[i] = vp89_rac_get_uint(c, 8);
474
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1097 times.
 1098 if (vp89_rac_get(c))
475
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1 times.
 4 for (i = 0; i < 3; i++)
476 3 s->prob->pred8x8c[i] = vp89_rac_get_uint(c, 8);
477
478 // 17.2 MV probability update
479
2/2
✓ Branch 0 taken 2196 times.
✓ Branch 1 taken 1098 times.
 3294 for (i = 0; i < 2; i++)
480
2/2
✓ Branch 0 taken 41604 times.
✓ Branch 1 taken 2196 times.
 43800 for (j = 0; j < mvc_size; j++)
481
2/2
✓ Branch 1 taken 306 times.
✓ Branch 2 taken 41298 times.
 41604 if (vpx_rac_get_prob_branchy(c, vp8_mv_update_prob[i][j]))
482 306 s->prob->mvc[i][j] = vp8_rac_get_nn(c);
483 1098 }
484
485 1068 static void update_refs(VP8Context *s)
486 {
487 1068 VPXRangeCoder *c = &s->c;
488
489 1068 int update_golden = vp89_rac_get(c);
490 1068 int update_altref = vp89_rac_get(c);
491
492 1068 s->update_golden = ref_to_update(s, update_golden, VP8_FRAME_GOLDEN);
493 1068 s->update_altref = ref_to_update(s, update_altref, VP8_FRAME_ALTREF);
494 1068 }
495
496 ✗ static void copy_chroma(AVFrame *dst, const AVFrame *src, int width, int height)
497 {
498 int i, j;
499
500 ✗ for (j = 1; j < 3; j++) {
501 ✗ for (i = 0; i < height / 2; i++)
502 ✗ memcpy(dst->data[j] + i * dst->linesize[j],
503 ✗ src->data[j] + i * src->linesize[j], width / 2);
504 }
505 ✗ }
506
507 ✗ static void fade(uint8_t *dst, ptrdiff_t dst_linesize,
508 const uint8_t *src, ptrdiff_t src_linesize,
509 int width, int height,
510 int alpha, int beta)
511 {
512 int i, j;
513 ✗ for (j = 0; j < height; j++) {
514 ✗ const uint8_t *src2 = src + j * src_linesize;
515 ✗ uint8_t *dst2 = dst + j * dst_linesize;
516 ✗ for (i = 0; i < width; i++) {
517 ✗ uint8_t y = src2[i];
518 ✗ dst2[i] = av_clip_uint8(y + ((y * beta) >> 8) + alpha);
519 }
520 }
521 ✗ }
522
523 31 static int vp7_fade_frame(VP8Context *s, int alpha, int beta)
524 {
525 int ret;
526
527
4/6
✓ Branch 0 taken 30 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 30 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 30 times.
 31 if (!s->keyframe && (alpha || beta)) {
528 ✗ int width = s->mb_width * 16;
529 ✗ int height = s->mb_height * 16;
530 const AVFrame *src;
531 AVFrame *dst;
532
533 ✗ if (!s->framep[VP8_FRAME_PREVIOUS] ||
534 ✗ !s->framep[VP8_FRAME_GOLDEN]) {
535 ✗ av_log(s->avctx, AV_LOG_WARNING, "Discarding interframe without a prior keyframe!\n");
536 ✗ return AVERROR_INVALIDDATA;
537 }
538
539 ✗ src =
540 ✗ dst = s->framep[VP8_FRAME_PREVIOUS]->tf.f;
541
542 /* preserve the golden frame, write a new previous frame */
543 ✗ if (s->framep[VP8_FRAME_GOLDEN] == s->framep[VP8_FRAME_PREVIOUS]) {
544 ✗ VP8Frame *prev_frame = vp8_find_free_buffer(s);
545
546 ✗ ret = vp8_alloc_frame(s, prev_frame, 1);
547 ✗ if (ret < 0)
548 ✗ return ret;
549 ✗ s->framep[VP8_FRAME_PREVIOUS] = prev_frame;
550
551 ✗ dst = s->framep[VP8_FRAME_PREVIOUS]->tf.f;
552
553 ✗ copy_chroma(dst, src, width, height);
554 }
555
556 ✗ fade(dst->data[0], dst->linesize[0],
557 ✗ src->data[0], src->linesize[0],
558 width, height, alpha, beta);
559 }
560
561 31 return 0;
562 }
563
564 31 static int vp7_decode_frame_header(VP8Context *s, const uint8_t *buf, int buf_size)
565 {
566 31 VPXRangeCoder *c = &s->c;
567 int part1_size, hscale, vscale, i, j, ret;
568 31 int width = s->avctx->width;
569 31 int height = s->avctx->height;
570 31 int alpha = 0;
571 31 int beta = 0;
572 31 int fade_present = 1;
573
574
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 31 times.
 31 if (buf_size < 4) {
575 ✗ return AVERROR_INVALIDDATA;
576 }
577
578 31 s->profile = (buf[0] >> 1) & 7;
579
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 31 times.
 31 if (s->profile > 1) {
580 ✗ avpriv_request_sample(s->avctx, "Unknown profile %d", s->profile);
581 ✗ return AVERROR_INVALIDDATA;
582 }
583
584 31 s->keyframe = !(buf[0] & 1);
585 31 s->invisible = 0;
586 31 part1_size = AV_RL24(buf) >> 4;
587
588
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 31 times.
 31 if (buf_size < 4 - s->profile + part1_size) {
589 ✗ av_log(s->avctx, AV_LOG_ERROR, "Buffer size %d is too small, needed : %d\n", buf_size, 4 - s->profile + part1_size);
590 ✗ return AVERROR_INVALIDDATA;
591 }
592
593 31 buf += 4 - s->profile;
594 31 buf_size -= 4 - s->profile;
595
596 31 memcpy(s->put_pixels_tab, s->vp8dsp.put_vp8_epel_pixels_tab, sizeof(s->put_pixels_tab));
597
598 31 ret = ff_vpx_init_range_decoder(c, buf, part1_size);
599
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 31 times.
 31 if (ret < 0)
600 ✗ return ret;
601 31 buf += part1_size;
602 31 buf_size -= part1_size;
603
604 /* A. Dimension information (keyframes only) */
605
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 30 times.
 31 if (s->keyframe) {
606 1 width = vp89_rac_get_uint(c, 12);
607 1 height = vp89_rac_get_uint(c, 12);
608 1 hscale = vp89_rac_get_uint(c, 2);
609 1 vscale = vp89_rac_get_uint(c, 2);
610
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
 1 if (hscale || vscale)
611 ✗ avpriv_request_sample(s->avctx, "Upscaling");
612
613 1 s->update_golden = s->update_altref = VP8_FRAME_CURRENT;
614 1 vp78_reset_probability_tables(s);
615 1 memcpy(s->prob->pred16x16, vp8_pred16x16_prob_inter,
616 sizeof(s->prob->pred16x16));
617 1 memcpy(s->prob->pred8x8c, vp8_pred8x8c_prob_inter,
618 sizeof(s->prob->pred8x8c));
619
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1 times.
 3 for (i = 0; i < 2; i++)
620 2 memcpy(s->prob->mvc[i], vp7_mv_default_prob[i],
621 sizeof(vp7_mv_default_prob[i]));
622 1 memset(&s->segmentation, 0, sizeof(s->segmentation));
623 1 memset(&s->lf_delta, 0, sizeof(s->lf_delta));
624 1 memcpy(s->prob[0].scan, ff_zigzag_scan, sizeof(s->prob[0].scan));
625 }
626
627
3/4
✓ Branch 0 taken 30 times.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 30 times.
 31 if (s->keyframe || s->profile > 0)
628 1 memset(s->inter_dc_pred, 0 , sizeof(s->inter_dc_pred));
629
630 /* B. Decoding information for all four macroblock-level features */
631
2/2
✓ Branch 0 taken 124 times.
✓ Branch 1 taken 31 times.
 155 for (i = 0; i < 4; i++) {
632 124 s->feature_enabled[i] = vp89_rac_get(c);
633
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 124 times.
 124 if (s->feature_enabled[i]) {
634 ✗ s->feature_present_prob[i] = vp89_rac_get_uint(c, 8);
635
636 ✗ for (j = 0; j < 3; j++)
637 ✗ s->feature_index_prob[i][j] =
638 ✗ vp89_rac_get(c) ? vp89_rac_get_uint(c, 8) : 255;
639
640 ✗ if (vp7_feature_value_size[s->profile][i])
641 ✗ for (j = 0; j < 4; j++)
642 ✗ s->feature_value[i][j] =
643 ✗ vp89_rac_get(c) ? vp89_rac_get_uint(c, vp7_feature_value_size[s->profile][i]) : 0;
644 }
645 }
646
647 31 s->segmentation.enabled = 0;
648 31 s->segmentation.update_map = 0;
649 31 s->lf_delta.enabled = 0;
650
651 31 s->num_coeff_partitions = 1;
652 31 ret = ff_vpx_init_range_decoder(&s->coeff_partition[0], buf, buf_size);
653
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 31 times.
 31 if (ret < 0)
654 ✗ return ret;
655
656
2/2
✓ Branch 0 taken 30 times.
✓ Branch 1 taken 1 times.
 31 if (!s->macroblocks_base || /* first frame */
657
2/4
✓ Branch 0 taken 30 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
✗ Branch 3 not taken.
 30 width != s->avctx->width || height != s->avctx->height ||
658
2/4
✓ Branch 0 taken 30 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 30 times.
 30 (width + 15) / 16 != s->mb_width || (height + 15) / 16 != s->mb_height) {
659
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
 1 if ((ret = vp7_update_dimensions(s, width, height)) < 0)
660 ✗ return ret;
661 }
662
663 /* C. Dequantization indices */
664 31 vp7_get_quants(s);
665
666 /* D. Golden frame update flag (a Flag) for interframes only */
667
2/2
✓ Branch 0 taken 30 times.
✓ Branch 1 taken 1 times.
 31 if (!s->keyframe) {
668
2/2
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 27 times.
 30 s->update_golden = vp89_rac_get(c) ? VP8_FRAME_CURRENT : VP8_FRAME_NONE;
669 30 s->sign_bias[VP8_FRAME_GOLDEN] = 0;
670 }
671
672 31 s->update_last = 1;
673 31 s->update_probabilities = 1;
674
675
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 31 times.
 31 if (s->profile > 0) {
676 ✗ s->update_probabilities = vp89_rac_get(c);
677 ✗ if (!s->update_probabilities)
678 ✗ s->prob[1] = s->prob[0];
679
680 ✗ if (!s->keyframe)
681 ✗ fade_present = vp89_rac_get(c);
682 }
683
684
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 31 times.
 31 if (vpx_rac_is_end(c))
685 ✗ return AVERROR_INVALIDDATA;
686 /* E. Fading information for previous frame */
687
2/4
✓ Branch 0 taken 31 times.
✗ Branch 1 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 31 times.
 31 if (fade_present && vp89_rac_get(c)) {
688 ✗ alpha = (int8_t) vp89_rac_get_uint(c, 8);
689 ✗ beta = (int8_t) vp89_rac_get_uint(c, 8);
690 }
691
692 /* F. Loop filter type */
693
1/2
✓ Branch 0 taken 31 times.
✗ Branch 1 not taken.
 31 if (!s->profile)
694 31 s->filter.simple = vp89_rac_get(c);
695
696 /* G. DCT coefficient ordering specification */
697
2/2
✓ Branch 1 taken 13 times.
✓ Branch 2 taken 18 times.
 31 if (vp89_rac_get(c))
698
2/2
✓ Branch 0 taken 195 times.
✓ Branch 1 taken 13 times.
 208 for (i = 1; i < 16; i++)
699 195 s->prob[0].scan[i] = ff_zigzag_scan[vp89_rac_get_uint(c, 4)];
700
701 /* H. Loop filter levels */
702
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 31 times.
 31 if (s->profile > 0)
703 ✗ s->filter.simple = vp89_rac_get(c);
704 31 s->filter.level = vp89_rac_get_uint(c, 6);
705 31 s->filter.sharpness = vp89_rac_get_uint(c, 3);
706
707 /* I. DCT coefficient probability update; 13.3 Token Probability Updates */
708 31 vp78_update_probability_tables(s);
709
710 31 s->mbskip_enabled = 0;
711
712 /* J. The remaining frame header data occurs ONLY FOR INTERFRAMES */
713
2/2
✓ Branch 0 taken 30 times.
✓ Branch 1 taken 1 times.
 31 if (!s->keyframe) {
714 30 s->prob->intra = vp89_rac_get_uint(c, 8);
715 30 s->prob->last = vp89_rac_get_uint(c, 8);
716 30 vp78_update_pred16x16_pred8x8_mvc_probabilities(s, VP7_MVC_SIZE);
717 }
718
719
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 31 times.
 31 if (vpx_rac_is_end(c))
720 ✗ return AVERROR_INVALIDDATA;
721
722
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 31 times.
 31 if ((ret = vp7_fade_frame(s, alpha, beta)) < 0)
723 ✗ return ret;
724
725 31 return 0;
726 }
727
728 1118 static int vp8_decode_frame_header(VP8Context *s, const uint8_t *buf, int buf_size)
729 {
730 1118 VPXRangeCoder *c = &s->c;
731 int header_size, hscale, vscale, ret;
732 1118 int width = s->avctx->width;
733 1118 int height = s->avctx->height;
734
735
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1118 times.
 1118 if (buf_size < 3) {
736 ✗ av_log(s->avctx, AV_LOG_ERROR, "Insufficent data (%d) for header\n", buf_size);
737 ✗ return AVERROR_INVALIDDATA;
738 }
739
740 1118 s->keyframe = !(buf[0] & 1);
741 1118 s->profile = (buf[0]>>1) & 7;
742 1118 s->invisible = !(buf[0] & 0x10);
743 1118 header_size = AV_RL24(buf) >> 5;
744 1118 buf += 3;
745 1118 buf_size -= 3;
746
747 1118 s->header_partition_size = header_size;
748
749
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1118 times.
 1118 if (s->profile > 3)
750 ✗ av_log(s->avctx, AV_LOG_WARNING, "Unknown profile %d\n", s->profile);
751
752
2/2
✓ Branch 0 taken 962 times.
✓ Branch 1 taken 156 times.
 1118 if (!s->profile)
753 962 memcpy(s->put_pixels_tab, s->vp8dsp.put_vp8_epel_pixels_tab,
754 sizeof(s->put_pixels_tab));
755 else // profile 1-3 use bilinear, 4+ aren't defined so whatever
756 156 memcpy(s->put_pixels_tab, s->vp8dsp.put_vp8_bilinear_pixels_tab,
757 sizeof(s->put_pixels_tab));
758
759
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1118 times.
 1118 if (header_size > buf_size - 7 * s->keyframe) {
760 ✗ av_log(s->avctx, AV_LOG_ERROR, "Header size larger than data provided\n");
761 ✗ return AVERROR_INVALIDDATA;
762 }
763
764
2/2
✓ Branch 0 taken 50 times.
✓ Branch 1 taken 1068 times.
 1118 if (s->keyframe) {
765
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 50 times.
 50 if (AV_RL24(buf) != 0x2a019d) {
766 ✗ av_log(s->avctx, AV_LOG_ERROR,
767 ✗ "Invalid start code 0x%x\n", AV_RL24(buf));
768 ✗ return AVERROR_INVALIDDATA;
769 }
770 50 width = AV_RL16(buf + 3) & 0x3fff;
771 50 height = AV_RL16(buf + 5) & 0x3fff;
772 50 hscale = buf[4] >> 6;
773 50 vscale = buf[6] >> 6;
774 50 buf += 7;
775 50 buf_size -= 7;
776
777
2/4
✓ Branch 0 taken 50 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 50 times.
 50 if (hscale || vscale)
778 ✗ avpriv_request_sample(s->avctx, "Upscaling");
779
780 50 s->update_golden = s->update_altref = VP8_FRAME_CURRENT;
781 50 vp78_reset_probability_tables(s);
782 50 memcpy(s->prob->pred16x16, vp8_pred16x16_prob_inter,
783 sizeof(s->prob->pred16x16));
784 50 memcpy(s->prob->pred8x8c, vp8_pred8x8c_prob_inter,
785 sizeof(s->prob->pred8x8c));
786 50 memcpy(s->prob->mvc, vp8_mv_default_prob,
787 sizeof(s->prob->mvc));
788 50 memset(&s->segmentation, 0, sizeof(s->segmentation));
789 50 memset(&s->lf_delta, 0, sizeof(s->lf_delta));
790 }
791
792 1118 ret = ff_vpx_init_range_decoder(c, buf, header_size);
793
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1118 times.
 1118 if (ret < 0)
794 ✗ return ret;
795 1118 buf += header_size;
796 1118 buf_size -= header_size;
797
798
2/2
✓ Branch 0 taken 50 times.
✓ Branch 1 taken 1068 times.
 1118 if (s->keyframe) {
799 50 s->colorspace = vp89_rac_get(c);
800
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 50 times.
 50 if (s->colorspace)
801 ✗ av_log(s->avctx, AV_LOG_WARNING, "Unspecified colorspace\n");
802 50 s->fullrange = vp89_rac_get(c);
803 }
804
805
2/2
✓ Branch 1 taken 433 times.
✓ Branch 2 taken 685 times.
 1118 if ((s->segmentation.enabled = vp89_rac_get(c)))
806 433 parse_segment_info(s);
807 else
808 685 s->segmentation.update_map = 0; // FIXME: move this to some init function?
809
810 1118 s->filter.simple = vp89_rac_get(c);
811 1118 s->filter.level = vp89_rac_get_uint(c, 6);
812 1118 s->filter.sharpness = vp89_rac_get_uint(c, 3);
813
814
2/2
✓ Branch 1 taken 1112 times.
✓ Branch 2 taken 6 times.
 1118 if ((s->lf_delta.enabled = vp89_rac_get(c))) {
815 1112 s->lf_delta.update = vp89_rac_get(c);
816
2/2
✓ Branch 0 taken 44 times.
✓ Branch 1 taken 1068 times.
 1112 if (s->lf_delta.update)
817 44 update_lf_deltas(s);
818 }
819
820
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1118 times.
 1118 if (setup_partitions(s, buf, buf_size)) {
821 ✗ av_log(s->avctx, AV_LOG_ERROR, "Invalid partitions\n");
822 ✗ return AVERROR_INVALIDDATA;
823 }
824
825
2/2
✓ Branch 0 taken 1091 times.
✓ Branch 1 taken 27 times.
 1118 if (!s->macroblocks_base || /* first frame */
826
4/4
✓ Branch 0 taken 1085 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 1080 times.
✓ Branch 3 taken 5 times.
 1091 width != s->avctx->width || height != s->avctx->height ||
827
2/4
✓ Branch 0 taken 1080 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1080 times.
 1080 (width+15)/16 != s->mb_width || (height+15)/16 != s->mb_height)
828
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 38 times.
 38 if ((ret = vp8_update_dimensions(s, width, height)) < 0)
829 ✗ return ret;
830
831 1118 vp8_get_quants(s);
832
833
2/2
✓ Branch 0 taken 1068 times.
✓ Branch 1 taken 50 times.
 1118 if (!s->keyframe) {
834 1068 update_refs(s);
835 1068 s->sign_bias[VP8_FRAME_GOLDEN] = vp89_rac_get(c);
836 1068 s->sign_bias[VP8_FRAME_ALTREF] = vp89_rac_get(c);
837 }
838
839 // if we aren't saving this frame's probabilities for future frames,
840 // make a copy of the current probabilities
841
2/2
✓ Branch 1 taken 64 times.
✓ Branch 2 taken 1054 times.
 1118 if (!(s->update_probabilities = vp89_rac_get(c)))
842 64 s->prob[1] = s->prob[0];
843
844
4/4
✓ Branch 0 taken 1068 times.
✓ Branch 1 taken 50 times.
✓ Branch 3 taken 1057 times.
✓ Branch 4 taken 11 times.
 1118 s->update_last = s->keyframe || vp89_rac_get(c);
845
846 1118 vp78_update_probability_tables(s);
847
848
2/2
✓ Branch 1 taken 1112 times.
✓ Branch 2 taken 6 times.
 1118 if ((s->mbskip_enabled = vp89_rac_get(c)))
849 1112 s->prob->mbskip = vp89_rac_get_uint(c, 8);
850
851
2/2
✓ Branch 0 taken 1068 times.
✓ Branch 1 taken 50 times.
 1118 if (!s->keyframe) {
852 1068 s->prob->intra = vp89_rac_get_uint(c, 8);
853 1068 s->prob->last = vp89_rac_get_uint(c, 8);
854 1068 s->prob->golden = vp89_rac_get_uint(c, 8);
855 1068 vp78_update_pred16x16_pred8x8_mvc_probabilities(s, VP8_MVC_SIZE);
856 }
857
858 // Record the entropy coder state here so that hwaccels can use it.
859 1118 s->c.code_word = vpx_rac_renorm(&s->c);
860 1118 s->coder_state_at_header_end.input = s->c.buffer - (-s->c.bits / 8);
861 1118 s->coder_state_at_header_end.range = s->c.high;
862 1118 s->coder_state_at_header_end.value = s->c.code_word >> 16;
863 1118 s->coder_state_at_header_end.bit_count = -s->c.bits % 8;
864
865 1118 return 0;
866 }
867
868 static av_always_inline
869 57182 void clamp_mv(const VP8mvbounds *s, VP8mv *dst, const VP8mv *src)
870 {
871 57182 dst->x = av_clip(src->x, av_clip(s->mv_min.x, INT16_MIN, INT16_MAX),
872 57182 av_clip(s->mv_max.x, INT16_MIN, INT16_MAX));
873 57182 dst->y = av_clip(src->y, av_clip(s->mv_min.y, INT16_MIN, INT16_MAX),
874 57182 av_clip(s->mv_max.y, INT16_MIN, INT16_MAX));
875 57182 }
876
877 /**
878 * Motion vector coding, 17.1.
879 */
880 84910 static av_always_inline int read_mv_component(VPXRangeCoder *c, const uint8_t *p, int vp7)
881 {
882 84910 int bit, x = 0;
883
884
2/2
✓ Branch 1 taken 19966 times.
✓ Branch 2 taken 64944 times.
 84910 if (vpx_rac_get_prob_branchy(c, p[0])) {
885 int i;
886
887
2/2
✓ Branch 0 taken 59898 times.
✓ Branch 1 taken 19966 times.
 79864 for (i = 0; i < 3; i++)
888 59898 x += vpx_rac_get_prob(c, p[9 + i]) << i;
889
3/4
✗ Branch 0 not taken.
✓ Branch 1 taken 19966 times.
✓ Branch 2 taken 119796 times.
✓ Branch 3 taken 19966 times.
 139762 for (i = (vp7 ? 7 : 9); i > 3; i--)
890 119796 x += vpx_rac_get_prob(c, p[9 + i]) << i;
891
5/6
✗ Branch 0 not taken.
✓ Branch 1 taken 19966 times.
✓ Branch 2 taken 12222 times.
✓ Branch 3 taken 7744 times.
✓ Branch 5 taken 5564 times.
✓ Branch 6 taken 6658 times.
 19966 if (!(x & (vp7 ? 0xF0 : 0xFFF0)) || vpx_rac_get_prob(c, p[12]))
892 13308 x += 8;
893 } else {
894 // small_mvtree
895 64944 const uint8_t *ps = p + 2;
896 64944 bit = vpx_rac_get_prob(c, *ps);
897 64944 ps += 1 + 3 * bit;
898 64944 x += 4 * bit;
899 64944 bit = vpx_rac_get_prob(c, *ps);
900 64944 ps += 1 + bit;
901 64944 x += 2 * bit;
902 64944 x += vpx_rac_get_prob(c, *ps);
903 }
904
905
4/4
✓ Branch 0 taken 66588 times.
✓ Branch 1 taken 18322 times.
✓ Branch 3 taken 34958 times.
✓ Branch 4 taken 31630 times.
 84910 return (x && vpx_rac_get_prob(c, p[1])) ? -x : x;
906 }
907
908 ✗ static int vp7_read_mv_component(VPXRangeCoder *c, const uint8_t *p)
909 {
910 ✗ return read_mv_component(c, p, 1);
911 }
912
913 28394 static int vp8_read_mv_component(VPXRangeCoder *c, const uint8_t *p)
914 {
915 28394 return read_mv_component(c, p, 0);
916 }
917
918 static av_always_inline
919 136610 const uint8_t *get_submv_prob(uint32_t left, uint32_t top, int is_vp7)
920 {
921
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 136610 times.
 136610 if (is_vp7)
922 ✗ return vp7_submv_prob;
923
924
2/2
✓ Branch 0 taken 58719 times.
✓ Branch 1 taken 77891 times.
 136610 if (left == top)
925
2/2
✓ Branch 0 taken 23422 times.
✓ Branch 1 taken 35297 times.
 58719 return vp8_submv_prob[4 - !!left];
926
2/2
✓ Branch 0 taken 18934 times.
✓ Branch 1 taken 58957 times.
 77891 if (!top)
927 18934 return vp8_submv_prob[2];
928 58957 return vp8_submv_prob[1 - !!left];
929 }
930
931 /**
932 * Split motion vector prediction, 16.4.
933 * @returns the number of motion vectors parsed (2, 4 or 16)
934 */
935 static av_always_inline
936 18330 int decode_splitmvs(const VP8Context *s, VPXRangeCoder *c, VP8Macroblock *mb,
937 int layout, int is_vp7)
938 {
939 int part_idx;
940 int n, num;
941 const VP8Macroblock *top_mb;
942 18330 const VP8Macroblock *left_mb = &mb[-1];
943 18330 const uint8_t *mbsplits_left = vp8_mbsplits[left_mb->partitioning];
944 const uint8_t *mbsplits_top, *mbsplits_cur, *firstidx;
945 const VP8mv *top_mv;
946 18330 const VP8mv *left_mv = left_mb->bmv;
947 18330 const VP8mv *cur_mv = mb->bmv;
948
949
1/2
✓ Branch 0 taken 18330 times.
✗ Branch 1 not taken.
 18330 if (!layout) // layout is inlined, s->mb_layout is not
950 18330 top_mb = &mb[2];
951 else
952 ✗ top_mb = &mb[-s->mb_width - 1];
953 18330 mbsplits_top = vp8_mbsplits[top_mb->partitioning];
954 18330 top_mv = top_mb->bmv;
955
956
2/2
✓ Branch 1 taken 11715 times.
✓ Branch 2 taken 6615 times.
 18330 if (vpx_rac_get_prob_branchy(c, vp8_mbsplit_prob[0])) {
957
2/2
✓ Branch 1 taken 8045 times.
✓ Branch 2 taken 3670 times.
 11715 if (vpx_rac_get_prob_branchy(c, vp8_mbsplit_prob[1]))
958 8045 part_idx = VP8_SPLITMVMODE_16x8 + vpx_rac_get_prob(c, vp8_mbsplit_prob[2]);
959 else
960 3670 part_idx = VP8_SPLITMVMODE_8x8;
961 } else {
962 6615 part_idx = VP8_SPLITMVMODE_4x4;
963 }
964
965 18330 num = vp8_mbsplit_count[part_idx];
966 18330 mbsplits_cur = vp8_mbsplits[part_idx],
967 18330 firstidx = vp8_mbfirstidx[part_idx];
968 18330 mb->partitioning = part_idx;
969
970
2/2
✓ Branch 0 taken 136610 times.
✓ Branch 1 taken 18330 times.
 154940 for (n = 0; n < num; n++) {
971 136610 int k = firstidx[n];
972 uint32_t left, above;
973 const uint8_t *submv_prob;
974
975
2/2
✓ Branch 0 taken 46755 times.
✓ Branch 1 taken 89855 times.
 136610 if (!(k & 3))
976 46755 left = AV_RN32A(&left_mv[mbsplits_left[k + 3]]);
977 else
978 89855 left = AV_RN32A(&cur_mv[mbsplits_cur[k - 1]]);
979
2/2
✓ Branch 0 taken 44980 times.
✓ Branch 1 taken 91630 times.
 136610 if (k <= 3)
980 44980 above = AV_RN32A(&top_mv[mbsplits_top[k + 12]]);
981 else
982 91630 above = AV_RN32A(&cur_mv[mbsplits_cur[k - 4]]);
983
984 136610 submv_prob = get_submv_prob(left, above, is_vp7);
985
986
2/2
✓ Branch 1 taken 50617 times.
✓ Branch 2 taken 85993 times.
 136610 if (vpx_rac_get_prob_branchy(c, submv_prob[0])) {
987
2/2
✓ Branch 1 taken 31746 times.
✓ Branch 2 taken 18871 times.
 50617 if (vpx_rac_get_prob_branchy(c, submv_prob[1])) {
988
2/2
✓ Branch 1 taken 28258 times.
✓ Branch 2 taken 3488 times.
 31746 if (vpx_rac_get_prob_branchy(c, submv_prob[2])) {
989 56516 mb->bmv[n].y = mb->mv.y +
990 28258 read_mv_component(c, s->prob->mvc[0], is_vp7);
991 28258 mb->bmv[n].x = mb->mv.x +
992 28258 read_mv_component(c, s->prob->mvc[1], is_vp7);
993 } else {
994 3488 AV_ZERO32(&mb->bmv[n]);
995 }
996 } else {
997 18871 AV_WN32A(&mb->bmv[n], above);
998 }
999 } else {
1000 85993 AV_WN32A(&mb->bmv[n], left);
1001 }
1002 }
1003
1004 18330 return num;
1005 }
1006
1007 /**
1008 * The vp7 reference decoder uses a padding macroblock column (added to right
1009 * edge of the frame) to guard against illegal macroblock offsets. The
1010 * algorithm has bugs that permit offsets to straddle the padding column.
1011 * This function replicates those bugs.
1012 *
1013 * @param[out] edge_x macroblock x address
1014 * @param[out] edge_y macroblock y address
1015 *
1016 * @return macroblock offset legal (boolean)
1017 */
1018 79200 static int vp7_calculate_mb_offset(int mb_x, int mb_y, int mb_width,
1019 int xoffset, int yoffset, int boundary,
1020 int *edge_x, int *edge_y)
1021 {
1022 79200 int vwidth = mb_width + 1;
1023 79200 int new = (mb_y + yoffset) * vwidth + mb_x + xoffset;
1024
4/4
✓ Branch 0 taken 69690 times.
✓ Branch 1 taken 9510 times.
✓ Branch 2 taken 2760 times.
✓ Branch 3 taken 66930 times.
 79200 if (new < boundary || new % vwidth == vwidth - 1)
1025 12270 return 0;
1026 66930 *edge_y = new / vwidth;
1027 66930 *edge_x = new % vwidth;
1028 66930 return 1;
1029 }
1030
1031 66930 static const VP8mv *get_bmv_ptr(const VP8Macroblock *mb, int subblock)
1032 {
1033
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 66930 times.
 66930 return &mb->bmv[mb->mode == VP8_MVMODE_SPLIT ? vp8_mbsplits[mb->partitioning][subblock] : 0];
1034 }
1035
1036 static av_always_inline
1037 6600 void vp7_decode_mvs(VP8Context *s, VP8Macroblock *mb,
1038 int mb_x, int mb_y, int layout)
1039 {
1040 enum { CNT_ZERO, CNT_NEAREST, CNT_NEAR };
1041 enum { VP8_EDGE_TOP, VP8_EDGE_LEFT, VP8_EDGE_TOPLEFT };
1042 6600 int idx = CNT_ZERO;
1043 VP8mv near_mv[3];
1044 6600 uint8_t cnt[3] = { 0 };
1045 6600 VPXRangeCoder *c = &s->c;
1046 int i;
1047
1048 6600 AV_ZERO32(&near_mv[0]);
1049 6600 AV_ZERO32(&near_mv[1]);
1050 6600 AV_ZERO32(&near_mv[2]);
1051
1052
2/2
✓ Branch 0 taken 79200 times.
✓ Branch 1 taken 6600 times.
 85800 for (i = 0; i < VP7_MV_PRED_COUNT; i++) {
1053 79200 const VP7MVPred * pred = &vp7_mv_pred[i];
1054 int edge_x, edge_y;
1055
1056
2/2
✓ Branch 0 taken 66930 times.
✓ Branch 1 taken 12270 times.
 79200 if (vp7_calculate_mb_offset(mb_x, mb_y, s->mb_width, pred->xoffset,
1057 79200 pred->yoffset, !s->profile, &edge_x, &edge_y)) {
1058
1/2
✓ Branch 0 taken 66930 times.
✗ Branch 1 not taken.
 66930 const VP8Macroblock *edge = (s->mb_layout == 1)
1059 66930 ? s->macroblocks_base + 1 + edge_x +
1060 66930 (s->mb_width + 1) * (edge_y + 1)
1061 ✗ : s->macroblocks + edge_x +
1062 ✗ (s->mb_height - edge_y - 1) * 2;
1063 66930 uint32_t mv = AV_RN32A(get_bmv_ptr(edge, vp7_mv_pred[i].subblock));
1064
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 66930 times.
 66930 if (mv) {
1065 ✗ if (AV_RN32A(&near_mv[CNT_NEAREST])) {
1066 ✗ if (mv == AV_RN32A(&near_mv[CNT_NEAREST])) {
1067 ✗ idx = CNT_NEAREST;
1068 ✗ } else if (AV_RN32A(&near_mv[CNT_NEAR])) {
1069 ✗ if (mv != AV_RN32A(&near_mv[CNT_NEAR]))
1070 ✗ continue;
1071 ✗ idx = CNT_NEAR;
1072 } else {
1073 ✗ AV_WN32A(&near_mv[CNT_NEAR], mv);
1074 ✗ idx = CNT_NEAR;
1075 }
1076 } else {
1077 ✗ AV_WN32A(&near_mv[CNT_NEAREST], mv);
1078 ✗ idx = CNT_NEAREST;
1079 }
1080 } else {
1081 66930 idx = CNT_ZERO;
1082 }
1083 } else {
1084 12270 idx = CNT_ZERO;
1085 }
1086 79200 cnt[idx] += vp7_mv_pred[i].score;
1087 }
1088
1089 6600 mb->partitioning = VP8_SPLITMVMODE_NONE;
1090
1091
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6600 times.
 6600 if (vpx_rac_get_prob_branchy(c, vp7_mode_contexts[cnt[CNT_ZERO]][0])) {
1092 ✗ mb->mode = VP8_MVMODE_MV;
1093
1094 ✗ if (vpx_rac_get_prob_branchy(c, vp7_mode_contexts[cnt[CNT_NEAREST]][1])) {
1095
1096 ✗ if (vpx_rac_get_prob_branchy(c, vp7_mode_contexts[cnt[CNT_NEAR]][2])) {
1097
1098 ✗ if (cnt[CNT_NEAREST] > cnt[CNT_NEAR])
1099 ✗ AV_WN32A(&mb->mv, cnt[CNT_ZERO] > cnt[CNT_NEAREST] ? 0 : AV_RN32A(&near_mv[CNT_NEAREST]));
1100 else
1101 ✗ AV_WN32A(&mb->mv, cnt[CNT_ZERO] > cnt[CNT_NEAR] ? 0 : AV_RN32A(&near_mv[CNT_NEAR]));
1102
1103 ✗ if (vpx_rac_get_prob_branchy(c, vp7_mode_contexts[cnt[CNT_NEAR]][3])) {
1104 ✗ mb->mode = VP8_MVMODE_SPLIT;
1105 ✗ mb->mv = mb->bmv[decode_splitmvs(s, c, mb, layout, IS_VP7) - 1];
1106 } else {
1107 ✗ mb->mv.y += vp7_read_mv_component(c, s->prob->mvc[0]);
1108 ✗ mb->mv.x += vp7_read_mv_component(c, s->prob->mvc[1]);
1109 ✗ mb->bmv[0] = mb->mv;
1110 }
1111 } else {
1112 ✗ mb->mv = near_mv[CNT_NEAR];
1113 ✗ mb->bmv[0] = mb->mv;
1114 }
1115 } else {
1116 ✗ mb->mv = near_mv[CNT_NEAREST];
1117 ✗ mb->bmv[0] = mb->mv;
1118 }
1119 } else {
1120 6600 mb->mode = VP8_MVMODE_ZERO;
1121 6600 AV_ZERO32(&mb->mv);
1122 6600 mb->bmv[0] = mb->mv;
1123 }
1124 6600 }
1125
1126 static av_always_inline
1127 379966 void vp8_decode_mvs(VP8Context *s, const VP8mvbounds *mv_bounds, VP8Macroblock *mb,
1128 int mb_x, int mb_y, int layout)
1129 {
1130 379966 VP8Macroblock *mb_edge[3] = { 0 /* top */,
1131 379966 mb - 1 /* left */,
1132 0 /* top-left */ };
1133 enum { CNT_ZERO, CNT_NEAREST, CNT_NEAR, CNT_SPLITMV };
1134 enum { VP8_EDGE_TOP, VP8_EDGE_LEFT, VP8_EDGE_TOPLEFT };
1135 379966 int idx = CNT_ZERO;
1136 379966 int cur_sign_bias = s->sign_bias[mb->ref_frame];
1137 379966 const int8_t *sign_bias = s->sign_bias;
1138 VP8mv near_mv[4];
1139 379966 uint8_t cnt[4] = { 0 };
1140 379966 VPXRangeCoder *c = &s->c;
1141
1142
1/2
✓ Branch 0 taken 379966 times.
✗ Branch 1 not taken.
 379966 if (!layout) { // layout is inlined (s->mb_layout is not)
1143 379966 mb_edge[0] = mb + 2;
1144 379966 mb_edge[2] = mb + 1;
1145 } else {
1146 ✗ mb_edge[0] = mb - s->mb_width - 1;
1147 ✗ mb_edge[2] = mb - s->mb_width - 2;
1148 }
1149
1150 379966 AV_ZERO32(&near_mv[0]);
1151 379966 AV_ZERO32(&near_mv[1]);
1152 379966 AV_ZERO32(&near_mv[2]);
1153
1154 /* Process MB on top, left and top-left */
1155 #define MV_EDGE_CHECK(n) \
1156 { \
1157 const VP8Macroblock *edge = mb_edge[n]; \
1158 int edge_ref = edge->ref_frame; \
1159 if (edge_ref != VP8_FRAME_CURRENT) { \
1160 uint32_t mv = AV_RN32A(&edge->mv); \
1161 if (mv) { \
1162 if (cur_sign_bias != sign_bias[edge_ref]) { \
1163 /* SWAR negate of the values in mv. */ \
1164 mv = ~mv; \
1165 mv = ((mv & 0x7fff7fff) + \
1166 0x00010001) ^ (mv & 0x80008000); \
1167 } \
1168 if (!n || mv != AV_RN32A(&near_mv[idx])) \
1169 AV_WN32A(&near_mv[++idx], mv); \
1170 cnt[idx] += 1 + (n != 2); \
1171 } else \
1172 cnt[CNT_ZERO] += 1 + (n != 2); \
1173 } \
1174 }
1175
1176
6/6
✓ Branch 0 taken 353088 times.
✓ Branch 1 taken 26878 times.
✓ Branch 2 taken 44594 times.
✓ Branch 3 taken 308494 times.
✓ Branch 4 taken 109 times.
✓ Branch 5 taken 44485 times.
 379966 MV_EDGE_CHECK(0)
1177
8/8
✓ Branch 0 taken 361057 times.
✓ Branch 1 taken 18909 times.
✓ Branch 2 taken 44761 times.
✓ Branch 3 taken 316296 times.
✓ Branch 4 taken 87 times.
✓ Branch 5 taken 44674 times.
✓ Branch 6 taken 36130 times.
✓ Branch 7 taken 8631 times.
 379966 MV_EDGE_CHECK(1)
1178
8/8
✓ Branch 0 taken 339875 times.
✓ Branch 1 taken 40091 times.
✓ Branch 2 taken 41903 times.
✓ Branch 3 taken 297972 times.
✓ Branch 4 taken 123 times.
✓ Branch 5 taken 41780 times.
✓ Branch 6 taken 24718 times.
✓ Branch 7 taken 17185 times.
 379966 MV_EDGE_CHECK(2)
1179
1180 379966 mb->partitioning = VP8_SPLITMVMODE_NONE;
1181
2/2
✓ Branch 1 taken 57182 times.
✓ Branch 2 taken 322784 times.
 379966 if (vpx_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_ZERO]][0])) {
1182 57182 mb->mode = VP8_MVMODE_MV;
1183
1184 /* If we have three distinct MVs, merge first and last if they're the same */
1185
2/2
✓ Branch 0 taken 12759 times.
✓ Branch 1 taken 44423 times.
 57182 if (cnt[CNT_SPLITMV] &&
1186
2/2
✓ Branch 0 taken 5465 times.
✓ Branch 1 taken 7294 times.
 12759 AV_RN32A(&near_mv[1 + VP8_EDGE_TOP]) == AV_RN32A(&near_mv[1 + VP8_EDGE_TOPLEFT]))
1187 5465 cnt[CNT_NEAREST] += 1;
1188
1189 /* Swap near and nearest if necessary */
1190
2/2
✓ Branch 0 taken 4482 times.
✓ Branch 1 taken 52700 times.
 57182 if (cnt[CNT_NEAR] > cnt[CNT_NEAREST]) {
1191 4482 FFSWAP(uint8_t, cnt[CNT_NEAREST], cnt[CNT_NEAR]);
1192 4482 FFSWAP(VP8mv, near_mv[CNT_NEAREST], near_mv[CNT_NEAR]);
1193 }
1194
1195
2/2
✓ Branch 1 taken 37615 times.
✓ Branch 2 taken 19567 times.
 57182 if (vpx_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_NEAREST]][1])) {
1196
2/2
✓ Branch 1 taken 32527 times.
✓ Branch 2 taken 5088 times.
 37615 if (vpx_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_NEAR]][2])) {
1197 /* Choose the best mv out of 0,0 and the nearest mv */
1198 32527 clamp_mv(mv_bounds, &mb->mv, &near_mv[CNT_ZERO + (cnt[CNT_NEAREST] >= cnt[CNT_ZERO])]);
1199 32527 cnt[CNT_SPLITMV] = ((mb_edge[VP8_EDGE_LEFT]->mode == VP8_MVMODE_SPLIT) +
1200 32527 (mb_edge[VP8_EDGE_TOP]->mode == VP8_MVMODE_SPLIT)) * 2 +
1201 32527 (mb_edge[VP8_EDGE_TOPLEFT]->mode == VP8_MVMODE_SPLIT);
1202
1203
2/2
✓ Branch 1 taken 18330 times.
✓ Branch 2 taken 14197 times.
 32527 if (vpx_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_SPLITMV]][3])) {
1204 18330 mb->mode = VP8_MVMODE_SPLIT;
1205 18330 mb->mv = mb->bmv[decode_splitmvs(s, c, mb, layout, IS_VP8) - 1];
1206 } else {
1207 14197 mb->mv.y += vp8_read_mv_component(c, s->prob->mvc[0]);
1208 14197 mb->mv.x += vp8_read_mv_component(c, s->prob->mvc[1]);
1209 14197 mb->bmv[0] = mb->mv;
1210 }
1211 } else {
1212 5088 clamp_mv(mv_bounds, &mb->mv, &near_mv[CNT_NEAR]);
1213 5088 mb->bmv[0] = mb->mv;
1214 }
1215 } else {
1216 19567 clamp_mv(mv_bounds, &mb->mv, &near_mv[CNT_NEAREST]);
1217 19567 mb->bmv[0] = mb->mv;
1218 }
1219 } else {
1220 322784 mb->mode = VP8_MVMODE_ZERO;
1221 322784 AV_ZERO32(&mb->mv);
1222 322784 mb->bmv[0] = mb->mv;
1223 }
1224 379966 }
1225
1226 static av_always_inline
1227 17852 void decode_intra4x4_modes(VP8Context *s, VPXRangeCoder *c, VP8Macroblock *mb,
1228 int mb_x, int keyframe, int layout)
1229 {
1230 17852 uint8_t *intra4x4 = mb->intra4x4_pred_mode_mb;
1231
1232
2/2
✓ Branch 0 taken 33 times.
✓ Branch 1 taken 17819 times.
 17852 if (layout) {
1233 33 VP8Macroblock *mb_top = mb - s->mb_width - 1;
1234 33 memcpy(mb->intra4x4_pred_mode_top, mb_top->intra4x4_pred_mode_top, 4);
1235 }
1236
2/2
✓ Branch 0 taken 10952 times.
✓ Branch 1 taken 6900 times.
 17852 if (keyframe) {
1237 int x, y;
1238 uint8_t *top;
1239 10952 uint8_t *const left = s->intra4x4_pred_mode_left;
1240
2/2
✓ Branch 0 taken 33 times.
✓ Branch 1 taken 10919 times.
 10952 if (layout)
1241 33 top = mb->intra4x4_pred_mode_top;
1242 else
1243 10919 top = s->intra4x4_pred_mode_top + 4 * mb_x;
1244
2/2
✓ Branch 0 taken 43808 times.
✓ Branch 1 taken 10952 times.
 54760 for (y = 0; y < 4; y++) {
1245
2/2
✓ Branch 0 taken 175232 times.
✓ Branch 1 taken 43808 times.
 219040 for (x = 0; x < 4; x++) {
1246 const uint8_t *ctx;
1247 175232 ctx = vp8_pred4x4_prob_intra[top[x]][left[y]];
1248 175232 *intra4x4 = vp89_rac_get_tree(c, vp8_pred4x4_tree, ctx);
1249 175232 left[y] = top[x] = *intra4x4;
1250 175232 intra4x4++;
1251 }
1252 }
1253 } else {
1254 int i;
1255
2/2
✓ Branch 0 taken 110400 times.
✓ Branch 1 taken 6900 times.
 117300 for (i = 0; i < 16; i++)
1256 110400 intra4x4[i] = vp89_rac_get_tree(c, vp8_pred4x4_tree,
1257 vp8_pred4x4_prob_inter);
1258 }
1259 17852 }
1260
1261 static av_always_inline
1262 444389 void decode_mb_mode(VP8Context *s, const VP8mvbounds *mv_bounds,
1263 VP8Macroblock *mb, int mb_x, int mb_y,
1264 uint8_t *segment, const uint8_t *ref, int layout, int is_vp7)
1265 {
1266 444389 VPXRangeCoder *c = &s->c;
1267 static const char * const vp7_feature_name[] = { "q-index",
1268 "lf-delta",
1269 "partial-golden-update",
1270 "blit-pitch" };
1271
2/2
✓ Branch 0 taken 6820 times.
✓ Branch 1 taken 437569 times.
 444389 if (is_vp7) {
1272 int i;
1273 6820 *segment = 0;
1274
2/2
✓ Branch 0 taken 27280 times.
✓ Branch 1 taken 6820 times.
 34100 for (i = 0; i < 4; i++) {
1275
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 27280 times.
 27280 if (s->feature_enabled[i]) {
1276 ✗ if (vpx_rac_get_prob_branchy(c, s->feature_present_prob[i])) {
1277 ✗ int index = vp89_rac_get_tree(c, vp7_feature_index_tree,
1278 ✗ s->feature_index_prob[i]);
1279 ✗ av_log(s->avctx, AV_LOG_WARNING,
1280 "Feature %s present in macroblock (value 0x%x)\n",
1281 ✗ vp7_feature_name[i], s->feature_value[i][index]);
1282 }
1283 }
1284 }
1285
2/2
✓ Branch 0 taken 8289 times.
✓ Branch 1 taken 429280 times.
 437569 } else if (s->segmentation.update_map) {
1286 8289 int bit = vpx_rac_get_prob(c, s->prob->segmentid[0]);
1287 8289 *segment = vpx_rac_get_prob(c, s->prob->segmentid[1+bit]) + 2*bit;
1288
2/2
✓ Branch 0 taken 94425 times.
✓ Branch 1 taken 334855 times.
 429280 } else if (s->segmentation.enabled)
1289
1/2
✓ Branch 0 taken 94425 times.
✗ Branch 1 not taken.
 94425 *segment = ref ? *ref : *segment;
1290 444389 mb->segment = *segment;
1291
1292
2/2
✓ Branch 0 taken 436815 times.
✓ Branch 1 taken 7574 times.
 444389 mb->skip = s->mbskip_enabled ? vpx_rac_get_prob(c, s->prob->mbskip) : 0;
1293
1294
2/2
✓ Branch 0 taken 33192 times.
✓ Branch 1 taken 411197 times.
 444389 if (s->keyframe) {
1295 33192 mb->mode = vp89_rac_get_tree(c, vp8_pred16x16_tree_intra,
1296 vp8_pred16x16_prob_intra);
1297
1298
2/2
✓ Branch 0 taken 10952 times.
✓ Branch 1 taken 22240 times.
 33192 if (mb->mode == MODE_I4x4) {
1299 10952 decode_intra4x4_modes(s, c, mb, mb_x, 1, layout);
1300 } else {
1301 22240 const uint32_t modes = (is_vp7 ? vp7_pred4x4_mode
1302
2/2
✓ Branch 0 taken 187 times.
✓ Branch 1 taken 22053 times.
 22240 : vp8_pred4x4_mode)[mb->mode] * 0x01010101u;
1303
2/2
✓ Branch 0 taken 187 times.
✓ Branch 1 taken 22053 times.
 22240 if (s->mb_layout)
1304 187 AV_WN32A(mb->intra4x4_pred_mode_top, modes);
1305 else
1306 22053 AV_WN32A(s->intra4x4_pred_mode_top + 4 * mb_x, modes);
1307 22240 AV_WN32A(s->intra4x4_pred_mode_left, modes);
1308 }
1309
1310 33192 mb->chroma_pred_mode = vp89_rac_get_tree(c, vp8_pred8x8c_tree,
1311 vp8_pred8x8c_prob_intra);
1312 33192 mb->ref_frame = VP8_FRAME_CURRENT;
1313
2/2
✓ Branch 1 taken 386566 times.
✓ Branch 2 taken 24631 times.
 411197 } else if (vpx_rac_get_prob_branchy(c, s->prob->intra)) {
1314 // inter MB, 16.2
1315
2/2
✓ Branch 1 taken 17281 times.
✓ Branch 2 taken 369285 times.
 386566 if (vpx_rac_get_prob_branchy(c, s->prob->last))
1316
2/2
✓ Branch 0 taken 17249 times.
✓ Branch 1 taken 32 times.
 34530 mb->ref_frame =
1317
2/2
✓ Branch 1 taken 8904 times.
✓ Branch 2 taken 8345 times.
 17249 (!is_vp7 && vpx_rac_get_prob(c, s->prob->golden)) ? VP8_FRAME_ALTREF
1318 : VP8_FRAME_GOLDEN;
1319 else
1320 369285 mb->ref_frame = VP8_FRAME_PREVIOUS;
1321 386566 s->ref_count[mb->ref_frame - 1]++;
1322
1323 // motion vectors, 16.3
1324
2/2
✓ Branch 0 taken 6600 times.
✓ Branch 1 taken 379966 times.
 386566 if (is_vp7)
1325 6600 vp7_decode_mvs(s, mb, mb_x, mb_y, layout);
1326 else
1327 379966 vp8_decode_mvs(s, mv_bounds, mb, mb_x, mb_y, layout);
1328 } else {
1329 // intra MB, 16.1
1330 49262 mb->mode = vp89_rac_get_tree(c, vp8_pred16x16_tree_inter,
1331 24631 s->prob->pred16x16);
1332
1333
2/2
✓ Branch 0 taken 6900 times.
✓ Branch 1 taken 17731 times.
 24631 if (mb->mode == MODE_I4x4)
1334 6900 decode_intra4x4_modes(s, c, mb, mb_x, 0, layout);
1335
1336 49262 mb->chroma_pred_mode = vp89_rac_get_tree(c, vp8_pred8x8c_tree,
1337 24631 s->prob->pred8x8c);
1338 24631 mb->ref_frame = VP8_FRAME_CURRENT;
1339 24631 mb->partitioning = VP8_SPLITMVMODE_NONE;
1340 24631 AV_ZERO32(&mb->bmv[0]);
1341 }
1342 444389 }
1343
1344 /**
1345 * @param r arithmetic bitstream reader context
1346 * @param block destination for block coefficients
1347 * @param probs probabilities to use when reading trees from the bitstream
1348 * @param i initial coeff index, 0 unless a separate DC block is coded
1349 * @param qmul array holding the dc/ac dequant factor at position 0/1
1350 *
1351 * @return 0 if no coeffs were decoded
1352 * otherwise, the index of the last coeff decoded plus one
1353 */
1354 static av_always_inline
1355 396199 int decode_block_coeffs_internal(VPXRangeCoder *r, int16_t block[16],
1356 uint8_t probs[16][3][NUM_DCT_TOKENS - 1],
1357 int i, const uint8_t *token_prob, const int16_t qmul[2],
1358 const uint8_t scan[16], int vp7)
1359 {
1360 396199 VPXRangeCoder c = *r;
1361 396199 goto skip_eob;
1362 do {
1363 int coeff;
1364 1117292 restart:
1365
2/2
✓ Branch 1 taken 375995 times.
✓ Branch 2 taken 743416 times.
 1119411 if (!vpx_rac_get_prob_branchy(&c, token_prob[0])) // DCT_EOB
1366 375995 break;
1367
1368 1585879 skip_eob:
1369
2/2
✓ Branch 1 taken 844582 times.
✓ Branch 2 taken 1137496 times.
 1982078 if (!vpx_rac_get_prob_branchy(&c, token_prob[1])) { // DCT_0
1370
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 844582 times.
 844582 if (++i == 16)
1371 ✗ break; // invalid input; blocks should end with EOB
1372 844582 token_prob = probs[i][0];
1373
2/2
✓ Branch 0 taken 2119 times.
✓ Branch 1 taken 842463 times.
 844582 if (vp7)
1374 2119 goto restart;
1375 842463 goto skip_eob;
1376 }
1377
1378
2/2
✓ Branch 1 taken 724324 times.
✓ Branch 2 taken 413172 times.
 1137496 if (!vpx_rac_get_prob_branchy(&c, token_prob[2])) { // DCT_1
1379 724324 coeff = 1;
1380 724324 token_prob = probs[i + 1][1];
1381 } else {
1382
2/2
✓ Branch 1 taken 277997 times.
✓ Branch 2 taken 135175 times.
 413172 if (!vpx_rac_get_prob_branchy(&c, token_prob[3])) { // DCT 2,3,4
1383 277997 coeff = vpx_rac_get_prob_branchy(&c, token_prob[4]);
1384
2/2
✓ Branch 0 taken 115384 times.
✓ Branch 1 taken 162613 times.
 277997 if (coeff)
1385 115384 coeff += vpx_rac_get_prob(&c, token_prob[5]);
1386 277997 coeff += 2;
1387 } else {
1388 // DCT_CAT*
1389
2/2
✓ Branch 1 taken 86560 times.
✓ Branch 2 taken 48615 times.
 135175 if (!vpx_rac_get_prob_branchy(&c, token_prob[6])) {
1390
2/2
✓ Branch 1 taken 46564 times.
✓ Branch 2 taken 39996 times.
 86560 if (!vpx_rac_get_prob_branchy(&c, token_prob[7])) { // DCT_CAT1
1391 46564 coeff = 5 + vpx_rac_get_prob(&c, vp8_dct_cat1_prob[0]);
1392 } else { // DCT_CAT2
1393 39996 coeff = 7;
1394 39996 coeff += vpx_rac_get_prob(&c, vp8_dct_cat2_prob[0]) << 1;
1395 39996 coeff += vpx_rac_get_prob(&c, vp8_dct_cat2_prob[1]);
1396 }
1397 } else { // DCT_CAT3 and up
1398 48615 int a = vpx_rac_get_prob(&c, token_prob[8]);
1399 48615 int b = vpx_rac_get_prob(&c, token_prob[9 + a]);
1400 48615 int cat = (a << 1) + b;
1401 48615 coeff = 3 + (8 << cat);
1402 48615 coeff += vp8_rac_get_coeff(&c, ff_vp8_dct_cat_prob[cat]);
1403 }
1404 }
1405 413172 token_prob = probs[i + 1][2];
1406 }
1407
4/4
✓ Branch 1 taken 572649 times.
✓ Branch 2 taken 564847 times.
✓ Branch 3 taken 836598 times.
✓ Branch 4 taken 300898 times.
 1137496 block[scan[i]] = (vp89_rac_get(&c) ? -coeff : coeff) * qmul[!!i];
1408
2/2
✓ Branch 0 taken 1117292 times.
✓ Branch 1 taken 20204 times.
 1137496 } while (++i < 16);
1409
1410 396199 *r = c;
1411 396199 return i;
1412 }
1413
1414 static av_always_inline
1415 6600 int inter_predict_dc(int16_t block[16], int16_t pred[2])
1416 {
1417 6600 int16_t dc = block[0];
1418 6600 int ret = 0;
1419
1420
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6600 times.
 6600 if (pred[1] > 3) {
1421 ✗ dc += pred[0];
1422 ✗ ret = 1;
1423 }
1424
1425
1/2
✓ Branch 0 taken 6600 times.
✗ Branch 1 not taken.
 6600 if (!pred[0] | !dc | ((int32_t)pred[0] ^ (int32_t)dc) >> 31) {
1426 6600 block[0] = pred[0] = dc;
1427 6600 pred[1] = 0;
1428 } else {
1429 ✗ if (pred[0] == dc)
1430 ✗ pred[1]++;
1431 ✗ block[0] = pred[0] = dc;
1432 }
1433
1434 6600 return ret;
1435 }
1436
1437 735 static int vp7_decode_block_coeffs_internal(VPXRangeCoder *r,
1438 int16_t block[16],
1439 uint8_t probs[16][3][NUM_DCT_TOKENS - 1],
1440 int i, const uint8_t *token_prob,
1441 const int16_t qmul[2],
1442 const uint8_t scan[16])
1443 {
1444 735 return decode_block_coeffs_internal(r, block, probs, i,
1445 token_prob, qmul, scan, IS_VP7);
1446 }
1447
1448 #ifndef vp8_decode_block_coeffs_internal
1449 395464 static int vp8_decode_block_coeffs_internal(VPXRangeCoder *r,
1450 int16_t block[16],
1451 uint8_t probs[16][3][NUM_DCT_TOKENS - 1],
1452 int i, const uint8_t *token_prob,
1453 const int16_t qmul[2])
1454 {
1455 395464 return decode_block_coeffs_internal(r, block, probs, i,
1456 token_prob, qmul, ff_zigzag_scan, IS_VP8);
1457 }
1458 #endif
1459
1460 /**
1461 * @param c arithmetic bitstream reader context
1462 * @param block destination for block coefficients
1463 * @param probs probabilities to use when reading trees from the bitstream
1464 * @param i initial coeff index, 0 unless a separate DC block is coded
1465 * @param zero_nhood the initial prediction context for number of surrounding
1466 * all-zero blocks (only left/top, so 0-2)
1467 * @param qmul array holding the dc/ac dequant factor at position 0/1
1468 * @param scan scan pattern (VP7 only)
1469 *
1470 * @return 0 if no coeffs were decoded
1471 * otherwise, the index of the last coeff decoded plus one
1472 */
1473 static av_always_inline
1474 2076155 int decode_block_coeffs(VPXRangeCoder *c, int16_t block[16],
1475 uint8_t probs[16][3][NUM_DCT_TOKENS - 1],
1476 int i, int zero_nhood, const int16_t qmul[2],
1477 const uint8_t scan[16], int vp7)
1478 {
1479 2076155 const uint8_t *token_prob = probs[i][zero_nhood];
1480
2/2
✓ Branch 1 taken 1679956 times.
✓ Branch 2 taken 396199 times.
 2076155 if (!vpx_rac_get_prob_branchy(c, token_prob[0])) // DCT_EOB
1481 1679956 return 0;
1482 735 return vp7 ? vp7_decode_block_coeffs_internal(c, block, probs, i,
1483 token_prob, qmul, scan)
1484
2/2
✓ Branch 0 taken 735 times.
✓ Branch 1 taken 395464 times.
 396934 : vp8_decode_block_coeffs_internal(c, block, probs, i,
1485 token_prob, qmul);
1486 }
1487
1488 static av_always_inline
1489 84344 void decode_mb_coeffs(VP8Context *s, VP8ThreadData *td, VPXRangeCoder *c,
1490 VP8Macroblock *mb, uint8_t t_nnz[9], uint8_t l_nnz[9],
1491 int is_vp7)
1492 {
1493 84344 int i, x, y, luma_start = 0, luma_ctx = 3;
1494 84344 int nnz_pred, nnz, nnz_total = 0;
1495 84344 int segment = mb->segment;
1496 84344 int block_dc = 0;
1497
1498
6/6
✓ Branch 0 taken 66962 times.
✓ Branch 1 taken 17382 times.
✓ Branch 2 taken 60175 times.
✓ Branch 3 taken 6787 times.
✓ Branch 4 taken 45112 times.
✓ Branch 5 taken 15063 times.
 84344 if (mb->mode != MODE_I4x4 && (is_vp7 || mb->mode != VP8_MVMODE_SPLIT)) {
1499 51899 nnz_pred = t_nnz[8] + l_nnz[8];
1500
1501 // decode DC values and do hadamard
1502 51899 nnz = decode_block_coeffs(c, td->block_dc, s->prob->token[1], 0,
1503 51899 nnz_pred, s->qmat[segment].luma_dc_qmul,
1504 ff_zigzag_scan, is_vp7);
1505 51899 l_nnz[8] = t_nnz[8] = !!nnz;
1506
1507
4/4
✓ Branch 0 taken 6787 times.
✓ Branch 1 taken 45112 times.
✓ Branch 2 taken 6600 times.
✓ Branch 3 taken 187 times.
 51899 if (is_vp7 && mb->mode > MODE_I4x4) {
1508 6600 nnz |= inter_predict_dc(td->block_dc,
1509 6600 s->inter_dc_pred[mb->ref_frame - 1]);
1510 }
1511
1512
2/2
✓ Branch 0 taken 35372 times.
✓ Branch 1 taken 16527 times.
 51899 if (nnz) {
1513 35372 nnz_total += nnz;
1514 35372 block_dc = 1;
1515
2/2
✓ Branch 0 taken 10511 times.
✓ Branch 1 taken 24861 times.
 35372 if (nnz == 1)
1516 10511 s->vp8dsp.vp8_luma_dc_wht_dc(td->block, td->block_dc);
1517 else
1518 24861 s->vp8dsp.vp8_luma_dc_wht(td->block, td->block_dc);
1519 }
1520 51899 luma_start = 1;
1521 51899 luma_ctx = 0;
1522 }
1523
1524 // luma blocks
1525
2/2
✓ Branch 0 taken 337376 times.
✓ Branch 1 taken 84344 times.
 421720 for (y = 0; y < 4; y++)
1526
2/2
✓ Branch 0 taken 1349504 times.
✓ Branch 1 taken 337376 times.
 1686880 for (x = 0; x < 4; x++) {
1527 1349504 nnz_pred = l_nnz[y] + t_nnz[x];
1528 1349504 nnz = decode_block_coeffs(c, td->block[y][x],
1529 1349504 s->prob->token[luma_ctx],
1530 luma_start, nnz_pred,
1531 1349504 s->qmat[segment].luma_qmul,
1532 1349504 s->prob[0].scan, is_vp7);
1533 /* nnz+block_dc may be one more than the actual last index,
1534 * but we don't care */
1535 1349504 td->non_zero_count_cache[y][x] = nnz + block_dc;
1536 1349504 t_nnz[x] = l_nnz[y] = !!nnz;
1537 1349504 nnz_total += nnz;
1538 }
1539
1540 // chroma blocks
1541 // TODO: what to do about dimensions? 2nd dim for luma is x,
1542 // but for chroma it's (y<<1)|x
1543
2/2
✓ Branch 0 taken 168688 times.
✓ Branch 1 taken 84344 times.
 253032 for (i = 4; i < 6; i++)
1544
2/2
✓ Branch 0 taken 337376 times.
✓ Branch 1 taken 168688 times.
 506064 for (y = 0; y < 2; y++)
1545
2/2
✓ Branch 0 taken 674752 times.
✓ Branch 1 taken 337376 times.
 1012128 for (x = 0; x < 2; x++) {
1546 674752 nnz_pred = l_nnz[i + 2 * y] + t_nnz[i + 2 * x];
1547 674752 nnz = decode_block_coeffs(c, td->block[i][(y << 1) + x],
1548 674752 s->prob->token[2], 0, nnz_pred,
1549 674752 s->qmat[segment].chroma_qmul,
1550 674752 s->prob[0].scan, is_vp7);
1551 674752 td->non_zero_count_cache[i][(y << 1) + x] = nnz;
1552 674752 t_nnz[i + 2 * x] = l_nnz[i + 2 * y] = !!nnz;
1553 674752 nnz_total += nnz;
1554 }
1555
1556 // if there were no coded coeffs despite the macroblock not being marked skip,
1557 // we MUST not do the inner loop filter and should not do IDCT
1558 // Since skip isn't used for bitstream prediction, just manually set it.
1559
2/2
✓ Branch 0 taken 6676 times.
✓ Branch 1 taken 77668 times.
 84344 if (!nnz_total)
1560 6676 mb->skip = 1;
1561 84344 }
1562
1563 static av_always_inline
1564 425089 void backup_mb_border(uint8_t *top_border, const uint8_t *src_y,
1565 const uint8_t *src_cb, const uint8_t *src_cr,
1566 ptrdiff_t linesize, ptrdiff_t uvlinesize, int simple)
1567 {
1568 425089 AV_COPY128(top_border, src_y + 15 * linesize);
1569
2/2
✓ Branch 0 taken 417367 times.
✓ Branch 1 taken 7722 times.
 425089 if (!simple) {
1570 417367 AV_COPY64(top_border + 16, src_cb + 7 * uvlinesize);
1571 417367 AV_COPY64(top_border + 24, src_cr + 7 * uvlinesize);
1572 }
1573 425089 }
1574
1575 static av_always_inline
1576 84358 void xchg_mb_border(uint8_t *top_border, uint8_t *src_y, uint8_t *src_cb,
1577 uint8_t *src_cr, ptrdiff_t linesize, ptrdiff_t uvlinesize, int mb_x,
1578 int mb_y, int mb_width, int simple, int xchg)
1579 {
1580 84358 uint8_t *top_border_m1 = top_border - 32; // for TL prediction
1581 84358 src_y -= linesize;
1582 84358 src_cb -= uvlinesize;
1583 84358 src_cr -= uvlinesize;
1584
1585 #define XCHG(a, b, xchg) \
1586 do { \
1587 if (xchg) \
1588 AV_SWAP64(b, a); \
1589 else \
1590 AV_COPY64(b, a); \
1591 } while (0)
1592
1593
2/2
✓ Branch 0 taken 42179 times.
✓ Branch 1 taken 42179 times.
 84358 XCHG(top_border_m1 + 8, src_y - 8, xchg);
1594
2/2
✓ Branch 0 taken 42179 times.
✓ Branch 1 taken 42179 times.
 84358 XCHG(top_border, src_y, xchg);
1595 84358 XCHG(top_border + 8, src_y + 8, 1);
1596
2/2
✓ Branch 0 taken 80910 times.
✓ Branch 1 taken 3448 times.
 84358 if (mb_x < mb_width - 1)
1597 80910 XCHG(top_border + 32, src_y + 16, 1);
1598
1599 // only copy chroma for normal loop filter
1600 // or to initialize the top row to 127
1601
3/4
✓ Branch 0 taken 3082 times.
✓ Branch 1 taken 81276 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 3082 times.
 84358 if (!simple || !mb_y) {
1602
2/2
✓ Branch 0 taken 40638 times.
✓ Branch 1 taken 40638 times.
 81276 XCHG(top_border_m1 + 16, src_cb - 8, xchg);
1603
2/2
✓ Branch 0 taken 40638 times.
✓ Branch 1 taken 40638 times.
 81276 XCHG(top_border_m1 + 24, src_cr - 8, xchg);
1604 81276 XCHG(top_border + 16, src_cb, 1);
1605 81276 XCHG(top_border + 24, src_cr, 1);
1606 }
1607 84358 }
1608
1609 static av_always_inline
1610 73479 int check_dc_pred8x8_mode(int mode, int mb_x, int mb_y)
1611 {
1612
2/2
✓ Branch 0 taken 3089 times.
✓ Branch 1 taken 70390 times.
 73479 if (!mb_x)
1613
2/2
✓ Branch 0 taken 2887 times.
✓ Branch 1 taken 202 times.
 3089 return mb_y ? TOP_DC_PRED8x8 : DC_128_PRED8x8;
1614 else
1615
2/2
✓ Branch 0 taken 65028 times.
✓ Branch 1 taken 5362 times.
 70390 return mb_y ? mode : LEFT_DC_PRED8x8;
1616 }
1617
1618 static av_always_inline
1619 1822 int check_tm_pred8x8_mode(int mode, int mb_x, int mb_y, int vp7)
1620 {
1621
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1821 times.
 1822 if (!mb_x)
1622
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 1 return mb_y ? VERT_PRED8x8 : (vp7 ? DC_128_PRED8x8 : DC_129_PRED8x8);
1623 else
1624
2/2
✓ Branch 0 taken 1819 times.
✓ Branch 1 taken 2 times.
 1821 return mb_y ? mode : HOR_PRED8x8;
1625 }
1626
1627 static av_always_inline
1628 97794 int check_intra_pred8x8_mode_emuedge(int mode, int mb_x, int mb_y, int vp7)
1629 {
1630
4/5
✓ Branch 0 taken 73479 times.
✓ Branch 1 taken 5795 times.
✓ Branch 2 taken 16698 times.
✓ Branch 3 taken 1822 times.
✗ Branch 4 not taken.
 97794 switch (mode) {
1631 73479 case DC_PRED8x8:
1632 73479 return check_dc_pred8x8_mode(mode, mb_x, mb_y);
1633 5795 case VERT_PRED8x8:
1634
3/4
✓ Branch 0 taken 66 times.
✓ Branch 1 taken 5729 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 66 times.
 5795 return !mb_y ? (vp7 ? DC_128_PRED8x8 : DC_127_PRED8x8) : mode;
1635 16698 case HOR_PRED8x8:
1636
3/4
✓ Branch 0 taken 142 times.
✓ Branch 1 taken 16556 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 142 times.
 16698 return !mb_x ? (vp7 ? DC_128_PRED8x8 : DC_129_PRED8x8) : mode;
1637 1822 case PLANE_PRED8x8: /* TM */
1638 1822 return check_tm_pred8x8_mode(mode, mb_x, mb_y, vp7);
1639 }
1640 ✗ return mode;
1641 }
1642
1643 static av_always_inline
1644 50224 int check_tm_pred4x4_mode(int mode, int mb_x, int mb_y, int vp7)
1645 {
1646
2/2
✓ Branch 0 taken 1362 times.
✓ Branch 1 taken 48862 times.
 50224 if (!mb_x) {
1647
3/4
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1361 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
 1362 return mb_y ? VERT_VP8_PRED : (vp7 ? DC_128_PRED : DC_129_PRED);
1648 } else {
1649
2/2
✓ Branch 0 taken 47453 times.
✓ Branch 1 taken 1409 times.
 48862 return mb_y ? mode : HOR_VP8_PRED;
1650 }
1651 }
1652
1653 static av_always_inline
1654 285632 int check_intra_pred4x4_mode_emuedge(int mode, int mb_x, int mb_y,
1655 int *copy_buf, int vp7)
1656 {
1657
6/7
✓ Branch 0 taken 13719 times.
✓ Branch 1 taken 21533 times.
✓ Branch 2 taken 19570 times.
✓ Branch 3 taken 12393 times.
✓ Branch 4 taken 50224 times.
✓ Branch 5 taken 168193 times.
✗ Branch 6 not taken.
 285632 switch (mode) {
1658 13719 case VERT_PRED:
1659
3/4
✓ Branch 0 taken 95 times.
✓ Branch 1 taken 13624 times.
✓ Branch 2 taken 95 times.
✗ Branch 3 not taken.
 13719 if (!mb_x && mb_y) {
1660 95 *copy_buf = 1;
1661 95 return mode;
1662 }
1663 /* fall-through */
1664 case DIAG_DOWN_LEFT_PRED:
1665 case VERT_LEFT_PRED:
1666
3/4
✓ Branch 0 taken 24 times.
✓ Branch 1 taken 35133 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 24 times.
 35157 return !mb_y ? (vp7 ? DC_128_PRED : DC_127_PRED) : mode;
1667 19570 case HOR_PRED:
1668
2/2
✓ Branch 0 taken 128 times.
✓ Branch 1 taken 19442 times.
 19570 if (!mb_y) {
1669 128 *copy_buf = 1;
1670 128 return mode;
1671 }
1672 /* fall-through */
1673 case HOR_UP_PRED:
1674
3/4
✓ Branch 0 taken 44 times.
✓ Branch 1 taken 31791 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 44 times.
 31835 return !mb_x ? (vp7 ? DC_128_PRED : DC_129_PRED) : mode;
1675 50224 case TM_VP8_PRED:
1676 50224 return check_tm_pred4x4_mode(mode, mb_x, mb_y, vp7);
1677 168193 case DC_PRED: /* 4x4 DC doesn't use the same "H.264-style" exceptions
1678 * as 16x16/8x8 DC */
1679 case DIAG_DOWN_RIGHT_PRED:
1680 case VERT_RIGHT_PRED:
1681 case HOR_DOWN_PRED:
1682
4/4
✓ Branch 0 taken 167619 times.
✓ Branch 1 taken 574 times.
✓ Branch 2 taken 566 times.
✓ Branch 3 taken 167053 times.
 168193 if (!mb_y || !mb_x)
1683 1140 *copy_buf = 1;
1684 168193 return mode;
1685 }
1686 ✗ return mode;
1687 }
1688
1689 static av_always_inline
1690 57823 void intra_predict(VP8Context *s, VP8ThreadData *td, uint8_t *const dst[3],
1691 VP8Macroblock *mb, int mb_x, int mb_y, int is_vp7)
1692 {
1693 int x, y, mode, nnz;
1694 uint32_t tr;
1695
1696 /* for the first row, we need to run xchg_mb_border to init the top edge
1697 * to 127 otherwise, skip it if we aren't going to deblock */
1698
6/8
✓ Branch 0 taken 54412 times.
✓ Branch 1 taken 3411 times.
✓ Branch 2 taken 12233 times.
✓ Branch 3 taken 42179 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 12233 times.
✓ Branch 6 taken 42179 times.
✗ Branch 7 not taken.
 57823 if (mb_y && (s->deblock_filter || !mb_y) && td->thread_nr == 0)
1699 42179 xchg_mb_border(s->top_border[mb_x + 1], dst[0], dst[1], dst[2],
1700 42179 s->linesize, s->uvlinesize, mb_x, mb_y, s->mb_width,
1701 42179 s->filter.simple, 1);
1702
1703
2/2
✓ Branch 0 taken 39971 times.
✓ Branch 1 taken 17852 times.
 57823 if (mb->mode < MODE_I4x4) {
1704 39971 mode = check_intra_pred8x8_mode_emuedge(mb->mode, mb_x, mb_y, is_vp7);
1705 39971 s->hpc.pred16x16[mode](dst[0], s->linesize);
1706 } else {
1707 17852 uint8_t *ptr = dst[0];
1708 17852 const uint8_t *intra4x4 = mb->intra4x4_pred_mode_mb;
1709
2/2
✓ Branch 0 taken 33 times.
✓ Branch 1 taken 17819 times.
 17852 const uint8_t lo = is_vp7 ? 128 : 127;
1710
2/2
✓ Branch 0 taken 33 times.
✓ Branch 1 taken 17819 times.
 17852 const uint8_t hi = is_vp7 ? 128 : 129;
1711 17852 const uint8_t tr_top[4] = { lo, lo, lo, lo };
1712
1713 // all blocks on the right edge of the macroblock use bottom edge
1714 // the top macroblock for their topright edge
1715 17852 const uint8_t *tr_right = ptr - s->linesize + 16;
1716
1717 // if we're on the right edge of the frame, said edge is extended
1718 // from the top macroblock
1719
4/4
✓ Branch 0 taken 17221 times.
✓ Branch 1 taken 631 times.
✓ Branch 2 taken 637 times.
✓ Branch 3 taken 16584 times.
 17852 if (mb_y && mb_x == s->mb_width - 1) {
1720 637 tr = tr_right[-1] * 0x01010101u;
1721 637 tr_right = (uint8_t *) &tr;
1722 }
1723
1724
2/2
✓ Branch 0 taken 471 times.
✓ Branch 1 taken 17381 times.
 17852 if (mb->skip)
1725 471 AV_ZERO128(td->non_zero_count_cache);
1726
1727
2/2
✓ Branch 0 taken 71408 times.
✓ Branch 1 taken 17852 times.
 89260 for (y = 0; y < 4; y++) {
1728 71408 const uint8_t *topright = ptr + 4 - s->linesize;
1729
2/2
✓ Branch 0 taken 285632 times.
✓ Branch 1 taken 71408 times.
 357040 for (x = 0; x < 4; x++) {
1730 285632 int copy = 0;
1731 285632 ptrdiff_t linesize = s->linesize;
1732 285632 uint8_t *dst = ptr + 4 * x;
1733 285632 LOCAL_ALIGNED(4, uint8_t, copy_dst, [5 * 8]);
1734
1735
6/6
✓ Branch 0 taken 214224 times.
✓ Branch 1 taken 71408 times.
✓ Branch 2 taken 53556 times.
✓ Branch 3 taken 160668 times.
✓ Branch 4 taken 4417 times.
✓ Branch 5 taken 120547 times.
 285632 if ((y == 0 || x == 3) && mb_y == 0) {
1736 4417 topright = tr_top;
1737
2/2
✓ Branch 0 taken 68884 times.
✓ Branch 1 taken 212331 times.
 281215 } else if (x == 3)
1738 68884 topright = tr_right;
1739
1740 285632 mode = check_intra_pred4x4_mode_emuedge(intra4x4[x], mb_x + x,
1741 mb_y + y, &copy, is_vp7);
1742
2/2
✓ Branch 0 taken 1363 times.
✓ Branch 1 taken 284269 times.
 285632 if (copy) {
1743 1363 dst = copy_dst + 12;
1744 1363 linesize = 8;
1745
2/2
✓ Branch 0 taken 702 times.
✓ Branch 1 taken 661 times.
 1363 if (!(mb_y + y)) {
1746 702 copy_dst[3] = lo;
1747 702 AV_WN32A(copy_dst + 4, lo * 0x01010101U);
1748 } else {
1749 661 AV_COPY32(copy_dst + 4, ptr + 4 * x - s->linesize);
1750
1/2
✓ Branch 0 taken 661 times.
✗ Branch 1 not taken.
 661 if (!(mb_x + x)) {
1751 661 copy_dst[3] = hi;
1752 } else {
1753 ✗ copy_dst[3] = ptr[4 * x - s->linesize - 1];
1754 }
1755 }
1756
2/2
✓ Branch 0 taken 702 times.
✓ Branch 1 taken 661 times.
 1363 if (!(mb_x + x)) {
1757 702 copy_dst[11] =
1758 702 copy_dst[19] =
1759 702 copy_dst[27] =
1760 702 copy_dst[35] = hi;
1761 } else {
1762 661 copy_dst[11] = ptr[4 * x - 1];
1763 661 copy_dst[19] = ptr[4 * x + s->linesize - 1];
1764 661 copy_dst[27] = ptr[4 * x + s->linesize * 2 - 1];
1765 661 copy_dst[35] = ptr[4 * x + s->linesize * 3 - 1];
1766 }
1767 }
1768 285632 s->hpc.pred4x4[mode](dst, topright, linesize);
1769
2/2
✓ Branch 0 taken 1363 times.
✓ Branch 1 taken 284269 times.
 285632 if (copy) {
1770 1363 AV_COPY32(ptr + 4 * x, copy_dst + 12);
1771 1363 AV_COPY32(ptr + 4 * x + s->linesize, copy_dst + 20);
1772 1363 AV_COPY32(ptr + 4 * x + s->linesize * 2, copy_dst + 28);
1773 1363 AV_COPY32(ptr + 4 * x + s->linesize * 3, copy_dst + 36);
1774 }
1775
1776 285632 nnz = td->non_zero_count_cache[y][x];
1777
2/2
✓ Branch 0 taken 123826 times.
✓ Branch 1 taken 161806 times.
 285632 if (nnz) {
1778
2/2
✓ Branch 0 taken 35355 times.
✓ Branch 1 taken 88471 times.
 123826 if (nnz == 1)
1779 35355 s->vp8dsp.vp8_idct_dc_add(ptr + 4 * x,
1780 35355 td->block[y][x], s->linesize);
1781 else
1782 88471 s->vp8dsp.vp8_idct_add(ptr + 4 * x,
1783 88471 td->block[y][x], s->linesize);
1784 }
1785 285632 topright += 4;
1786 }
1787
1788 71408 ptr += 4 * s->linesize;
1789 71408 intra4x4 += 4;
1790 }
1791 }
1792
1793 57823 mode = check_intra_pred8x8_mode_emuedge(mb->chroma_pred_mode,
1794 mb_x, mb_y, is_vp7);
1795 57823 s->hpc.pred8x8[mode](dst[1], s->uvlinesize);
1796 57823 s->hpc.pred8x8[mode](dst[2], s->uvlinesize);
1797
1798
6/8
✓ Branch 0 taken 54412 times.
✓ Branch 1 taken 3411 times.
✓ Branch 2 taken 12233 times.
✓ Branch 3 taken 42179 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 12233 times.
✓ Branch 6 taken 42179 times.
✗ Branch 7 not taken.
 57823 if (mb_y && (s->deblock_filter || !mb_y) && td->thread_nr == 0)
1799 42179 xchg_mb_border(s->top_border[mb_x + 1], dst[0], dst[1], dst[2],
1800 42179 s->linesize, s->uvlinesize, mb_x, mb_y, s->mb_width,
1801 42179 s->filter.simple, 0);
1802 57823 }
1803
1804 static const uint8_t subpel_idx[3][8] = {
1805 { 0, 1, 2, 1, 2, 1, 2, 1 }, // nr. of left extra pixels,
1806 // also function pointer index
1807 { 0, 3, 5, 3, 5, 3, 5, 3 }, // nr. of extra pixels required
1808 { 0, 2, 3, 2, 3, 2, 3, 2 }, // nr. of right extra pixels
1809 };
1810
1811 /**
1812 * luma MC function
1813 *
1814 * @param s VP8 decoding context
1815 * @param dst target buffer for block data at block position
1816 * @param ref reference picture buffer at origin (0, 0)
1817 * @param mv motion vector (relative to block position) to get pixel data from
1818 * @param x_off horizontal position of block from origin (0, 0)
1819 * @param y_off vertical position of block from origin (0, 0)
1820 * @param block_w width of block (16, 8 or 4)
1821 * @param block_h height of block (always same as block_w)
1822 * @param width width of src/dst plane data
1823 * @param height height of src/dst plane data
1824 * @param linesize size of a single line of plane data, including padding
1825 * @param mc_func motion compensation function pointers (bilinear or sixtap MC)
1826 */
1827 static av_always_inline
1828 504846 void vp8_mc_luma(VP8Context *s, VP8ThreadData *td, uint8_t *dst,
1829 const ProgressFrame *ref, const VP8mv *mv,
1830 int x_off, int y_off, int block_w, int block_h,
1831 int width, int height, ptrdiff_t linesize,
1832 vp8_mc_func mc_func[3][3])
1833 {
1834 504846 const uint8_t *src = ref->f->data[0];
1835
1836
2/2
✓ Branch 0 taken 124899 times.
✓ Branch 1 taken 379947 times.
 504846 if (AV_RN32A(mv)) {
1837 124899 ptrdiff_t src_linesize = linesize;
1838
1839 124899 int mx = (mv->x * 2) & 7, mx_idx = subpel_idx[0][mx];
1840 124899 int my = (mv->y * 2) & 7, my_idx = subpel_idx[0][my];
1841
1842 124899 x_off += mv->x >> 2;
1843 124899 y_off += mv->y >> 2;
1844
1845 // edge emulation
1846 124899 ff_progress_frame_await(ref, (3 + y_off + block_h + subpel_idx[2][my]) >> 4);
1847 124899 src += y_off * linesize + x_off;
1848
6/6
✓ Branch 0 taken 123700 times.
✓ Branch 1 taken 1199 times.
✓ Branch 2 taken 120199 times.
✓ Branch 3 taken 3501 times.
✓ Branch 4 taken 118706 times.
✓ Branch 5 taken 1493 times.
 124899 if (x_off < mx_idx || x_off >= width - block_w - subpel_idx[2][mx] ||
1849
2/2
✓ Branch 0 taken 3043 times.
✓ Branch 1 taken 115663 times.
 118706 y_off < my_idx || y_off >= height - block_h - subpel_idx[2][my]) {
1850 9236 s->vdsp.emulated_edge_mc(td->edge_emu_buffer,
1851 9236 src - my_idx * linesize - mx_idx,
1852 EDGE_EMU_LINESIZE, linesize,
1853 9236 block_w + subpel_idx[1][mx],
1854 9236 block_h + subpel_idx[1][my],
1855 x_off - mx_idx, y_off - my_idx,
1856 width, height);
1857 9236 src = td->edge_emu_buffer + mx_idx + EDGE_EMU_LINESIZE * my_idx;
1858 9236 src_linesize = EDGE_EMU_LINESIZE;
1859 }
1860 124899 mc_func[my_idx][mx_idx](dst, linesize, src, src_linesize, block_h, mx, my);
1861 } else {
1862 379947 ff_progress_frame_await(ref, (3 + y_off + block_h) >> 4);
1863 379947 mc_func[0][0](dst, linesize, src + y_off * linesize + x_off,
1864 linesize, block_h, 0, 0);
1865 }
1866 504846 }
1867
1868 /**
1869 * chroma MC function
1870 *
1871 * @param s VP8 decoding context
1872 * @param dst1 target buffer for block data at block position (U plane)
1873 * @param dst2 target buffer for block data at block position (V plane)
1874 * @param ref reference picture buffer at origin (0, 0)
1875 * @param mv motion vector (relative to block position) to get pixel data from
1876 * @param x_off horizontal position of block from origin (0, 0)
1877 * @param y_off vertical position of block from origin (0, 0)
1878 * @param block_w width of block (16, 8 or 4)
1879 * @param block_h height of block (always same as block_w)
1880 * @param width width of src/dst plane data
1881 * @param height height of src/dst plane data
1882 * @param linesize size of a single line of plane data, including padding
1883 * @param mc_func motion compensation function pointers (bilinear or sixtap MC)
1884 */
1885 static av_always_inline
1886 425466 void vp8_mc_chroma(VP8Context *s, VP8ThreadData *td, uint8_t *dst1,
1887 uint8_t *dst2, const ProgressFrame *ref, const VP8mv *mv,
1888 int x_off, int y_off, int block_w, int block_h,
1889 int width, int height, ptrdiff_t linesize,
1890 vp8_mc_func mc_func[3][3])
1891 {
1892 425466 const uint8_t *src1 = ref->f->data[1], *src2 = ref->f->data[2];
1893
1894
2/2
✓ Branch 0 taken 79190 times.
✓ Branch 1 taken 346276 times.
 425466 if (AV_RN32A(mv)) {
1895 79190 int mx = mv->x & 7, mx_idx = subpel_idx[0][mx];
1896 79190 int my = mv->y & 7, my_idx = subpel_idx[0][my];
1897
1898 79190 x_off += mv->x >> 3;
1899 79190 y_off += mv->y >> 3;
1900
1901 // edge emulation
1902 79190 src1 += y_off * linesize + x_off;
1903 79190 src2 += y_off * linesize + x_off;
1904 79190 ff_progress_frame_await(ref, (3 + y_off + block_h + subpel_idx[2][my]) >> 3);
1905
6/6
✓ Branch 0 taken 77874 times.
✓ Branch 1 taken 1316 times.
✓ Branch 2 taken 74583 times.
✓ Branch 3 taken 3291 times.
✓ Branch 4 taken 73050 times.
✓ Branch 5 taken 1533 times.
 79190 if (x_off < mx_idx || x_off >= width - block_w - subpel_idx[2][mx] ||
1906
2/2
✓ Branch 0 taken 3017 times.
✓ Branch 1 taken 70033 times.
 73050 y_off < my_idx || y_off >= height - block_h - subpel_idx[2][my]) {
1907 9157 s->vdsp.emulated_edge_mc(td->edge_emu_buffer,
1908 9157 src1 - my_idx * linesize - mx_idx,
1909 EDGE_EMU_LINESIZE, linesize,
1910 9157 block_w + subpel_idx[1][mx],
1911 9157 block_h + subpel_idx[1][my],
1912 x_off - mx_idx, y_off - my_idx, width, height);
1913 9157 src1 = td->edge_emu_buffer + mx_idx + EDGE_EMU_LINESIZE * my_idx;
1914 9157 mc_func[my_idx][mx_idx](dst1, linesize, src1, EDGE_EMU_LINESIZE, block_h, mx, my);
1915
1916 9157 s->vdsp.emulated_edge_mc(td->edge_emu_buffer,
1917 9157 src2 - my_idx * linesize - mx_idx,
1918 EDGE_EMU_LINESIZE, linesize,
1919 9157 block_w + subpel_idx[1][mx],
1920 9157 block_h + subpel_idx[1][my],
1921 x_off - mx_idx, y_off - my_idx, width, height);
1922 9157 src2 = td->edge_emu_buffer + mx_idx + EDGE_EMU_LINESIZE * my_idx;
1923 9157 mc_func[my_idx][mx_idx](dst2, linesize, src2, EDGE_EMU_LINESIZE, block_h, mx, my);
1924 } else {
1925 70033 mc_func[my_idx][mx_idx](dst1, linesize, src1, linesize, block_h, mx, my);
1926 70033 mc_func[my_idx][mx_idx](dst2, linesize, src2, linesize, block_h, mx, my);
1927 }
1928 } else {
1929 346276 ff_progress_frame_await(ref, (3 + y_off + block_h) >> 3);
1930 346276 mc_func[0][0](dst1, linesize, src1 + y_off * linesize + x_off, linesize, block_h, 0, 0);
1931 346276 mc_func[0][0](dst2, linesize, src2 + y_off * linesize + x_off, linesize, block_h, 0, 0);
1932 }
1933 425466 }
1934
1935 static av_always_inline
1936 399006 void vp8_mc_part(VP8Context *s, VP8ThreadData *td, uint8_t *const dst[3],
1937 const ProgressFrame *ref_frame, int x_off, int y_off,
1938 int bx_off, int by_off, int block_w, int block_h,
1939 int width, int height, const VP8mv *mv)
1940 {
1941 399006 VP8mv uvmv = *mv;
1942
1943 /* Y */
1944 399006 vp8_mc_luma(s, td, dst[0] + by_off * s->linesize + bx_off,
1945 ref_frame, mv, x_off + bx_off, y_off + by_off,
1946 block_w, block_h, width, height, s->linesize,
1947 399006 s->put_pixels_tab[block_w == 8]);
1948
1949 /* U/V */
1950
2/2
✓ Branch 0 taken 4775 times.
✓ Branch 1 taken 394231 times.
 399006 if (s->profile == 3) {
1951 /* this block only applies VP8; it is safe to check
1952 * only the profile, as VP7 profile <= 1 */
1953 4775 uvmv.x &= ~7;
1954 4775 uvmv.y &= ~7;
1955 }
1956 399006 x_off >>= 1;
1957 399006 y_off >>= 1;
1958 399006 bx_off >>= 1;
1959 399006 by_off >>= 1;
1960 399006 width >>= 1;
1961 399006 height >>= 1;
1962 399006 block_w >>= 1;
1963 399006 block_h >>= 1;
1964 399006 vp8_mc_chroma(s, td, dst[1] + by_off * s->uvlinesize + bx_off,
1965 399006 dst[2] + by_off * s->uvlinesize + bx_off, ref_frame,
1966 &uvmv, x_off + bx_off, y_off + by_off,
1967 block_w, block_h, width, height, s->uvlinesize,
1968
2/2
✓ Branch 0 taken 20950 times.
✓ Branch 1 taken 378056 times.
 399006 s->put_pixels_tab[1 + (block_w == 4)]);
1969 399006 }
1970
1971 /* Fetch pixels for estimated mv 4 macroblocks ahead.
1972 * Optimized for 64-byte cache lines. Inspired by ffh264 prefetch_motion. */
1973 static av_always_inline
1974 1333167 void prefetch_motion(const VP8Context *s, const VP8Macroblock *mb,
1975 int mb_x, int mb_y, int mb_xy, int ref)
1976 {
1977 /* Don't prefetch refs that haven't been used very often this frame. */
1978
2/2
✓ Branch 0 taken 479591 times.
✓ Branch 1 taken 853576 times.
 1333167 if (s->ref_count[ref - 1] > (mb_xy >> 5)) {
1979 479591 int x_off = mb_x << 4, y_off = mb_y << 4;
1980 479591 int mx = (mb->mv.x >> 2) + x_off + 8;
1981 479591 int my = (mb->mv.y >> 2) + y_off;
1982 479591 uint8_t **src = s->framep[ref]->tf.f->data;
1983 479591 int off = mx + (my + (mb_x & 3) * 4) * s->linesize + 64;
1984 /* For threading, a ff_thread_await_progress here might be useful, but
1985 * it actually slows down the decoder. Since a bad prefetch doesn't
1986 * generate bad decoder output, we don't run it here. */
1987 479591 s->vdsp.prefetch(src[0] + off, s->linesize, 4);
1988 479591 off = (mx >> 1) + ((my >> 1) + (mb_x & 7)) * s->uvlinesize + 64;
1989 479591 s->vdsp.prefetch(src[1] + off, src[2] - src[1], 2);
1990 }
1991 1333167 }
1992
1993 /**
1994 * Apply motion vectors to prediction buffer, chapter 18.
1995 */
1996 static av_always_inline
1997 386566 void inter_predict(VP8Context *s, VP8ThreadData *td, uint8_t *const dst[3],
1998 VP8Macroblock *mb, int mb_x, int mb_y)
1999 {
2000 386566 int x_off = mb_x << 4, y_off = mb_y << 4;
2001 386566 int width = 16 * s->mb_width, height = 16 * s->mb_height;
2002 386566 const ProgressFrame *ref = &s->framep[mb->ref_frame]->tf;
2003 386566 const VP8mv *bmv = mb->bmv;
2004
2005
5/6
✓ Branch 0 taken 368236 times.
✓ Branch 1 taken 6615 times.
✓ Branch 2 taken 4910 times.
✓ Branch 3 taken 3135 times.
✓ Branch 4 taken 3670 times.
✗ Branch 5 not taken.
 386566 switch (mb->partitioning) {
2006 368236 case VP8_SPLITMVMODE_NONE:
2007 368236 vp8_mc_part(s, td, dst, ref, x_off, y_off,
2008 368236 0, 0, 16, 16, width, height, &mb->mv);
2009 368236 break;
2010 6615 case VP8_SPLITMVMODE_4x4: {
2011 int x, y;
2012 VP8mv uvmv;
2013
2014 /* Y */
2015
2/2
✓ Branch 0 taken 26460 times.
✓ Branch 1 taken 6615 times.
 33075 for (y = 0; y < 4; y++) {
2016
2/2
✓ Branch 0 taken 105840 times.
✓ Branch 1 taken 26460 times.
 132300 for (x = 0; x < 4; x++) {
2017 105840 vp8_mc_luma(s, td, dst[0] + 4 * y * s->linesize + x * 4,
2018 105840 ref, &bmv[4 * y + x],
2019 105840 4 * x + x_off, 4 * y + y_off, 4, 4,
2020 width, height, s->linesize,
2021 105840 s->put_pixels_tab[2]);
2022 }
2023 }
2024
2025 /* U/V */
2026 6615 x_off >>= 1;
2027 6615 y_off >>= 1;
2028 6615 width >>= 1;
2029 6615 height >>= 1;
2030
2/2
✓ Branch 0 taken 13230 times.
✓ Branch 1 taken 6615 times.
 19845 for (y = 0; y < 2; y++) {
2031
2/2
✓ Branch 0 taken 26460 times.
✓ Branch 1 taken 13230 times.
 39690 for (x = 0; x < 2; x++) {
2032 26460 uvmv.x = mb->bmv[2 * y * 4 + 2 * x ].x +
2033 26460 mb->bmv[2 * y * 4 + 2 * x + 1].x +
2034 26460 mb->bmv[(2 * y + 1) * 4 + 2 * x ].x +
2035 26460 mb->bmv[(2 * y + 1) * 4 + 2 * x + 1].x;
2036 26460 uvmv.y = mb->bmv[2 * y * 4 + 2 * x ].y +
2037 26460 mb->bmv[2 * y * 4 + 2 * x + 1].y +
2038 26460 mb->bmv[(2 * y + 1) * 4 + 2 * x ].y +
2039 26460 mb->bmv[(2 * y + 1) * 4 + 2 * x + 1].y;
2040 26460 uvmv.x = (uvmv.x + 2 + FF_SIGNBIT(uvmv.x)) >> 2;
2041 26460 uvmv.y = (uvmv.y + 2 + FF_SIGNBIT(uvmv.y)) >> 2;
2042
2/2
✓ Branch 0 taken 492 times.
✓ Branch 1 taken 25968 times.
 26460 if (s->profile == 3) {
2043 492 uvmv.x &= ~7;
2044 492 uvmv.y &= ~7;
2045 }
2046 26460 vp8_mc_chroma(s, td, dst[1] + 4 * y * s->uvlinesize + x * 4,
2047 26460 dst[2] + 4 * y * s->uvlinesize + x * 4, ref,
2048 26460 &uvmv, 4 * x + x_off, 4 * y + y_off, 4, 4,
2049 width, height, s->uvlinesize,
2050 26460 s->put_pixels_tab[2]);
2051 }
2052 }
2053 6615 break;
2054 }
2055 4910 case VP8_SPLITMVMODE_16x8:
2056 4910 vp8_mc_part(s, td, dst, ref, x_off, y_off,
2057 0, 0, 16, 8, width, height, &bmv[0]);
2058 4910 vp8_mc_part(s, td, dst, ref, x_off, y_off,
2059 0, 8, 16, 8, width, height, &bmv[1]);
2060 4910 break;
2061 3135 case VP8_SPLITMVMODE_8x16:
2062 3135 vp8_mc_part(s, td, dst, ref, x_off, y_off,
2063 0, 0, 8, 16, width, height, &bmv[0]);
2064 3135 vp8_mc_part(s, td, dst, ref, x_off, y_off,
2065 8, 0, 8, 16, width, height, &bmv[1]);
2066 3135 break;
2067 3670 case VP8_SPLITMVMODE_8x8:
2068 3670 vp8_mc_part(s, td, dst, ref, x_off, y_off,
2069 0, 0, 8, 8, width, height, &bmv[0]);
2070 3670 vp8_mc_part(s, td, dst, ref, x_off, y_off,
2071 8, 0, 8, 8, width, height, &bmv[1]);
2072 3670 vp8_mc_part(s, td, dst, ref, x_off, y_off,
2073 0, 8, 8, 8, width, height, &bmv[2]);
2074 3670 vp8_mc_part(s, td, dst, ref, x_off, y_off,
2075 8, 8, 8, 8, width, height, &bmv[3]);
2076 3670 break;
2077 }
2078 386566 }
2079
2080 static av_always_inline
2081 77668 void idct_mb(VP8Context *s, VP8ThreadData *td, uint8_t *const dst[3],
2082 const VP8Macroblock *mb)
2083 {
2084 int x, y, ch;
2085
2086
2/2
✓ Branch 0 taken 60287 times.
✓ Branch 1 taken 17381 times.
 77668 if (mb->mode != MODE_I4x4) {
2087 60287 uint8_t *y_dst = dst[0];
2088
2/2
✓ Branch 0 taken 241148 times.
✓ Branch 1 taken 60287 times.
 301435 for (y = 0; y < 4; y++) {
2089 241148 uint32_t nnz4 = AV_RL32(td->non_zero_count_cache[y]);
2090
2/2
✓ Branch 0 taken 178412 times.
✓ Branch 1 taken 62736 times.
 241148 if (nnz4) {
2091
2/2
✓ Branch 0 taken 45190 times.
✓ Branch 1 taken 133222 times.
 178412 if (nnz4 & ~0x01010101) {
2092
1/2
✓ Branch 0 taken 157106 times.
✗ Branch 1 not taken.
 157106 for (x = 0; x < 4; x++) {
2093
2/2
✓ Branch 0 taken 54633 times.
✓ Branch 1 taken 102473 times.
 157106 if ((uint8_t) nnz4 == 1)
2094 54633 s->vp8dsp.vp8_idct_dc_add(y_dst + 4 * x,
2095 54633 td->block[y][x],
2096 s->linesize);
2097
2/2
✓ Branch 0 taken 74939 times.
✓ Branch 1 taken 27534 times.
 102473 else if ((uint8_t) nnz4 > 1)
2098 74939 s->vp8dsp.vp8_idct_add(y_dst + 4 * x,
2099 74939 td->block[y][x],
2100 s->linesize);
2101 157106 nnz4 >>= 8;
2102
2/2
✓ Branch 0 taken 45190 times.
✓ Branch 1 taken 111916 times.
 157106 if (!nnz4)
2103 45190 break;
2104 }
2105 } else {
2106 133222 s->vp8dsp.vp8_idct_dc_add4y(y_dst, td->block[y], s->linesize);
2107 }
2108 }
2109 241148 y_dst += 4 * s->linesize;
2110 }
2111 }
2112
2113
2/2
✓ Branch 0 taken 155336 times.
✓ Branch 1 taken 77668 times.
 233004 for (ch = 0; ch < 2; ch++) {
2114 155336 uint32_t nnz4 = AV_RL32(td->non_zero_count_cache[4 + ch]);
2115
2/2
✓ Branch 0 taken 95075 times.
✓ Branch 1 taken 60261 times.
 155336 if (nnz4) {
2116 60261 uint8_t *ch_dst = dst[1 + ch];
2117
2/2
✓ Branch 0 taken 30144 times.
✓ Branch 1 taken 30117 times.
 60261 if (nnz4 & ~0x01010101) {
2118
1/2
✓ Branch 0 taken 55868 times.
✗ Branch 1 not taken.
 55868 for (y = 0; y < 2; y++) {
2119
2/2
✓ Branch 0 taken 106984 times.
✓ Branch 1 taken 25724 times.
 132708 for (x = 0; x < 2; x++) {
2120
2/2
✓ Branch 0 taken 16090 times.
✓ Branch 1 taken 90894 times.
 106984 if ((uint8_t) nnz4 == 1)
2121 16090 s->vp8dsp.vp8_idct_dc_add(ch_dst + 4 * x,
2122 16090 td->block[4 + ch][(y << 1) + x],
2123 s->uvlinesize);
2124
2/2
✓ Branch 0 taken 67283 times.
✓ Branch 1 taken 23611 times.
 90894 else if ((uint8_t) nnz4 > 1)
2125 67283 s->vp8dsp.vp8_idct_add(ch_dst + 4 * x,
2126 67283 td->block[4 + ch][(y << 1) + x],
2127 s->uvlinesize);
2128 106984 nnz4 >>= 8;
2129
2/2
✓ Branch 0 taken 30144 times.
✓ Branch 1 taken 76840 times.
 106984 if (!nnz4)
2130 30144 goto chroma_idct_end;
2131 }
2132 25724 ch_dst += 4 * s->uvlinesize;
2133 }
2134 } else {
2135 30117 s->vp8dsp.vp8_idct_dc_add4uv(ch_dst, td->block[4 + ch], s->uvlinesize);
2136 }
2137 }
2138 155336 chroma_idct_end:
2139 ;
2140 }
2141 77668 }
2142
2143 static av_always_inline
2144 425089 void filter_level_for_mb(const VP8Context *s, const VP8Macroblock *mb,
2145 VP8FilterStrength *f, int is_vp7)
2146 {
2147 int interior_limit, filter_level;
2148
2149
2/2
✓ Branch 0 taken 102219 times.
✓ Branch 1 taken 322870 times.
 425089 if (s->segmentation.enabled) {
2150 102219 filter_level = s->segmentation.filter_level[mb->segment];
2151
2/2
✓ Branch 0 taken 98895 times.
✓ Branch 1 taken 3324 times.
 102219 if (!s->segmentation.absolute_vals)
2152 98895 filter_level += s->filter.level;
2153 } else
2154 322870 filter_level = s->filter.level;
2155
2156
2/2
✓ Branch 0 taken 417515 times.
✓ Branch 1 taken 7574 times.
 425089 if (s->lf_delta.enabled) {
2157 417515 filter_level += s->lf_delta.ref[mb->ref_frame];
2158 417515 filter_level += s->lf_delta.mode[mb->mode];
2159 }
2160
2161 425089 filter_level = av_clip_uintp2(filter_level, 6);
2162
2163 425089 interior_limit = filter_level;
2164
2/2
✓ Branch 0 taken 2772 times.
✓ Branch 1 taken 422317 times.
 425089 if (s->filter.sharpness) {
2165 2772 interior_limit >>= (s->filter.sharpness + 3) >> 2;
2166 2772 interior_limit = FFMIN(interior_limit, 9 - s->filter.sharpness);
2167 }
2168 425089 interior_limit = FFMAX(interior_limit, 1);
2169
2170 425089 f->filter_level = filter_level;
2171 425089 f->inner_limit = interior_limit;
2172
6/6
✓ Branch 0 taken 418269 times.
✓ Branch 1 taken 6820 times.
✓ Branch 2 taken 353407 times.
✓ Branch 3 taken 64862 times.
✓ Branch 4 taken 353119 times.
✓ Branch 5 taken 288 times.
 778208 f->inner_filter = is_vp7 || !mb->skip || mb->mode == MODE_I4x4 ||
2173
2/2
✓ Branch 0 taken 3237 times.
✓ Branch 1 taken 349882 times.
 353119 mb->mode == VP8_MVMODE_SPLIT;
2174 425089 }
2175
2176 static av_always_inline
2177 417367 void filter_mb(const VP8Context *s, uint8_t *const dst[3], const VP8FilterStrength *f,
2178 int mb_x, int mb_y, int is_vp7)
2179 {
2180 int mbedge_lim, bedge_lim_y, bedge_lim_uv, hev_thresh;
2181 417367 int filter_level = f->filter_level;
2182 417367 int inner_limit = f->inner_limit;
2183 417367 int inner_filter = f->inner_filter;
2184 417367 ptrdiff_t linesize = s->linesize;
2185 417367 ptrdiff_t uvlinesize = s->uvlinesize;
2186 static const uint8_t hev_thresh_lut[2][64] = {
2187 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
2188 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2189 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
2190 3, 3, 3, 3 },
2191 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
2192 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2193 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2194 2, 2, 2, 2 }
2195 };
2196
2197
2/2
✓ Branch 0 taken 5877 times.
✓ Branch 1 taken 411490 times.
 417367 if (!filter_level)
2198 5877 return;
2199
2200
2/2
✓ Branch 0 taken 6820 times.
✓ Branch 1 taken 404670 times.
 411490 if (is_vp7) {
2201 6820 bedge_lim_y = filter_level;
2202 6820 bedge_lim_uv = filter_level * 2;
2203 6820 mbedge_lim = filter_level + 2;
2204 } else {
2205 404670 bedge_lim_y =
2206 404670 bedge_lim_uv = filter_level * 2 + inner_limit;
2207 404670 mbedge_lim = bedge_lim_y + 4;
2208 }
2209
2210 411490 hev_thresh = hev_thresh_lut[s->keyframe][filter_level];
2211
2212
2/2
✓ Branch 0 taken 397334 times.
✓ Branch 1 taken 14156 times.
 411490 if (mb_x) {
2213 397334 s->vp8dsp.vp8_h_loop_filter16y(dst[0], linesize,
2214 mbedge_lim, inner_limit, hev_thresh);
2215 397334 s->vp8dsp.vp8_h_loop_filter8uv(dst[1], dst[2], uvlinesize,
2216 mbedge_lim, inner_limit, hev_thresh);
2217 }
2218
2219 #define H_LOOP_FILTER_16Y_INNER(cond) \
2220 if (cond && inner_filter) { \
2221 s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0] + 4, linesize, \
2222 bedge_lim_y, inner_limit, \
2223 hev_thresh); \
2224 s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0] + 8, linesize, \
2225 bedge_lim_y, inner_limit, \
2226 hev_thresh); \
2227 s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0] + 12, linesize, \
2228 bedge_lim_y, inner_limit, \
2229 hev_thresh); \
2230 s->vp8dsp.vp8_h_loop_filter8uv_inner(dst[1] + 4, dst[2] + 4, \
2231 uvlinesize, bedge_lim_uv, \
2232 inner_limit, hev_thresh); \
2233 }
2234
2235
4/4
✓ Branch 0 taken 404670 times.
✓ Branch 1 taken 6820 times.
✓ Branch 2 taken 63137 times.
✓ Branch 3 taken 341533 times.
 411490 H_LOOP_FILTER_16Y_INNER(!is_vp7)
2236
2237
2/2
✓ Branch 0 taken 390396 times.
✓ Branch 1 taken 21094 times.
 411490 if (mb_y) {
2238 390396 s->vp8dsp.vp8_v_loop_filter16y(dst[0], linesize,
2239 mbedge_lim, inner_limit, hev_thresh);
2240 390396 s->vp8dsp.vp8_v_loop_filter8uv(dst[1], dst[2], uvlinesize,
2241 mbedge_lim, inner_limit, hev_thresh);
2242 }
2243
2244
2/2
✓ Branch 0 taken 69957 times.
✓ Branch 1 taken 341533 times.
 411490 if (inner_filter) {
2245 69957 s->vp8dsp.vp8_v_loop_filter16y_inner(dst[0] + 4 * linesize,
2246 linesize, bedge_lim_y,
2247 inner_limit, hev_thresh);
2248 69957 s->vp8dsp.vp8_v_loop_filter16y_inner(dst[0] + 8 * linesize,
2249 linesize, bedge_lim_y,
2250 inner_limit, hev_thresh);
2251 69957 s->vp8dsp.vp8_v_loop_filter16y_inner(dst[0] + 12 * linesize,
2252 linesize, bedge_lim_y,
2253 inner_limit, hev_thresh);
2254 69957 s->vp8dsp.vp8_v_loop_filter8uv_inner(dst[1] + 4 * uvlinesize,
2255 69957 dst[2] + 4 * uvlinesize,
2256 uvlinesize, bedge_lim_uv,
2257 inner_limit, hev_thresh);
2258 }
2259
2260
3/4
✓ Branch 0 taken 6820 times.
✓ Branch 1 taken 404670 times.
✓ Branch 2 taken 6820 times.
✗ Branch 3 not taken.
 411490 H_LOOP_FILTER_16Y_INNER(is_vp7)
2261 }
2262
2263 static av_always_inline
2264 7722 void filter_mb_simple(const VP8Context *s, uint8_t *dst, const VP8FilterStrength *f,
2265 int mb_x, int mb_y)
2266 {
2267 int mbedge_lim, bedge_lim;
2268 7722 int filter_level = f->filter_level;
2269 7722 int inner_limit = f->inner_limit;
2270 7722 int inner_filter = f->inner_filter;
2271 7722 ptrdiff_t linesize = s->linesize;
2272
2273
2/2
✓ Branch 0 taken 332 times.
✓ Branch 1 taken 7390 times.
 7722 if (!filter_level)
2274 332 return;
2275
2276 7390 bedge_lim = 2 * filter_level + inner_limit;
2277 7390 mbedge_lim = bedge_lim + 4;
2278
2279
2/2
✓ Branch 0 taken 6713 times.
✓ Branch 1 taken 677 times.
 7390 if (mb_x)
2280 6713 s->vp8dsp.vp8_h_loop_filter_simple(dst, linesize, mbedge_lim);
2281
2/2
✓ Branch 0 taken 3523 times.
✓ Branch 1 taken 3867 times.
 7390 if (inner_filter) {
2282 3523 s->vp8dsp.vp8_h_loop_filter_simple(dst + 4, linesize, bedge_lim);
2283 3523 s->vp8dsp.vp8_h_loop_filter_simple(dst + 8, linesize, bedge_lim);
2284 3523 s->vp8dsp.vp8_h_loop_filter_simple(dst + 12, linesize, bedge_lim);
2285 }
2286
2287
2/2
✓ Branch 0 taken 6609 times.
✓ Branch 1 taken 781 times.
 7390 if (mb_y)
2288 6609 s->vp8dsp.vp8_v_loop_filter_simple(dst, linesize, mbedge_lim);
2289
2/2
✓ Branch 0 taken 3523 times.
✓ Branch 1 taken 3867 times.
 7390 if (inner_filter) {
2290 3523 s->vp8dsp.vp8_v_loop_filter_simple(dst + 4 * linesize, linesize, bedge_lim);
2291 3523 s->vp8dsp.vp8_v_loop_filter_simple(dst + 8 * linesize, linesize, bedge_lim);
2292 3523 s->vp8dsp.vp8_v_loop_filter_simple(dst + 12 * linesize, linesize, bedge_lim);
2293 }
2294 }
2295
2296 #define MARGIN (16 << 2)
2297 static av_always_inline
2298 31 int vp78_decode_mv_mb_modes(AVCodecContext *avctx, VP8Frame *curframe,
2299 const VP8Frame *prev_frame, int is_vp7)
2300 {
2301 31 VP8Context *s = avctx->priv_data;
2302 int mb_x, mb_y;
2303
2304 31 s->mv_bounds.mv_min.y = -MARGIN;
2305 31 s->mv_bounds.mv_max.y = ((s->mb_height - 1) << 6) + MARGIN;
2306
2/2
✓ Branch 0 taken 341 times.
✓ Branch 1 taken 31 times.
 372 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
2307 341 VP8Macroblock *mb = s->macroblocks_base +
2308 341 ((s->mb_width + 1) * (mb_y + 1) + 1);
2309 341 int mb_xy = mb_y * s->mb_width;
2310
2311 341 AV_WN32A(s->intra4x4_pred_mode_left, DC_PRED * 0x01010101);
2312
2313 341 s->mv_bounds.mv_min.x = -MARGIN;
2314 341 s->mv_bounds.mv_max.x = ((s->mb_width - 1) << 6) + MARGIN;
2315
2316
2/2
✓ Branch 0 taken 6820 times.
✓ Branch 1 taken 341 times.
 7161 for (mb_x = 0; mb_x < s->mb_width; mb_x++, mb_xy++, mb++) {
2317
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6820 times.
 6820 if (vpx_rac_is_end(&s->c)) {
2318 ✗ return AVERROR_INVALIDDATA;
2319 }
2320
2/2
✓ Branch 0 taken 620 times.
✓ Branch 1 taken 6200 times.
 6820 if (mb_y == 0)
2321 620 AV_WN32A((mb - s->mb_width - 1)->intra4x4_pred_mode_top,
2322 DC_PRED * 0x01010101);
2323
2/2
✓ Branch 0 taken 6600 times.
✓ Branch 1 taken 220 times.
 13420 decode_mb_mode(s, &s->mv_bounds, mb, mb_x, mb_y, curframe->seg_map + mb_xy,
2324
1/2
✓ Branch 0 taken 6600 times.
✗ Branch 1 not taken.
 6600 prev_frame && prev_frame->seg_map ?
2325 6600 prev_frame->seg_map + mb_xy : NULL, 1, is_vp7);
2326 6820 s->mv_bounds.mv_min.x -= 64;
2327 6820 s->mv_bounds.mv_max.x -= 64;
2328 }
2329 341 s->mv_bounds.mv_min.y -= 64;
2330 341 s->mv_bounds.mv_max.y -= 64;
2331 }
2332 31 return 0;
2333 }
2334
2335 31 static int vp7_decode_mv_mb_modes(AVCodecContext *avctx, VP8Frame *cur_frame,
2336 const VP8Frame *prev_frame)
2337 {
2338 31 return vp78_decode_mv_mb_modes(avctx, cur_frame, prev_frame, IS_VP7);
2339 }
2340
2341 ✗ static int vp8_decode_mv_mb_modes(AVCodecContext *avctx, VP8Frame *cur_frame,
2342 const VP8Frame *prev_frame)
2343 {
2344 ✗ return vp78_decode_mv_mb_modes(avctx, cur_frame, prev_frame, IS_VP8);
2345 }
2346
2347 #if HAVE_THREADS
2348 #define check_thread_pos(td, otd, mb_x_check, mb_y_check) \
2349 do { \
2350 int tmp = (mb_y_check << 16) | (mb_x_check & 0xFFFF); \
2351 if (atomic_load(&otd->thread_mb_pos) < tmp) { \
2352 pthread_mutex_lock(&otd->lock); \
2353 atomic_store(&td->wait_mb_pos, tmp); \
2354 do { \
2355 if (atomic_load(&otd->thread_mb_pos) >= tmp) \
2356 break; \
2357 pthread_cond_wait(&otd->cond, &otd->lock); \
2358 } while (1); \
2359 atomic_store(&td->wait_mb_pos, INT_MAX); \
2360 pthread_mutex_unlock(&otd->lock); \
2361 } \
2362 } while (0)
2363
2364 #define update_pos(td, mb_y, mb_x) \
2365 do { \
2366 int pos = (mb_y << 16) | (mb_x & 0xFFFF); \
2367 int sliced_threading = (avctx->active_thread_type == FF_THREAD_SLICE) && \
2368 (num_jobs > 1); \
2369 int is_null = !next_td || !prev_td; \
2370 int pos_check = (is_null) ? 1 : \
2371 (next_td != td && pos >= atomic_load(&next_td->wait_mb_pos)) || \
2372 (prev_td != td && pos >= atomic_load(&prev_td->wait_mb_pos)); \
2373 atomic_store(&td->thread_mb_pos, pos); \
2374 if (sliced_threading && pos_check) { \
2375 pthread_mutex_lock(&td->lock); \
2376 pthread_cond_broadcast(&td->cond); \
2377 pthread_mutex_unlock(&td->lock); \
2378 } \
2379 } while (0)
2380 #else
2381 #define check_thread_pos(td, otd, mb_x_check, mb_y_check) while(0)
2382 #define update_pos(td, mb_y, mb_x) while(0)
2383 #endif
2384
2385 16252 static av_always_inline int decode_mb_row_no_filter(AVCodecContext *avctx, void *tdata,
2386 int jobnr, int threadnr, int is_vp7)
2387 {
2388 16252 VP8Context *s = avctx->priv_data;
2389 16252 VP8ThreadData *prev_td, *next_td, *td = &s->thread_data[threadnr];
2390 16252 int mb_y = atomic_load(&td->thread_mb_pos) >> 16;
2391 16252 int mb_x, mb_xy = mb_y * s->mb_width;
2392 16252 int num_jobs = s->num_jobs;
2393 16252 const VP8Frame *prev_frame = s->prev_frame;
2394 16252 VP8Frame *curframe = s->curframe;
2395 16252 VPXRangeCoder *coeff_c = &s->coeff_partition[mb_y & (s->num_coeff_partitions - 1)];
2396
2397 VP8Macroblock *mb;
2398 16252 uint8_t *dst[3] = {
2399 16252 curframe->tf.f->data[0] + 16 * mb_y * s->linesize,
2400 16252 curframe->tf.f->data[1] + 8 * mb_y * s->uvlinesize,
2401 16252 curframe->tf.f->data[2] + 8 * mb_y * s->uvlinesize
2402 };
2403
2404
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 16252 times.
 16252 if (vpx_rac_is_end(&s->c))
2405 ✗ return AVERROR_INVALIDDATA;
2406
2407
2/2
✓ Branch 0 taken 1149 times.
✓ Branch 1 taken 15103 times.
 16252 if (mb_y == 0)
2408 1149 prev_td = td;
2409 else
2410 15103 prev_td = &s->thread_data[(jobnr + num_jobs - 1) % num_jobs];
2411
2/2
✓ Branch 0 taken 1149 times.
✓ Branch 1 taken 15103 times.
 16252 if (mb_y == s->mb_height - 1)
2412 1149 next_td = td;
2413 else
2414 15103 next_td = &s->thread_data[(jobnr + 1) % num_jobs];
2415
2/2
✓ Branch 0 taken 341 times.
✓ Branch 1 taken 15911 times.
 16252 if (s->mb_layout == 1)
2416 341 mb = s->macroblocks_base + ((s->mb_width + 1) * (mb_y + 1) + 1);
2417 else {
2418 // Make sure the previous frame has read its segmentation map,
2419 // if we re-use the same map.
2420
4/4
✓ Branch 0 taken 15296 times.
✓ Branch 1 taken 615 times.
✓ Branch 2 taken 5598 times.
✓ Branch 3 taken 9698 times.
 15911 if (prev_frame && s->segmentation.enabled &&
2421
2/2
✓ Branch 0 taken 5025 times.
✓ Branch 1 taken 573 times.
 5598 !s->segmentation.update_map)
2422 5025 ff_progress_frame_await(&prev_frame->tf, mb_y);
2423 15911 mb = s->macroblocks + (s->mb_height - mb_y - 1) * 2;
2424 15911 memset(mb - 1, 0, sizeof(*mb)); // zero left macroblock
2425 15911 AV_WN32A(s->intra4x4_pred_mode_left, DC_PRED * 0x01010101);
2426 }
2427
2428
4/4
✓ Branch 0 taken 341 times.
✓ Branch 1 taken 15911 times.
✓ Branch 2 taken 31 times.
✓ Branch 3 taken 310 times.
 16252 if (!is_vp7 || mb_y == 0)
2429 15942 memset(td->left_nnz, 0, sizeof(td->left_nnz));
2430
2431 16252 td->mv_bounds.mv_min.x = -MARGIN;
2432 16252 td->mv_bounds.mv_max.x = ((s->mb_width - 1) << 6) + MARGIN;
2433
2434
2/2
✓ Branch 0 taken 444389 times.
✓ Branch 1 taken 16252 times.
 460641 for (mb_x = 0; mb_x < s->mb_width; mb_x++, mb_xy++, mb++) {
2435
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 444389 times.
 444389 if (vpx_rac_is_end(&s->c))
2436 ✗ return AVERROR_INVALIDDATA;
2437 // Wait for previous thread to read mb_x+2, and reach mb_y-1.
2438
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 444389 times.
 444389 if (prev_td != td) {
2439 ✗ if (threadnr != 0) {
2440 ✗ check_thread_pos(td, prev_td,
2441 mb_x + (is_vp7 ? 2 : 1),
2442 mb_y - (is_vp7 ? 2 : 1));
2443 } else {
2444 ✗ check_thread_pos(td, prev_td,
2445 mb_x + (is_vp7 ? 2 : 1) + s->mb_width + 3,
2446 mb_y - (is_vp7 ? 2 : 1));
2447 }
2448 }
2449
2450 444389 s->vdsp.prefetch(dst[0] + (mb_x & 3) * 4 * s->linesize + 64,
2451 s->linesize, 4);
2452 444389 s->vdsp.prefetch(dst[1] + (mb_x & 7) * s->uvlinesize + 64,
2453 444389 dst[2] - dst[1], 2);
2454
2455
2/2
✓ Branch 0 taken 437569 times.
✓ Branch 1 taken 6820 times.
 444389 if (!s->mb_layout)
2456
2/2
✓ Branch 0 taken 406589 times.
✓ Branch 1 taken 30980 times.
 844158 decode_mb_mode(s, &td->mv_bounds, mb, mb_x, mb_y, curframe->seg_map + mb_xy,
2457
1/2
✓ Branch 0 taken 406589 times.
✗ Branch 1 not taken.
 406589 prev_frame && prev_frame->seg_map ?
2458 406589 prev_frame->seg_map + mb_xy : NULL, 0, is_vp7);
2459
2460 444389 prefetch_motion(s, mb, mb_x, mb_y, mb_xy, VP8_FRAME_PREVIOUS);
2461
2462
2/2
✓ Branch 0 taken 84344 times.
✓ Branch 1 taken 360045 times.
 444389 if (!mb->skip) {
2463
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 84344 times.
 84344 if (vpx_rac_is_end(coeff_c))
2464 ✗ return AVERROR_INVALIDDATA;
2465 84344 decode_mb_coeffs(s, td, coeff_c, mb, s->top_nnz[mb_x], td->left_nnz, is_vp7);
2466 }
2467
2468
2/2
✓ Branch 0 taken 57823 times.
✓ Branch 1 taken 386566 times.
 444389 if (mb->mode <= MODE_I4x4)
2469 57823 intra_predict(s, td, dst, mb, mb_x, mb_y, is_vp7);
2470 else
2471 386566 inter_predict(s, td, dst, mb, mb_x, mb_y);
2472
2473 444389 prefetch_motion(s, mb, mb_x, mb_y, mb_xy, VP8_FRAME_GOLDEN);
2474
2475
2/2
✓ Branch 0 taken 77668 times.
✓ Branch 1 taken 366721 times.
 444389 if (!mb->skip) {
2476 77668 idct_mb(s, td, dst, mb);
2477 } else {
2478 366721 AV_ZERO64(td->left_nnz);
2479 366721 AV_WN64(s->top_nnz[mb_x], 0); // array of 9, so unaligned
2480
2481 /* Reset DC block predictors if they would exist
2482 * if the mb had coefficients */
2483
4/4
✓ Branch 0 taken 366250 times.
✓ Branch 1 taken 471 times.
✓ Branch 2 taken 362983 times.
✓ Branch 3 taken 3267 times.
 366721 if (mb->mode != MODE_I4x4 && mb->mode != VP8_MVMODE_SPLIT) {
2484 362983 td->left_nnz[8] = 0;
2485 362983 s->top_nnz[mb_x][8] = 0;
2486 }
2487 }
2488
2489
2/2
✓ Branch 0 taken 425089 times.
✓ Branch 1 taken 19300 times.
 444389 if (s->deblock_filter)
2490 425089 filter_level_for_mb(s, mb, &td->filter_strength[mb_x], is_vp7);
2491
2492
3/6
✓ Branch 0 taken 425089 times.
✓ Branch 1 taken 19300 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 425089 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 444389 if (s->deblock_filter && num_jobs != 1 && threadnr == num_jobs - 1) {
2493 ✗ if (s->filter.simple)
2494 ✗ backup_mb_border(s->top_border[mb_x + 1], dst[0],
2495 NULL, NULL, s->linesize, 0, 1);
2496 else
2497 ✗ backup_mb_border(s->top_border[mb_x + 1], dst[0],
2498 ✗ dst[1], dst[2], s->linesize, s->uvlinesize, 0);
2499 }
2500
2501 444389 prefetch_motion(s, mb, mb_x, mb_y, mb_xy, VP8_FRAME_ALTREF);
2502
2503 444389 dst[0] += 16;
2504 444389 dst[1] += 8;
2505 444389 dst[2] += 8;
2506 444389 td->mv_bounds.mv_min.x -= 64;
2507 444389 td->mv_bounds.mv_max.x -= 64;
2508
2509
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 444389 times.
 444389 if (mb_x == s->mb_width + 1) {
2510 ✗ update_pos(td, mb_y, s->mb_width + 3);
2511 } else {
2512
7/22
✗ Branch 0 not taken.
✓ Branch 1 taken 444389 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 444389 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 444389 times.
✓ Branch 8 taken 444389 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✓ Branch 11 taken 444389 times.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✓ Branch 15 taken 444389 times.
✗ Branch 16 not taken.
✗ Branch 17 not taken.
✗ Branch 18 not taken.
✓ Branch 19 taken 444389 times.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
 444389 update_pos(td, mb_y, mb_x);
2513 }
2514 }
2515 16252 return 0;
2516 }
2517
2518 15166 static av_always_inline void filter_mb_row(AVCodecContext *avctx, void *tdata,
2519 int jobnr, int threadnr, int is_vp7)
2520 {
2521 15166 VP8Context *s = avctx->priv_data;
2522 15166 VP8ThreadData *td = &s->thread_data[threadnr];
2523 15166 int mb_x, mb_y = atomic_load(&td->thread_mb_pos) >> 16, num_jobs = s->num_jobs;
2524 15166 AVFrame *curframe = s->curframe->tf.f;
2525 VP8Macroblock *mb;
2526 VP8ThreadData *prev_td, *next_td;
2527 15166 uint8_t *dst[3] = {
2528 15166 curframe->data[0] + 16 * mb_y * s->linesize,
2529 15166 curframe->data[1] + 8 * mb_y * s->uvlinesize,
2530 15166 curframe->data[2] + 8 * mb_y * s->uvlinesize
2531 };
2532
2533
2/2
✓ Branch 0 taken 341 times.
✓ Branch 1 taken 14825 times.
 15166 if (s->mb_layout == 1)
2534 341 mb = s->macroblocks_base + ((s->mb_width + 1) * (mb_y + 1) + 1);
2535 else
2536 14825 mb = s->macroblocks + (s->mb_height - mb_y - 1) * 2;
2537
2538
2/2
✓ Branch 0 taken 1039 times.
✓ Branch 1 taken 14127 times.
 15166 if (mb_y == 0)
2539 1039 prev_td = td;
2540 else
2541 14127 prev_td = &s->thread_data[(jobnr + num_jobs - 1) % num_jobs];
2542
2/2
✓ Branch 0 taken 1039 times.
✓ Branch 1 taken 14127 times.
 15166 if (mb_y == s->mb_height - 1)
2543 1039 next_td = td;
2544 else
2545 14127 next_td = &s->thread_data[(jobnr + 1) % num_jobs];
2546
2547
2/2
✓ Branch 0 taken 425089 times.
✓ Branch 1 taken 15166 times.
 440255 for (mb_x = 0; mb_x < s->mb_width; mb_x++, mb++) {
2548 425089 const VP8FilterStrength *f = &td->filter_strength[mb_x];
2549
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 425089 times.
 425089 if (prev_td != td)
2550 ✗ check_thread_pos(td, prev_td,
2551 (mb_x + 1) + (s->mb_width + 3), mb_y - 1);
2552
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 425089 times.
 425089 if (next_td != td)
2553 ✗ if (next_td != &s->thread_data[0])
2554 ✗ check_thread_pos(td, next_td, mb_x + 1, mb_y + 1);
2555
2556
1/2
✓ Branch 0 taken 425089 times.
✗ Branch 1 not taken.
 425089 if (num_jobs == 1) {
2557
2/2
✓ Branch 0 taken 7722 times.
✓ Branch 1 taken 417367 times.
 425089 if (s->filter.simple)
2558 7722 backup_mb_border(s->top_border[mb_x + 1], dst[0],
2559 NULL, NULL, s->linesize, 0, 1);
2560 else
2561 417367 backup_mb_border(s->top_border[mb_x + 1], dst[0],
2562 417367 dst[1], dst[2], s->linesize, s->uvlinesize, 0);
2563 }
2564
2565
2/2
✓ Branch 0 taken 7722 times.
✓ Branch 1 taken 417367 times.
 425089 if (s->filter.simple)
2566 7722 filter_mb_simple(s, dst[0], f, mb_x, mb_y);
2567 else
2568 417367 filter_mb(s, dst, f, mb_x, mb_y, is_vp7);
2569 425089 dst[0] += 16;
2570 425089 dst[1] += 8;
2571 425089 dst[2] += 8;
2572
2573
7/22
✗ Branch 0 not taken.
✓ Branch 1 taken 425089 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 425089 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 425089 times.
✓ Branch 8 taken 425089 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✓ Branch 11 taken 425089 times.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✓ Branch 15 taken 425089 times.
✗ Branch 16 not taken.
✗ Branch 17 not taken.
✗ Branch 18 not taken.
✓ Branch 19 taken 425089 times.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
 425089 update_pos(td, mb_y, (s->mb_width + 3) + mb_x);
2574 }
2575 15166 }
2576
2577 static av_always_inline
2578 1149 int vp78_decode_mb_row_sliced(AVCodecContext *avctx, void *tdata, int jobnr,
2579 int threadnr, int is_vp7)
2580 {
2581 1149 const VP8Context *s = avctx->priv_data;
2582 1149 VP8ThreadData *td = &s->thread_data[jobnr];
2583 1149 VP8ThreadData *next_td = NULL, *prev_td = NULL;
2584 1149 VP8Frame *curframe = s->curframe;
2585 1149 int mb_y, num_jobs = s->num_jobs;
2586 int ret;
2587
2588 1149 td->thread_nr = threadnr;
2589 1149 td->mv_bounds.mv_min.y = -MARGIN - 64 * threadnr;
2590 1149 td->mv_bounds.mv_max.y = ((s->mb_height - 1) << 6) + MARGIN - 64 * threadnr;
2591
2/2
✓ Branch 0 taken 16252 times.
✓ Branch 1 taken 1149 times.
 17401 for (mb_y = jobnr; mb_y < s->mb_height; mb_y += num_jobs) {
2592 16252 atomic_store(&td->thread_mb_pos, mb_y << 16);
2593 16252 ret = s->decode_mb_row_no_filter(avctx, tdata, jobnr, threadnr);
2594
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16252 times.
 16252 if (ret < 0) {
2595 ✗ update_pos(td, s->mb_height, INT_MAX & 0xFFFF);
2596 ✗ return ret;
2597 }
2598
2/2
✓ Branch 0 taken 15166 times.
✓ Branch 1 taken 1086 times.
 16252 if (s->deblock_filter)
2599 15166 s->filter_mb_row(avctx, tdata, jobnr, threadnr);
2600
4/22
✗ Branch 0 not taken.
✓ Branch 1 taken 16252 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 16252 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✓ Branch 9 taken 16252 times.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✗ Branch 15 not taken.
✗ Branch 16 not taken.
✗ Branch 17 not taken.
✗ Branch 18 not taken.
✓ Branch 19 taken 16252 times.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
 16252 update_pos(td, mb_y, INT_MAX & 0xFFFF);
2601
2602 16252 td->mv_bounds.mv_min.y -= 64 * num_jobs;
2603 16252 td->mv_bounds.mv_max.y -= 64 * num_jobs;
2604
2605
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16252 times.
 16252 if (avctx->active_thread_type == FF_THREAD_FRAME)
2606 ✗ ff_progress_frame_report(&curframe->tf, mb_y);
2607 }
2608
2609 1149 return 0;
2610 }
2611
2612 31 static int vp7_decode_mb_row_sliced(AVCodecContext *avctx, void *tdata,
2613 int jobnr, int threadnr)
2614 {
2615 31 return vp78_decode_mb_row_sliced(avctx, tdata, jobnr, threadnr, IS_VP7);
2616 }
2617
2618 1118 static int vp8_decode_mb_row_sliced(AVCodecContext *avctx, void *tdata,
2619 int jobnr, int threadnr)
2620 {
2621 1118 return vp78_decode_mb_row_sliced(avctx, tdata, jobnr, threadnr, IS_VP8);
2622 }
2623
2624 static av_always_inline
2625 1149 int vp78_decode_frame(AVCodecContext *avctx, AVFrame *rframe, int *got_frame,
2626 const AVPacket *avpkt, int is_vp7)
2627 {
2628 1149 VP8Context *s = avctx->priv_data;
2629 int ret, i, referenced, num_jobs;
2630 enum AVDiscard skip_thresh;
2631 1149 VP8Frame *av_uninit(curframe), *prev_frame;
2632
2633
2/2
✓ Branch 0 taken 31 times.
✓ Branch 1 taken 1118 times.
 1149 if (is_vp7)
2634 31 ret = vp7_decode_frame_header(s, avpkt->data, avpkt->size);
2635 else
2636 1118 ret = vp8_decode_frame_header(s, avpkt->data, avpkt->size);
2637
2638
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1149 times.
 1149 if (ret < 0)
2639 ✗ goto err;
2640
2641
4/4
✓ Branch 0 taken 1118 times.
✓ Branch 1 taken 31 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 1112 times.
 1149 if (!is_vp7 && s->actually_webp) {
2642 // VP8 in WebP is supposed to be intra-only. Enforce this here
2643 // to ensure that output is reproducible with frame-threading.
2644
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (!s->keyframe)
2645 ✗ return AVERROR_INVALIDDATA;
2646 // avctx->pix_fmt already set in caller.
2647
3/4
✓ Branch 0 taken 1112 times.
✓ Branch 1 taken 31 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1112 times.
 1143 } else if (!is_vp7 && s->pix_fmt == AV_PIX_FMT_NONE) {
2648 ✗ s->pix_fmt = get_pixel_format(s);
2649 ✗ if (s->pix_fmt < 0) {
2650 ✗ ret = AVERROR(EINVAL);
2651 ✗ goto err;
2652 }
2653 ✗ avctx->pix_fmt = s->pix_fmt;
2654 }
2655
2656 1149 prev_frame = s->framep[VP8_FRAME_CURRENT];
2657
2658
3/4
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 1138 times.
✓ Branch 2 taken 11 times.
✗ Branch 3 not taken.
 1160 referenced = s->update_last || s->update_golden == VP8_FRAME_CURRENT ||
2659
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 2 times.
 11 s->update_altref == VP8_FRAME_CURRENT;
2660
2661 1149 skip_thresh = !referenced ? AVDISCARD_NONREF
2662
4/4
✓ Branch 0 taken 1147 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 1096 times.
✓ Branch 3 taken 51 times.
 1149 : !s->keyframe ? AVDISCARD_NONKEY
2663 : AVDISCARD_ALL;
2664
2665
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1149 times.
 1149 if (avctx->skip_frame >= skip_thresh) {
2666 ✗ s->invisible = 1;
2667 ✗ memcpy(&s->next_framep[0], &s->framep[0], sizeof(s->framep[0]) * 4);
2668 ✗ goto skip_decode;
2669 }
2670
3/4
✓ Branch 0 taken 1039 times.
✓ Branch 1 taken 110 times.
✓ Branch 2 taken 1039 times.
✗ Branch 3 not taken.
 1149 s->deblock_filter = s->filter.level && avctx->skip_loop_filter < skip_thresh;
2671
2672 // release no longer referenced frames
2673
2/2
✓ Branch 0 taken 5745 times.
✓ Branch 1 taken 1149 times.
 6894 for (i = 0; i < 5; i++)
2674
2/2
✓ Branch 0 taken 3835 times.
✓ Branch 1 taken 1910 times.
 5745 if (s->frames[i].tf.f &&
2675
2/2
✓ Branch 0 taken 2725 times.
✓ Branch 1 taken 1110 times.
 3835 &s->frames[i] != prev_frame &&
2676
2/2
✓ Branch 0 taken 2714 times.
✓ Branch 1 taken 11 times.
 2725 &s->frames[i] != s->framep[VP8_FRAME_PREVIOUS] &&
2677
2/2
✓ Branch 0 taken 1742 times.
✓ Branch 1 taken 972 times.
 2714 &s->frames[i] != s->framep[VP8_FRAME_GOLDEN] &&
2678
2/2
✓ Branch 0 taken 1034 times.
✓ Branch 1 taken 708 times.
 1742 &s->frames[i] != s->framep[VP8_FRAME_ALTREF])
2679 1034 vp8_release_frame(&s->frames[i]);
2680
2681
1/2
✓ Branch 0 taken 1149 times.
✗ Branch 1 not taken.
 1149 if (!s->colorspace)
2682 1149 avctx->colorspace = AVCOL_SPC_BT470BG;
2683
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1149 times.
 1149 if (s->fullrange)
2684 ✗ avctx->color_range = AVCOL_RANGE_JPEG;
2685 else
2686 1149 avctx->color_range = AVCOL_RANGE_MPEG;
2687
2688 /* Given that arithmetic probabilities are updated every frame, it's quite
2689 * likely that the values we have on a random interframe are complete
2690 * junk if we didn't start decode on a keyframe. So just don't display
2691 * anything rather than junk. */
2692
3/4
✓ Branch 0 taken 1098 times.
✓ Branch 1 taken 51 times.
✓ Branch 2 taken 1098 times.
✗ Branch 3 not taken.
 1149 if (!s->keyframe && (!s->framep[VP8_FRAME_PREVIOUS] ||
2693
1/2
✓ Branch 0 taken 1098 times.
✗ Branch 1 not taken.
 1098 !s->framep[VP8_FRAME_GOLDEN] ||
2694
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1098 times.
 1098 !s->framep[VP8_FRAME_ALTREF])) {
2695 ✗ av_log(avctx, AV_LOG_WARNING,
2696 "Discarding interframe without a prior keyframe!\n");
2697 ✗ ret = AVERROR_INVALIDDATA;
2698 ✗ goto err;
2699 }
2700
2701 1149 curframe = vp8_find_free_buffer(s);
2702
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1149 times.
 1149 if ((ret = vp8_alloc_frame(s, curframe, referenced)) < 0)
2703 ✗ goto err;
2704 1149 s->framep[VP8_FRAME_CURRENT] = curframe;
2705
2/2
✓ Branch 0 taken 51 times.
✓ Branch 1 taken 1098 times.
 1149 if (s->keyframe)
2706 51 curframe->tf.f->flags |= AV_FRAME_FLAG_KEY;
2707 else
2708 1098 curframe->tf.f->flags &= ~AV_FRAME_FLAG_KEY;
2709 2298 curframe->tf.f->pict_type = s->keyframe ? AV_PICTURE_TYPE_I
2710
2/2
✓ Branch 0 taken 51 times.
✓ Branch 1 taken 1098 times.
 1149 : AV_PICTURE_TYPE_P;
2711
2712 // check if golden and altref are swapped
2713
2/2
✓ Branch 0 taken 199 times.
✓ Branch 1 taken 950 times.
 1149 if (s->update_altref != VP8_FRAME_NONE)
2714 199 s->next_framep[VP8_FRAME_ALTREF] = s->framep[s->update_altref];
2715 else
2716 950 s->next_framep[VP8_FRAME_ALTREF] = s->framep[VP8_FRAME_ALTREF];
2717
2718
2/2
✓ Branch 0 taken 141 times.
✓ Branch 1 taken 1008 times.
 1149 if (s->update_golden != VP8_FRAME_NONE)
2719 141 s->next_framep[VP8_FRAME_GOLDEN] = s->framep[s->update_golden];
2720 else
2721 1008 s->next_framep[VP8_FRAME_GOLDEN] = s->framep[VP8_FRAME_GOLDEN];
2722
2723
2/2
✓ Branch 0 taken 1138 times.
✓ Branch 1 taken 11 times.
 1149 if (s->update_last)
2724 1138 s->next_framep[VP8_FRAME_PREVIOUS] = curframe;
2725 else
2726 11 s->next_framep[VP8_FRAME_PREVIOUS] = s->framep[VP8_FRAME_PREVIOUS];
2727
2728 1149 s->next_framep[VP8_FRAME_CURRENT] = curframe;
2729
2730
4/4
✓ Branch 0 taken 1118 times.
✓ Branch 1 taken 31 times.
✓ Branch 2 taken 1112 times.
✓ Branch 3 taken 6 times.
 1149 if (!is_vp7 && !s->actually_webp)
2731 1112 ff_thread_finish_setup(avctx);
2732
2733
3/4
✓ Branch 0 taken 1118 times.
✓ Branch 1 taken 31 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1118 times.
 1149 if (!is_vp7 && avctx->hwaccel) {
2734 ✗ const FFHWAccel *hwaccel = ffhwaccel(avctx->hwaccel);
2735 ✗ ret = hwaccel->start_frame(avctx, avpkt->buf, avpkt->data, avpkt->size);
2736 ✗ if (ret < 0)
2737 ✗ goto err;
2738
2739 ✗ ret = hwaccel->decode_slice(avctx, avpkt->data, avpkt->size);
2740 ✗ if (ret < 0)
2741 ✗ goto err;
2742
2743 ✗ ret = hwaccel->end_frame(avctx);
2744 ✗ if (ret < 0)
2745 ✗ goto err;
2746
2747 } else {
2748 1149 s->linesize = curframe->tf.f->linesize[0];
2749 1149 s->uvlinesize = curframe->tf.f->linesize[1];
2750
2751 1149 memset(s->top_nnz, 0, s->mb_width * sizeof(*s->top_nnz));
2752 /* Zero macroblock structures for top/top-left prediction
2753 * from outside the frame. */
2754
2/2
✓ Branch 0 taken 1118 times.
✓ Branch 1 taken 31 times.
 1149 if (!s->mb_layout)
2755 1118 memset(s->macroblocks + s->mb_height * 2 - 1, 0,
2756 1118 (s->mb_width + 1) * sizeof(*s->macroblocks));
2757
4/4
✓ Branch 0 taken 1118 times.
✓ Branch 1 taken 31 times.
✓ Branch 2 taken 50 times.
✓ Branch 3 taken 1068 times.
 1149 if (!s->mb_layout && s->keyframe)
2758 50 memset(s->intra4x4_pred_mode_top, DC_PRED, s->mb_width * 4);
2759
2760 1149 memset(s->ref_count, 0, sizeof(s->ref_count));
2761
2762
2/2
✓ Branch 0 taken 31 times.
✓ Branch 1 taken 1118 times.
 1149 if (s->mb_layout == 1) {
2763 // Make sure the previous frame has read its segmentation map,
2764 // if we re-use the same map.
2765
3/4
✓ Branch 0 taken 30 times.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 30 times.
 31 if (prev_frame && s->segmentation.enabled &&
2766 ✗ !s->segmentation.update_map)
2767 ✗ ff_progress_frame_await(&prev_frame->tf, 1);
2768
1/2
✓ Branch 0 taken 31 times.
✗ Branch 1 not taken.
 31 if (is_vp7)
2769 31 ret = vp7_decode_mv_mb_modes(avctx, curframe, prev_frame);
2770 else
2771 ✗ ret = vp8_decode_mv_mb_modes(avctx, curframe, prev_frame);
2772
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 31 times.
 31 if (ret < 0)
2773 ✗ goto err;
2774 }
2775
2776
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1149 times.
 1149 if (avctx->active_thread_type == FF_THREAD_FRAME)
2777 ✗ num_jobs = 1;
2778 else
2779 1149 num_jobs = FFMIN(s->num_coeff_partitions, avctx->thread_count);
2780 1149 s->num_jobs = num_jobs;
2781 1149 s->curframe = curframe;
2782 1149 s->prev_frame = prev_frame;
2783 1149 s->mv_bounds.mv_min.y = -MARGIN;
2784 1149 s->mv_bounds.mv_max.y = ((s->mb_height - 1) << 6) + MARGIN;
2785
2/2
✓ Branch 0 taken 9192 times.
✓ Branch 1 taken 1149 times.
 10341 for (i = 0; i < MAX_THREADS; i++) {
2786 9192 VP8ThreadData *td = &s->thread_data[i];
2787 9192 atomic_init(&td->thread_mb_pos, 0);
2788 9192 atomic_init(&td->wait_mb_pos, INT_MAX);
2789 }
2790
2/2
✓ Branch 0 taken 31 times.
✓ Branch 1 taken 1118 times.
 1149 if (is_vp7)
2791 31 avctx->execute2(avctx, vp7_decode_mb_row_sliced, s->thread_data, NULL,
2792 num_jobs);
2793 else
2794 1118 avctx->execute2(avctx, vp8_decode_mb_row_sliced, s->thread_data, NULL,
2795 num_jobs);
2796 }
2797
2798 1149 ff_progress_frame_report(&curframe->tf, INT_MAX);
2799 1149 memcpy(&s->framep[0], &s->next_framep[0], sizeof(s->framep[0]) * 4);
2800
2801 1149 skip_decode:
2802 // if future frames don't use the updated probabilities,
2803 // reset them to the values we saved
2804
2/2
✓ Branch 0 taken 64 times.
✓ Branch 1 taken 1085 times.
 1149 if (!s->update_probabilities)
2805 64 s->prob[0] = s->prob[1];
2806
2807
2/2
✓ Branch 0 taken 1140 times.
✓ Branch 1 taken 9 times.
 1149 if (!s->invisible) {
2808
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1140 times.
 1140 if ((ret = av_frame_ref(rframe, curframe->tf.f)) < 0)
2809 ✗ return ret;
2810 1140 *got_frame = 1;
2811 }
2812
2813 1149 return avpkt->size;
2814 ✗ err:
2815 ✗ memcpy(&s->next_framep[0], &s->framep[0], sizeof(s->framep[0]) * 4);
2816 ✗ return ret;
2817 }
2818
2819 63 av_cold int ff_vp8_decode_free(AVCodecContext *avctx)
2820 {
2821 63 vp8_decode_flush_impl(avctx, 1);
2822
2823 63 return 0;
2824 }
2825
2826 63 static av_cold void vp78_decode_init(AVCodecContext *avctx)
2827 {
2828 63 VP8Context *s = avctx->priv_data;
2829
2830 63 s->avctx = avctx;
2831 63 s->pix_fmt = AV_PIX_FMT_NONE;
2832 63 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
2833
2834 63 ff_videodsp_init(&s->vdsp, 8);
2835
2836 63 ff_vp78dsp_init(&s->vp8dsp);
2837
2838 /* does not change for VP8 */
2839 63 memcpy(s->prob[0].scan, ff_zigzag_scan, sizeof(s->prob[0].scan));
2840 63 }
2841
2842 #if CONFIG_VP8_DECODER
2843 15911 static int vp8_decode_mb_row_no_filter(AVCodecContext *avctx, void *tdata,
2844 int jobnr, int threadnr)
2845 {
2846 15911 return decode_mb_row_no_filter(avctx, tdata, jobnr, threadnr, 0);
2847 }
2848
2849 14825 static void vp8_filter_mb_row(AVCodecContext *avctx, void *tdata,
2850 int jobnr, int threadnr)
2851 {
2852 14825 filter_mb_row(avctx, tdata, jobnr, threadnr, 0);
2853 14825 }
2854
2855 1118 int ff_vp8_decode_frame(AVCodecContext *avctx, AVFrame *frame,
2856 int *got_frame, AVPacket *avpkt)
2857 {
2858 1118 return vp78_decode_frame(avctx, frame, got_frame, avpkt, IS_VP8);
2859 }
2860
2861 60 av_cold int ff_vp8_decode_init(AVCodecContext *avctx)
2862 {
2863 60 VP8Context *s = avctx->priv_data;
2864
2865 60 vp78_decode_init(avctx);
2866 60 ff_h264_pred_init(&s->hpc, AV_CODEC_ID_VP8, 8, 1);
2867 60 ff_vp8dsp_init(&s->vp8dsp);
2868 60 s->decode_mb_row_no_filter = vp8_decode_mb_row_no_filter;
2869 60 s->filter_mb_row = vp8_filter_mb_row;
2870
2871 60 return 0;
2872 }
2873
2874 #if HAVE_THREADS
2875 ✗ static void vp8_replace_frame(VP8Frame *dst, const VP8Frame *src)
2876 {
2877 ✗ ff_progress_frame_replace(&dst->tf, &src->tf);
2878 ✗ av_refstruct_replace(&dst->seg_map, src->seg_map);
2879 ✗ av_refstruct_replace(&dst->hwaccel_picture_private,
2880 ✗ src->hwaccel_picture_private);
2881 ✗ }
2882
2883 #define REBASE(pic) ((pic) ? (pic) - &s_src->frames[0] + &s->frames[0] : NULL)
2884
2885 ✗ static int vp8_decode_update_thread_context(AVCodecContext *dst,
2886 const AVCodecContext *src)
2887 {
2888 ✗ VP8Context *s = dst->priv_data, *s_src = src->priv_data;
2889
2890 ✗ if (s->macroblocks_base &&
2891 ✗ (s_src->mb_width != s->mb_width || s_src->mb_height != s->mb_height)) {
2892 ✗ free_buffers(s);
2893 ✗ s->mb_width = s_src->mb_width;
2894 ✗ s->mb_height = s_src->mb_height;
2895 }
2896
2897 ✗ s->pix_fmt = s_src->pix_fmt;
2898 ✗ s->prob[0] = s_src->prob[!s_src->update_probabilities];
2899 ✗ s->segmentation = s_src->segmentation;
2900 ✗ s->lf_delta = s_src->lf_delta;
2901 ✗ memcpy(s->sign_bias, s_src->sign_bias, sizeof(s->sign_bias));
2902
2903 ✗ for (int i = 0; i < FF_ARRAY_ELEMS(s_src->frames); i++)
2904 ✗ vp8_replace_frame(&s->frames[i], &s_src->frames[i]);
2905
2906 ✗ s->framep[0] = REBASE(s_src->next_framep[0]);
2907 ✗ s->framep[1] = REBASE(s_src->next_framep[1]);
2908 ✗ s->framep[2] = REBASE(s_src->next_framep[2]);
2909 ✗ s->framep[3] = REBASE(s_src->next_framep[3]);
2910
2911 ✗ return 0;
2912 }
2913 #endif /* HAVE_THREADS */
2914 #endif /* CONFIG_VP8_DECODER */
2915
2916 #if CONFIG_VP7_DECODER
2917 341 static int vp7_decode_mb_row_no_filter(AVCodecContext *avctx, void *tdata,
2918 int jobnr, int threadnr)
2919 {
2920 341 return decode_mb_row_no_filter(avctx, tdata, jobnr, threadnr, 1);
2921 }
2922
2923 341 static void vp7_filter_mb_row(AVCodecContext *avctx, void *tdata,
2924 int jobnr, int threadnr)
2925 {
2926 341 filter_mb_row(avctx, tdata, jobnr, threadnr, 1);
2927 341 }
2928
2929 31 static int vp7_decode_frame(AVCodecContext *avctx, AVFrame *frame,
2930 int *got_frame, AVPacket *avpkt)
2931 {
2932 31 return vp78_decode_frame(avctx, frame, got_frame, avpkt, IS_VP7);
2933 }
2934
2935 3 av_cold static int vp7_decode_init(AVCodecContext *avctx)
2936 {
2937 3 VP8Context *s = avctx->priv_data;
2938
2939 3 vp78_decode_init(avctx);
2940 3 ff_h264_pred_init(&s->hpc, AV_CODEC_ID_VP7, 8, 1);
2941 3 ff_vp7dsp_init(&s->vp8dsp);
2942 3 s->decode_mb_row_no_filter = vp7_decode_mb_row_no_filter;
2943 3 s->filter_mb_row = vp7_filter_mb_row;
2944
2945 3 return 0;
2946 }
2947
2948 const FFCodec ff_vp7_decoder = {
2949 .p.name = "vp7",
2950 CODEC_LONG_NAME("On2 VP7"),
2951 .p.type = AVMEDIA_TYPE_VIDEO,
2952 .p.id = AV_CODEC_ID_VP7,
2953 .priv_data_size = sizeof(VP8Context),
2954 .init = vp7_decode_init,
2955 .close = ff_vp8_decode_free,
2956 FF_CODEC_DECODE_CB(vp7_decode_frame),
2957 .p.capabilities = AV_CODEC_CAP_DR1,
2958 .flush = vp8_decode_flush,
2959 .caps_internal = FF_CODEC_CAP_USES_PROGRESSFRAMES,
2960 };
2961 #endif /* CONFIG_VP7_DECODER */
2962
2963 #if CONFIG_VP8_DECODER
2964 const FFCodec ff_vp8_decoder = {
2965 .p.name = "vp8",
2966 CODEC_LONG_NAME("On2 VP8"),
2967 .p.type = AVMEDIA_TYPE_VIDEO,
2968 .p.id = AV_CODEC_ID_VP8,
2969 .priv_data_size = sizeof(VP8Context),
2970 .init = ff_vp8_decode_init,
2971 .close = ff_vp8_decode_free,
2972 FF_CODEC_DECODE_CB(ff_vp8_decode_frame),
2973 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS |
2974 AV_CODEC_CAP_SLICE_THREADS,
2975 .caps_internal = FF_CODEC_CAP_USES_PROGRESSFRAMES,
2976 .flush = vp8_decode_flush,
2977 UPDATE_THREAD_CONTEXT(vp8_decode_update_thread_context),
2978 .hw_configs = (const AVCodecHWConfigInternal *const []) {
2979 #if CONFIG_VP8_VAAPI_HWACCEL
2980 HWACCEL_VAAPI(vp8),
2981 #endif
2982 #if CONFIG_VP8_NVDEC_HWACCEL
2983 HWACCEL_NVDEC(vp8),
2984 #endif
2985 NULL
2986 },
2987 };
2988 #endif /* CONFIG_VP8_DECODER */
2989