FFmpeg coverage

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