FFmpeg coverage

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