FFmpeg coverage

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