FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/vp9.c
Date: 2026-01-14 03:33:33
Exec Total Coverage
Lines: 855 1188 72.0%
Functions: 20 27 74.1%
Branches: 577 798 72.3%
Line Branch Exec Source
1 /*
2 * VP9 compatible video decoder
3 *
4 * Copyright (C) 2013 Ronald S. Bultje <rsbultje gmail com>
5 * Copyright (C) 2013 Clément Bœsch <u pkh me>
6 *
7 * This file is part of FFmpeg.
8 *
9 * FFmpeg is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * FFmpeg is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with FFmpeg; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 */
23
24 #include "config_components.h"
25
26 #include "avcodec.h"
27 #include "codec_internal.h"
28 #include "decode.h"
29 #include "get_bits.h"
30 #include "hwaccel_internal.h"
31 #include "hwconfig.h"
32 #include "profiles.h"
33 #include "progressframe.h"
34 #include "libavutil/refstruct.h"
35 #include "thread.h"
36 #include "pthread_internal.h"
37
38 #include "videodsp.h"
39 #include "vp89_rac.h"
40 #include "vp9.h"
41 #include "vp9data.h"
42 #include "vp9dec.h"
43 #include "vpx_rac.h"
44 #include "libavutil/attributes.h"
45 #include "libavutil/avassert.h"
46 #include "libavutil/mem.h"
47 #include "libavutil/pixdesc.h"
48 #include "libavutil/video_enc_params.h"
49
50 #define VP9_SYNCCODE 0x498342
51
52 #if HAVE_THREADS
53 DEFINE_OFFSET_ARRAY(VP9Context, vp9_context, pthread_init_cnt,
54 (offsetof(VP9Context, progress_mutex)),
55 (offsetof(VP9Context, progress_cond)));
56
57 479 static int vp9_alloc_entries(AVCodecContext *avctx, int n) {
58 479 VP9Context *s = avctx->priv_data;
59
60
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 479 times.
 479 if (avctx->active_thread_type & FF_THREAD_SLICE) {
61 ✗ if (s->entries)
62 ✗ av_freep(&s->entries);
63
64 ✗ s->entries = av_malloc_array(n, sizeof(atomic_int));
65 ✗ if (!s->entries)
66 ✗ return AVERROR(ENOMEM);
67 }
68 479 return 0;
69 }
70
71 ✗ static void vp9_report_tile_progress(VP9Context *s, int field, int n) {
72 ✗ pthread_mutex_lock(&s->progress_mutex);
73 ✗ atomic_fetch_add_explicit(&s->entries[field], n, memory_order_release);
74 ✗ pthread_cond_signal(&s->progress_cond);
75 ✗ pthread_mutex_unlock(&s->progress_mutex);
76 ✗ }
77
78 ✗ static void vp9_await_tile_progress(VP9Context *s, int field, int n) {
79 ✗ if (atomic_load_explicit(&s->entries[field], memory_order_acquire) >= n)
80 ✗ return;
81
82 ✗ pthread_mutex_lock(&s->progress_mutex);
83 ✗ while (atomic_load_explicit(&s->entries[field], memory_order_relaxed) != n)
84 ✗ pthread_cond_wait(&s->progress_cond, &s->progress_mutex);
85 ✗ pthread_mutex_unlock(&s->progress_mutex);
86 }
87 #else
88 static int vp9_alloc_entries(AVCodecContext *avctx, int n) { return 0; }
89 #endif
90
91 962 static void vp9_tile_data_free(VP9TileData *td)
92 {
93 962 av_freep(&td->b_base);
94 962 av_freep(&td->block_base);
95 962 av_freep(&td->block_structure);
96 962 }
97
98 8120 static void vp9_frame_unref(VP9Frame *f)
99 {
100 8120 ff_progress_frame_unref(&f->tf);
101 8120 av_refstruct_unref(&f->header_ref);
102 8120 av_refstruct_unref(&f->extradata);
103 8120 av_refstruct_unref(&f->hwaccel_picture_private);
104 8120 f->segmentation_map = NULL;
105 8120 }
106
107 2300 static int vp9_frame_alloc(AVCodecContext *avctx, VP9Frame *f)
108 {
109 2300 VP9Context *s = avctx->priv_data;
110 int ret, sz;
111
112 2300 ret = ff_progress_frame_get_buffer(avctx, &f->tf, AV_GET_BUFFER_FLAG_REF);
113
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2300 times.
 2300 if (ret < 0)
114 ✗ return ret;
115
116 2300 sz = 64 * s->sb_cols * s->sb_rows;
117
2/2
✓ Branch 0 taken 481 times.
✓ Branch 1 taken 1819 times.
 2300 if (sz != s->frame_extradata_pool_size) {
118 481 av_refstruct_pool_uninit(&s->frame_extradata_pool);
119 481 s->frame_extradata_pool = av_refstruct_pool_alloc(sz * (1 + sizeof(VP9mvrefPair)),
120 AV_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME);
121
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 481 times.
 481 if (!s->frame_extradata_pool) {
122 ✗ s->frame_extradata_pool_size = 0;
123 ✗ ret = AVERROR(ENOMEM);
124 ✗ goto fail;
125 }
126 481 s->frame_extradata_pool_size = sz;
127 }
128 2300 f->extradata = av_refstruct_pool_get(s->frame_extradata_pool);
129
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2300 times.
 2300 if (!f->extradata) {
130 ✗ ret = AVERROR(ENOMEM);
131 ✗ goto fail;
132 }
133
134 2300 f->segmentation_map = f->extradata;
135 2300 f->mv = (VP9mvrefPair *) ((char*)f->extradata + sz);
136
137 2300 ret = ff_hwaccel_frame_priv_alloc(avctx, &f->hwaccel_picture_private);
138
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2300 times.
 2300 if (ret < 0)
139 ✗ goto fail;
140
141 2300 return 0;
142
143 ✗ fail:
144 ✗ vp9_frame_unref(f);
145 ✗ return ret;
146 }
147
148 3072 static void vp9_frame_replace(VP9Frame *dst, const VP9Frame *src)
149 {
150 3072 av_refstruct_replace(&dst->header_ref, src->header_ref);
151 3072 dst->frame_header = src->frame_header;
152
153 3072 ff_progress_frame_replace(&dst->tf, &src->tf);
154
155 3072 av_refstruct_replace(&dst->extradata, src->extradata);
156
157 3072 dst->segmentation_map = src->segmentation_map;
158 3072 dst->mv = src->mv;
159 3072 dst->uses_2pass = src->uses_2pass;
160
161 3072 av_refstruct_replace(&dst->hwaccel_picture_private,
162 3072 src->hwaccel_picture_private);
163 3072 }
164
165 2300 static int update_size(AVCodecContext *avctx, int w, int h)
166 {
167 #define HWACCEL_MAX (CONFIG_VP9_DXVA2_HWACCEL + \
168 CONFIG_VP9_D3D11VA_HWACCEL * 2 + \
169 CONFIG_VP9_D3D12VA_HWACCEL + \
170 CONFIG_VP9_NVDEC_HWACCEL + \
171 CONFIG_VP9_VAAPI_HWACCEL + \
172 CONFIG_VP9_VDPAU_HWACCEL + \
173 CONFIG_VP9_VIDEOTOOLBOX_HWACCEL + \
174 CONFIG_VP9_VULKAN_HWACCEL)
175 2300 enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmtp = pix_fmts;
176 2300 VP9Context *s = avctx->priv_data;
177 uint8_t *p;
178 2300 int bytesperpixel = s->bytesperpixel, ret, cols, rows;
179 int lflvl_len, i;
180
181
2/4
✓ Branch 0 taken 2300 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2300 times.
 2300 av_assert0(w > 0 && h > 0);
182
183
5/6
✓ Branch 0 taken 2266 times.
✓ Branch 1 taken 34 times.
✓ Branch 2 taken 1819 times.
✓ Branch 3 taken 447 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 1819 times.
 2300 if (!(s->pix_fmt == s->gf_fmt && w == s->w && h == s->h)) {
184
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 481 times.
 481 if ((ret = ff_set_dimensions(avctx, w, h)) < 0)
185 ✗ return ret;
186
187
4/5
✓ Branch 0 taken 456 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 15 times.
 481 switch (s->pix_fmt) {
188 456 case AV_PIX_FMT_YUV420P:
189 case AV_PIX_FMT_YUV420P10:
190 #if CONFIG_VP9_DXVA2_HWACCEL
191 *fmtp++ = AV_PIX_FMT_DXVA2_VLD;
192 #endif
193 #if CONFIG_VP9_D3D11VA_HWACCEL
194 *fmtp++ = AV_PIX_FMT_D3D11VA_VLD;
195 *fmtp++ = AV_PIX_FMT_D3D11;
196 #endif
197 #if CONFIG_VP9_D3D12VA_HWACCEL
198 *fmtp++ = AV_PIX_FMT_D3D12;
199 #endif
200 #if CONFIG_VP9_NVDEC_HWACCEL
201 *fmtp++ = AV_PIX_FMT_CUDA;
202 #endif
203 #if CONFIG_VP9_VAAPI_HWACCEL
204 456 *fmtp++ = AV_PIX_FMT_VAAPI;
205 #endif
206 #if CONFIG_VP9_VDPAU_HWACCEL
207 456 *fmtp++ = AV_PIX_FMT_VDPAU;
208 #endif
209 #if CONFIG_VP9_VIDEOTOOLBOX_HWACCEL
210 *fmtp++ = AV_PIX_FMT_VIDEOTOOLBOX;
211 #endif
212 #if CONFIG_VP9_VULKAN_HWACCEL
213 *fmtp++ = AV_PIX_FMT_VULKAN;
214 #endif
215 456 break;
216 2 case AV_PIX_FMT_YUV420P12:
217 #if CONFIG_VP9_NVDEC_HWACCEL
218 *fmtp++ = AV_PIX_FMT_CUDA;
219 #endif
220 #if CONFIG_VP9_VAAPI_HWACCEL
221 2 *fmtp++ = AV_PIX_FMT_VAAPI;
222 #endif
223 #if CONFIG_VP9_VDPAU_HWACCEL
224 2 *fmtp++ = AV_PIX_FMT_VDPAU;
225 #endif
226 #if CONFIG_VP9_VULKAN_HWACCEL
227 *fmtp++ = AV_PIX_FMT_VULKAN;
228 #endif
229 2 break;
230 8 case AV_PIX_FMT_YUV444P:
231 case AV_PIX_FMT_YUV444P10:
232 case AV_PIX_FMT_YUV444P12:
233 #if CONFIG_VP9_VAAPI_HWACCEL
234 8 *fmtp++ = AV_PIX_FMT_VAAPI;
235 #endif
236 #if CONFIG_VP9_VULKAN_HWACCEL
237 *fmtp++ = AV_PIX_FMT_VULKAN;
238 #endif
239 8 break;
240 ✗ case AV_PIX_FMT_GBRP:
241 case AV_PIX_FMT_GBRP10:
242 case AV_PIX_FMT_GBRP12:
243 #if CONFIG_VP9_VAAPI_HWACCEL
244 ✗ *fmtp++ = AV_PIX_FMT_VAAPI;
245 #endif
246 #if CONFIG_VP9_VULKAN_HWACCEL
247 *fmtp++ = AV_PIX_FMT_VULKAN;
248 #endif
249 ✗ break;
250 }
251
252 481 *fmtp++ = s->pix_fmt;
253 481 *fmtp = AV_PIX_FMT_NONE;
254
255 481 ret = ff_get_format(avctx, pix_fmts);
256
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 481 times.
 481 if (ret < 0)
257 ✗ return ret;
258
259 481 avctx->pix_fmt = ret;
260 481 s->gf_fmt = s->pix_fmt;
261 481 s->w = w;
262 481 s->h = h;
263 }
264
265 2300 cols = (w + 7) >> 3;
266 2300 rows = (h + 7) >> 3;
267
268
6/8
✓ Branch 0 taken 1821 times.
✓ Branch 1 taken 479 times.
✓ Branch 2 taken 1819 times.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 1819 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1819 times.
✗ Branch 7 not taken.
 2300 if (s->intra_pred_data[0] && cols == s->cols && rows == s->rows && s->pix_fmt == s->last_fmt)
269 1819 return 0;
270
271 481 s->last_fmt = s->pix_fmt;
272 481 s->sb_cols = (w + 63) >> 6;
273 481 s->sb_rows = (h + 63) >> 6;
274 481 s->cols = (w + 7) >> 3;
275 481 s->rows = (h + 7) >> 3;
276
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 481 times.
 481 lflvl_len = avctx->active_thread_type == FF_THREAD_SLICE ? s->sb_rows : 1;
277
278 #define assign(var, type, n) var = (type) p; p += s->sb_cols * (n) * sizeof(*var)
279 481 av_freep(&s->intra_pred_data[0]);
280 // FIXME we slightly over-allocate here for subsampled chroma, but a little
281 // bit of padding shouldn't affect performance...
282 481 p = av_malloc(s->sb_cols * (128 + 192 * bytesperpixel +
283 481 lflvl_len * sizeof(*s->lflvl) + 16 * sizeof(*s->above_mv_ctx)));
284
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 481 times.
 481 if (!p)
285 ✗ return AVERROR(ENOMEM);
286 481 assign(s->intra_pred_data[0], uint8_t *, 64 * bytesperpixel);
287 481 assign(s->intra_pred_data[1], uint8_t *, 64 * bytesperpixel);
288 481 assign(s->intra_pred_data[2], uint8_t *, 64 * bytesperpixel);
289 481 assign(s->above_y_nnz_ctx, uint8_t *, 16);
290 481 assign(s->above_mode_ctx, uint8_t *, 16);
291 481 assign(s->above_mv_ctx, VP9mv(*)[2], 16);
292 481 assign(s->above_uv_nnz_ctx[0], uint8_t *, 16);
293 481 assign(s->above_uv_nnz_ctx[1], uint8_t *, 16);
294 481 assign(s->above_partition_ctx, uint8_t *, 8);
295 481 assign(s->above_skip_ctx, uint8_t *, 8);
296 481 assign(s->above_txfm_ctx, uint8_t *, 8);
297 481 assign(s->above_segpred_ctx, uint8_t *, 8);
298 481 assign(s->above_intra_ctx, uint8_t *, 8);
299 481 assign(s->above_comp_ctx, uint8_t *, 8);
300 481 assign(s->above_ref_ctx, uint8_t *, 8);
301 481 assign(s->above_filter_ctx, uint8_t *, 8);
302 481 assign(s->lflvl, VP9Filter *, lflvl_len);
303 #undef assign
304
305
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 479 times.
 481 if (s->td) {
306
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2 times.
 4 for (i = 0; i < s->active_tile_cols; i++)
307 2 vp9_tile_data_free(&s->td[i]);
308 }
309
310
2/2
✓ Branch 0 taken 479 times.
✓ Branch 1 taken 2 times.
 481 if (s->s.h.bpp != s->last_bpp) {
311 479 ff_vp9dsp_init(&s->dsp, s->s.h.bpp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
312 479 ff_videodsp_init(&s->vdsp, s->s.h.bpp);
313 479 s->last_bpp = s->s.h.bpp;
314 }
315
316 481 return 0;
317 }
318
319 2300 static int update_block_buffers(AVCodecContext *avctx)
320 {
321 int i;
322 2300 VP9Context *s = avctx->priv_data;
323 2300 int chroma_blocks, chroma_eobs, bytesperpixel = s->bytesperpixel;
324 2300 VP9TileData *td = &s->td[0];
325
326
4/6
✓ Branch 0 taken 1819 times.
✓ Branch 1 taken 481 times.
✓ Branch 2 taken 1819 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1819 times.
✗ Branch 5 not taken.
 2300 if (td->b_base && td->block_base && s->block_alloc_using_2pass == s->s.frames[CUR_FRAME].uses_2pass)
327 1819 return 0;
328
329 481 vp9_tile_data_free(td);
330 481 chroma_blocks = 64 * 64 >> (s->ss_h + s->ss_v);
331 481 chroma_eobs = 16 * 16 >> (s->ss_h + s->ss_v);
332
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 481 times.
 481 if (s->s.frames[CUR_FRAME].uses_2pass) {
333 ✗ int sbs = s->sb_cols * s->sb_rows;
334
335 ✗ td->b_base = av_malloc_array(s->cols * s->rows, sizeof(VP9Block));
336 ✗ td->block_base = av_mallocz(((64 * 64 + 2 * chroma_blocks) * bytesperpixel * sizeof(int16_t) +
337 ✗ 16 * 16 + 2 * chroma_eobs) * sbs);
338 ✗ if (!td->b_base || !td->block_base)
339 ✗ return AVERROR(ENOMEM);
340 ✗ td->uvblock_base[0] = td->block_base + sbs * 64 * 64 * bytesperpixel;
341 ✗ td->uvblock_base[1] = td->uvblock_base[0] + sbs * chroma_blocks * bytesperpixel;
342 ✗ td->eob_base = (uint8_t *) (td->uvblock_base[1] + sbs * chroma_blocks * bytesperpixel);
343 ✗ td->uveob_base[0] = td->eob_base + 16 * 16 * sbs;
344 ✗ td->uveob_base[1] = td->uveob_base[0] + chroma_eobs * sbs;
345
346 ✗ if (avctx->export_side_data & AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS) {
347 ✗ td->block_structure = av_malloc_array(s->cols * s->rows, sizeof(*td->block_structure));
348 ✗ if (!td->block_structure)
349 ✗ return AVERROR(ENOMEM);
350 }
351 } else {
352
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 481 times.
 481 for (i = 1; i < s->active_tile_cols; i++)
353 ✗ vp9_tile_data_free(&s->td[i]);
354
355
2/2
✓ Branch 0 taken 481 times.
✓ Branch 1 taken 481 times.
 962 for (i = 0; i < s->active_tile_cols; i++) {
356 481 s->td[i].b_base = av_malloc(sizeof(VP9Block));
357 962 s->td[i].block_base = av_mallocz((64 * 64 + 2 * chroma_blocks) * bytesperpixel * sizeof(int16_t) +
358 481 16 * 16 + 2 * chroma_eobs);
359
2/4
✓ Branch 0 taken 481 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 481 times.
 481 if (!s->td[i].b_base || !s->td[i].block_base)
360 ✗ return AVERROR(ENOMEM);
361 481 s->td[i].uvblock_base[0] = s->td[i].block_base + 64 * 64 * bytesperpixel;
362 481 s->td[i].uvblock_base[1] = s->td[i].uvblock_base[0] + chroma_blocks * bytesperpixel;
363 481 s->td[i].eob_base = (uint8_t *) (s->td[i].uvblock_base[1] + chroma_blocks * bytesperpixel);
364 481 s->td[i].uveob_base[0] = s->td[i].eob_base + 16 * 16;
365 481 s->td[i].uveob_base[1] = s->td[i].uveob_base[0] + chroma_eobs;
366
367
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 480 times.
 481 if (avctx->export_side_data & AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS) {
368 1 s->td[i].block_structure = av_malloc_array(s->cols * s->rows, sizeof(*td->block_structure));
369
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (!s->td[i].block_structure)
370 ✗ return AVERROR(ENOMEM);
371 }
372 }
373 }
374 481 s->block_alloc_using_2pass = s->s.frames[CUR_FRAME].uses_2pass;
375
376 481 return 0;
377 }
378
379 // The sign bit is at the end, not the start, of a bit sequence
380 1748 static av_always_inline int get_sbits_inv(GetBitContext *gb, int n)
381 {
382 1748 int v = get_bits(gb, n);
383
2/2
✓ Branch 1 taken 1139 times.
✓ Branch 2 taken 609 times.
 1748 return get_bits1(gb) ? -v : v;
384 }
385
386 26242 static av_always_inline int inv_recenter_nonneg(int v, int m)
387 {
388
2/2
✓ Branch 0 taken 7120 times.
✓ Branch 1 taken 19122 times.
 26242 if (v > 2 * m)
389 7120 return v;
390
2/2
✓ Branch 0 taken 11436 times.
✓ Branch 1 taken 7686 times.
 19122 if (v & 1)
391 11436 return m - ((v + 1) >> 1);
392 7686 return m + (v >> 1);
393 }
394
395 // differential forward probability updates
396 26242 static int update_prob(VPXRangeCoder *c, int p)
397 {
398 static const uint8_t inv_map_table[255] = {
399 7, 20, 33, 46, 59, 72, 85, 98, 111, 124, 137, 150, 163, 176,
400 189, 202, 215, 228, 241, 254, 1, 2, 3, 4, 5, 6, 8, 9,
401 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 21, 22, 23, 24,
402 25, 26, 27, 28, 29, 30, 31, 32, 34, 35, 36, 37, 38, 39,
403 40, 41, 42, 43, 44, 45, 47, 48, 49, 50, 51, 52, 53, 54,
404 55, 56, 57, 58, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
405 70, 71, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
406 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 99, 100,
407 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 112, 113, 114, 115,
408 116, 117, 118, 119, 120, 121, 122, 123, 125, 126, 127, 128, 129, 130,
409 131, 132, 133, 134, 135, 136, 138, 139, 140, 141, 142, 143, 144, 145,
410 146, 147, 148, 149, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160,
411 161, 162, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
412 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 190, 191,
413 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 203, 204, 205, 206,
414 207, 208, 209, 210, 211, 212, 213, 214, 216, 217, 218, 219, 220, 221,
415 222, 223, 224, 225, 226, 227, 229, 230, 231, 232, 233, 234, 235, 236,
416 237, 238, 239, 240, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251,
417 252, 253, 253,
418 };
419 int d;
420
421 /* This code is trying to do a differential probability update. For a
422 * current probability A in the range [1, 255], the difference to a new
423 * probability of any value can be expressed differentially as 1-A, 255-A
424 * where some part of this (absolute range) exists both in positive as
425 * well as the negative part, whereas another part only exists in one
426 * half. We're trying to code this shared part differentially, i.e.
427 * times two where the value of the lowest bit specifies the sign, and
428 * the single part is then coded on top of this. This absolute difference
429 * then again has a value of [0, 254], but a bigger value in this range
430 * indicates that we're further away from the original value A, so we
431 * can code this as a VLC code, since higher values are increasingly
432 * unlikely. The first 20 values in inv_map_table[] allow 'cheap, rough'
433 * updates vs. the 'fine, exact' updates further down the range, which
434 * adds one extra dimension to this differential update model. */
435
436
2/2
✓ Branch 1 taken 19664 times.
✓ Branch 2 taken 6578 times.
 26242 if (!vp89_rac_get(c)) {
437 19664 d = vp89_rac_get_uint(c, 4) + 0;
438
2/2
✓ Branch 1 taken 2443 times.
✓ Branch 2 taken 4135 times.
 6578 } else if (!vp89_rac_get(c)) {
439 2443 d = vp89_rac_get_uint(c, 4) + 16;
440
2/2
✓ Branch 1 taken 2863 times.
✓ Branch 2 taken 1272 times.
 4135 } else if (!vp89_rac_get(c)) {
441 2863 d = vp89_rac_get_uint(c, 5) + 32;
442 } else {
443 1272 d = vp89_rac_get_uint(c, 7);
444
2/2
✓ Branch 0 taken 196 times.
✓ Branch 1 taken 1076 times.
 1272 if (d >= 65)
445 196 d = (d << 1) - 65 + vp89_rac_get(c);
446 1272 d += 64;
447 av_assert2(d < FF_ARRAY_ELEMS(inv_map_table));
448 }
449
450
2/2
✓ Branch 0 taken 14783 times.
✓ Branch 1 taken 11459 times.
 37701 return p <= 128 ? 1 + inv_recenter_nonneg(inv_map_table[d], p - 1) :
451 11459 255 - inv_recenter_nonneg(inv_map_table[d], 255 - p);
452 }
453
454 479 static int read_colorspace_details(AVCodecContext *avctx)
455 {
456 static const enum AVColorSpace colorspaces[8] = {
457 AVCOL_SPC_UNSPECIFIED, AVCOL_SPC_BT470BG, AVCOL_SPC_BT709, AVCOL_SPC_SMPTE170M,
458 AVCOL_SPC_SMPTE240M, AVCOL_SPC_BT2020_NCL, AVCOL_SPC_RESERVED, AVCOL_SPC_RGB,
459 };
460 479 VP9Context *s = avctx->priv_data;
461
2/2
✓ Branch 0 taken 26 times.
✓ Branch 1 taken 453 times.
 479 int bits = avctx->profile <= 1 ? 0 : 1 + get_bits1(&s->gb); // 0:8, 1:10, 2:12
462
463 479 s->bpp_index = bits;
464 479 s->s.h.bpp = 8 + bits * 2;
465 479 s->bytesperpixel = (7 + s->s.h.bpp) >> 3;
466 479 avctx->colorspace = colorspaces[get_bits(&s->gb, 3)];
467
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 479 times.
 479 if (avctx->colorspace == AVCOL_SPC_RGB) { // RGB = profile 1
468 static const enum AVPixelFormat pix_fmt_rgb[3] = {
469 AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12
470 };
471 ✗ s->ss_h = s->ss_v = 0;
472 ✗ avctx->color_range = AVCOL_RANGE_JPEG;
473 ✗ s->pix_fmt = pix_fmt_rgb[bits];
474 ✗ if (avctx->profile & 1) {
475 ✗ if (get_bits1(&s->gb)) {
476 ✗ av_log(avctx, AV_LOG_ERROR, "Reserved bit set in RGB\n");
477 ✗ return AVERROR_INVALIDDATA;
478 }
479 } else {
480 ✗ av_log(avctx, AV_LOG_ERROR, "RGB not supported in profile %d\n",
481 avctx->profile);
482 ✗ return AVERROR_INVALIDDATA;
483 }
484 } else {
485 static const enum AVPixelFormat pix_fmt_for_ss[3][2 /* v */][2 /* h */] = {
486 { { AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P },
487 { AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV420P } },
488 { { AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV422P10 },
489 { AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV420P10 } },
490 { { AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV422P12 },
491 { AV_PIX_FMT_YUV440P12, AV_PIX_FMT_YUV420P12 } }
492 };
493
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 479 times.
 479 avctx->color_range = get_bits1(&s->gb) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
494
2/2
✓ Branch 0 taken 23 times.
✓ Branch 1 taken 456 times.
 479 if (avctx->profile & 1) {
495 23 s->ss_h = get_bits1(&s->gb);
496 23 s->ss_v = get_bits1(&s->gb);
497 23 s->pix_fmt = pix_fmt_for_ss[bits][s->ss_v][s->ss_h];
498
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23 times.
 23 if (s->pix_fmt == AV_PIX_FMT_YUV420P) {
499 ✗ av_log(avctx, AV_LOG_ERROR, "YUV 4:2:0 not supported in profile %d\n",
500 avctx->profile);
501 ✗ return AVERROR_INVALIDDATA;
502
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 23 times.
 23 } else if (get_bits1(&s->gb)) {
503 ✗ av_log(avctx, AV_LOG_ERROR, "Profile %d color details reserved bit set\n",
504 avctx->profile);
505 ✗ return AVERROR_INVALIDDATA;
506 }
507 } else {
508 456 s->ss_h = s->ss_v = 1;
509 456 s->pix_fmt = pix_fmt_for_ss[bits][1][1];
510 }
511 }
512
513 479 return 0;
514 }
515
516 2319 static int decode_frame_header(AVCodecContext *avctx,
517 const uint8_t *data, int size, int *ref)
518 {
519 2319 VP9Context *s = avctx->priv_data;
520 int c, i, j, k, l, m, n, w, h, max, size2, ret, sharp;
521 int last_invisible;
522 const uint8_t *data2;
523
524 /* general header */
525
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2319 times.
 2319 if ((ret = init_get_bits8(&s->gb, data, size)) < 0) {
526 ✗ av_log(avctx, AV_LOG_ERROR, "Failed to initialize bitstream reader\n");
527 ✗ return ret;
528 }
529
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2319 times.
 2319 if (get_bits(&s->gb, 2) != 0x2) { // frame marker
530 ✗ av_log(avctx, AV_LOG_ERROR, "Invalid frame marker\n");
531 ✗ return AVERROR_INVALIDDATA;
532 }
533 2319 avctx->profile = get_bits1(&s->gb);
534 2319 avctx->profile |= get_bits1(&s->gb) << 1;
535
2/2
✓ Branch 0 taken 112 times.
✓ Branch 1 taken 2207 times.
 2319 if (avctx->profile == 3) avctx->profile += get_bits1(&s->gb);
536
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2319 times.
 2319 if (avctx->profile > 3) {
537 ✗ av_log(avctx, AV_LOG_ERROR, "Profile %d is not yet supported\n", avctx->profile);
538 ✗ return AVERROR_INVALIDDATA;
539 }
540 2319 s->s.h.profile = avctx->profile;
541
2/2
✓ Branch 1 taken 19 times.
✓ Branch 2 taken 2300 times.
 2319 if (get_bits1(&s->gb)) {
542 19 *ref = get_bits(&s->gb, 3);
543 19 return 0;
544 }
545
546 2300 s->last_keyframe = s->s.h.keyframe;
547 2300 s->s.h.keyframe = !get_bits1(&s->gb);
548
549 2300 last_invisible = s->s.h.invisible;
550 2300 s->s.h.invisible = !get_bits1(&s->gb);
551 2300 s->s.h.errorres = get_bits1(&s->gb);
552
4/4
✓ Branch 0 taken 2289 times.
✓ Branch 1 taken 11 times.
✓ Branch 2 taken 2224 times.
✓ Branch 3 taken 65 times.
 2300 s->s.h.use_last_frame_mvs = !s->s.h.errorres && !last_invisible;
553
554
2/2
✓ Branch 0 taken 479 times.
✓ Branch 1 taken 1821 times.
 2300 if (s->s.h.keyframe) {
555
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 479 times.
 479 if (get_bits(&s->gb, 24) != VP9_SYNCCODE) { // synccode
556 ✗ av_log(avctx, AV_LOG_ERROR, "Invalid sync code\n");
557 ✗ return AVERROR_INVALIDDATA;
558 }
559
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 479 times.
 479 if ((ret = read_colorspace_details(avctx)) < 0)
560 ✗ return ret;
561 // for profile 1, here follows the subsampling bits
562 479 s->s.h.refreshrefmask = 0xff;
563 479 w = get_bits(&s->gb, 16) + 1;
564 479 h = get_bits(&s->gb, 16) + 1;
565
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 479 times.
 479 if (get_bits1(&s->gb)) // display size
566 ✗ skip_bits(&s->gb, 32);
567 } else {
568
2/2
✓ Branch 0 taken 65 times.
✓ Branch 1 taken 1756 times.
 1821 s->s.h.intraonly = s->s.h.invisible ? get_bits1(&s->gb) : 0;
569
2/2
✓ Branch 0 taken 1812 times.
✓ Branch 1 taken 9 times.
 1821 s->s.h.resetctx = s->s.h.errorres ? 0 : get_bits(&s->gb, 2);
570
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 1815 times.
 1821 if (s->s.h.intraonly) {
571
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
 6 if (get_bits(&s->gb, 24) != VP9_SYNCCODE) { // synccode
572 ✗ av_log(avctx, AV_LOG_ERROR, "Invalid sync code\n");
573 ✗ return AVERROR_INVALIDDATA;
574 }
575
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (avctx->profile >= 1) {
576 ✗ if ((ret = read_colorspace_details(avctx)) < 0)
577 ✗ return ret;
578 } else {
579 6 s->ss_h = s->ss_v = 1;
580 6 s->s.h.bpp = 8;
581 6 s->bpp_index = 0;
582 6 s->bytesperpixel = 1;
583 6 s->pix_fmt = AV_PIX_FMT_YUV420P;
584 6 avctx->colorspace = AVCOL_SPC_BT470BG;
585 6 avctx->color_range = AVCOL_RANGE_MPEG;
586 }
587 6 s->s.h.refreshrefmask = get_bits(&s->gb, 8);
588 6 w = get_bits(&s->gb, 16) + 1;
589 6 h = get_bits(&s->gb, 16) + 1;
590
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
 6 if (get_bits1(&s->gb)) // display size
591 ✗ skip_bits(&s->gb, 32);
592 } else {
593 1815 s->s.h.refreshrefmask = get_bits(&s->gb, 8);
594 1815 s->s.h.refidx[0] = get_bits(&s->gb, 3);
595
1/4
✗ Branch 1 not taken.
✓ Branch 2 taken 1815 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 1815 s->s.h.signbias[0] = get_bits1(&s->gb) && !s->s.h.errorres;
596 1815 s->s.h.refidx[1] = get_bits(&s->gb, 3);
597
1/4
✗ Branch 1 not taken.
✓ Branch 2 taken 1815 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 1815 s->s.h.signbias[1] = get_bits1(&s->gb) && !s->s.h.errorres;
598 1815 s->s.h.refidx[2] = get_bits(&s->gb, 3);
599
3/4
✓ Branch 1 taken 459 times.
✓ Branch 2 taken 1356 times.
✓ Branch 3 taken 459 times.
✗ Branch 4 not taken.
 1815 s->s.h.signbias[2] = get_bits1(&s->gb) && !s->s.h.errorres;
600
1/2
✓ Branch 0 taken 1815 times.
✗ Branch 1 not taken.
 1815 if (!s->s.refs[s->s.h.refidx[0]].f ||
601
1/2
✓ Branch 0 taken 1815 times.
✗ Branch 1 not taken.
 1815 !s->s.refs[s->s.h.refidx[1]].f ||
602
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1815 times.
 1815 !s->s.refs[s->s.h.refidx[2]].f) {
603 ✗ av_log(avctx, AV_LOG_ERROR, "Not all references are available\n");
604 ✗ return AVERROR_INVALIDDATA;
605 }
606
2/2
✓ Branch 1 taken 1813 times.
✓ Branch 2 taken 2 times.
 1815 if (get_bits1(&s->gb)) {
607 1813 w = s->s.refs[s->s.h.refidx[0]].f->width;
608 1813 h = s->s.refs[s->s.h.refidx[0]].f->height;
609
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1 times.
 2 } else if (get_bits1(&s->gb)) {
610 1 w = s->s.refs[s->s.h.refidx[1]].f->width;
611 1 h = s->s.refs[s->s.h.refidx[1]].f->height;
612
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
 1 } else if (get_bits1(&s->gb)) {
613 ✗ w = s->s.refs[s->s.h.refidx[2]].f->width;
614 ✗ h = s->s.refs[s->s.h.refidx[2]].f->height;
615 } else {
616 1 w = get_bits(&s->gb, 16) + 1;
617 1 h = get_bits(&s->gb, 16) + 1;
618 }
619 // Note that in this code, "CUR_FRAME" is actually before we
620 // have formally allocated a frame, and thus actually represents
621 // the _last_ frame
622 5445 s->s.h.use_last_frame_mvs &= s->s.frames[CUR_FRAME].tf.f &&
623
3/4
✓ Branch 0 taken 1815 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1813 times.
✓ Branch 3 taken 2 times.
 3628 s->s.frames[CUR_FRAME].tf.f->width == w &&
624
1/2
✓ Branch 0 taken 1813 times.
✗ Branch 1 not taken.
 1813 s->s.frames[CUR_FRAME].tf.f->height == h;
625
2/2
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 1812 times.
 1815 if (get_bits1(&s->gb)) // display size
626 3 skip_bits(&s->gb, 32);
627 1815 s->s.h.highprecisionmvs = get_bits1(&s->gb);
628
2/2
✓ Branch 1 taken 494 times.
✓ Branch 2 taken 1321 times.
 1815 s->s.h.filtermode = get_bits1(&s->gb) ? FILTER_SWITCHABLE :
629 494 get_bits(&s->gb, 2);
630
1/2
✓ Branch 0 taken 1815 times.
✗ Branch 1 not taken.
 3630 s->s.h.allowcompinter = s->s.h.signbias[0] != s->s.h.signbias[1] ||
631
2/2
✓ Branch 0 taken 459 times.
✓ Branch 1 taken 1356 times.
 1815 s->s.h.signbias[0] != s->s.h.signbias[2];
632
2/2
✓ Branch 0 taken 459 times.
✓ Branch 1 taken 1356 times.
 1815 if (s->s.h.allowcompinter) {
633
1/2
✓ Branch 0 taken 459 times.
✗ Branch 1 not taken.
 459 if (s->s.h.signbias[0] == s->s.h.signbias[1]) {
634 459 s->s.h.fixcompref = 2;
635 459 s->s.h.varcompref[0] = 0;
636 459 s->s.h.varcompref[1] = 1;
637 ✗ } else if (s->s.h.signbias[0] == s->s.h.signbias[2]) {
638 ✗ s->s.h.fixcompref = 1;
639 ✗ s->s.h.varcompref[0] = 0;
640 ✗ s->s.h.varcompref[1] = 2;
641 } else {
642 ✗ s->s.h.fixcompref = 0;
643 ✗ s->s.h.varcompref[0] = 1;
644 ✗ s->s.h.varcompref[1] = 2;
645 }
646 }
647 }
648 }
649
2/2
✓ Branch 0 taken 2289 times.
✓ Branch 1 taken 11 times.
 2300 s->s.h.refreshctx = s->s.h.errorres ? 0 : get_bits1(&s->gb);
650
2/2
✓ Branch 0 taken 2289 times.
✓ Branch 1 taken 11 times.
 2300 s->s.h.parallelmode = s->s.h.errorres ? 1 : get_bits1(&s->gb);
651 2300 s->s.h.framectxid = c = get_bits(&s->gb, 2);
652
4/4
✓ Branch 0 taken 1821 times.
✓ Branch 1 taken 479 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 1815 times.
 2300 if (s->s.h.keyframe || s->s.h.intraonly)
653 485 s->s.h.framectxid = 0; // BUG: libvpx ignores this field in keyframes
654
655 /* loopfilter header data */
656
6/6
✓ Branch 0 taken 1821 times.
✓ Branch 1 taken 479 times.
✓ Branch 2 taken 1812 times.
✓ Branch 3 taken 9 times.
✓ Branch 4 taken 6 times.
✓ Branch 5 taken 1806 times.
 2300 if (s->s.h.keyframe || s->s.h.errorres || s->s.h.intraonly) {
657 // reset loopfilter defaults
658 494 s->s.h.lf_delta.ref[0] = 1;
659 494 s->s.h.lf_delta.ref[1] = 0;
660 494 s->s.h.lf_delta.ref[2] = -1;
661 494 s->s.h.lf_delta.ref[3] = -1;
662 494 s->s.h.lf_delta.mode[0] = 0;
663 494 s->s.h.lf_delta.mode[1] = 0;
664 494 memset(s->s.h.segmentation.feat, 0, sizeof(s->s.h.segmentation.feat));
665 }
666 2300 s->s.h.filter.level = get_bits(&s->gb, 6);
667 2300 sharp = get_bits(&s->gb, 3);
668 // if sharpness changed, reinit lim/mblim LUTs. if it didn't change, keep
669 // the old cache values since they are still valid
670
2/2
✓ Branch 0 taken 486 times.
✓ Branch 1 taken 1814 times.
 2300 if (s->s.h.filter.sharpness != sharp) {
671
2/2
✓ Branch 0 taken 30618 times.
✓ Branch 1 taken 486 times.
 31104 for (i = 1; i <= 63; i++) {
672 30618 int limit = i;
673
674
2/2
✓ Branch 0 taken 441 times.
✓ Branch 1 taken 30177 times.
 30618 if (sharp > 0) {
675 441 limit >>= (sharp + 3) >> 2;
676 441 limit = FFMIN(limit, 9 - sharp);
677 }
678 30618 limit = FFMAX(limit, 1);
679
680 30618 s->filter_lut.lim_lut[i] = limit;
681 30618 s->filter_lut.mblim_lut[i] = 2 * (i + 2) + limit;
682 }
683 }
684 2300 s->s.h.filter.sharpness = sharp;
685
2/2
✓ Branch 1 taken 2285 times.
✓ Branch 2 taken 15 times.
 2300 if ((s->s.h.lf_delta.enabled = get_bits1(&s->gb))) {
686
2/2
✓ Branch 1 taken 508 times.
✓ Branch 2 taken 1777 times.
 2285 if ((s->s.h.lf_delta.updated = get_bits1(&s->gb))) {
687
2/2
✓ Branch 0 taken 2032 times.
✓ Branch 1 taken 508 times.
 2540 for (i = 0; i < 4; i++)
688
2/2
✓ Branch 1 taken 1485 times.
✓ Branch 2 taken 547 times.
 2032 if (get_bits1(&s->gb))
689 1485 s->s.h.lf_delta.ref[i] = get_sbits_inv(&s->gb, 6);
690
2/2
✓ Branch 0 taken 1016 times.
✓ Branch 1 taken 508 times.
 1524 for (i = 0; i < 2; i++)
691
2/2
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 1014 times.
 1016 if (get_bits1(&s->gb))
692 2 s->s.h.lf_delta.mode[i] = get_sbits_inv(&s->gb, 6);
693 }
694 }
695
696 /* quantization header data */
697 2300 s->s.h.yac_qi = get_bits(&s->gb, 8);
698
2/2
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 2297 times.
 2300 s->s.h.ydc_qdelta = get_bits1(&s->gb) ? get_sbits_inv(&s->gb, 4) : 0;
699
2/2
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 2297 times.
 2300 s->s.h.uvdc_qdelta = get_bits1(&s->gb) ? get_sbits_inv(&s->gb, 4) : 0;
700
2/2
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 2297 times.
 2300 s->s.h.uvac_qdelta = get_bits1(&s->gb) ? get_sbits_inv(&s->gb, 4) : 0;
701
1/2
✓ Branch 0 taken 17 times.
✗ Branch 1 not taken.
 17 s->s.h.lossless = s->s.h.yac_qi == 0 && s->s.h.ydc_qdelta == 0 &&
702
4/6
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 2283 times.
✓ Branch 2 taken 17 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 17 times.
✗ Branch 5 not taken.
 2317 s->s.h.uvdc_qdelta == 0 && s->s.h.uvac_qdelta == 0;
703 #if FF_API_CODEC_PROPS
704 FF_DISABLE_DEPRECATION_WARNINGS
705
2/2
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 2283 times.
 2300 if (s->s.h.lossless)
706 17 avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
707 FF_ENABLE_DEPRECATION_WARNINGS
708 #endif
709
710 /* segmentation header info */
711
2/2
✓ Branch 1 taken 236 times.
✓ Branch 2 taken 2064 times.
 2300 if ((s->s.h.segmentation.enabled = get_bits1(&s->gb))) {
712
2/2
✓ Branch 1 taken 68 times.
✓ Branch 2 taken 168 times.
 236 if ((s->s.h.segmentation.update_map = get_bits1(&s->gb))) {
713
2/2
✓ Branch 0 taken 476 times.
✓ Branch 1 taken 68 times.
 544 for (i = 0; i < 7; i++)
714
2/2
✓ Branch 1 taken 341 times.
✓ Branch 2 taken 135 times.
 817 s->s.h.segmentation.prob[i] = get_bits1(&s->gb) ?
715 341 get_bits(&s->gb, 8) : 255;
716
2/2
✓ Branch 1 taken 60 times.
✓ Branch 2 taken 8 times.
 68 if ((s->s.h.segmentation.temporal = get_bits1(&s->gb)))
717
2/2
✓ Branch 0 taken 180 times.
✓ Branch 1 taken 60 times.
 240 for (i = 0; i < 3; i++)
718
1/2
✓ Branch 1 taken 180 times.
✗ Branch 2 not taken.
 360 s->s.h.segmentation.pred_prob[i] = get_bits1(&s->gb) ?
719 180 get_bits(&s->gb, 8) : 255;
720 }
721
722
2/2
✓ Branch 1 taken 70 times.
✓ Branch 2 taken 166 times.
 236 if (get_bits1(&s->gb)) {
723 70 s->s.h.segmentation.absolute_vals = get_bits1(&s->gb);
724
2/2
✓ Branch 0 taken 560 times.
✓ Branch 1 taken 70 times.
 630 for (i = 0; i < 8; i++) {
725
2/2
✓ Branch 1 taken 249 times.
✓ Branch 2 taken 311 times.
 560 if ((s->s.h.segmentation.feat[i].q_enabled = get_bits1(&s->gb)))
726 249 s->s.h.segmentation.feat[i].q_val = get_sbits_inv(&s->gb, 8);
727
2/2
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 557 times.
 560 if ((s->s.h.segmentation.feat[i].lf_enabled = get_bits1(&s->gb)))
728 3 s->s.h.segmentation.feat[i].lf_val = get_sbits_inv(&s->gb, 6);
729
2/2
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 557 times.
 560 if ((s->s.h.segmentation.feat[i].ref_enabled = get_bits1(&s->gb)))
730 3 s->s.h.segmentation.feat[i].ref_val = get_bits(&s->gb, 2);
731 560 s->s.h.segmentation.feat[i].skip_enabled = get_bits1(&s->gb);
732 }
733 }
734 } else {
735 // Reset fields under segmentation switch if segmentation is disabled.
736 // This is necessary because some hwaccels don't ignore these fields
737 // if segmentation is disabled.
738 2064 s->s.h.segmentation.temporal = 0;
739 2064 s->s.h.segmentation.update_map = 0;
740 }
741
742 // set qmul[] based on Y/UV, AC/DC and segmentation Q idx deltas
743
4/4
✓ Branch 0 taken 2124 times.
✓ Branch 1 taken 4128 times.
✓ Branch 2 taken 3952 times.
✓ Branch 3 taken 2300 times.
 6252 for (i = 0; i < (s->s.h.segmentation.enabled ? 8 : 1); i++) {
744 int qyac, qydc, quvac, quvdc, lflvl, sh;
745
746
4/4
✓ Branch 0 taken 1888 times.
✓ Branch 1 taken 2064 times.
✓ Branch 2 taken 424 times.
✓ Branch 3 taken 1464 times.
 3952 if (s->s.h.segmentation.enabled && s->s.h.segmentation.feat[i].q_enabled) {
747
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 424 times.
 424 if (s->s.h.segmentation.absolute_vals)
748 ✗ qyac = av_clip_uintp2(s->s.h.segmentation.feat[i].q_val, 8);
749 else
750 424 qyac = av_clip_uintp2(s->s.h.yac_qi + s->s.h.segmentation.feat[i].q_val, 8);
751 } else {
752 3528 qyac = s->s.h.yac_qi;
753 }
754 3952 qydc = av_clip_uintp2(qyac + s->s.h.ydc_qdelta, 8);
755 3952 quvdc = av_clip_uintp2(qyac + s->s.h.uvdc_qdelta, 8);
756 3952 quvac = av_clip_uintp2(qyac + s->s.h.uvac_qdelta, 8);
757 3952 qyac = av_clip_uintp2(qyac, 8);
758
759 3952 s->s.h.segmentation.feat[i].qmul[0][0] = ff_vp9_dc_qlookup[s->bpp_index][qydc];
760 3952 s->s.h.segmentation.feat[i].qmul[0][1] = ff_vp9_ac_qlookup[s->bpp_index][qyac];
761 3952 s->s.h.segmentation.feat[i].qmul[1][0] = ff_vp9_dc_qlookup[s->bpp_index][quvdc];
762 3952 s->s.h.segmentation.feat[i].qmul[1][1] = ff_vp9_ac_qlookup[s->bpp_index][quvac];
763
764 3952 sh = s->s.h.filter.level >= 32;
765
4/4
✓ Branch 0 taken 1888 times.
✓ Branch 1 taken 2064 times.
✓ Branch 2 taken 17 times.
✓ Branch 3 taken 1871 times.
 3952 if (s->s.h.segmentation.enabled && s->s.h.segmentation.feat[i].lf_enabled) {
766
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 17 times.
 17 if (s->s.h.segmentation.absolute_vals)
767 ✗ lflvl = av_clip_uintp2(s->s.h.segmentation.feat[i].lf_val, 6);
768 else
769 17 lflvl = av_clip_uintp2(s->s.h.filter.level + s->s.h.segmentation.feat[i].lf_val, 6);
770 } else {
771 3935 lflvl = s->s.h.filter.level;
772 }
773
2/2
✓ Branch 0 taken 3937 times.
✓ Branch 1 taken 15 times.
 3952 if (s->s.h.lf_delta.enabled) {
774 3937 s->s.h.segmentation.feat[i].lflvl[0][0] =
775 3937 s->s.h.segmentation.feat[i].lflvl[0][1] =
776 3937 av_clip_uintp2(lflvl + (s->s.h.lf_delta.ref[0] * (1 << sh)), 6);
777
2/2
✓ Branch 0 taken 11811 times.
✓ Branch 1 taken 3937 times.
 15748 for (j = 1; j < 4; j++) {
778 11811 s->s.h.segmentation.feat[i].lflvl[j][0] =
779 11811 av_clip_uintp2(lflvl + ((s->s.h.lf_delta.ref[j] +
780 11811 s->s.h.lf_delta.mode[0]) * (1 << sh)), 6);
781 11811 s->s.h.segmentation.feat[i].lflvl[j][1] =
782 11811 av_clip_uintp2(lflvl + ((s->s.h.lf_delta.ref[j] +
783 11811 s->s.h.lf_delta.mode[1]) * (1 << sh)), 6);
784 }
785 } else {
786 15 memset(s->s.h.segmentation.feat[i].lflvl, lflvl,
787 sizeof(s->s.h.segmentation.feat[i].lflvl));
788 }
789 }
790
791 /* tiling info */
792
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2300 times.
 2300 if ((ret = update_size(avctx, w, h)) < 0) {
793 ✗ av_log(avctx, AV_LOG_ERROR, "Failed to initialize decoder for %dx%d @ %d\n",
794 ✗ w, h, s->pix_fmt);
795 ✗ return ret;
796 }
797 2300 for (s->s.h.tiling.log2_tile_cols = 0;
798
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2300 times.
 2300 s->sb_cols > (64 << s->s.h.tiling.log2_tile_cols);
799 ✗ s->s.h.tiling.log2_tile_cols++) ;
800
2/2
✓ Branch 0 taken 1647 times.
✓ Branch 1 taken 2300 times.
 3947 for (max = 0; (s->sb_cols >> max) >= 4; max++) ;
801 2300 max = FFMAX(0, max - 1);
802
2/2
✓ Branch 0 taken 219 times.
✓ Branch 1 taken 2115 times.
 2334 while (max > s->s.h.tiling.log2_tile_cols) {
803
2/2
✓ Branch 1 taken 34 times.
✓ Branch 2 taken 185 times.
 219 if (get_bits1(&s->gb))
804 34 s->s.h.tiling.log2_tile_cols++;
805 else
806 185 break;
807 }
808 2300 s->s.h.tiling.log2_tile_rows = decode012(&s->gb);
809 2300 s->s.h.tiling.tile_rows = 1 << s->s.h.tiling.log2_tile_rows;
810
2/2
✓ Branch 0 taken 479 times.
✓ Branch 1 taken 1821 times.
 2300 if (s->s.h.tiling.tile_cols != (1 << s->s.h.tiling.log2_tile_cols)) {
811 int n_range_coders;
812 VPXRangeCoder *rc;
813
814
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 479 times.
 479 if (s->td) {
815 ✗ for (i = 0; i < s->active_tile_cols; i++)
816 ✗ vp9_tile_data_free(&s->td[i]);
817 ✗ av_freep(&s->td);
818 }
819
820 479 s->s.h.tiling.tile_cols = 1 << s->s.h.tiling.log2_tile_cols;
821 958 s->active_tile_cols = avctx->active_thread_type == FF_THREAD_SLICE ?
822
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 479 times.
 479 s->s.h.tiling.tile_cols : 1;
823 479 vp9_alloc_entries(avctx, s->sb_rows);
824
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 479 times.
 479 if (avctx->active_thread_type == FF_THREAD_SLICE) {
825 ✗ n_range_coders = 4; // max_tile_rows
826 } else {
827 479 n_range_coders = s->s.h.tiling.tile_cols;
828 }
829 479 s->td = av_calloc(s->active_tile_cols, sizeof(VP9TileData) +
830 n_range_coders * sizeof(VPXRangeCoder));
831
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 479 times.
 479 if (!s->td)
832 ✗ return AVERROR(ENOMEM);
833 479 rc = (VPXRangeCoder *) &s->td[s->active_tile_cols];
834
2/2
✓ Branch 0 taken 479 times.
✓ Branch 1 taken 479 times.
 958 for (i = 0; i < s->active_tile_cols; i++) {
835 479 s->td[i].s = s;
836 479 s->td[i].c_b = rc;
837 479 rc += n_range_coders;
838 }
839 }
840
841 /* check reference frames */
842
4/4
✓ Branch 0 taken 1821 times.
✓ Branch 1 taken 479 times.
✓ Branch 2 taken 1815 times.
✓ Branch 3 taken 6 times.
 2300 if (!s->s.h.keyframe && !s->s.h.intraonly) {
843 1815 int valid_ref_frame = 0;
844
2/2
✓ Branch 0 taken 5445 times.
✓ Branch 1 taken 1815 times.
 7260 for (i = 0; i < 3; i++) {
845 5445 AVFrame *ref = s->s.refs[s->s.h.refidx[i]].f;
846 5445 int refw = ref->width, refh = ref->height;
847
848
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5445 times.
 5445 if (ref->format != avctx->pix_fmt) {
849 ✗ av_log(avctx, AV_LOG_ERROR,
850 "Ref pixfmt (%s) did not match current frame (%s)",
851 ✗ av_get_pix_fmt_name(ref->format),
852 av_get_pix_fmt_name(avctx->pix_fmt));
853 ✗ return AVERROR_INVALIDDATA;
854
3/4
✓ Branch 0 taken 5437 times.
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 5437 times.
✗ Branch 3 not taken.
 5445 } else if (refw == w && refh == h) {
855 5437 s->mvscale[i][0] = s->mvscale[i][1] = 0;
856 } else {
857 /* Check to make sure at least one of frames that */
858 /* this frame references has valid dimensions */
859
4/8
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 8 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 8 times.
 8 if (w * 2 < refw || h * 2 < refh || w > 16 * refw || h > 16 * refh) {
860 ✗ av_log(avctx, AV_LOG_WARNING,
861 "Invalid ref frame dimensions %dx%d for frame size %dx%d\n",
862 refw, refh, w, h);
863 ✗ s->mvscale[i][0] = s->mvscale[i][1] = REF_INVALID_SCALE;
864 ✗ continue;
865 }
866 8 s->mvscale[i][0] = (refw << 14) / w;
867 8 s->mvscale[i][1] = (refh << 14) / h;
868 8 s->mvstep[i][0] = 16 * s->mvscale[i][0] >> 14;
869 8 s->mvstep[i][1] = 16 * s->mvscale[i][1] >> 14;
870 }
871 5445 valid_ref_frame++;
872 }
873
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1815 times.
 1815 if (!valid_ref_frame) {
874 ✗ av_log(avctx, AV_LOG_ERROR, "No valid reference frame is found, bitstream not supported\n");
875 ✗ return AVERROR_INVALIDDATA;
876 }
877 }
878
879
7/8
✓ Branch 0 taken 1821 times.
✓ Branch 1 taken 479 times.
✓ Branch 2 taken 1812 times.
✓ Branch 3 taken 9 times.
✓ Branch 4 taken 6 times.
✓ Branch 5 taken 1806 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 6 times.
 2300 if (s->s.h.keyframe || s->s.h.errorres || (s->s.h.intraonly && s->s.h.resetctx == 3)) {
880 488 s->prob_ctx[0].p = s->prob_ctx[1].p = s->prob_ctx[2].p =
881 488 s->prob_ctx[3].p = ff_vp9_default_probs;
882 488 memcpy(s->prob_ctx[0].coef, ff_vp9_default_coef_probs,
883 sizeof(ff_vp9_default_coef_probs));
884 488 memcpy(s->prob_ctx[1].coef, ff_vp9_default_coef_probs,
885 sizeof(ff_vp9_default_coef_probs));
886 488 memcpy(s->prob_ctx[2].coef, ff_vp9_default_coef_probs,
887 sizeof(ff_vp9_default_coef_probs));
888 488 memcpy(s->prob_ctx[3].coef, ff_vp9_default_coef_probs,
889 sizeof(ff_vp9_default_coef_probs));
890
3/4
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 1806 times.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
 1812 } else if (s->s.h.intraonly && s->s.h.resetctx == 2) {
891 6 s->prob_ctx[c].p = ff_vp9_default_probs;
892 6 memcpy(s->prob_ctx[c].coef, ff_vp9_default_coef_probs,
893 sizeof(ff_vp9_default_coef_probs));
894 }
895
896 // next 16 bits is size of the rest of the header (arith-coded)
897 2300 s->s.h.compressed_header_size = size2 = get_bits(&s->gb, 16);
898 2300 s->s.h.uncompressed_header_size = (get_bits_count(&s->gb) + 7) / 8;
899
900 2300 data2 = align_get_bits(&s->gb);
901
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2300 times.
 2300 if (size2 > size - (data2 - data)) {
902 ✗ av_log(avctx, AV_LOG_ERROR, "Invalid compressed header size\n");
903 ✗ return AVERROR_INVALIDDATA;
904 }
905 2300 ret = ff_vpx_init_range_decoder(&s->c, data2, size2);
906
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2300 times.
 2300 if (ret < 0)
907 ✗ return ret;
908
909
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2300 times.
 2300 if (vpx_rac_get_prob_branchy(&s->c, 128)) { // marker bit
910 ✗ av_log(avctx, AV_LOG_ERROR, "Marker bit was set\n");
911 ✗ return AVERROR_INVALIDDATA;
912 }
913
914
2/2
✓ Branch 0 taken 2300 times.
✓ Branch 1 taken 2300 times.
 4600 for (i = 0; i < s->active_tile_cols; i++) {
915
4/4
✓ Branch 0 taken 1821 times.
✓ Branch 1 taken 479 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 1815 times.
 2300 if (s->s.h.keyframe || s->s.h.intraonly) {
916 485 memset(s->td[i].counts.coef, 0, sizeof(s->td[0].counts.coef));
917 485 memset(s->td[i].counts.eob, 0, sizeof(s->td[0].counts.eob));
918 } else {
919 1815 memset(&s->td[i].counts, 0, sizeof(s->td[0].counts));
920 }
921 2300 s->td[i].nb_block_structure = 0;
922 }
923
924 /* FIXME is it faster to not copy here, but do it down in the fw updates
925 * as explicit copies if the fw update is missing (and skip the copy upon
926 * fw update)? */
927 2300 s->prob.p = s->prob_ctx[c].p;
928
929 // txfm updates
930
2/2
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 2283 times.
 2300 if (s->s.h.lossless) {
931 17 s->s.h.txfmmode = TX_4X4;
932 } else {
933 2283 s->s.h.txfmmode = vp89_rac_get_uint(&s->c, 2);
934
2/2
✓ Branch 0 taken 1929 times.
✓ Branch 1 taken 354 times.
 2283 if (s->s.h.txfmmode == 3)
935 1929 s->s.h.txfmmode += vp89_rac_get(&s->c);
936
937
2/2
✓ Branch 0 taken 1726 times.
✓ Branch 1 taken 557 times.
 2283 if (s->s.h.txfmmode == TX_SWITCHABLE) {
938
2/2
✓ Branch 0 taken 3452 times.
✓ Branch 1 taken 1726 times.
 5178 for (i = 0; i < 2; i++)
939
2/2
✓ Branch 1 taken 229 times.
✓ Branch 2 taken 3223 times.
 3452 if (vpx_rac_get_prob_branchy(&s->c, 252))
940 229 s->prob.p.tx8p[i] = update_prob(&s->c, s->prob.p.tx8p[i]);
941
2/2
✓ Branch 0 taken 3452 times.
✓ Branch 1 taken 1726 times.
 5178 for (i = 0; i < 2; i++)
942
2/2
✓ Branch 0 taken 6904 times.
✓ Branch 1 taken 3452 times.
 10356 for (j = 0; j < 2; j++)
943
2/2
✓ Branch 1 taken 187 times.
✓ Branch 2 taken 6717 times.
 6904 if (vpx_rac_get_prob_branchy(&s->c, 252))
944 187 s->prob.p.tx16p[i][j] =
945 187 update_prob(&s->c, s->prob.p.tx16p[i][j]);
946
2/2
✓ Branch 0 taken 3452 times.
✓ Branch 1 taken 1726 times.
 5178 for (i = 0; i < 2; i++)
947
2/2
✓ Branch 0 taken 10356 times.
✓ Branch 1 taken 3452 times.
 13808 for (j = 0; j < 3; j++)
948
2/2
✓ Branch 1 taken 53 times.
✓ Branch 2 taken 10303 times.
 10356 if (vpx_rac_get_prob_branchy(&s->c, 252))
949 53 s->prob.p.tx32p[i][j] =
950 53 update_prob(&s->c, s->prob.p.tx32p[i][j]);
951 }
952 }
953
954 // coef updates
955
2/2
✓ Branch 0 taken 8324 times.
✓ Branch 1 taken 1726 times.
 10050 for (i = 0; i < 4; i++) {
956 8324 uint8_t (*ref)[2][6][6][3] = s->prob_ctx[c].coef[i];
957
2/2
✓ Branch 1 taken 1641 times.
✓ Branch 2 taken 6683 times.
 8324 if (vp89_rac_get(&s->c)) {
958
2/2
✓ Branch 0 taken 3282 times.
✓ Branch 1 taken 1641 times.
 4923 for (j = 0; j < 2; j++)
959
2/2
✓ Branch 0 taken 6564 times.
✓ Branch 1 taken 3282 times.
 9846 for (k = 0; k < 2; k++)
960
2/2
✓ Branch 0 taken 39384 times.
✓ Branch 1 taken 6564 times.
 45948 for (l = 0; l < 6; l++)
961
2/2
✓ Branch 0 taken 223176 times.
✓ Branch 1 taken 32820 times.
 255996 for (m = 0; m < 6; m++) {
962 223176 uint8_t *p = s->prob.coef[i][j][k][l][m];
963 223176 uint8_t *r = ref[j][k][l][m];
964
4/4
✓ Branch 0 taken 105024 times.
✓ Branch 1 taken 118152 times.
✓ Branch 2 taken 6564 times.
✓ Branch 3 taken 98460 times.
 223176 if (m >= 3 && l == 0) // dc only has 3 pt
965 6564 break;
966
2/2
✓ Branch 0 taken 649836 times.
✓ Branch 1 taken 216612 times.
 866448 for (n = 0; n < 3; n++) {
967
2/2
✓ Branch 1 taken 23624 times.
✓ Branch 2 taken 626212 times.
 649836 if (vpx_rac_get_prob_branchy(&s->c, 252))
968 23624 p[n] = update_prob(&s->c, r[n]);
969 else
970 626212 p[n] = r[n];
971 }
972 216612 memcpy(&p[3], ff_vp9_model_pareto8[p[2]], 8);
973 }
974 } else {
975
2/2
✓ Branch 0 taken 13366 times.
✓ Branch 1 taken 6683 times.
 20049 for (j = 0; j < 2; j++)
976
2/2
✓ Branch 0 taken 26732 times.
✓ Branch 1 taken 13366 times.
 40098 for (k = 0; k < 2; k++)
977
2/2
✓ Branch 0 taken 160392 times.
✓ Branch 1 taken 26732 times.
 187124 for (l = 0; l < 6; l++)
978
2/2
✓ Branch 0 taken 935620 times.
✓ Branch 1 taken 133660 times.
 1069280 for (m = 0; m < 6; m++) {
979 935620 uint8_t *p = s->prob.coef[i][j][k][l][m];
980 935620 uint8_t *r = ref[j][k][l][m];
981
4/4
✓ Branch 0 taken 294052 times.
✓ Branch 1 taken 641568 times.
✓ Branch 2 taken 26732 times.
✓ Branch 3 taken 267320 times.
 935620 if (m > 3 && l == 0) // dc only has 3 pt
982 26732 break;
983 908888 memcpy(p, r, 3);
984 908888 memcpy(&p[3], ff_vp9_model_pareto8[p[2]], 8);
985 }
986 }
987
2/2
✓ Branch 0 taken 574 times.
✓ Branch 1 taken 7750 times.
 8324 if (s->s.h.txfmmode == i)
988 574 break;
989 }
990
991 // mode updates
992
2/2
✓ Branch 0 taken 6900 times.
✓ Branch 1 taken 2300 times.
 9200 for (i = 0; i < 3; i++)
993
2/2
✓ Branch 1 taken 743 times.
✓ Branch 2 taken 6157 times.
 6900 if (vpx_rac_get_prob_branchy(&s->c, 252))
994 743 s->prob.p.skip[i] = update_prob(&s->c, s->prob.p.skip[i]);
995
4/4
✓ Branch 0 taken 1821 times.
✓ Branch 1 taken 479 times.
✓ Branch 2 taken 1815 times.
✓ Branch 3 taken 6 times.
 2300 if (!s->s.h.keyframe && !s->s.h.intraonly) {
996
2/2
✓ Branch 0 taken 12705 times.
✓ Branch 1 taken 1815 times.
 14520 for (i = 0; i < 7; i++)
997
2/2
✓ Branch 0 taken 38115 times.
✓ Branch 1 taken 12705 times.
 50820 for (j = 0; j < 3; j++)
998
2/2
✓ Branch 1 taken 313 times.
✓ Branch 2 taken 37802 times.
 38115 if (vpx_rac_get_prob_branchy(&s->c, 252))
999 313 s->prob.p.mv_mode[i][j] =
1000 313 update_prob(&s->c, s->prob.p.mv_mode[i][j]);
1001
1002
2/2
✓ Branch 0 taken 1321 times.
✓ Branch 1 taken 494 times.
 1815 if (s->s.h.filtermode == FILTER_SWITCHABLE)
1003
2/2
✓ Branch 0 taken 5284 times.
✓ Branch 1 taken 1321 times.
 6605 for (i = 0; i < 4; i++)
1004
2/2
✓ Branch 0 taken 10568 times.
✓ Branch 1 taken 5284 times.
 15852 for (j = 0; j < 2; j++)
1005
2/2
✓ Branch 1 taken 184 times.
✓ Branch 2 taken 10384 times.
 10568 if (vpx_rac_get_prob_branchy(&s->c, 252))
1006 184 s->prob.p.filter[i][j] =
1007 184 update_prob(&s->c, s->prob.p.filter[i][j]);
1008
1009
2/2
✓ Branch 0 taken 7260 times.
✓ Branch 1 taken 1815 times.
 9075 for (i = 0; i < 4; i++)
1010
2/2
✓ Branch 1 taken 100 times.
✓ Branch 2 taken 7160 times.
 7260 if (vpx_rac_get_prob_branchy(&s->c, 252))
1011 100 s->prob.p.intra[i] = update_prob(&s->c, s->prob.p.intra[i]);
1012
1013
2/2
✓ Branch 0 taken 459 times.
✓ Branch 1 taken 1356 times.
 1815 if (s->s.h.allowcompinter) {
1014 459 s->s.h.comppredmode = vp89_rac_get(&s->c);
1015
2/2
✓ Branch 0 taken 313 times.
✓ Branch 1 taken 146 times.
 459 if (s->s.h.comppredmode)
1016 313 s->s.h.comppredmode += vp89_rac_get(&s->c);
1017
2/2
✓ Branch 0 taken 311 times.
✓ Branch 1 taken 148 times.
 459 if (s->s.h.comppredmode == PRED_SWITCHABLE)
1018
2/2
✓ Branch 0 taken 1555 times.
✓ Branch 1 taken 311 times.
 1866 for (i = 0; i < 5; i++)
1019
2/2
✓ Branch 1 taken 43 times.
✓ Branch 2 taken 1512 times.
 1555 if (vpx_rac_get_prob_branchy(&s->c, 252))
1020 43 s->prob.p.comp[i] =
1021 43 update_prob(&s->c, s->prob.p.comp[i]);
1022 } else {
1023 1356 s->s.h.comppredmode = PRED_SINGLEREF;
1024 }
1025
1026
2/2
✓ Branch 0 taken 1813 times.
✓ Branch 1 taken 2 times.
 1815 if (s->s.h.comppredmode != PRED_COMPREF) {
1027
2/2
✓ Branch 0 taken 9065 times.
✓ Branch 1 taken 1813 times.
 10878 for (i = 0; i < 5; i++) {
1028
2/2
✓ Branch 1 taken 319 times.
✓ Branch 2 taken 8746 times.
 9065 if (vpx_rac_get_prob_branchy(&s->c, 252))
1029 319 s->prob.p.single_ref[i][0] =
1030 319 update_prob(&s->c, s->prob.p.single_ref[i][0]);
1031
2/2
✓ Branch 1 taken 53 times.
✓ Branch 2 taken 9012 times.
 9065 if (vpx_rac_get_prob_branchy(&s->c, 252))
1032 53 s->prob.p.single_ref[i][1] =
1033 53 update_prob(&s->c, s->prob.p.single_ref[i][1]);
1034 }
1035 }
1036
1037
2/2
✓ Branch 0 taken 313 times.
✓ Branch 1 taken 1502 times.
 1815 if (s->s.h.comppredmode != PRED_SINGLEREF) {
1038
2/2
✓ Branch 0 taken 1565 times.
✓ Branch 1 taken 313 times.
 1878 for (i = 0; i < 5; i++)
1039
2/2
✓ Branch 1 taken 10 times.
✓ Branch 2 taken 1555 times.
 1565 if (vpx_rac_get_prob_branchy(&s->c, 252))
1040 10 s->prob.p.comp_ref[i] =
1041 10 update_prob(&s->c, s->prob.p.comp_ref[i]);
1042 }
1043
1044
2/2
✓ Branch 0 taken 7260 times.
✓ Branch 1 taken 1815 times.
 9075 for (i = 0; i < 4; i++)
1045
2/2
✓ Branch 0 taken 65340 times.
✓ Branch 1 taken 7260 times.
 72600 for (j = 0; j < 9; j++)
1046
2/2
✓ Branch 1 taken 127 times.
✓ Branch 2 taken 65213 times.
 65340 if (vpx_rac_get_prob_branchy(&s->c, 252))
1047 127 s->prob.p.y_mode[i][j] =
1048 127 update_prob(&s->c, s->prob.p.y_mode[i][j]);
1049
1050
2/2
✓ Branch 0 taken 7260 times.
✓ Branch 1 taken 1815 times.
 9075 for (i = 0; i < 4; i++)
1051
2/2
✓ Branch 0 taken 29040 times.
✓ Branch 1 taken 7260 times.
 36300 for (j = 0; j < 4; j++)
1052
2/2
✓ Branch 0 taken 87120 times.
✓ Branch 1 taken 29040 times.
 116160 for (k = 0; k < 3; k++)
1053
2/2
✓ Branch 1 taken 257 times.
✓ Branch 2 taken 86863 times.
 87120 if (vpx_rac_get_prob_branchy(&s->c, 252))
1054 257 s->prob.p.partition[3 - i][j][k] =
1055 257 update_prob(&s->c,
1056 257 s->prob.p.partition[3 - i][j][k]);
1057
1058 // mv fields don't use the update_prob subexp model for some reason
1059
2/2
✓ Branch 0 taken 5445 times.
✓ Branch 1 taken 1815 times.
 7260 for (i = 0; i < 3; i++)
1060
2/2
✓ Branch 1 taken 259 times.
✓ Branch 2 taken 5186 times.
 5445 if (vpx_rac_get_prob_branchy(&s->c, 252))
1061 259 s->prob.p.mv_joint[i] = (vp89_rac_get_uint(&s->c, 7) << 1) | 1;
1062
1063
2/2
✓ Branch 0 taken 3630 times.
✓ Branch 1 taken 1815 times.
 5445 for (i = 0; i < 2; i++) {
1064
2/2
✓ Branch 1 taken 153 times.
✓ Branch 2 taken 3477 times.
 3630 if (vpx_rac_get_prob_branchy(&s->c, 252))
1065 153 s->prob.p.mv_comp[i].sign =
1066 153 (vp89_rac_get_uint(&s->c, 7) << 1) | 1;
1067
1068
2/2
✓ Branch 0 taken 36300 times.
✓ Branch 1 taken 3630 times.
 39930 for (j = 0; j < 10; j++)
1069
2/2
✓ Branch 1 taken 86 times.
✓ Branch 2 taken 36214 times.
 36300 if (vpx_rac_get_prob_branchy(&s->c, 252))
1070 86 s->prob.p.mv_comp[i].classes[j] =
1071 86 (vp89_rac_get_uint(&s->c, 7) << 1) | 1;
1072
1073
2/2
✓ Branch 1 taken 86 times.
✓ Branch 2 taken 3544 times.
 3630 if (vpx_rac_get_prob_branchy(&s->c, 252))
1074 86 s->prob.p.mv_comp[i].class0 =
1075 86 (vp89_rac_get_uint(&s->c, 7) << 1) | 1;
1076
1077
2/2
✓ Branch 0 taken 36300 times.
✓ Branch 1 taken 3630 times.
 39930 for (j = 0; j < 10; j++)
1078
2/2
✓ Branch 1 taken 15 times.
✓ Branch 2 taken 36285 times.
 36300 if (vpx_rac_get_prob_branchy(&s->c, 252))
1079 15 s->prob.p.mv_comp[i].bits[j] =
1080 15 (vp89_rac_get_uint(&s->c, 7) << 1) | 1;
1081 }
1082
1083
2/2
✓ Branch 0 taken 3630 times.
✓ Branch 1 taken 1815 times.
 5445 for (i = 0; i < 2; i++) {
1084
2/2
✓ Branch 0 taken 7260 times.
✓ Branch 1 taken 3630 times.
 10890 for (j = 0; j < 2; j++)
1085
2/2
✓ Branch 0 taken 21780 times.
✓ Branch 1 taken 7260 times.
 29040 for (k = 0; k < 3; k++)
1086
2/2
✓ Branch 1 taken 209 times.
✓ Branch 2 taken 21571 times.
 21780 if (vpx_rac_get_prob_branchy(&s->c, 252))
1087 209 s->prob.p.mv_comp[i].class0_fp[j][k] =
1088 209 (vp89_rac_get_uint(&s->c, 7) << 1) | 1;
1089
1090
2/2
✓ Branch 0 taken 10890 times.
✓ Branch 1 taken 3630 times.
 14520 for (j = 0; j < 3; j++)
1091
2/2
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 10886 times.
 10890 if (vpx_rac_get_prob_branchy(&s->c, 252))
1092 4 s->prob.p.mv_comp[i].fp[j] =
1093 4 (vp89_rac_get_uint(&s->c, 7) << 1) | 1;
1094 }
1095
1096
2/2
✓ Branch 0 taken 1417 times.
✓ Branch 1 taken 398 times.
 1815 if (s->s.h.highprecisionmvs) {
1097
2/2
✓ Branch 0 taken 2834 times.
✓ Branch 1 taken 1417 times.
 4251 for (i = 0; i < 2; i++) {
1098
2/2
✓ Branch 1 taken 86 times.
✓ Branch 2 taken 2748 times.
 2834 if (vpx_rac_get_prob_branchy(&s->c, 252))
1099 86 s->prob.p.mv_comp[i].class0_hp =
1100 86 (vp89_rac_get_uint(&s->c, 7) << 1) | 1;
1101
1102
2/2
✓ Branch 1 taken 30 times.
✓ Branch 2 taken 2804 times.
 2834 if (vpx_rac_get_prob_branchy(&s->c, 252))
1103 30 s->prob.p.mv_comp[i].hp =
1104 30 (vp89_rac_get_uint(&s->c, 7) << 1) | 1;
1105 }
1106 }
1107 }
1108
1109 2300 return (data2 - data) + size2;
1110 }
1111
1112 1020721 static void decode_sb(VP9TileData *td, int row, int col, VP9Filter *lflvl,
1113 ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
1114 {
1115 1020721 const VP9Context *s = td->s;
1116 1020721 int c = ((s->above_partition_ctx[col] >> (3 - bl)) & 1) |
1117 1020721 (((td->left_partition_ctx[row & 0x7] >> (3 - bl)) & 1) << 1);
1118
4/4
✓ Branch 0 taken 708188 times.
✓ Branch 1 taken 312533 times.
✓ Branch 2 taken 3150 times.
✓ Branch 3 taken 705038 times.
 1020721 const uint8_t *p = s->s.h.keyframe || s->s.h.intraonly ? ff_vp9_default_kf_partition_probs[bl][c] :
1119 s->prob.p.partition[bl][c];
1120 enum BlockPartition bp;
1121 1020721 ptrdiff_t hbs = 4 >> bl;
1122 1020721 AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
1123 1020721 ptrdiff_t y_stride = f->linesize[0], uv_stride = f->linesize[1];
1124 1020721 int bytesperpixel = s->bytesperpixel;
1125
1126
2/2
✓ Branch 0 taken 503538 times.
✓ Branch 1 taken 517183 times.
 1020721 if (bl == BL_8X8) {
1127 503538 bp = vp89_rac_get_tree(td->c, ff_vp9_partition_tree, p);
1128 503538 ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
1129
2/2
✓ Branch 0 taken 494897 times.
✓ Branch 1 taken 22286 times.
 517183 } else if (col + hbs < s->cols) { // FIXME why not <=?
1130
2/2
✓ Branch 0 taken 480754 times.
✓ Branch 1 taken 14143 times.
 494897 if (row + hbs < s->rows) { // FIXME why not <=?
1131 480754 bp = vp89_rac_get_tree(td->c, ff_vp9_partition_tree, p);
1132
4/5
✓ Branch 0 taken 200252 times.
✓ Branch 1 taken 30126 times.
✓ Branch 2 taken 22824 times.
✓ Branch 3 taken 227552 times.
✗ Branch 4 not taken.
 480754 switch (bp) {
1133 200252 case PARTITION_NONE:
1134 200252 ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
1135 200252 break;
1136 30126 case PARTITION_H:
1137 30126 ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
1138 30126 yoff += hbs * 8 * y_stride;
1139 30126 uvoff += hbs * 8 * uv_stride >> s->ss_v;
1140 30126 ff_vp9_decode_block(td, row + hbs, col, lflvl, yoff, uvoff, bl, bp);
1141 30126 break;
1142 22824 case PARTITION_V:
1143 22824 ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
1144 22824 yoff += hbs * 8 * bytesperpixel;
1145 22824 uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
1146 22824 ff_vp9_decode_block(td, row, col + hbs, lflvl, yoff, uvoff, bl, bp);
1147 22824 break;
1148 227552 case PARTITION_SPLIT:
1149 227552 decode_sb(td, row, col, lflvl, yoff, uvoff, bl + 1);
1150 227552 decode_sb(td, row, col + hbs, lflvl,
1151 227552 yoff + 8 * hbs * bytesperpixel,
1152 227552 uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
1153 227552 yoff += hbs * 8 * y_stride;
1154 227552 uvoff += hbs * 8 * uv_stride >> s->ss_v;
1155 227552 decode_sb(td, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
1156 227552 decode_sb(td, row + hbs, col + hbs, lflvl,
1157 227552 yoff + 8 * hbs * bytesperpixel,
1158 227552 uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
1159 227552 break;
1160 ✗ default:
1161 ✗ av_unreachable("ff_vp9_partition_tree only has "
1162 "the four PARTITION_* terminal codes");
1163 }
1164
2/2
✓ Branch 1 taken 10204 times.
✓ Branch 2 taken 3939 times.
 14143 } else if (vpx_rac_get_prob_branchy(td->c, p[1])) {
1165 10204 bp = PARTITION_SPLIT;
1166 10204 decode_sb(td, row, col, lflvl, yoff, uvoff, bl + 1);
1167 10204 decode_sb(td, row, col + hbs, lflvl,
1168 10204 yoff + 8 * hbs * bytesperpixel,
1169 10204 uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
1170 } else {
1171 3939 bp = PARTITION_H;
1172 3939 ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
1173 }
1174
2/2
✓ Branch 0 taken 19419 times.
✓ Branch 1 taken 2867 times.
 22286 } else if (row + hbs < s->rows) { // FIXME why not <=?
1175
2/2
✓ Branch 1 taken 16251 times.
✓ Branch 2 taken 3168 times.
 19419 if (vpx_rac_get_prob_branchy(td->c, p[2])) {
1176 16251 bp = PARTITION_SPLIT;
1177 16251 decode_sb(td, row, col, lflvl, yoff, uvoff, bl + 1);
1178 16251 yoff += hbs * 8 * y_stride;
1179 16251 uvoff += hbs * 8 * uv_stride >> s->ss_v;
1180 16251 decode_sb(td, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
1181 } else {
1182 3168 bp = PARTITION_V;
1183 3168 ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
1184 }
1185 } else {
1186 2867 bp = PARTITION_SPLIT;
1187 2867 decode_sb(td, row, col, lflvl, yoff, uvoff, bl + 1);
1188 }
1189 1020721 td->counts.partition[bl][c][bp]++;
1190 1020721 }
1191
1192 ✗ static void decode_sb_mem(VP9TileData *td, int row, int col, VP9Filter *lflvl,
1193 ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
1194 {
1195 ✗ const VP9Context *s = td->s;
1196 ✗ VP9Block *b = td->b;
1197 ✗ ptrdiff_t hbs = 4 >> bl;
1198 ✗ AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
1199 ✗ ptrdiff_t y_stride = f->linesize[0], uv_stride = f->linesize[1];
1200 ✗ int bytesperpixel = s->bytesperpixel;
1201
1202 ✗ if (bl == BL_8X8) {
1203 av_assert2(b->bl == BL_8X8);
1204 ✗ ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, b->bl, b->bp);
1205 ✗ } else if (td->b->bl == bl) {
1206 ✗ ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, b->bl, b->bp);
1207 ✗ if (b->bp == PARTITION_H && row + hbs < s->rows) {
1208 ✗ yoff += hbs * 8 * y_stride;
1209 ✗ uvoff += hbs * 8 * uv_stride >> s->ss_v;
1210 ✗ ff_vp9_decode_block(td, row + hbs, col, lflvl, yoff, uvoff, b->bl, b->bp);
1211 ✗ } else if (b->bp == PARTITION_V && col + hbs < s->cols) {
1212 ✗ yoff += hbs * 8 * bytesperpixel;
1213 ✗ uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
1214 ✗ ff_vp9_decode_block(td, row, col + hbs, lflvl, yoff, uvoff, b->bl, b->bp);
1215 }
1216 } else {
1217 ✗ decode_sb_mem(td, row, col, lflvl, yoff, uvoff, bl + 1);
1218 ✗ if (col + hbs < s->cols) { // FIXME why not <=?
1219 ✗ if (row + hbs < s->rows) {
1220 ✗ decode_sb_mem(td, row, col + hbs, lflvl, yoff + 8 * hbs * bytesperpixel,
1221 ✗ uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
1222 ✗ yoff += hbs * 8 * y_stride;
1223 ✗ uvoff += hbs * 8 * uv_stride >> s->ss_v;
1224 ✗ decode_sb_mem(td, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
1225 ✗ decode_sb_mem(td, row + hbs, col + hbs, lflvl,
1226 ✗ yoff + 8 * hbs * bytesperpixel,
1227 ✗ uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
1228 } else {
1229 ✗ yoff += hbs * 8 * bytesperpixel;
1230 ✗ uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
1231 ✗ decode_sb_mem(td, row, col + hbs, lflvl, yoff, uvoff, bl + 1);
1232 }
1233 ✗ } else if (row + hbs < s->rows) {
1234 ✗ yoff += hbs * 8 * y_stride;
1235 ✗ uvoff += hbs * 8 * uv_stride >> s->ss_v;
1236 ✗ decode_sb_mem(td, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
1237 }
1238 }
1239 ✗ }
1240
1241 11161 static void set_tile_offset(int *start, int *end, int idx, int log2_n, int n)
1242 {
1243 11161 int sb_start = ( idx * n) >> log2_n;
1244 11161 int sb_end = ((idx + 1) * n) >> log2_n;
1245 11161 *start = FFMIN(sb_start, n) << 3;
1246 11161 *end = FFMIN(sb_end, n) << 3;
1247 11161 }
1248
1249 484 static void free_buffers(VP9Context *s)
1250 {
1251 int i;
1252
1253 484 av_freep(&s->intra_pred_data[0]);
1254
2/2
✓ Branch 0 taken 479 times.
✓ Branch 1 taken 484 times.
 963 for (i = 0; i < s->active_tile_cols; i++)
1255 479 vp9_tile_data_free(&s->td[i]);
1256 484 }
1257
1258 484 static av_cold int vp9_decode_free(AVCodecContext *avctx)
1259 {
1260 484 VP9Context *s = avctx->priv_data;
1261 int i;
1262
1263
2/2
✓ Branch 0 taken 1452 times.
✓ Branch 1 taken 484 times.
 1936 for (int i = 0; i < 3; i++)
1264 1452 vp9_frame_unref(&s->s.frames[i]);
1265 484 av_refstruct_pool_uninit(&s->frame_extradata_pool);
1266
2/2
✓ Branch 0 taken 3872 times.
✓ Branch 1 taken 484 times.
 4356 for (i = 0; i < 8; i++) {
1267 3872 ff_progress_frame_unref(&s->s.refs[i]);
1268 3872 ff_progress_frame_unref(&s->next_refs[i]);
1269 3872 vp9_frame_unref(&s->s.ref_frames[i]);
1270 }
1271
1272 484 free_buffers(s);
1273 #if HAVE_THREADS
1274 484 av_freep(&s->entries);
1275 484 ff_pthread_free(s, vp9_context_offsets);
1276 #endif
1277
1278 484 av_refstruct_unref(&s->header_ref);
1279 484 ff_cbs_fragment_free(&s->current_frag);
1280 484 ff_cbs_close(&s->cbc);
1281
1282 484 av_freep(&s->td);
1283 484 return 0;
1284 }
1285
1286 2300 static int decode_tiles(AVCodecContext *avctx,
1287 const uint8_t *data, int size)
1288 {
1289 2300 VP9Context *s = avctx->priv_data;
1290 2300 VP9TileData *td = &s->td[0];
1291 int row, col, tile_row, tile_col, ret;
1292 int bytesperpixel;
1293 int tile_row_start, tile_row_end, tile_col_start, tile_col_end;
1294 AVFrame *f;
1295 ptrdiff_t yoff, uvoff, ls_y, ls_uv;
1296
1297 2300 f = s->s.frames[CUR_FRAME].tf.f;
1298 2300 ls_y = f->linesize[0];
1299 2300 ls_uv =f->linesize[1];
1300 2300 bytesperpixel = s->bytesperpixel;
1301
1302 2300 yoff = uvoff = 0;
1303
2/2
✓ Branch 0 taken 2304 times.
✓ Branch 1 taken 2300 times.
 4604 for (tile_row = 0; tile_row < s->s.h.tiling.tile_rows; tile_row++) {
1304 2304 set_tile_offset(&tile_row_start, &tile_row_end,
1305 2304 tile_row, s->s.h.tiling.log2_tile_rows, s->sb_rows);
1306
1307
2/2
✓ Branch 0 taken 2357 times.
✓ Branch 1 taken 2304 times.
 4661 for (tile_col = 0; tile_col < s->s.h.tiling.tile_cols; tile_col++) {
1308 int64_t tile_size;
1309
1310
2/2
✓ Branch 0 taken 2304 times.
✓ Branch 1 taken 53 times.
 2357 if (tile_col == s->s.h.tiling.tile_cols - 1 &&
1311
2/2
✓ Branch 0 taken 2300 times.
✓ Branch 1 taken 4 times.
 2304 tile_row == s->s.h.tiling.tile_rows - 1) {
1312 2300 tile_size = size;
1313 } else {
1314 57 tile_size = AV_RB32(data);
1315 57 data += 4;
1316 57 size -= 4;
1317 }
1318
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2357 times.
 2357 if (tile_size > size)
1319 ✗ return AVERROR_INVALIDDATA;
1320 2357 ret = ff_vpx_init_range_decoder(&td->c_b[tile_col], data, tile_size);
1321
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2357 times.
 2357 if (ret < 0)
1322 ✗ return ret;
1323
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2357 times.
 2357 if (vpx_rac_get_prob_branchy(&td->c_b[tile_col], 128)) // marker bit
1324 ✗ return AVERROR_INVALIDDATA;
1325 2357 data += tile_size;
1326 2357 size -= tile_size;
1327 }
1328
1329
2/2
✓ Branch 0 taken 8204 times.
✓ Branch 1 taken 2304 times.
 10508 for (row = tile_row_start; row < tile_row_end;
1330 8204 row += 8, yoff += ls_y * 64, uvoff += ls_uv * 64 >> s->ss_v) {
1331 8204 VP9Filter *lflvl_ptr = s->lflvl;
1332 8204 ptrdiff_t yoff2 = yoff, uvoff2 = uvoff;
1333
1334
2/2
✓ Branch 0 taken 8857 times.
✓ Branch 1 taken 8204 times.
 17061 for (tile_col = 0; tile_col < s->s.h.tiling.tile_cols; tile_col++) {
1335 8857 set_tile_offset(&tile_col_start, &tile_col_end,
1336 8857 tile_col, s->s.h.tiling.log2_tile_cols, s->sb_cols);
1337 8857 td->tile_col_start = tile_col_start;
1338
1/2
✓ Branch 0 taken 8857 times.
✗ Branch 1 not taken.
 8857 if (s->pass != 2) {
1339 8857 memset(td->left_partition_ctx, 0, 8);
1340 8857 memset(td->left_skip_ctx, 0, 8);
1341
4/4
✓ Branch 0 taken 6546 times.
✓ Branch 1 taken 2311 times.
✓ Branch 2 taken 30 times.
✓ Branch 3 taken 6516 times.
 8857 if (s->s.h.keyframe || s->s.h.intraonly) {
1342 2341 memset(td->left_mode_ctx, DC_PRED, 16);
1343 } else {
1344 6516 memset(td->left_mode_ctx, NEARESTMV, 8);
1345 }
1346 8857 memset(td->left_y_nnz_ctx, 0, 16);
1347 8857 memset(td->left_uv_nnz_ctx, 0, 32);
1348 8857 memset(td->left_segpred_ctx, 0, 8);
1349
1350 8857 td->c = &td->c_b[tile_col];
1351 }
1352
1353 8857 for (col = tile_col_start;
1354
2/2
✓ Branch 0 taken 54736 times.
✓ Branch 1 taken 8857 times.
 63593 col < tile_col_end;
1355 54736 col += 8, yoff2 += 64 * bytesperpixel,
1356 54736 uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
1357 // FIXME integrate with lf code (i.e. zero after each
1358 // use, similar to invtxfm coefficients, or similar)
1359
1/2
✓ Branch 0 taken 54736 times.
✗ Branch 1 not taken.
 54736 if (s->pass != 1) {
1360 54736 memset(lflvl_ptr->mask, 0, sizeof(lflvl_ptr->mask));
1361 }
1362
1363
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 54736 times.
 54736 if (s->pass == 2) {
1364 ✗ decode_sb_mem(td, row, col, lflvl_ptr,
1365 yoff2, uvoff2, BL_64X64);
1366 } else {
1367
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 54736 times.
 54736 if (vpx_rac_is_end(td->c)) {
1368 ✗ return AVERROR_INVALIDDATA;
1369 }
1370 54736 decode_sb(td, row, col, lflvl_ptr,
1371 yoff2, uvoff2, BL_64X64);
1372 }
1373 }
1374 }
1375
1376
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8204 times.
 8204 if (s->pass == 1)
1377 ✗ continue;
1378
1379 // backup pre-loopfilter reconstruction data for intra
1380 // prediction of next row of sb64s
1381
2/2
✓ Branch 0 taken 5904 times.
✓ Branch 1 taken 2300 times.
 8204 if (row + 8 < s->rows) {
1382 5904 memcpy(s->intra_pred_data[0],
1383 5904 f->data[0] + yoff + 63 * ls_y,
1384 5904 8 * s->cols * bytesperpixel);
1385 5904 memcpy(s->intra_pred_data[1],
1386 5904 f->data[1] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
1387 5904 8 * s->cols * bytesperpixel >> s->ss_h);
1388 5904 memcpy(s->intra_pred_data[2],
1389 5904 f->data[2] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
1390 5904 8 * s->cols * bytesperpixel >> s->ss_h);
1391 }
1392
1393 // loopfilter one row
1394
2/2
✓ Branch 0 taken 7607 times.
✓ Branch 1 taken 597 times.
 8204 if (s->s.h.filter.level) {
1395 7607 yoff2 = yoff;
1396 7607 uvoff2 = uvoff;
1397 7607 lflvl_ptr = s->lflvl;
1398
2/2
✓ Branch 0 taken 49766 times.
✓ Branch 1 taken 7607 times.
 57373 for (col = 0; col < s->cols;
1399 49766 col += 8, yoff2 += 64 * bytesperpixel,
1400 49766 uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
1401 49766 ff_vp9_loopfilter_sb(avctx, lflvl_ptr, row, col,
1402 yoff2, uvoff2);
1403 }
1404 }
1405
1406 // FIXME maybe we can make this more finegrained by running the
1407 // loopfilter per-block instead of after each sbrow
1408 // In fact that would also make intra pred left preparation easier?
1409 8204 ff_progress_frame_report(&s->s.frames[CUR_FRAME].tf, row >> 3);
1410 }
1411 }
1412 2300 return 0;
1413 }
1414
1415 #if HAVE_THREADS
1416 static av_always_inline
1417 ✗ int decode_tiles_mt(AVCodecContext *avctx, void *tdata, int jobnr,
1418 int threadnr)
1419 {
1420 ✗ VP9Context *s = avctx->priv_data;
1421 ✗ VP9TileData *td = &s->td[jobnr];
1422 ptrdiff_t uvoff, yoff, ls_y, ls_uv;
1423 ✗ int bytesperpixel = s->bytesperpixel, row, col, tile_row;
1424 unsigned tile_cols_len;
1425 int tile_row_start, tile_row_end, tile_col_start, tile_col_end;
1426 VP9Filter *lflvl_ptr_base;
1427 AVFrame *f;
1428
1429 ✗ f = s->s.frames[CUR_FRAME].tf.f;
1430 ✗ ls_y = f->linesize[0];
1431 ✗ ls_uv =f->linesize[1];
1432
1433 ✗ set_tile_offset(&tile_col_start, &tile_col_end,
1434 ✗ jobnr, s->s.h.tiling.log2_tile_cols, s->sb_cols);
1435 ✗ td->tile_col_start = tile_col_start;
1436 ✗ uvoff = (64 * bytesperpixel >> s->ss_h)*(tile_col_start >> 3);
1437 ✗ yoff = (64 * bytesperpixel)*(tile_col_start >> 3);
1438 ✗ lflvl_ptr_base = s->lflvl+(tile_col_start >> 3);
1439
1440 ✗ for (tile_row = 0; tile_row < s->s.h.tiling.tile_rows; tile_row++) {
1441 ✗ set_tile_offset(&tile_row_start, &tile_row_end,
1442 ✗ tile_row, s->s.h.tiling.log2_tile_rows, s->sb_rows);
1443
1444 ✗ td->c = &td->c_b[tile_row];
1445 ✗ for (row = tile_row_start; row < tile_row_end;
1446 ✗ row += 8, yoff += ls_y * 64, uvoff += ls_uv * 64 >> s->ss_v) {
1447 ✗ ptrdiff_t yoff2 = yoff, uvoff2 = uvoff;
1448 ✗ VP9Filter *lflvl_ptr = lflvl_ptr_base+s->sb_cols*(row >> 3);
1449
1450 ✗ memset(td->left_partition_ctx, 0, 8);
1451 ✗ memset(td->left_skip_ctx, 0, 8);
1452 ✗ if (s->s.h.keyframe || s->s.h.intraonly) {
1453 ✗ memset(td->left_mode_ctx, DC_PRED, 16);
1454 } else {
1455 ✗ memset(td->left_mode_ctx, NEARESTMV, 8);
1456 }
1457 ✗ memset(td->left_y_nnz_ctx, 0, 16);
1458 ✗ memset(td->left_uv_nnz_ctx, 0, 32);
1459 ✗ memset(td->left_segpred_ctx, 0, 8);
1460
1461 ✗ for (col = tile_col_start;
1462 ✗ col < tile_col_end;
1463 ✗ col += 8, yoff2 += 64 * bytesperpixel,
1464 ✗ uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
1465 // FIXME integrate with lf code (i.e. zero after each
1466 // use, similar to invtxfm coefficients, or similar)
1467 ✗ memset(lflvl_ptr->mask, 0, sizeof(lflvl_ptr->mask));
1468 ✗ decode_sb(td, row, col, lflvl_ptr,
1469 yoff2, uvoff2, BL_64X64);
1470 }
1471
1472 // backup pre-loopfilter reconstruction data for intra
1473 // prediction of next row of sb64s
1474 ✗ tile_cols_len = tile_col_end - tile_col_start;
1475 ✗ if (row + 8 < s->rows) {
1476 ✗ memcpy(s->intra_pred_data[0] + (tile_col_start * 8 * bytesperpixel),
1477 ✗ f->data[0] + yoff + 63 * ls_y,
1478 ✗ 8 * tile_cols_len * bytesperpixel);
1479 ✗ memcpy(s->intra_pred_data[1] + (tile_col_start * 8 * bytesperpixel >> s->ss_h),
1480 ✗ f->data[1] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
1481 ✗ 8 * tile_cols_len * bytesperpixel >> s->ss_h);
1482 ✗ memcpy(s->intra_pred_data[2] + (tile_col_start * 8 * bytesperpixel >> s->ss_h),
1483 ✗ f->data[2] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
1484 ✗ 8 * tile_cols_len * bytesperpixel >> s->ss_h);
1485 }
1486
1487 ✗ vp9_report_tile_progress(s, row >> 3, 1);
1488 }
1489 }
1490 ✗ return 0;
1491 }
1492
1493 static av_always_inline
1494 ✗ int loopfilter_proc(AVCodecContext *avctx)
1495 {
1496 ✗ VP9Context *s = avctx->priv_data;
1497 ptrdiff_t uvoff, yoff, ls_y, ls_uv;
1498 VP9Filter *lflvl_ptr;
1499 ✗ int bytesperpixel = s->bytesperpixel, col, i;
1500 AVFrame *f;
1501
1502 ✗ f = s->s.frames[CUR_FRAME].tf.f;
1503 ✗ ls_y = f->linesize[0];
1504 ✗ ls_uv =f->linesize[1];
1505
1506 ✗ for (i = 0; i < s->sb_rows; i++) {
1507 ✗ vp9_await_tile_progress(s, i, s->s.h.tiling.tile_cols);
1508
1509 ✗ if (s->s.h.filter.level) {
1510 ✗ yoff = (ls_y * 64)*i;
1511 ✗ uvoff = (ls_uv * 64 >> s->ss_v)*i;
1512 ✗ lflvl_ptr = s->lflvl+s->sb_cols*i;
1513 ✗ for (col = 0; col < s->cols;
1514 ✗ col += 8, yoff += 64 * bytesperpixel,
1515 ✗ uvoff += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
1516 ✗ ff_vp9_loopfilter_sb(avctx, lflvl_ptr, i << 3, col,
1517 yoff, uvoff);
1518 }
1519 }
1520 }
1521 ✗ return 0;
1522 }
1523 #endif
1524
1525 6 static int vp9_export_enc_params(VP9Context *s, VP9Frame *frame)
1526 {
1527 AVVideoEncParams *par;
1528 6 unsigned int tile, nb_blocks = 0;
1529
1530
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 if (s->s.h.segmentation.enabled) {
1531
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 6 times.
 12 for (tile = 0; tile < s->active_tile_cols; tile++)
1532 6 nb_blocks += s->td[tile].nb_block_structure;
1533 }
1534
1535 6 par = av_video_enc_params_create_side_data(frame->tf.f,
1536 AV_VIDEO_ENC_PARAMS_VP9, nb_blocks);
1537
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (!par)
1538 ✗ return AVERROR(ENOMEM);
1539
1540 6 par->qp = s->s.h.yac_qi;
1541 6 par->delta_qp[0][0] = s->s.h.ydc_qdelta;
1542 6 par->delta_qp[1][0] = s->s.h.uvdc_qdelta;
1543 6 par->delta_qp[2][0] = s->s.h.uvdc_qdelta;
1544 6 par->delta_qp[1][1] = s->s.h.uvac_qdelta;
1545 6 par->delta_qp[2][1] = s->s.h.uvac_qdelta;
1546
1547
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 if (nb_blocks) {
1548 6 unsigned int block = 0;
1549 unsigned int tile, block_tile;
1550
1551
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 6 times.
 12 for (tile = 0; tile < s->active_tile_cols; tile++) {
1552 6 VP9TileData *td = &s->td[tile];
1553
1554
2/2
✓ Branch 0 taken 1204 times.
✓ Branch 1 taken 6 times.
 1210 for (block_tile = 0; block_tile < td->nb_block_structure; block_tile++) {
1555 1204 AVVideoBlockParams *b = av_video_enc_params_block(par, block++);
1556 1204 unsigned int row = td->block_structure[block_tile].row;
1557 1204 unsigned int col = td->block_structure[block_tile].col;
1558 1204 uint8_t seg_id = frame->segmentation_map[row * 8 * s->sb_cols + col];
1559
1560 1204 b->src_x = col * 8;
1561 1204 b->src_y = row * 8;
1562 1204 b->w = 1 << (3 + td->block_structure[block_tile].block_size_idx_x);
1563 1204 b->h = 1 << (3 + td->block_structure[block_tile].block_size_idx_y);
1564
1565
2/2
✓ Branch 0 taken 977 times.
✓ Branch 1 taken 227 times.
 1204 if (s->s.h.segmentation.feat[seg_id].q_enabled) {
1566 977 b->delta_qp = s->s.h.segmentation.feat[seg_id].q_val;
1567
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 977 times.
 977 if (s->s.h.segmentation.absolute_vals)
1568 ✗ b->delta_qp -= par->qp;
1569 }
1570 }
1571 }
1572 }
1573
1574 6 return 0;
1575 }
1576
1577 2319 static int vp9_decode_frame(AVCodecContext *avctx, AVFrame *frame,
1578 int *got_frame, AVPacket *pkt)
1579 {
1580 2319 const uint8_t *data = pkt->data;
1581 2319 int size = pkt->size;
1582 2319 VP9Context *s = avctx->priv_data;
1583 int ret, i, j, ref;
1584 CodedBitstreamUnit *unit;
1585 VP9RawFrame *rf;
1586
1587
2/2
✓ Branch 0 taken 1596 times.
✓ Branch 1 taken 723 times.
 3915 int retain_segmap_ref = s->s.frames[REF_FRAME_SEGMAP].segmentation_map &&
1588
4/4
✓ Branch 0 taken 215 times.
✓ Branch 1 taken 1381 times.
✓ Branch 2 taken 166 times.
✓ Branch 3 taken 49 times.
 1596 (!s->s.h.segmentation.enabled || !s->s.h.segmentation.update_map);
1589 const VP9Frame *src;
1590 AVFrame *f;
1591
1592 2319 ret = ff_cbs_read_packet(s->cbc, &s->current_frag, pkt);
1593
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2319 times.
 2319 if (ret < 0) {
1594 ✗ ff_cbs_fragment_reset(&s->current_frag);
1595 ✗ av_log(avctx, AV_LOG_ERROR, "Failed to read frame header.\n");
1596 ✗ return ret;
1597 }
1598
1599 2319 unit = &s->current_frag.units[0];
1600 2319 rf = unit->content;
1601
1602 2319 av_refstruct_replace(&s->header_ref, unit->content_ref);
1603 2319 s->frame_header = &rf->header;
1604
1605
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2319 times.
 2319 if ((ret = decode_frame_header(avctx, data, size, &ref)) < 0) {
1606 ✗ return ret;
1607
2/2
✓ Branch 0 taken 19 times.
✓ Branch 1 taken 2300 times.
 2319 } else if (ret == 0) {
1608
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19 times.
 19 if (!s->s.refs[ref].f) {
1609 ✗ av_log(avctx, AV_LOG_ERROR, "Requested reference %d not available\n", ref);
1610 ✗ return AVERROR_INVALIDDATA;
1611 }
1612
2/2
✓ Branch 0 taken 152 times.
✓ Branch 1 taken 19 times.
 171 for (int i = 0; i < 8; i++)
1613 152 ff_progress_frame_replace(&s->next_refs[i], &s->s.refs[i]);
1614 19 ff_thread_finish_setup(avctx);
1615 19 ff_progress_frame_await(&s->s.refs[ref], INT_MAX);
1616 19 ff_cbs_fragment_reset(&s->current_frag);
1617
1618
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 19 times.
 19 if ((ret = av_frame_ref(frame, s->s.refs[ref].f)) < 0)
1619 ✗ return ret;
1620 19 frame->pts = pkt->pts;
1621 19 frame->pkt_dts = pkt->dts;
1622 19 *got_frame = 1;
1623 19 return pkt->size;
1624 }
1625 2300 data += ret;
1626 2300 size -= ret;
1627
1628
6/6
✓ Branch 0 taken 1821 times.
✓ Branch 1 taken 479 times.
✓ Branch 2 taken 1815 times.
✓ Branch 3 taken 6 times.
✓ Branch 4 taken 1806 times.
✓ Branch 5 taken 9 times.
 2300 src = !s->s.h.keyframe && !s->s.h.intraonly && !s->s.h.errorres ?
1629 &s->s.frames[CUR_FRAME] : &s->s.frames[BLANK_FRAME];
1630
4/6
✓ Branch 0 taken 1528 times.
✓ Branch 1 taken 772 times.
✓ Branch 2 taken 1528 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 1528 times.
 2300 if (!retain_segmap_ref || s->s.h.keyframe || s->s.h.intraonly)
1631 772 vp9_frame_replace(&s->s.frames[REF_FRAME_SEGMAP], src);
1632 2300 vp9_frame_replace(&s->s.frames[REF_FRAME_MVPAIR], src);
1633 2300 vp9_frame_unref(&s->s.frames[CUR_FRAME]);
1634
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2300 times.
 2300 if ((ret = vp9_frame_alloc(avctx, &s->s.frames[CUR_FRAME])) < 0)
1635 ✗ return ret;
1636
1637 2300 s->s.frames[CUR_FRAME].header_ref = av_refstruct_ref(s->header_ref);
1638 2300 s->s.frames[CUR_FRAME].frame_header = s->frame_header;
1639
1640 2300 f = s->s.frames[CUR_FRAME].tf.f;
1641
2/2
✓ Branch 0 taken 479 times.
✓ Branch 1 taken 1821 times.
 2300 if (s->s.h.keyframe)
1642 479 f->flags |= AV_FRAME_FLAG_KEY;
1643 else
1644 1821 f->flags &= ~AV_FRAME_FLAG_KEY;
1645
2/2
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 2283 times.
 2300 if (s->s.h.lossless)
1646 17 f->flags |= AV_FRAME_FLAG_LOSSLESS;
1647 else
1648 2283 f->flags &= ~AV_FRAME_FLAG_LOSSLESS;
1649
4/4
✓ Branch 0 taken 1821 times.
✓ Branch 1 taken 479 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 1815 times.
 2300 f->pict_type = (s->s.h.keyframe || s->s.h.intraonly) ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
1650
1651 // Non-existent frames have the implicit dimension 0x0 != CUR_FRAME
1652
2/2
✓ Branch 0 taken 1806 times.
✓ Branch 1 taken 494 times.
 2300 if (!s->s.frames[REF_FRAME_MVPAIR].tf.f ||
1653
2/2
✓ Branch 0 taken 1804 times.
✓ Branch 1 taken 2 times.
 1806 (s->s.frames[REF_FRAME_MVPAIR].tf.f->width != s->s.frames[CUR_FRAME].tf.f->width ||
1654
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1804 times.
 1804 s->s.frames[REF_FRAME_MVPAIR].tf.f->height != s->s.frames[CUR_FRAME].tf.f->height)) {
1655 496 vp9_frame_unref(&s->s.frames[REF_FRAME_SEGMAP]);
1656 }
1657
1658 // ref frame setup
1659
2/2
✓ Branch 0 taken 18400 times.
✓ Branch 1 taken 2300 times.
 20700 for (i = 0; i < 8; i++) {
1660 18400 ff_progress_frame_replace(&s->next_refs[i],
1661
2/2
✓ Branch 0 taken 5680 times.
✓ Branch 1 taken 12720 times.
 18400 s->s.h.refreshrefmask & (1 << i) ?
1662 &s->s.frames[CUR_FRAME].tf : &s->s.refs[i]);
1663 }
1664
1665
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2300 times.
 2300 if (avctx->hwaccel) {
1666 ✗ const FFHWAccel *hwaccel = ffhwaccel(avctx->hwaccel);
1667 ✗ ret = hwaccel->start_frame(avctx, pkt->buf, pkt->data, pkt->size);
1668 ✗ if (ret < 0)
1669 ✗ return ret;
1670 ✗ ret = hwaccel->decode_slice(avctx, pkt->data, pkt->size);
1671 ✗ if (ret < 0)
1672 ✗ return ret;
1673 ✗ ret = hwaccel->end_frame(avctx);
1674 ✗ if (ret < 0)
1675 ✗ return ret;
1676
1677 ✗ for (i = 0; i < 8; i++) {
1678 ✗ vp9_frame_replace(&s->s.ref_frames[i],
1679 ✗ s->s.h.refreshrefmask & (1 << i) ?
1680 &s->s.frames[CUR_FRAME] : &s->s.ref_frames[i]);
1681 }
1682
1683 ✗ goto finish;
1684 }
1685
1686 // main tile decode loop
1687 2300 memset(s->above_partition_ctx, 0, s->cols);
1688 2300 memset(s->above_skip_ctx, 0, s->cols);
1689
4/4
✓ Branch 0 taken 1821 times.
✓ Branch 1 taken 479 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 1815 times.
 2300 if (s->s.h.keyframe || s->s.h.intraonly) {
1690 485 memset(s->above_mode_ctx, DC_PRED, s->cols * 2);
1691 } else {
1692 1815 memset(s->above_mode_ctx, NEARESTMV, s->cols);
1693 }
1694 2300 memset(s->above_y_nnz_ctx, 0, s->sb_cols * 16);
1695 2300 memset(s->above_uv_nnz_ctx[0], 0, s->sb_cols * 16 >> s->ss_h);
1696 2300 memset(s->above_uv_nnz_ctx[1], 0, s->sb_cols * 16 >> s->ss_h);
1697 2300 memset(s->above_segpred_ctx, 0, s->cols);
1698 2300 s->pass = s->s.frames[CUR_FRAME].uses_2pass =
1699
1/6
✗ Branch 0 not taken.
✓ Branch 1 taken 2300 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 2300 avctx->active_thread_type == FF_THREAD_FRAME && s->s.h.refreshctx && !s->s.h.parallelmode;
1700
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2300 times.
 2300 if ((ret = update_block_buffers(avctx)) < 0) {
1701 ✗ av_log(avctx, AV_LOG_ERROR,
1702 "Failed to allocate block buffers\n");
1703 ✗ return ret;
1704 }
1705
4/4
✓ Branch 0 taken 2289 times.
✓ Branch 1 taken 11 times.
✓ Branch 2 taken 42 times.
✓ Branch 3 taken 2247 times.
 2342 if (s->s.h.refreshctx && s->s.h.parallelmode) {
1706 int j, k, l, m;
1707
1708
2/2
✓ Branch 0 taken 126 times.
✓ Branch 1 taken 13 times.
 139 for (i = 0; i < 4; i++) {
1709
2/2
✓ Branch 0 taken 252 times.
✓ Branch 1 taken 126 times.
 378 for (j = 0; j < 2; j++)
1710
2/2
✓ Branch 0 taken 504 times.
✓ Branch 1 taken 252 times.
 756 for (k = 0; k < 2; k++)
1711
2/2
✓ Branch 0 taken 3024 times.
✓ Branch 1 taken 504 times.
 3528 for (l = 0; l < 6; l++)
1712
2/2
✓ Branch 0 taken 18144 times.
✓ Branch 1 taken 3024 times.
 21168 for (m = 0; m < 6; m++)
1713 18144 memcpy(s->prob_ctx[s->s.h.framectxid].coef[i][j][k][l][m],
1714 18144 s->prob.coef[i][j][k][l][m], 3);
1715
2/2
✓ Branch 0 taken 29 times.
✓ Branch 1 taken 97 times.
 126 if (s->s.h.txfmmode == i)
1716 29 break;
1717 }
1718 42 s->prob_ctx[s->s.h.framectxid].p = s->prob.p;
1719 42 ff_thread_finish_setup(avctx);
1720
2/2
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 2247 times.
 2258 } else if (!s->s.h.refreshctx) {
1721 11 ff_thread_finish_setup(avctx);
1722 }
1723
1724 #if HAVE_THREADS
1725
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2300 times.
 2300 if (avctx->active_thread_type & FF_THREAD_SLICE) {
1726 ✗ for (i = 0; i < s->sb_rows; i++)
1727 ✗ atomic_init(&s->entries[i], 0);
1728 }
1729 #endif
1730
1731 do {
1732
2/2
✓ Branch 0 taken 2300 times.
✓ Branch 1 taken 2300 times.
 4600 for (i = 0; i < s->active_tile_cols; i++) {
1733 2300 s->td[i].b = s->td[i].b_base;
1734 2300 s->td[i].block = s->td[i].block_base;
1735 2300 s->td[i].uvblock[0] = s->td[i].uvblock_base[0];
1736 2300 s->td[i].uvblock[1] = s->td[i].uvblock_base[1];
1737 2300 s->td[i].eob = s->td[i].eob_base;
1738 2300 s->td[i].uveob[0] = s->td[i].uveob_base[0];
1739 2300 s->td[i].uveob[1] = s->td[i].uveob_base[1];
1740 2300 s->td[i].error_info = 0;
1741 }
1742
1743 #if HAVE_THREADS
1744
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2300 times.
 2300 if (avctx->active_thread_type == FF_THREAD_SLICE) {
1745 int tile_row, tile_col;
1746
1747 av_assert1(!s->pass);
1748
1749 ✗ for (tile_row = 0; tile_row < s->s.h.tiling.tile_rows; tile_row++) {
1750 ✗ for (tile_col = 0; tile_col < s->s.h.tiling.tile_cols; tile_col++) {
1751 int64_t tile_size;
1752
1753 ✗ if (tile_col == s->s.h.tiling.tile_cols - 1 &&
1754 ✗ tile_row == s->s.h.tiling.tile_rows - 1) {
1755 ✗ tile_size = size;
1756 } else {
1757 ✗ tile_size = AV_RB32(data);
1758 ✗ data += 4;
1759 ✗ size -= 4;
1760 }
1761 ✗ if (tile_size > size)
1762 ✗ return AVERROR_INVALIDDATA;
1763 ✗ ret = ff_vpx_init_range_decoder(&s->td[tile_col].c_b[tile_row], data, tile_size);
1764 ✗ if (ret < 0)
1765 ✗ return ret;
1766 ✗ if (vpx_rac_get_prob_branchy(&s->td[tile_col].c_b[tile_row], 128)) // marker bit
1767 ✗ return AVERROR_INVALIDDATA;
1768 ✗ data += tile_size;
1769 ✗ size -= tile_size;
1770 }
1771 }
1772
1773 ✗ ff_slice_thread_execute_with_mainfunc(avctx, decode_tiles_mt, loopfilter_proc, s->td, NULL, s->s.h.tiling.tile_cols);
1774 } else
1775 #endif
1776 {
1777 2300 ret = decode_tiles(avctx, data, size);
1778
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2300 times.
 2300 if (ret < 0)
1779 ✗ goto fail;
1780 }
1781
1782 // Sum all counts fields into td[0].counts for tile threading
1783
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2300 times.
 2300 if (avctx->active_thread_type == FF_THREAD_SLICE)
1784 ✗ for (i = 1; i < s->s.h.tiling.tile_cols; i++)
1785 ✗ for (j = 0; j < sizeof(s->td[i].counts) / sizeof(unsigned); j++)
1786 ✗ ((unsigned *)&s->td[0].counts)[j] += ((unsigned *)&s->td[i].counts)[j];
1787
1788
5/6
✓ Branch 0 taken 2300 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2289 times.
✓ Branch 3 taken 11 times.
✓ Branch 4 taken 2247 times.
✓ Branch 5 taken 42 times.
 2300 if (s->pass < 2 && s->s.h.refreshctx && !s->s.h.parallelmode) {
1789 2247 ff_vp9_adapt_probs(s);
1790 2247 ff_thread_finish_setup(avctx);
1791 }
1792
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2300 times.
 2300 } while (s->pass++ == 1);
1793
1794
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2300 times.
 2300 if (s->td->error_info < 0) {
1795 ✗ av_log(avctx, AV_LOG_ERROR, "Failed to decode tile data\n");
1796 ✗ s->td->error_info = 0;
1797 ✗ ret = AVERROR_INVALIDDATA;
1798 ✗ goto fail;
1799 }
1800
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 2294 times.
 2300 if (avctx->export_side_data & AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS) {
1801 6 ret = vp9_export_enc_params(s, &s->s.frames[CUR_FRAME]);
1802
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 if (ret < 0)
1803 ✗ goto fail;
1804 }
1805
1806 2300 finish:
1807 2300 ff_cbs_fragment_reset(&s->current_frag);
1808
1809 2300 ff_progress_frame_report(&s->s.frames[CUR_FRAME].tf, INT_MAX);
1810 // ref frame setup
1811
2/2
✓ Branch 0 taken 18400 times.
✓ Branch 1 taken 2300 times.
 20700 for (int i = 0; i < 8; i++)
1812 18400 ff_progress_frame_replace(&s->s.refs[i], &s->next_refs[i]);
1813
1814
2/2
✓ Branch 0 taken 2235 times.
✓ Branch 1 taken 65 times.
 2300 if (!s->s.h.invisible) {
1815
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2235 times.
 2235 if ((ret = av_frame_ref(frame, s->s.frames[CUR_FRAME].tf.f)) < 0)
1816 ✗ return ret;
1817 2235 *got_frame = 1;
1818 }
1819
1820 2300 return pkt->size;
1821 ✗ fail:
1822 ✗ ff_progress_frame_report(&s->s.frames[CUR_FRAME].tf, INT_MAX);
1823 ✗ return ret;
1824 }
1825
1826 ✗ static av_cold void vp9_decode_flush(AVCodecContext *avctx)
1827 {
1828 ✗ VP9Context *s = avctx->priv_data;
1829 int i;
1830
1831 ✗ for (i = 0; i < 3; i++)
1832 ✗ vp9_frame_unref(&s->s.frames[i]);
1833
1834 ✗ for (i = 0; i < 8; i++) {
1835 ✗ ff_progress_frame_unref(&s->s.refs[i]);
1836 ✗ vp9_frame_unref(&s->s.ref_frames[i]);
1837 }
1838
1839 ✗ ff_cbs_fragment_reset(&s->current_frag);
1840 ✗ ff_cbs_flush(s->cbc);
1841
1842 ✗ if (FF_HW_HAS_CB(avctx, flush))
1843 ✗ FF_HW_SIMPLE_CALL(avctx, flush);
1844 ✗ }
1845
1846 484 static av_cold int vp9_decode_init(AVCodecContext *avctx)
1847 {
1848 484 VP9Context *s = avctx->priv_data;
1849 int ret;
1850
1851 484 s->last_bpp = 0;
1852 484 s->s.h.filter.sharpness = -1;
1853
1854 484 ret = ff_cbs_init(&s->cbc, AV_CODEC_ID_VP9, avctx);
1855
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 484 times.
 484 if (ret < 0)
1856 ✗ return ret;
1857
1858 #if HAVE_THREADS
1859
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 484 times.
 484 if (avctx->active_thread_type & FF_THREAD_SLICE) {
1860 ✗ ret = ff_pthread_init(s, vp9_context_offsets);
1861 ✗ if (ret < 0)
1862 ✗ return ret;
1863 }
1864 #endif
1865
1866 484 return 0;
1867 }
1868
1869 #if HAVE_THREADS
1870 ✗ static int vp9_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
1871 {
1872 ✗ VP9Context *s = dst->priv_data, *ssrc = src->priv_data;
1873
1874 ✗ for (int i = 0; i < 3; i++)
1875 ✗ vp9_frame_replace(&s->s.frames[i], &ssrc->s.frames[i]);
1876 ✗ for (int i = 0; i < 8; i++)
1877 ✗ ff_progress_frame_replace(&s->s.refs[i], &ssrc->next_refs[i]);
1878 ✗ av_refstruct_replace(&s->frame_extradata_pool, ssrc->frame_extradata_pool);
1879 ✗ s->frame_extradata_pool_size = ssrc->frame_extradata_pool_size;
1880
1881 ✗ av_refstruct_replace(&s->header_ref, ssrc->header_ref);
1882 ✗ for (int i = 0; i < 8; i++)
1883 ✗ vp9_frame_replace(&s->s.ref_frames[i], &ssrc->s.ref_frames[i]);
1884
1885 ✗ s->frame_header = ssrc->frame_header;
1886 ✗ memcpy(s->cbc->priv_data, ssrc->cbc->priv_data, sizeof(CodedBitstreamVP9Context));
1887
1888 ✗ s->s.h.invisible = ssrc->s.h.invisible;
1889 ✗ s->s.h.keyframe = ssrc->s.h.keyframe;
1890 ✗ s->s.h.intraonly = ssrc->s.h.intraonly;
1891 ✗ s->ss_v = ssrc->ss_v;
1892 ✗ s->ss_h = ssrc->ss_h;
1893 ✗ s->s.h.segmentation.enabled = ssrc->s.h.segmentation.enabled;
1894 ✗ s->s.h.segmentation.update_map = ssrc->s.h.segmentation.update_map;
1895 ✗ s->s.h.segmentation.absolute_vals = ssrc->s.h.segmentation.absolute_vals;
1896 ✗ s->bytesperpixel = ssrc->bytesperpixel;
1897 ✗ s->gf_fmt = ssrc->gf_fmt;
1898 ✗ s->w = ssrc->w;
1899 ✗ s->h = ssrc->h;
1900 ✗ s->s.h.bpp = ssrc->s.h.bpp;
1901 ✗ s->bpp_index = ssrc->bpp_index;
1902 ✗ s->pix_fmt = ssrc->pix_fmt;
1903 ✗ memcpy(&s->prob_ctx, &ssrc->prob_ctx, sizeof(s->prob_ctx));
1904 ✗ memcpy(&s->s.h.lf_delta, &ssrc->s.h.lf_delta, sizeof(s->s.h.lf_delta));
1905 ✗ memcpy(&s->s.h.segmentation.feat, &ssrc->s.h.segmentation.feat,
1906 sizeof(s->s.h.segmentation.feat));
1907
1908 ✗ return 0;
1909 }
1910 #endif
1911
1912 const FFCodec ff_vp9_decoder = {
1913 .p.name = "vp9",
1914 CODEC_LONG_NAME("Google VP9"),
1915 .p.type = AVMEDIA_TYPE_VIDEO,
1916 .p.id = AV_CODEC_ID_VP9,
1917 .priv_data_size = sizeof(VP9Context),
1918 .init = vp9_decode_init,
1919 .close = vp9_decode_free,
1920 FF_CODEC_DECODE_CB(vp9_decode_frame),
1921 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS,
1922 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP |
1923 FF_CODEC_CAP_SLICE_THREAD_HAS_MF |
1924 FF_CODEC_CAP_USES_PROGRESSFRAMES,
1925 .flush = vp9_decode_flush,
1926 UPDATE_THREAD_CONTEXT(vp9_decode_update_thread_context),
1927 .p.profiles = NULL_IF_CONFIG_SMALL(ff_vp9_profiles),
1928 .bsfs = "vp9_superframe_split",
1929 .hw_configs = (const AVCodecHWConfigInternal *const []) {
1930 #if CONFIG_VP9_DXVA2_HWACCEL
1931 HWACCEL_DXVA2(vp9),
1932 #endif
1933 #if CONFIG_VP9_D3D11VA_HWACCEL
1934 HWACCEL_D3D11VA(vp9),
1935 #endif
1936 #if CONFIG_VP9_D3D11VA2_HWACCEL
1937 HWACCEL_D3D11VA2(vp9),
1938 #endif
1939 #if CONFIG_VP9_D3D12VA_HWACCEL
1940 HWACCEL_D3D12VA(vp9),
1941 #endif
1942 #if CONFIG_VP9_NVDEC_HWACCEL
1943 HWACCEL_NVDEC(vp9),
1944 #endif
1945 #if CONFIG_VP9_VAAPI_HWACCEL
1946 HWACCEL_VAAPI(vp9),
1947 #endif
1948 #if CONFIG_VP9_VDPAU_HWACCEL
1949 HWACCEL_VDPAU(vp9),
1950 #endif
1951 #if CONFIG_VP9_VIDEOTOOLBOX_HWACCEL
1952 HWACCEL_VIDEOTOOLBOX(vp9),
1953 #endif
1954 #if CONFIG_VP9_VULKAN_HWACCEL
1955 HWACCEL_VULKAN(vp9),
1956 #endif
1957 NULL
1958 },
1959 };
1960