FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/vp9.c
Date: 2022-01-16 20:33:26
Exec Total Coverage
Lines: 852 1188 71.7%
Branches: 610 852 71.6%

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 "avcodec.h"
25 #include "get_bits.h"
26 #include "hwconfig.h"
27 #include "internal.h"
28 #include "profiles.h"
29 #include "thread.h"
30 #include "pthread_internal.h"
31
32 #include "videodsp.h"
33 #include "vp56.h"
34 #include "vp9.h"
35 #include "vp9data.h"
36 #include "vp9dec.h"
37 #include "libavutil/avassert.h"
38 #include "libavutil/pixdesc.h"
39 #include "libavutil/video_enc_params.h"
40
41 #define VP9_SYNCCODE 0x498342
42
43 #if HAVE_THREADS
44 DEFINE_OFFSET_ARRAY(VP9Context, vp9_context, pthread_init_cnt,
45 (offsetof(VP9Context, progress_mutex)),
46 (offsetof(VP9Context, progress_cond)));
47
48 467 static int vp9_alloc_entries(AVCodecContext *avctx, int n) {
49 467 VP9Context *s = avctx->priv_data;
50 int i;
51
52
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 467 times.
467 if (avctx->active_thread_type & FF_THREAD_SLICE) {
53 if (s->entries)
54 av_freep(&s->entries);
55
56 s->entries = av_malloc_array(n, sizeof(atomic_int));
57 if (!s->entries)
58 return AVERROR(ENOMEM);
59
60 for (i = 0; i < n; i++)
61 atomic_init(&s->entries[i], 0);
62 }
63 467 return 0;
64 }
65
66 static void vp9_report_tile_progress(VP9Context *s, int field, int n) {
67 pthread_mutex_lock(&s->progress_mutex);
68 atomic_fetch_add_explicit(&s->entries[field], n, memory_order_release);
69 pthread_cond_signal(&s->progress_cond);
70 pthread_mutex_unlock(&s->progress_mutex);
71 }
72
73 static void vp9_await_tile_progress(VP9Context *s, int field, int n) {
74 if (atomic_load_explicit(&s->entries[field], memory_order_acquire) >= n)
75 return;
76
77 pthread_mutex_lock(&s->progress_mutex);
78 while (atomic_load_explicit(&s->entries[field], memory_order_relaxed) != n)
79 pthread_cond_wait(&s->progress_cond, &s->progress_mutex);
80 pthread_mutex_unlock(&s->progress_mutex);
81 }
82 #else
83 static int vp9_alloc_entries(AVCodecContext *avctx, int n) { return 0; }
84 #endif
85
86 938 static void vp9_tile_data_free(VP9TileData *td)
87 {
88 938 av_freep(&td->b_base);
89 938 av_freep(&td->block_base);
90 938 av_freep(&td->block_structure);
91 938 }
92
93 4858 static void vp9_frame_unref(AVCodecContext *avctx, VP9Frame *f)
94 {
95 4858 ff_thread_release_buffer(avctx, &f->tf);
96 4858 av_buffer_unref(&f->extradata);
97 4858 av_buffer_unref(&f->hwaccel_priv_buf);
98 4858 f->segmentation_map = NULL;
99 4858 f->hwaccel_picture_private = NULL;
100 4858 }
101
102 2288 static int vp9_frame_alloc(AVCodecContext *avctx, VP9Frame *f)
103 {
104 2288 VP9Context *s = avctx->priv_data;
105 int ret, sz;
106
107 2288 ret = ff_thread_get_buffer(avctx, &f->tf, AV_GET_BUFFER_FLAG_REF);
108
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2288 times.
2288 if (ret < 0)
109 return ret;
110
111 2288 sz = 64 * s->sb_cols * s->sb_rows;
112
2/2
✓ Branch 0 taken 469 times.
✓ Branch 1 taken 1819 times.
2288 if (sz != s->frame_extradata_pool_size) {
113 469 av_buffer_pool_uninit(&s->frame_extradata_pool);
114 469 s->frame_extradata_pool = av_buffer_pool_init(sz * (1 + sizeof(VP9mvrefPair)), NULL);
115
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 469 times.
469 if (!s->frame_extradata_pool) {
116 s->frame_extradata_pool_size = 0;
117 goto fail;
118 }
119 469 s->frame_extradata_pool_size = sz;
120 }
121 2288 f->extradata = av_buffer_pool_get(s->frame_extradata_pool);
122
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2288 times.
2288 if (!f->extradata) {
123 goto fail;
124 }
125 2288 memset(f->extradata->data, 0, f->extradata->size);
126
127 2288 f->segmentation_map = f->extradata->data;
128 2288 f->mv = (VP9mvrefPair *) (f->extradata->data + sz);
129
130
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2288 times.
2288 if (avctx->hwaccel) {
131 const AVHWAccel *hwaccel = avctx->hwaccel;
132 av_assert0(!f->hwaccel_picture_private);
133 if (hwaccel->frame_priv_data_size) {
134 f->hwaccel_priv_buf = av_buffer_allocz(hwaccel->frame_priv_data_size);
135 if (!f->hwaccel_priv_buf)
136 goto fail;
137 f->hwaccel_picture_private = f->hwaccel_priv_buf->data;
138 }
139 }
140
141 2288 return 0;
142
143 fail:
144 vp9_frame_unref(avctx, f);
145 return AVERROR(ENOMEM);
146 }
147
148 2084 static int vp9_frame_ref(AVCodecContext *avctx, VP9Frame *dst, VP9Frame *src)
149 {
150 int ret;
151
152 2084 ret = ff_thread_ref_frame(&dst->tf, &src->tf);
153
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2084 times.
2084 if (ret < 0)
154 return ret;
155
156 2084 dst->extradata = av_buffer_ref(src->extradata);
157
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2084 times.
2084 if (!dst->extradata)
158 goto fail;
159
160 2084 dst->segmentation_map = src->segmentation_map;
161 2084 dst->mv = src->mv;
162 2084 dst->uses_2pass = src->uses_2pass;
163
164
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2084 times.
2084 if (src->hwaccel_picture_private) {
165 dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
166 if (!dst->hwaccel_priv_buf)
167 goto fail;
168 dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
169 }
170
171 2084 return 0;
172
173 fail:
174 vp9_frame_unref(avctx, dst);
175 return AVERROR(ENOMEM);
176 }
177
178 2288 static int update_size(AVCodecContext *avctx, int w, int h)
179 {
180 #define HWACCEL_MAX (CONFIG_VP9_DXVA2_HWACCEL + \
181 CONFIG_VP9_D3D11VA_HWACCEL * 2 + \
182 CONFIG_VP9_NVDEC_HWACCEL + \
183 CONFIG_VP9_VAAPI_HWACCEL + \
184 CONFIG_VP9_VDPAU_HWACCEL + \
185 CONFIG_VP9_VIDEOTOOLBOX_HWACCEL)
186 2288 enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmtp = pix_fmts;
187 2288 VP9Context *s = avctx->priv_data;
188 uint8_t *p;
189 2288 int bytesperpixel = s->bytesperpixel, ret, cols, rows;
190 int lflvl_len, i;
191
192
2/4
✓ Branch 0 taken 2288 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2288 times.
2288 av_assert0(w > 0 && h > 0);
193
194
5/6
✓ Branch 0 taken 2260 times.
✓ Branch 1 taken 28 times.
✓ Branch 2 taken 1819 times.
✓ Branch 3 taken 441 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 1819 times.
2288 if (!(s->pix_fmt == s->gf_fmt && w == s->w && h == s->h)) {
195
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 469 times.
469 if ((ret = ff_set_dimensions(avctx, w, h)) < 0)
196 return ret;
197
198
3/3
✓ Branch 0 taken 444 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 23 times.
469 switch (s->pix_fmt) {
199 444 case AV_PIX_FMT_YUV420P:
200 case AV_PIX_FMT_YUV420P10:
201 #if CONFIG_VP9_DXVA2_HWACCEL
202 *fmtp++ = AV_PIX_FMT_DXVA2_VLD;
203 #endif
204 #if CONFIG_VP9_D3D11VA_HWACCEL
205 *fmtp++ = AV_PIX_FMT_D3D11VA_VLD;
206 *fmtp++ = AV_PIX_FMT_D3D11;
207 #endif
208 #if CONFIG_VP9_NVDEC_HWACCEL
209 *fmtp++ = AV_PIX_FMT_CUDA;
210 #endif
211 #if CONFIG_VP9_VAAPI_HWACCEL
212 444 *fmtp++ = AV_PIX_FMT_VAAPI;
213 #endif
214 #if CONFIG_VP9_VDPAU_HWACCEL
215 444 *fmtp++ = AV_PIX_FMT_VDPAU;
216 #endif
217 #if CONFIG_VP9_VIDEOTOOLBOX_HWACCEL
218 *fmtp++ = AV_PIX_FMT_VIDEOTOOLBOX;
219 #endif
220 444 break;
221 2 case AV_PIX_FMT_YUV420P12:
222 #if CONFIG_VP9_NVDEC_HWACCEL
223 *fmtp++ = AV_PIX_FMT_CUDA;
224 #endif
225 #if CONFIG_VP9_VAAPI_HWACCEL
226 2 *fmtp++ = AV_PIX_FMT_VAAPI;
227 #endif
228 #if CONFIG_VP9_VDPAU_HWACCEL
229 2 *fmtp++ = AV_PIX_FMT_VDPAU;
230 #endif
231 2 break;
232 }
233
234 469 *fmtp++ = s->pix_fmt;
235 469 *fmtp = AV_PIX_FMT_NONE;
236
237 469 ret = ff_thread_get_format(avctx, pix_fmts);
238
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 469 times.
469 if (ret < 0)
239 return ret;
240
241 469 avctx->pix_fmt = ret;
242 469 s->gf_fmt = s->pix_fmt;
243 469 s->w = w;
244 469 s->h = h;
245 }
246
247 2288 cols = (w + 7) >> 3;
248 2288 rows = (h + 7) >> 3;
249
250
6/8
✓ Branch 0 taken 1821 times.
✓ Branch 1 taken 467 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.
2288 if (s->intra_pred_data[0] && cols == s->cols && rows == s->rows && s->pix_fmt == s->last_fmt)
251 1819 return 0;
252
253 469 s->last_fmt = s->pix_fmt;
254 469 s->sb_cols = (w + 63) >> 6;
255 469 s->sb_rows = (h + 63) >> 6;
256 469 s->cols = (w + 7) >> 3;
257 469 s->rows = (h + 7) >> 3;
258
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 469 times.
469 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 469 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 469 p = av_malloc(s->sb_cols * (128 + 192 * bytesperpixel +
265 469 lflvl_len * sizeof(*s->lflvl) + 16 * sizeof(*s->above_mv_ctx)));
266
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 469 times.
469 if (!p)
267 return AVERROR(ENOMEM);
268 469 assign(s->intra_pred_data[0], uint8_t *, 64 * bytesperpixel);
269 469 assign(s->intra_pred_data[1], uint8_t *, 64 * bytesperpixel);
270 469 assign(s->intra_pred_data[2], uint8_t *, 64 * bytesperpixel);
271 469 assign(s->above_y_nnz_ctx, uint8_t *, 16);
272 469 assign(s->above_mode_ctx, uint8_t *, 16);
273 469 assign(s->above_mv_ctx, VP56mv(*)[2], 16);
274 469 assign(s->above_uv_nnz_ctx[0], uint8_t *, 16);
275 469 assign(s->above_uv_nnz_ctx[1], uint8_t *, 16);
276 469 assign(s->above_partition_ctx, uint8_t *, 8);
277 469 assign(s->above_skip_ctx, uint8_t *, 8);
278 469 assign(s->above_txfm_ctx, uint8_t *, 8);
279 469 assign(s->above_segpred_ctx, uint8_t *, 8);
280 469 assign(s->above_intra_ctx, uint8_t *, 8);
281 469 assign(s->above_comp_ctx, uint8_t *, 8);
282 469 assign(s->above_ref_ctx, uint8_t *, 8);
283 469 assign(s->above_filter_ctx, uint8_t *, 8);
284 469 assign(s->lflvl, VP9Filter *, lflvl_len);
285 #undef assign
286
287
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 467 times.
469 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 467 times.
✓ Branch 1 taken 2 times.
469 if (s->s.h.bpp != s->last_bpp) {
293 467 ff_vp9dsp_init(&s->dsp, s->s.h.bpp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
294 467 ff_videodsp_init(&s->vdsp, s->s.h.bpp);
295 467 s->last_bpp = s->s.h.bpp;
296 }
297
298 469 return 0;
299 }
300
301 2288 static int update_block_buffers(AVCodecContext *avctx)
302 {
303 int i;
304 2288 VP9Context *s = avctx->priv_data;
305 2288 int chroma_blocks, chroma_eobs, bytesperpixel = s->bytesperpixel;
306 2288 VP9TileData *td = &s->td[0];
307
308
4/6
✓ Branch 0 taken 1819 times.
✓ Branch 1 taken 469 times.
✓ Branch 2 taken 1819 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1819 times.
✗ Branch 5 not taken.
2288 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 469 vp9_tile_data_free(td);
312 469 chroma_blocks = 64 * 64 >> (s->ss_h + s->ss_v);
313 469 chroma_eobs = 16 * 16 >> (s->ss_h + s->ss_v);
314
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 469 times.
469 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 469 times.
469 for (i = 1; i < s->active_tile_cols; i++)
335 vp9_tile_data_free(&s->td[i]);
336
337
2/2
✓ Branch 0 taken 469 times.
✓ Branch 1 taken 469 times.
938 for (i = 0; i < s->active_tile_cols; i++) {
338 469 s->td[i].b_base = av_malloc(sizeof(VP9Block));
339 938 s->td[i].block_base = av_mallocz((64 * 64 + 2 * chroma_blocks) * bytesperpixel * sizeof(int16_t) +
340 469 16 * 16 + 2 * chroma_eobs);
341
2/4
✓ Branch 0 taken 469 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 469 times.
469 if (!s->td[i].b_base || !s->td[i].block_base)
342 return AVERROR(ENOMEM);
343 469 s->td[i].uvblock_base[0] = s->td[i].block_base + 64 * 64 * bytesperpixel;
344 469 s->td[i].uvblock_base[1] = s->td[i].uvblock_base[0] + chroma_blocks * bytesperpixel;
345 469 s->td[i].eob_base = (uint8_t *) (s->td[i].uvblock_base[1] + chroma_blocks * bytesperpixel);
346 469 s->td[i].uveob_base[0] = s->td[i].eob_base + 16 * 16;
347 469 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 468 times.
469 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 469 s->block_alloc_using_2pass = s->s.frames[CUR_FRAME].uses_2pass;
357
358 469 return 0;
359 }
360
361 // The sign bit is at the end, not the start, of a bit sequence
362 1712 static av_always_inline int get_sbits_inv(GetBitContext *gb, int n)
363 {
364 1712 int v = get_bits(gb, n);
365
2/2
✓ Branch 1 taken 1115 times.
✓ Branch 2 taken 597 times.
1712 return get_bits1(gb) ? -v : v;
366 }
367
368 25312 static av_always_inline int inv_recenter_nonneg(int v, int m)
369 {
370
2/2
✓ Branch 0 taken 6772 times.
✓ Branch 1 taken 18540 times.
25312 if (v > 2 * m)
371 6772 return v;
372
2/2
✓ Branch 0 taken 11090 times.
✓ Branch 1 taken 7450 times.
18540 if (v & 1)
373 11090 return m - ((v + 1) >> 1);
374 7450 return m + (v >> 1);
375 }
376
377 // differential forward probability updates
378 25312 static int update_prob(VP56RangeCoder *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 18934 times.
✓ Branch 2 taken 6378 times.
25312 if (!vp8_rac_get(c)) {
419 18934 d = vp8_rac_get_uint(c, 4) + 0;
420
2/2
✓ Branch 1 taken 2370 times.
✓ Branch 2 taken 4008 times.
6378 } else if (!vp8_rac_get(c)) {
421 2370 d = vp8_rac_get_uint(c, 4) + 16;
422
2/2
✓ Branch 1 taken 2769 times.
✓ Branch 2 taken 1239 times.
4008 } else if (!vp8_rac_get(c)) {
423 2769 d = vp8_rac_get_uint(c, 5) + 32;
424 } else {
425 1239 d = vp8_rac_get_uint(c, 7);
426
2/2
✓ Branch 0 taken 193 times.
✓ Branch 1 taken 1046 times.
1239 if (d >= 65)
427 193 d = (d << 1) - 65 + vp8_rac_get(c);
428 1239 d += 64;
429 av_assert2(d < FF_ARRAY_ELEMS(inv_map_table));
430 }
431
432
2/2
✓ Branch 0 taken 14187 times.
✓ Branch 1 taken 11125 times.
36437 return p <= 128 ? 1 + inv_recenter_nonneg(inv_map_table[d], p - 1) :
433 11125 255 - inv_recenter_nonneg(inv_map_table[d], 255 - p);
434 }
435
436 467 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 467 VP9Context *s = avctx->priv_data;
443
2/2
✓ Branch 0 taken 20 times.
✓ Branch 1 taken 447 times.
467 int bits = avctx->profile <= 1 ? 0 : 1 + get_bits1(&s->gb); // 0:8, 1:10, 2:12
444
445 467 s->bpp_index = bits;
446 467 s->s.h.bpp = 8 + bits * 2;
447 467 s->bytesperpixel = (7 + s->s.h.bpp) >> 3;
448 467 avctx->colorspace = colorspaces[get_bits(&s->gb, 3)];
449
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 467 times.
467 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 467 times.
467 avctx->color_range = get_bits1(&s->gb) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
476
2/2
✓ Branch 0 taken 23 times.
✓ Branch 1 taken 444 times.
467 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 444 s->ss_h = s->ss_v = 1;
491 444 s->pix_fmt = pix_fmt_for_ss[bits][1][1];
492 }
493 }
494
495 467 return 0;
496 }
497
498 2307 static int decode_frame_header(AVCodecContext *avctx,
499 const uint8_t *data, int size, int *ref)
500 {
501 2307 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 2307 times.
2307 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 2307 times.
2307 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 2307 avctx->profile = get_bits1(&s->gb);
516 2307 avctx->profile |= get_bits1(&s->gb) << 1;
517
2/2
✓ Branch 0 taken 112 times.
✓ Branch 1 taken 2195 times.
2307 if (avctx->profile == 3) avctx->profile += get_bits1(&s->gb);
518
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2307 times.
2307 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 2307 s->s.h.profile = avctx->profile;
523
2/2
✓ Branch 1 taken 19 times.
✓ Branch 2 taken 2288 times.
2307 if (get_bits1(&s->gb)) {
524 19 *ref = get_bits(&s->gb, 3);
525 19 return 0;
526 }
527
528 2288 s->last_keyframe = s->s.h.keyframe;
529 2288 s->s.h.keyframe = !get_bits1(&s->gb);
530
531 2288 last_invisible = s->s.h.invisible;
532 2288 s->s.h.invisible = !get_bits1(&s->gb);
533 2288 s->s.h.errorres = get_bits1(&s->gb);
534
4/4
✓ Branch 0 taken 2277 times.
✓ Branch 1 taken 11 times.
✓ Branch 2 taken 2212 times.
✓ Branch 3 taken 65 times.
2288 s->s.h.use_last_frame_mvs = !s->s.h.errorres && !last_invisible;
535
536
2/2
✓ Branch 0 taken 467 times.
✓ Branch 1 taken 1821 times.
2288 if (s->s.h.keyframe) {
537
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 467 times.
467 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 467 times.
467 if ((ret = read_colorspace_details(avctx)) < 0)
542 return ret;
543 // for profile 1, here follows the subsampling bits
544 467 s->s.h.refreshrefmask = 0xff;
545 467 w = get_bits(&s->gb, 16) + 1;
546 467 h = get_bits(&s->gb, 16) + 1;
547
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 467 times.
467 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->buf[0] ||
583
1/2
✓ Branch 0 taken 1815 times.
✗ Branch 1 not taken.
1815 !s->s.refs[s->s.h.refidx[1]].f->buf[0] ||
584
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1815 times.
1815 !s->s.refs[s->s.h.refidx[2]].f->buf[0]) {
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
2/2
✓ Branch 0 taken 1813 times.
✓ Branch 1 taken 2 times.
3628 s->s.h.use_last_frame_mvs &= s->s.frames[CUR_FRAME].tf.f->width == w &&
605
1/2
✓ Branch 0 taken 1813 times.
✗ Branch 1 not taken.
1813 s->s.frames[CUR_FRAME].tf.f->height == h;
606
2/2
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 1812 times.
1815 if (get_bits1(&s->gb)) // display size
607 3 skip_bits(&s->gb, 32);
608 1815 s->s.h.highprecisionmvs = get_bits1(&s->gb);
609
2/2
✓ Branch 1 taken 494 times.
✓ Branch 2 taken 1321 times.
1815 s->s.h.filtermode = get_bits1(&s->gb) ? FILTER_SWITCHABLE :
610 494 get_bits(&s->gb, 2);
611
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] ||
612
2/2
✓ Branch 0 taken 459 times.
✓ Branch 1 taken 1356 times.
1815 s->s.h.signbias[0] != s->s.h.signbias[2];
613
2/2
✓ Branch 0 taken 459 times.
✓ Branch 1 taken 1356 times.
1815 if (s->s.h.allowcompinter) {
614
1/2
✓ Branch 0 taken 459 times.
✗ Branch 1 not taken.
459 if (s->s.h.signbias[0] == s->s.h.signbias[1]) {
615 459 s->s.h.fixcompref = 2;
616 459 s->s.h.varcompref[0] = 0;
617 459 s->s.h.varcompref[1] = 1;
618 } else if (s->s.h.signbias[0] == s->s.h.signbias[2]) {
619 s->s.h.fixcompref = 1;
620 s->s.h.varcompref[0] = 0;
621 s->s.h.varcompref[1] = 2;
622 } else {
623 s->s.h.fixcompref = 0;
624 s->s.h.varcompref[0] = 1;
625 s->s.h.varcompref[1] = 2;
626 }
627 }
628 }
629 }
630
2/2
✓ Branch 0 taken 2277 times.
✓ Branch 1 taken 11 times.
2288 s->s.h.refreshctx = s->s.h.errorres ? 0 : get_bits1(&s->gb);
631
2/2
✓ Branch 0 taken 2277 times.
✓ Branch 1 taken 11 times.
2288 s->s.h.parallelmode = s->s.h.errorres ? 1 : get_bits1(&s->gb);
632 2288 s->s.h.framectxid = c = get_bits(&s->gb, 2);
633
4/4
✓ Branch 0 taken 1821 times.
✓ Branch 1 taken 467 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 1815 times.
2288 if (s->s.h.keyframe || s->s.h.intraonly)
634 473 s->s.h.framectxid = 0; // BUG: libvpx ignores this field in keyframes
635
636 /* loopfilter header data */
637
6/6
✓ Branch 0 taken 1821 times.
✓ Branch 1 taken 467 times.
✓ Branch 2 taken 1812 times.
✓ Branch 3 taken 9 times.
✓ Branch 4 taken 6 times.
✓ Branch 5 taken 1806 times.
2288 if (s->s.h.keyframe || s->s.h.errorres || s->s.h.intraonly) {
638 // reset loopfilter defaults
639 482 s->s.h.lf_delta.ref[0] = 1;
640 482 s->s.h.lf_delta.ref[1] = 0;
641 482 s->s.h.lf_delta.ref[2] = -1;
642 482 s->s.h.lf_delta.ref[3] = -1;
643 482 s->s.h.lf_delta.mode[0] = 0;
644 482 s->s.h.lf_delta.mode[1] = 0;
645 482 memset(s->s.h.segmentation.feat, 0, sizeof(s->s.h.segmentation.feat));
646 }
647 2288 s->s.h.filter.level = get_bits(&s->gb, 6);
648 2288 sharp = get_bits(&s->gb, 3);
649 // if sharpness changed, reinit lim/mblim LUTs. if it didn't change, keep
650 // the old cache values since they are still valid
651
2/2
✓ Branch 0 taken 474 times.
✓ Branch 1 taken 1814 times.
2288 if (s->s.h.filter.sharpness != sharp) {
652
2/2
✓ Branch 0 taken 29862 times.
✓ Branch 1 taken 474 times.
30336 for (i = 1; i <= 63; i++) {
653 29862 int limit = i;
654
655
2/2
✓ Branch 0 taken 441 times.
✓ Branch 1 taken 29421 times.
29862 if (sharp > 0) {
656 441 limit >>= (sharp + 3) >> 2;
657 441 limit = FFMIN(limit, 9 - sharp);
658 }
659 29862 limit = FFMAX(limit, 1);
660
661 29862 s->filter_lut.lim_lut[i] = limit;
662 29862 s->filter_lut.mblim_lut[i] = 2 * (i + 2) + limit;
663 }
664 }
665 2288 s->s.h.filter.sharpness = sharp;
666
2/2
✓ Branch 1 taken 2273 times.
✓ Branch 2 taken 15 times.
2288 if ((s->s.h.lf_delta.enabled = get_bits1(&s->gb))) {
667
2/2
✓ Branch 1 taken 496 times.
✓ Branch 2 taken 1777 times.
2273 if ((s->s.h.lf_delta.updated = get_bits1(&s->gb))) {
668
2/2
✓ Branch 0 taken 1984 times.
✓ Branch 1 taken 496 times.
2480 for (i = 0; i < 4; i++)
669
2/2
✓ Branch 1 taken 1449 times.
✓ Branch 2 taken 535 times.
1984 if (get_bits1(&s->gb))
670 1449 s->s.h.lf_delta.ref[i] = get_sbits_inv(&s->gb, 6);
671
2/2
✓ Branch 0 taken 992 times.
✓ Branch 1 taken 496 times.
1488 for (i = 0; i < 2; i++)
672
2/2
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 990 times.
992 if (get_bits1(&s->gb))
673 2 s->s.h.lf_delta.mode[i] = get_sbits_inv(&s->gb, 6);
674 }
675 }
676
677 /* quantization header data */
678 2288 s->s.h.yac_qi = get_bits(&s->gb, 8);
679
2/2
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 2285 times.
2288 s->s.h.ydc_qdelta = get_bits1(&s->gb) ? get_sbits_inv(&s->gb, 4) : 0;
680
2/2
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 2285 times.
2288 s->s.h.uvdc_qdelta = get_bits1(&s->gb) ? get_sbits_inv(&s->gb, 4) : 0;
681
2/2
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 2285 times.
2288 s->s.h.uvac_qdelta = get_bits1(&s->gb) ? get_sbits_inv(&s->gb, 4) : 0;
682
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 &&
683
4/6
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 2271 times.
✓ Branch 2 taken 17 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 17 times.
✗ Branch 5 not taken.
2305 s->s.h.uvdc_qdelta == 0 && s->s.h.uvac_qdelta == 0;
684
2/2
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 2271 times.
2288 if (s->s.h.lossless)
685 17 avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
686
687 /* segmentation header info */
688
2/2
✓ Branch 1 taken 236 times.
✓ Branch 2 taken 2052 times.
2288 if ((s->s.h.segmentation.enabled = get_bits1(&s->gb))) {
689
2/2
✓ Branch 1 taken 68 times.
✓ Branch 2 taken 168 times.
236 if ((s->s.h.segmentation.update_map = get_bits1(&s->gb))) {
690
2/2
✓ Branch 0 taken 476 times.
✓ Branch 1 taken 68 times.
544 for (i = 0; i < 7; i++)
691
2/2
✓ Branch 1 taken 341 times.
✓ Branch 2 taken 135 times.
817 s->s.h.segmentation.prob[i] = get_bits1(&s->gb) ?
692 341 get_bits(&s->gb, 8) : 255;
693
2/2
✓ Branch 1 taken 60 times.
✓ Branch 2 taken 8 times.
68 if ((s->s.h.segmentation.temporal = get_bits1(&s->gb)))
694
2/2
✓ Branch 0 taken 180 times.
✓ Branch 1 taken 60 times.
240 for (i = 0; i < 3; i++)
695
1/2
✓ Branch 1 taken 180 times.
✗ Branch 2 not taken.
360 s->s.h.segmentation.pred_prob[i] = get_bits1(&s->gb) ?
696 180 get_bits(&s->gb, 8) : 255;
697 }
698
699
2/2
✓ Branch 1 taken 70 times.
✓ Branch 2 taken 166 times.
236 if (get_bits1(&s->gb)) {
700 70 s->s.h.segmentation.absolute_vals = get_bits1(&s->gb);
701
2/2
✓ Branch 0 taken 560 times.
✓ Branch 1 taken 70 times.
630 for (i = 0; i < 8; i++) {
702
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)))
703 249 s->s.h.segmentation.feat[i].q_val = get_sbits_inv(&s->gb, 8);
704
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)))
705 3 s->s.h.segmentation.feat[i].lf_val = get_sbits_inv(&s->gb, 6);
706
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)))
707 3 s->s.h.segmentation.feat[i].ref_val = get_bits(&s->gb, 2);
708 560 s->s.h.segmentation.feat[i].skip_enabled = get_bits1(&s->gb);
709 }
710 }
711 }
712
713 // set qmul[] based on Y/UV, AC/DC and segmentation Q idx deltas
714
4/4
✓ Branch 0 taken 2124 times.
✓ Branch 1 taken 4104 times.
✓ Branch 2 taken 3940 times.
✓ Branch 3 taken 2288 times.
6228 for (i = 0; i < (s->s.h.segmentation.enabled ? 8 : 1); i++) {
715 int qyac, qydc, quvac, quvdc, lflvl, sh;
716
717
4/4
✓ Branch 0 taken 1888 times.
✓ Branch 1 taken 2052 times.
✓ Branch 2 taken 424 times.
✓ Branch 3 taken 1464 times.
3940 if (s->s.h.segmentation.enabled && s->s.h.segmentation.feat[i].q_enabled) {
718
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 424 times.
424 if (s->s.h.segmentation.absolute_vals)
719 qyac = av_clip_uintp2(s->s.h.segmentation.feat[i].q_val, 8);
720 else
721 424 qyac = av_clip_uintp2(s->s.h.yac_qi + s->s.h.segmentation.feat[i].q_val, 8);
722 } else {
723 3516 qyac = s->s.h.yac_qi;
724 }
725 3940 qydc = av_clip_uintp2(qyac + s->s.h.ydc_qdelta, 8);
726 3940 quvdc = av_clip_uintp2(qyac + s->s.h.uvdc_qdelta, 8);
727 3940 quvac = av_clip_uintp2(qyac + s->s.h.uvac_qdelta, 8);
728 3940 qyac = av_clip_uintp2(qyac, 8);
729
730 3940 s->s.h.segmentation.feat[i].qmul[0][0] = ff_vp9_dc_qlookup[s->bpp_index][qydc];
731 3940 s->s.h.segmentation.feat[i].qmul[0][1] = ff_vp9_ac_qlookup[s->bpp_index][qyac];
732 3940 s->s.h.segmentation.feat[i].qmul[1][0] = ff_vp9_dc_qlookup[s->bpp_index][quvdc];
733 3940 s->s.h.segmentation.feat[i].qmul[1][1] = ff_vp9_ac_qlookup[s->bpp_index][quvac];
734
735 3940 sh = s->s.h.filter.level >= 32;
736
4/4
✓ Branch 0 taken 1888 times.
✓ Branch 1 taken 2052 times.
✓ Branch 2 taken 17 times.
✓ Branch 3 taken 1871 times.
3940 if (s->s.h.segmentation.enabled && s->s.h.segmentation.feat[i].lf_enabled) {
737
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 17 times.
17 if (s->s.h.segmentation.absolute_vals)
738 lflvl = av_clip_uintp2(s->s.h.segmentation.feat[i].lf_val, 6);
739 else
740 17 lflvl = av_clip_uintp2(s->s.h.filter.level + s->s.h.segmentation.feat[i].lf_val, 6);
741 } else {
742 3923 lflvl = s->s.h.filter.level;
743 }
744
2/2
✓ Branch 0 taken 3925 times.
✓ Branch 1 taken 15 times.
3940 if (s->s.h.lf_delta.enabled) {
745 3925 s->s.h.segmentation.feat[i].lflvl[0][0] =
746 3925 s->s.h.segmentation.feat[i].lflvl[0][1] =
747 3925 av_clip_uintp2(lflvl + (s->s.h.lf_delta.ref[0] * (1 << sh)), 6);
748
2/2
✓ Branch 0 taken 11775 times.
✓ Branch 1 taken 3925 times.
15700 for (j = 1; j < 4; j++) {
749 11775 s->s.h.segmentation.feat[i].lflvl[j][0] =
750 11775 av_clip_uintp2(lflvl + ((s->s.h.lf_delta.ref[j] +
751 11775 s->s.h.lf_delta.mode[0]) * (1 << sh)), 6);
752 11775 s->s.h.segmentation.feat[i].lflvl[j][1] =
753 11775 av_clip_uintp2(lflvl + ((s->s.h.lf_delta.ref[j] +
754 11775 s->s.h.lf_delta.mode[1]) * (1 << sh)), 6);
755 }
756 } else {
757 15 memset(s->s.h.segmentation.feat[i].lflvl, lflvl,
758 sizeof(s->s.h.segmentation.feat[i].lflvl));
759 }
760 }
761
762 /* tiling info */
763
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2288 times.
2288 if ((ret = update_size(avctx, w, h)) < 0) {
764 av_log(avctx, AV_LOG_ERROR, "Failed to initialize decoder for %dx%d @ %d\n",
765 w, h, s->pix_fmt);
766 return ret;
767 }
768 2288 for (s->s.h.tiling.log2_tile_cols = 0;
769
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2288 times.
2288 s->sb_cols > (64 << s->s.h.tiling.log2_tile_cols);
770 s->s.h.tiling.log2_tile_cols++) ;
771
2/2
✓ Branch 0 taken 1617 times.
✓ Branch 1 taken 2288 times.
3905 for (max = 0; (s->sb_cols >> max) >= 4; max++) ;
772 2288 max = FFMAX(0, max - 1);
773
2/2
✓ Branch 0 taken 201 times.
✓ Branch 1 taken 2103 times.
2304 while (max > s->s.h.tiling.log2_tile_cols) {
774
2/2
✓ Branch 1 taken 16 times.
✓ Branch 2 taken 185 times.
201 if (get_bits1(&s->gb))
775 16 s->s.h.tiling.log2_tile_cols++;
776 else
777 185 break;
778 }
779 2288 s->s.h.tiling.log2_tile_rows = decode012(&s->gb);
780 2288 s->s.h.tiling.tile_rows = 1 << s->s.h.tiling.log2_tile_rows;
781
2/2
✓ Branch 0 taken 467 times.
✓ Branch 1 taken 1821 times.
2288 if (s->s.h.tiling.tile_cols != (1 << s->s.h.tiling.log2_tile_cols)) {
782 int n_range_coders;
783 VP56RangeCoder *rc;
784
785
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 467 times.
467 if (s->td) {
786 for (i = 0; i < s->active_tile_cols; i++)
787 vp9_tile_data_free(&s->td[i]);
788 av_freep(&s->td);
789 }
790
791 467 s->s.h.tiling.tile_cols = 1 << s->s.h.tiling.log2_tile_cols;
792 934 s->active_tile_cols = avctx->active_thread_type == FF_THREAD_SLICE ?
793
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 467 times.
467 s->s.h.tiling.tile_cols : 1;
794 467 vp9_alloc_entries(avctx, s->sb_rows);
795
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 467 times.
467 if (avctx->active_thread_type == FF_THREAD_SLICE) {
796 n_range_coders = 4; // max_tile_rows
797 } else {
798 467 n_range_coders = s->s.h.tiling.tile_cols;
799 }
800 467 s->td = av_calloc(s->active_tile_cols, sizeof(VP9TileData) +
801 n_range_coders * sizeof(VP56RangeCoder));
802
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 467 times.
467 if (!s->td)
803 return AVERROR(ENOMEM);
804 467 rc = (VP56RangeCoder *) &s->td[s->active_tile_cols];
805
2/2
✓ Branch 0 taken 467 times.
✓ Branch 1 taken 467 times.
934 for (i = 0; i < s->active_tile_cols; i++) {
806 467 s->td[i].s = s;
807 467 s->td[i].c_b = rc;
808 467 rc += n_range_coders;
809 }
810 }
811
812 /* check reference frames */
813
4/4
✓ Branch 0 taken 1821 times.
✓ Branch 1 taken 467 times.
✓ Branch 2 taken 1815 times.
✓ Branch 3 taken 6 times.
2288 if (!s->s.h.keyframe && !s->s.h.intraonly) {
814 1815 int valid_ref_frame = 0;
815
2/2
✓ Branch 0 taken 5445 times.
✓ Branch 1 taken 1815 times.
7260 for (i = 0; i < 3; i++) {
816 5445 AVFrame *ref = s->s.refs[s->s.h.refidx[i]].f;
817 5445 int refw = ref->width, refh = ref->height;
818
819
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5445 times.
5445 if (ref->format != avctx->pix_fmt) {
820 av_log(avctx, AV_LOG_ERROR,
821 "Ref pixfmt (%s) did not match current frame (%s)",
822 av_get_pix_fmt_name(ref->format),
823 av_get_pix_fmt_name(avctx->pix_fmt));
824 return AVERROR_INVALIDDATA;
825
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) {
826 5437 s->mvscale[i][0] = s->mvscale[i][1] = 0;
827 } else {
828 /* Check to make sure at least one of frames that */
829 /* this frame references has valid dimensions */
830
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) {
831 av_log(avctx, AV_LOG_WARNING,
832 "Invalid ref frame dimensions %dx%d for frame size %dx%d\n",
833 refw, refh, w, h);
834 s->mvscale[i][0] = s->mvscale[i][1] = REF_INVALID_SCALE;
835 continue;
836 }
837 8 s->mvscale[i][0] = (refw << 14) / w;
838 8 s->mvscale[i][1] = (refh << 14) / h;
839 8 s->mvstep[i][0] = 16 * s->mvscale[i][0] >> 14;
840 8 s->mvstep[i][1] = 16 * s->mvscale[i][1] >> 14;
841 }
842 5445 valid_ref_frame++;
843 }
844
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1815 times.
1815 if (!valid_ref_frame) {
845 av_log(avctx, AV_LOG_ERROR, "No valid reference frame is found, bitstream not supported\n");
846 return AVERROR_INVALIDDATA;
847 }
848 }
849
850
7/8
✓ Branch 0 taken 1821 times.
✓ Branch 1 taken 467 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.
2288 if (s->s.h.keyframe || s->s.h.errorres || (s->s.h.intraonly && s->s.h.resetctx == 3)) {
851 476 s->prob_ctx[0].p = s->prob_ctx[1].p = s->prob_ctx[2].p =
852 476 s->prob_ctx[3].p = ff_vp9_default_probs;
853 476 memcpy(s->prob_ctx[0].coef, ff_vp9_default_coef_probs,
854 sizeof(ff_vp9_default_coef_probs));
855 476 memcpy(s->prob_ctx[1].coef, ff_vp9_default_coef_probs,
856 sizeof(ff_vp9_default_coef_probs));
857 476 memcpy(s->prob_ctx[2].coef, ff_vp9_default_coef_probs,
858 sizeof(ff_vp9_default_coef_probs));
859 476 memcpy(s->prob_ctx[3].coef, ff_vp9_default_coef_probs,
860 sizeof(ff_vp9_default_coef_probs));
861
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) {
862 6 s->prob_ctx[c].p = ff_vp9_default_probs;
863 6 memcpy(s->prob_ctx[c].coef, ff_vp9_default_coef_probs,
864 sizeof(ff_vp9_default_coef_probs));
865 }
866
867 // next 16 bits is size of the rest of the header (arith-coded)
868 2288 s->s.h.compressed_header_size = size2 = get_bits(&s->gb, 16);
869 2288 s->s.h.uncompressed_header_size = (get_bits_count(&s->gb) + 7) / 8;
870
871 2288 data2 = align_get_bits(&s->gb);
872
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2288 times.
2288 if (size2 > size - (data2 - data)) {
873 av_log(avctx, AV_LOG_ERROR, "Invalid compressed header size\n");
874 return AVERROR_INVALIDDATA;
875 }
876 2288 ret = ff_vp56_init_range_decoder(&s->c, data2, size2);
877
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2288 times.
2288 if (ret < 0)
878 return ret;
879
880
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2288 times.
2288 if (vp56_rac_get_prob_branchy(&s->c, 128)) { // marker bit
881 av_log(avctx, AV_LOG_ERROR, "Marker bit was set\n");
882 return AVERROR_INVALIDDATA;
883 }
884
885
2/2
✓ Branch 0 taken 2288 times.
✓ Branch 1 taken 2288 times.
4576 for (i = 0; i < s->active_tile_cols; i++) {
886
4/4
✓ Branch 0 taken 1821 times.
✓ Branch 1 taken 467 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 1815 times.
2288 if (s->s.h.keyframe || s->s.h.intraonly) {
887 473 memset(s->td[i].counts.coef, 0, sizeof(s->td[0].counts.coef));
888 473 memset(s->td[i].counts.eob, 0, sizeof(s->td[0].counts.eob));
889 } else {
890 1815 memset(&s->td[i].counts, 0, sizeof(s->td[0].counts));
891 }
892 2288 s->td[i].nb_block_structure = 0;
893 }
894
895 /* FIXME is it faster to not copy here, but do it down in the fw updates
896 * as explicit copies if the fw update is missing (and skip the copy upon
897 * fw update)? */
898 2288 s->prob.p = s->prob_ctx[c].p;
899
900 // txfm updates
901
2/2
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 2271 times.
2288 if (s->s.h.lossless) {
902 17 s->s.h.txfmmode = TX_4X4;
903 } else {
904 2271 s->s.h.txfmmode = vp8_rac_get_uint(&s->c, 2);
905
2/2
✓ Branch 0 taken 1917 times.
✓ Branch 1 taken 354 times.
2271 if (s->s.h.txfmmode == 3)
906 1917 s->s.h.txfmmode += vp8_rac_get(&s->c);
907
908
2/2
✓ Branch 0 taken 1717 times.
✓ Branch 1 taken 554 times.
2271 if (s->s.h.txfmmode == TX_SWITCHABLE) {
909
2/2
✓ Branch 0 taken 3434 times.
✓ Branch 1 taken 1717 times.
5151 for (i = 0; i < 2; i++)
910
2/2
✓ Branch 1 taken 215 times.
✓ Branch 2 taken 3219 times.
3434 if (vp56_rac_get_prob_branchy(&s->c, 252))
911 215 s->prob.p.tx8p[i] = update_prob(&s->c, s->prob.p.tx8p[i]);
912
2/2
✓ Branch 0 taken 3434 times.
✓ Branch 1 taken 1717 times.
5151 for (i = 0; i < 2; i++)
913
2/2
✓ Branch 0 taken 6868 times.
✓ Branch 1 taken 3434 times.
10302 for (j = 0; j < 2; j++)
914
2/2
✓ Branch 1 taken 168 times.
✓ Branch 2 taken 6700 times.
6868 if (vp56_rac_get_prob_branchy(&s->c, 252))
915 168 s->prob.p.tx16p[i][j] =
916 168 update_prob(&s->c, s->prob.p.tx16p[i][j]);
917
2/2
✓ Branch 0 taken 3434 times.
✓ Branch 1 taken 1717 times.
5151 for (i = 0; i < 2; i++)
918
2/2
✓ Branch 0 taken 10302 times.
✓ Branch 1 taken 3434 times.
13736 for (j = 0; j < 3; j++)
919
2/2
✓ Branch 1 taken 41 times.
✓ Branch 2 taken 10261 times.
10302 if (vp56_rac_get_prob_branchy(&s->c, 252))
920 41 s->prob.p.tx32p[i][j] =
921 41 update_prob(&s->c, s->prob.p.tx32p[i][j]);
922 }
923 }
924
925 // coef updates
926
2/2
✓ Branch 0 taken 8276 times.
✓ Branch 1 taken 1717 times.
9993 for (i = 0; i < 4; i++) {
927 8276 uint8_t (*ref)[2][6][6][3] = s->prob_ctx[c].coef[i];
928
2/2
✓ Branch 1 taken 1605 times.
✓ Branch 2 taken 6671 times.
8276 if (vp8_rac_get(&s->c)) {
929
2/2
✓ Branch 0 taken 3210 times.
✓ Branch 1 taken 1605 times.
4815 for (j = 0; j < 2; j++)
930
2/2
✓ Branch 0 taken 6420 times.
✓ Branch 1 taken 3210 times.
9630 for (k = 0; k < 2; k++)
931
2/2
✓ Branch 0 taken 38520 times.
✓ Branch 1 taken 6420 times.
44940 for (l = 0; l < 6; l++)
932
2/2
✓ Branch 0 taken 218280 times.
✓ Branch 1 taken 32100 times.
250380 for (m = 0; m < 6; m++) {
933 218280 uint8_t *p = s->prob.coef[i][j][k][l][m];
934 218280 uint8_t *r = ref[j][k][l][m];
935
4/4
✓ Branch 0 taken 102720 times.
✓ Branch 1 taken 115560 times.
✓ Branch 2 taken 6420 times.
✓ Branch 3 taken 96300 times.
218280 if (m >= 3 && l == 0) // dc only has 3 pt
936 6420 break;
937
2/2
✓ Branch 0 taken 635580 times.
✓ Branch 1 taken 211860 times.
847440 for (n = 0; n < 3; n++) {
938
2/2
✓ Branch 1 taken 22748 times.
✓ Branch 2 taken 612832 times.
635580 if (vp56_rac_get_prob_branchy(&s->c, 252))
939 22748 p[n] = update_prob(&s->c, r[n]);
940 else
941 612832 p[n] = r[n];
942 }
943 211860 memcpy(&p[3], ff_vp9_model_pareto8[p[2]], 8);
944 }
945 } else {
946
2/2
✓ Branch 0 taken 13342 times.
✓ Branch 1 taken 6671 times.
20013 for (j = 0; j < 2; j++)
947
2/2
✓ Branch 0 taken 26684 times.
✓ Branch 1 taken 13342 times.
40026 for (k = 0; k < 2; k++)
948
2/2
✓ Branch 0 taken 160104 times.
✓ Branch 1 taken 26684 times.
186788 for (l = 0; l < 6; l++)
949
2/2
✓ Branch 0 taken 933940 times.
✓ Branch 1 taken 133420 times.
1067360 for (m = 0; m < 6; m++) {
950 933940 uint8_t *p = s->prob.coef[i][j][k][l][m];
951 933940 uint8_t *r = ref[j][k][l][m];
952
4/4
✓ Branch 0 taken 293524 times.
✓ Branch 1 taken 640416 times.
✓ Branch 2 taken 26684 times.
✓ Branch 3 taken 266840 times.
933940 if (m > 3 && l == 0) // dc only has 3 pt
953 26684 break;
954 907256 memcpy(p, r, 3);
955 907256 memcpy(&p[3], ff_vp9_model_pareto8[p[2]], 8);
956 }
957 }
958
2/2
✓ Branch 0 taken 571 times.
✓ Branch 1 taken 7705 times.
8276 if (s->s.h.txfmmode == i)
959 571 break;
960 }
961
962 // mode updates
963
2/2
✓ Branch 0 taken 6864 times.
✓ Branch 1 taken 2288 times.
9152 for (i = 0; i < 3; i++)
964
2/2
✓ Branch 1 taken 734 times.
✓ Branch 2 taken 6130 times.
6864 if (vp56_rac_get_prob_branchy(&s->c, 252))
965 734 s->prob.p.skip[i] = update_prob(&s->c, s->prob.p.skip[i]);
966
4/4
✓ Branch 0 taken 1821 times.
✓ Branch 1 taken 467 times.
✓ Branch 2 taken 1815 times.
✓ Branch 3 taken 6 times.
2288 if (!s->s.h.keyframe && !s->s.h.intraonly) {
967
2/2
✓ Branch 0 taken 12705 times.
✓ Branch 1 taken 1815 times.
14520 for (i = 0; i < 7; i++)
968
2/2
✓ Branch 0 taken 38115 times.
✓ Branch 1 taken 12705 times.
50820 for (j = 0; j < 3; j++)
969
2/2
✓ Branch 1 taken 313 times.
✓ Branch 2 taken 37802 times.
38115 if (vp56_rac_get_prob_branchy(&s->c, 252))
970 313 s->prob.p.mv_mode[i][j] =
971 313 update_prob(&s->c, s->prob.p.mv_mode[i][j]);
972
973
2/2
✓ Branch 0 taken 1321 times.
✓ Branch 1 taken 494 times.
1815 if (s->s.h.filtermode == FILTER_SWITCHABLE)
974
2/2
✓ Branch 0 taken 5284 times.
✓ Branch 1 taken 1321 times.
6605 for (i = 0; i < 4; i++)
975
2/2
✓ Branch 0 taken 10568 times.
✓ Branch 1 taken 5284 times.
15852 for (j = 0; j < 2; j++)
976
2/2
✓ Branch 1 taken 184 times.
✓ Branch 2 taken 10384 times.
10568 if (vp56_rac_get_prob_branchy(&s->c, 252))
977 184 s->prob.p.filter[i][j] =
978 184 update_prob(&s->c, s->prob.p.filter[i][j]);
979
980
2/2
✓ Branch 0 taken 7260 times.
✓ Branch 1 taken 1815 times.
9075 for (i = 0; i < 4; i++)
981
2/2
✓ Branch 1 taken 100 times.
✓ Branch 2 taken 7160 times.
7260 if (vp56_rac_get_prob_branchy(&s->c, 252))
982 100 s->prob.p.intra[i] = update_prob(&s->c, s->prob.p.intra[i]);
983
984
2/2
✓ Branch 0 taken 459 times.
✓ Branch 1 taken 1356 times.
1815 if (s->s.h.allowcompinter) {
985 459 s->s.h.comppredmode = vp8_rac_get(&s->c);
986
2/2
✓ Branch 0 taken 313 times.
✓ Branch 1 taken 146 times.
459 if (s->s.h.comppredmode)
987 313 s->s.h.comppredmode += vp8_rac_get(&s->c);
988
2/2
✓ Branch 0 taken 311 times.
✓ Branch 1 taken 148 times.
459 if (s->s.h.comppredmode == PRED_SWITCHABLE)
989
2/2
✓ Branch 0 taken 1555 times.
✓ Branch 1 taken 311 times.
1866 for (i = 0; i < 5; i++)
990
2/2
✓ Branch 1 taken 43 times.
✓ Branch 2 taken 1512 times.
1555 if (vp56_rac_get_prob_branchy(&s->c, 252))
991 43 s->prob.p.comp[i] =
992 43 update_prob(&s->c, s->prob.p.comp[i]);
993 } else {
994 1356 s->s.h.comppredmode = PRED_SINGLEREF;
995 }
996
997
2/2
✓ Branch 0 taken 1813 times.
✓ Branch 1 taken 2 times.
1815 if (s->s.h.comppredmode != PRED_COMPREF) {
998
2/2
✓ Branch 0 taken 9065 times.
✓ Branch 1 taken 1813 times.
10878 for (i = 0; i < 5; i++) {
999
2/2
✓ Branch 1 taken 319 times.
✓ Branch 2 taken 8746 times.
9065 if (vp56_rac_get_prob_branchy(&s->c, 252))
1000 319 s->prob.p.single_ref[i][0] =
1001 319 update_prob(&s->c, s->prob.p.single_ref[i][0]);
1002
2/2
✓ Branch 1 taken 53 times.
✓ Branch 2 taken 9012 times.
9065 if (vp56_rac_get_prob_branchy(&s->c, 252))
1003 53 s->prob.p.single_ref[i][1] =
1004 53 update_prob(&s->c, s->prob.p.single_ref[i][1]);
1005 }
1006 }
1007
1008
2/2
✓ Branch 0 taken 313 times.
✓ Branch 1 taken 1502 times.
1815 if (s->s.h.comppredmode != PRED_SINGLEREF) {
1009
2/2
✓ Branch 0 taken 1565 times.
✓ Branch 1 taken 313 times.
1878 for (i = 0; i < 5; i++)
1010
2/2
✓ Branch 1 taken 10 times.
✓ Branch 2 taken 1555 times.
1565 if (vp56_rac_get_prob_branchy(&s->c, 252))
1011 10 s->prob.p.comp_ref[i] =
1012 10 update_prob(&s->c, s->prob.p.comp_ref[i]);
1013 }
1014
1015
2/2
✓ Branch 0 taken 7260 times.
✓ Branch 1 taken 1815 times.
9075 for (i = 0; i < 4; i++)
1016
2/2
✓ Branch 0 taken 65340 times.
✓ Branch 1 taken 7260 times.
72600 for (j = 0; j < 9; j++)
1017
2/2
✓ Branch 1 taken 127 times.
✓ Branch 2 taken 65213 times.
65340 if (vp56_rac_get_prob_branchy(&s->c, 252))
1018 127 s->prob.p.y_mode[i][j] =
1019 127 update_prob(&s->c, s->prob.p.y_mode[i][j]);
1020
1021
2/2
✓ Branch 0 taken 7260 times.
✓ Branch 1 taken 1815 times.
9075 for (i = 0; i < 4; i++)
1022
2/2
✓ Branch 0 taken 29040 times.
✓ Branch 1 taken 7260 times.
36300 for (j = 0; j < 4; j++)
1023
2/2
✓ Branch 0 taken 87120 times.
✓ Branch 1 taken 29040 times.
116160 for (k = 0; k < 3; k++)
1024
2/2
✓ Branch 1 taken 257 times.
✓ Branch 2 taken 86863 times.
87120 if (vp56_rac_get_prob_branchy(&s->c, 252))
1025 257 s->prob.p.partition[3 - i][j][k] =
1026 257 update_prob(&s->c,
1027 257 s->prob.p.partition[3 - i][j][k]);
1028
1029 // mv fields don't use the update_prob subexp model for some reason
1030
2/2
✓ Branch 0 taken 5445 times.
✓ Branch 1 taken 1815 times.
7260 for (i = 0; i < 3; i++)
1031
2/2
✓ Branch 1 taken 259 times.
✓ Branch 2 taken 5186 times.
5445 if (vp56_rac_get_prob_branchy(&s->c, 252))
1032 259 s->prob.p.mv_joint[i] = (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1033
1034
2/2
✓ Branch 0 taken 3630 times.
✓ Branch 1 taken 1815 times.
5445 for (i = 0; i < 2; i++) {
1035
2/2
✓ Branch 1 taken 153 times.
✓ Branch 2 taken 3477 times.
3630 if (vp56_rac_get_prob_branchy(&s->c, 252))
1036 153 s->prob.p.mv_comp[i].sign =
1037 153 (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1038
1039
2/2
✓ Branch 0 taken 36300 times.
✓ Branch 1 taken 3630 times.
39930 for (j = 0; j < 10; j++)
1040
2/2
✓ Branch 1 taken 86 times.
✓ Branch 2 taken 36214 times.
36300 if (vp56_rac_get_prob_branchy(&s->c, 252))
1041 86 s->prob.p.mv_comp[i].classes[j] =
1042 86 (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1043
1044
2/2
✓ Branch 1 taken 86 times.
✓ Branch 2 taken 3544 times.
3630 if (vp56_rac_get_prob_branchy(&s->c, 252))
1045 86 s->prob.p.mv_comp[i].class0 =
1046 86 (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1047
1048
2/2
✓ Branch 0 taken 36300 times.
✓ Branch 1 taken 3630 times.
39930 for (j = 0; j < 10; j++)
1049
2/2
✓ Branch 1 taken 15 times.
✓ Branch 2 taken 36285 times.
36300 if (vp56_rac_get_prob_branchy(&s->c, 252))
1050 15 s->prob.p.mv_comp[i].bits[j] =
1051 15 (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1052 }
1053
1054
2/2
✓ Branch 0 taken 3630 times.
✓ Branch 1 taken 1815 times.
5445 for (i = 0; i < 2; i++) {
1055
2/2
✓ Branch 0 taken 7260 times.
✓ Branch 1 taken 3630 times.
10890 for (j = 0; j < 2; j++)
1056
2/2
✓ Branch 0 taken 21780 times.
✓ Branch 1 taken 7260 times.
29040 for (k = 0; k < 3; k++)
1057
2/2
✓ Branch 1 taken 209 times.
✓ Branch 2 taken 21571 times.
21780 if (vp56_rac_get_prob_branchy(&s->c, 252))
1058 209 s->prob.p.mv_comp[i].class0_fp[j][k] =
1059 209 (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1060
1061
2/2
✓ Branch 0 taken 10890 times.
✓ Branch 1 taken 3630 times.
14520 for (j = 0; j < 3; j++)
1062
2/2
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 10886 times.
10890 if (vp56_rac_get_prob_branchy(&s->c, 252))
1063 4 s->prob.p.mv_comp[i].fp[j] =
1064 4 (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1065 }
1066
1067
2/2
✓ Branch 0 taken 1417 times.
✓ Branch 1 taken 398 times.
1815 if (s->s.h.highprecisionmvs) {
1068
2/2
✓ Branch 0 taken 2834 times.
✓ Branch 1 taken 1417 times.
4251 for (i = 0; i < 2; i++) {
1069
2/2
✓ Branch 1 taken 86 times.
✓ Branch 2 taken 2748 times.
2834 if (vp56_rac_get_prob_branchy(&s->c, 252))
1070 86 s->prob.p.mv_comp[i].class0_hp =
1071 86 (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1072
1073
2/2
✓ Branch 1 taken 30 times.
✓ Branch 2 taken 2804 times.
2834 if (vp56_rac_get_prob_branchy(&s->c, 252))
1074 30 s->prob.p.mv_comp[i].hp =
1075 30 (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1076 }
1077 }
1078 }
1079
1080 2288 return (data2 - data) + size2;
1081 }
1082
1083 994296 static void decode_sb(VP9TileData *td, int row, int col, VP9Filter *lflvl,
1084 ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
1085 {
1086 994296 const VP9Context *s = td->s;
1087 994296 int c = ((s->above_partition_ctx[col] >> (3 - bl)) & 1) |
1088 994296 (((td->left_partition_ctx[row & 0x7] >> (3 - bl)) & 1) << 1);
1089
4/4
✓ Branch 0 taken 708188 times.
✓ Branch 1 taken 286108 times.
✓ Branch 2 taken 3150 times.
✓ Branch 3 taken 705038 times.
994296 const uint8_t *p = s->s.h.keyframe || s->s.h.intraonly ? ff_vp9_default_kf_partition_probs[bl][c] :
1090 s->prob.p.partition[bl][c];
1091 enum BlockPartition bp;
1092 994296 ptrdiff_t hbs = 4 >> bl;
1093 994296 AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
1094 994296 ptrdiff_t y_stride = f->linesize[0], uv_stride = f->linesize[1];
1095 994296 int bytesperpixel = s->bytesperpixel;
1096
1097
2/2
✓ Branch 0 taken 493574 times.
✓ Branch 1 taken 500722 times.
994296 if (bl == BL_8X8) {
1098 493574 bp = vp8_rac_get_tree(td->c, ff_vp9_partition_tree, p);
1099 493574 ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
1100
2/2
✓ Branch 0 taken 478451 times.
✓ Branch 1 taken 22271 times.
500722 } else if (col + hbs < s->cols) { // FIXME why not <=?
1101
2/2
✓ Branch 0 taken 464587 times.
✓ Branch 1 taken 13864 times.
478451 if (row + hbs < s->rows) { // FIXME why not <=?
1102 464587 bp = vp8_rac_get_tree(td->c, ff_vp9_partition_tree, p);
1103
4/5
✓ Branch 0 taken 191786 times.
✓ Branch 1 taken 28403 times.
✓ Branch 2 taken 22569 times.
✓ Branch 3 taken 221829 times.
✗ Branch 4 not taken.
464587 switch (bp) {
1104 191786 case PARTITION_NONE:
1105 191786 ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
1106 191786 break;
1107 28403 case PARTITION_H:
1108 28403 ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
1109 28403 yoff += hbs * 8 * y_stride;
1110 28403 uvoff += hbs * 8 * uv_stride >> s->ss_v;
1111 28403 ff_vp9_decode_block(td, row + hbs, col, lflvl, yoff, uvoff, bl, bp);
1112 28403 break;
1113 22569 case PARTITION_V:
1114 22569 ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
1115 22569 yoff += hbs * 8 * bytesperpixel;
1116 22569 uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
1117 22569 ff_vp9_decode_block(td, row, col + hbs, lflvl, yoff, uvoff, bl, bp);
1118 22569 break;
1119 221829 case PARTITION_SPLIT:
1120 221829 decode_sb(td, row, col, lflvl, yoff, uvoff, bl + 1);
1121 221829 decode_sb(td, row, col + hbs, lflvl,
1122 221829 yoff + 8 * hbs * bytesperpixel,
1123 221829 uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
1124 221829 yoff += hbs * 8 * y_stride;
1125 221829 uvoff += hbs * 8 * uv_stride >> s->ss_v;
1126 221829 decode_sb(td, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
1127 221829 decode_sb(td, row + hbs, col + hbs, lflvl,
1128 221829 yoff + 8 * hbs * bytesperpixel,
1129 221829 uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
1130 221829 break;
1131 default:
1132 av_assert0(0);
1133 }
1134
2/2
✓ Branch 1 taken 9981 times.
✓ Branch 2 taken 3883 times.
13864 } else if (vp56_rac_get_prob_branchy(td->c, p[1])) {
1135 9981 bp = PARTITION_SPLIT;
1136 9981 decode_sb(td, row, col, lflvl, yoff, uvoff, bl + 1);
1137 9981 decode_sb(td, row, col + hbs, lflvl,
1138 9981 yoff + 8 * hbs * bytesperpixel,
1139 9981 uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
1140 } else {
1141 3883 bp = PARTITION_H;
1142 3883 ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
1143 }
1144
2/2
✓ Branch 0 taken 19407 times.
✓ Branch 1 taken 2864 times.
22271 } else if (row + hbs < s->rows) { // FIXME why not <=?
1145
2/2
✓ Branch 1 taken 16239 times.
✓ Branch 2 taken 3168 times.
19407 if (vp56_rac_get_prob_branchy(td->c, p[2])) {
1146 16239 bp = PARTITION_SPLIT;
1147 16239 decode_sb(td, row, col, lflvl, yoff, uvoff, bl + 1);
1148 16239 yoff += hbs * 8 * y_stride;
1149 16239 uvoff += hbs * 8 * uv_stride >> s->ss_v;
1150 16239 decode_sb(td, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
1151 } else {
1152 3168 bp = PARTITION_V;
1153 3168 ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
1154 }
1155 } else {
1156 2864 bp = PARTITION_SPLIT;
1157 2864 decode_sb(td, row, col, lflvl, yoff, uvoff, bl + 1);
1158 }
1159 994296 td->counts.partition[bl][c][bp]++;
1160 994296 }
1161
1162 static void decode_sb_mem(VP9TileData *td, int row, int col, VP9Filter *lflvl,
1163 ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
1164 {
1165 const VP9Context *s = td->s;
1166 VP9Block *b = td->b;
1167 ptrdiff_t hbs = 4 >> bl;
1168 AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
1169 ptrdiff_t y_stride = f->linesize[0], uv_stride = f->linesize[1];
1170 int bytesperpixel = s->bytesperpixel;
1171
1172 if (bl == BL_8X8) {
1173 av_assert2(b->bl == BL_8X8);
1174 ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, b->bl, b->bp);
1175 } else if (td->b->bl == bl) {
1176 ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, b->bl, b->bp);
1177 if (b->bp == PARTITION_H && row + hbs < s->rows) {
1178 yoff += hbs * 8 * y_stride;
1179 uvoff += hbs * 8 * uv_stride >> s->ss_v;
1180 ff_vp9_decode_block(td, row + hbs, col, lflvl, yoff, uvoff, b->bl, b->bp);
1181 } else if (b->bp == PARTITION_V && col + hbs < s->cols) {
1182 yoff += hbs * 8 * bytesperpixel;
1183 uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
1184 ff_vp9_decode_block(td, row, col + hbs, lflvl, yoff, uvoff, b->bl, b->bp);
1185 }
1186 } else {
1187 decode_sb_mem(td, row, col, lflvl, yoff, uvoff, bl + 1);
1188 if (col + hbs < s->cols) { // FIXME why not <=?
1189 if (row + hbs < s->rows) {
1190 decode_sb_mem(td, row, col + hbs, lflvl, yoff + 8 * hbs * bytesperpixel,
1191 uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
1192 yoff += hbs * 8 * y_stride;
1193 uvoff += hbs * 8 * uv_stride >> s->ss_v;
1194 decode_sb_mem(td, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
1195 decode_sb_mem(td, row + hbs, col + hbs, lflvl,
1196 yoff + 8 * hbs * bytesperpixel,
1197 uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
1198 } else {
1199 yoff += hbs * 8 * bytesperpixel;
1200 uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
1201 decode_sb_mem(td, row, col + hbs, lflvl, yoff, uvoff, bl + 1);
1202 }
1203 } else if (row + hbs < s->rows) {
1204 yoff += hbs * 8 * y_stride;
1205 uvoff += hbs * 8 * uv_stride >> s->ss_v;
1206 decode_sb_mem(td, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
1207 }
1208 }
1209 }
1210
1211 10642 static void set_tile_offset(int *start, int *end, int idx, int log2_n, int n)
1212 {
1213 10642 int sb_start = ( idx * n) >> log2_n;
1214 10642 int sb_end = ((idx + 1) * n) >> log2_n;
1215 10642 *start = FFMIN(sb_start, n) << 3;
1216 10642 *end = FFMIN(sb_end, n) << 3;
1217 10642 }
1218
1219 469 static void free_buffers(VP9Context *s)
1220 {
1221 int i;
1222
1223 469 av_freep(&s->intra_pred_data[0]);
1224
2/2
✓ Branch 0 taken 467 times.
✓ Branch 1 taken 469 times.
936 for (i = 0; i < s->active_tile_cols; i++)
1225 467 vp9_tile_data_free(&s->td[i]);
1226 469 }
1227
1228 469 static av_cold int vp9_decode_free(AVCodecContext *avctx)
1229 {
1230 469 VP9Context *s = avctx->priv_data;
1231 int i;
1232
1233
2/2
✓ Branch 0 taken 1407 times.
✓ Branch 1 taken 469 times.
1876 for (i = 0; i < 3; i++) {
1234 1407 vp9_frame_unref(avctx, &s->s.frames[i]);
1235 1407 av_frame_free(&s->s.frames[i].tf.f);
1236 }
1237 469 av_buffer_pool_uninit(&s->frame_extradata_pool);
1238
2/2
✓ Branch 0 taken 3752 times.
✓ Branch 1 taken 469 times.
4221 for (i = 0; i < 8; i++) {
1239 3752 ff_thread_release_buffer(avctx, &s->s.refs[i]);
1240 3752 av_frame_free(&s->s.refs[i].f);
1241 3752 ff_thread_release_buffer(avctx, &s->next_refs[i]);
1242 3752 av_frame_free(&s->next_refs[i].f);
1243 }
1244
1245 469 free_buffers(s);
1246 #if HAVE_THREADS
1247 469 av_freep(&s->entries);
1248 469 ff_pthread_free(s, vp9_context_offsets);
1249 #endif
1250 469 av_freep(&s->td);
1251 469 return 0;
1252 }
1253
1254 2288 static int decode_tiles(AVCodecContext *avctx,
1255 const uint8_t *data, int size)
1256 {
1257 2288 VP9Context *s = avctx->priv_data;
1258 2288 VP9TileData *td = &s->td[0];
1259 int row, col, tile_row, tile_col, ret;
1260 int bytesperpixel;
1261 int tile_row_start, tile_row_end, tile_col_start, tile_col_end;
1262 AVFrame *f;
1263 ptrdiff_t yoff, uvoff, ls_y, ls_uv;
1264
1265 2288 f = s->s.frames[CUR_FRAME].tf.f;
1266 2288 ls_y = f->linesize[0];
1267 2288 ls_uv =f->linesize[1];
1268 2288 bytesperpixel = s->bytesperpixel;
1269
1270 2288 yoff = uvoff = 0;
1271
2/2
✓ Branch 0 taken 2292 times.
✓ Branch 1 taken 2288 times.
4580 for (tile_row = 0; tile_row < s->s.h.tiling.tile_rows; tile_row++) {
1272 2292 set_tile_offset(&tile_row_start, &tile_row_end,
1273 2292 tile_row, s->s.h.tiling.log2_tile_rows, s->sb_rows);
1274
1275
2/2
✓ Branch 0 taken 2318 times.
✓ Branch 1 taken 2292 times.
4610 for (tile_col = 0; tile_col < s->s.h.tiling.tile_cols; tile_col++) {
1276 int64_t tile_size;
1277
1278
2/2
✓ Branch 0 taken 2292 times.
✓ Branch 1 taken 26 times.
2318 if (tile_col == s->s.h.tiling.tile_cols - 1 &&
1279
2/2
✓ Branch 0 taken 2288 times.
✓ Branch 1 taken 4 times.
2292 tile_row == s->s.h.tiling.tile_rows - 1) {
1280 2288 tile_size = size;
1281 } else {
1282 30 tile_size = AV_RB32(data);
1283 30 data += 4;
1284 30 size -= 4;
1285 }
1286
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2318 times.
2318 if (tile_size > size) {
1287 ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, INT_MAX, 0);
1288 return AVERROR_INVALIDDATA;
1289 }
1290 2318 ret = ff_vp56_init_range_decoder(&td->c_b[tile_col], data, tile_size);
1291
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2318 times.
2318 if (ret < 0)
1292 return ret;
1293
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2318 times.
2318 if (vp56_rac_get_prob_branchy(&td->c_b[tile_col], 128)) { // marker bit
1294 ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, INT_MAX, 0);
1295 return AVERROR_INVALIDDATA;
1296 }
1297 2318 data += tile_size;
1298 2318 size -= tile_size;
1299 }
1300
1301
2/2
✓ Branch 0 taken 8066 times.
✓ Branch 1 taken 2292 times.
10358 for (row = tile_row_start; row < tile_row_end;
1302 8066 row += 8, yoff += ls_y * 64, uvoff += ls_uv * 64 >> s->ss_v) {
1303 8066 VP9Filter *lflvl_ptr = s->lflvl;
1304 8066 ptrdiff_t yoff2 = yoff, uvoff2 = uvoff;
1305
1306
2/2
✓ Branch 0 taken 8350 times.
✓ Branch 1 taken 8066 times.
16416 for (tile_col = 0; tile_col < s->s.h.tiling.tile_cols; tile_col++) {
1307 8350 set_tile_offset(&tile_col_start, &tile_col_end,
1308 8350 tile_col, s->s.h.tiling.log2_tile_cols, s->sb_cols);
1309 8350 td->tile_col_start = tile_col_start;
1310
1/2
✓ Branch 0 taken 8350 times.
✗ Branch 1 not taken.
8350 if (s->pass != 2) {
1311 8350 memset(td->left_partition_ctx, 0, 8);
1312 8350 memset(td->left_skip_ctx, 0, 8);
1313
4/4
✓ Branch 0 taken 6546 times.
✓ Branch 1 taken 1804 times.
✓ Branch 2 taken 30 times.
✓ Branch 3 taken 6516 times.
8350 if (s->s.h.keyframe || s->s.h.intraonly) {
1314 1834 memset(td->left_mode_ctx, DC_PRED, 16);
1315 } else {
1316 6516 memset(td->left_mode_ctx, NEARESTMV, 8);
1317 }
1318 8350 memset(td->left_y_nnz_ctx, 0, 16);
1319 8350 memset(td->left_uv_nnz_ctx, 0, 32);
1320 8350 memset(td->left_segpred_ctx, 0, 8);
1321
1322 8350 td->c = &td->c_b[tile_col];
1323 }
1324
1325 8350 for (col = tile_col_start;
1326
2/2
✓ Branch 0 taken 51676 times.
✓ Branch 1 taken 8350 times.
60026 col < tile_col_end;
1327 51676 col += 8, yoff2 += 64 * bytesperpixel,
1328 51676 uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
1329 // FIXME integrate with lf code (i.e. zero after each
1330 // use, similar to invtxfm coefficients, or similar)
1331
1/2
✓ Branch 0 taken 51676 times.
✗ Branch 1 not taken.
51676 if (s->pass != 1) {
1332 51676 memset(lflvl_ptr->mask, 0, sizeof(lflvl_ptr->mask));
1333 }
1334
1335
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 51676 times.
51676 if (s->pass == 2) {
1336 decode_sb_mem(td, row, col, lflvl_ptr,
1337 yoff2, uvoff2, BL_64X64);
1338 } else {
1339
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 51676 times.
51676 if (vpX_rac_is_end(td->c)) {
1340 return AVERROR_INVALIDDATA;
1341 }
1342 51676 decode_sb(td, row, col, lflvl_ptr,
1343 yoff2, uvoff2, BL_64X64);
1344 }
1345 }
1346 }
1347
1348
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8066 times.
8066 if (s->pass == 1)
1349 continue;
1350
1351 // backup pre-loopfilter reconstruction data for intra
1352 // prediction of next row of sb64s
1353
2/2
✓ Branch 0 taken 5778 times.
✓ Branch 1 taken 2288 times.
8066 if (row + 8 < s->rows) {
1354 5778 memcpy(s->intra_pred_data[0],
1355 5778 f->data[0] + yoff + 63 * ls_y,
1356 5778 8 * s->cols * bytesperpixel);
1357 5778 memcpy(s->intra_pred_data[1],
1358 5778 f->data[1] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
1359 5778 8 * s->cols * bytesperpixel >> s->ss_h);
1360 5778 memcpy(s->intra_pred_data[2],
1361 5778 f->data[2] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
1362 5778 8 * s->cols * bytesperpixel >> s->ss_h);
1363 }
1364
1365 // loopfilter one row
1366
2/2
✓ Branch 0 taken 7520 times.
✓ Branch 1 taken 546 times.
8066 if (s->s.h.filter.level) {
1367 7520 yoff2 = yoff;
1368 7520 uvoff2 = uvoff;
1369 7520 lflvl_ptr = s->lflvl;
1370
2/2
✓ Branch 0 taken 48236 times.
✓ Branch 1 taken 7520 times.
55756 for (col = 0; col < s->cols;
1371 48236 col += 8, yoff2 += 64 * bytesperpixel,
1372 48236 uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
1373 48236 ff_vp9_loopfilter_sb(avctx, lflvl_ptr, row, col,
1374 yoff2, uvoff2);
1375 }
1376 }
1377
1378 // FIXME maybe we can make this more finegrained by running the
1379 // loopfilter per-block instead of after each sbrow
1380 // In fact that would also make intra pred left preparation easier?
1381 8066 ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, row >> 3, 0);
1382 }
1383 }
1384 2288 return 0;
1385 }
1386
1387 #if HAVE_THREADS
1388 static av_always_inline
1389 int decode_tiles_mt(AVCodecContext *avctx, void *tdata, int jobnr,
1390 int threadnr)
1391 {
1392 VP9Context *s = avctx->priv_data;
1393 VP9TileData *td = &s->td[jobnr];
1394 ptrdiff_t uvoff, yoff, ls_y, ls_uv;
1395 int bytesperpixel = s->bytesperpixel, row, col, tile_row;
1396 unsigned tile_cols_len;
1397 int tile_row_start, tile_row_end, tile_col_start, tile_col_end;
1398 VP9Filter *lflvl_ptr_base;
1399 AVFrame *f;
1400
1401 f = s->s.frames[CUR_FRAME].tf.f;
1402 ls_y = f->linesize[0];
1403 ls_uv =f->linesize[1];
1404
1405 set_tile_offset(&tile_col_start, &tile_col_end,
1406 jobnr, s->s.h.tiling.log2_tile_cols, s->sb_cols);
1407 td->tile_col_start = tile_col_start;
1408 uvoff = (64 * bytesperpixel >> s->ss_h)*(tile_col_start >> 3);
1409 yoff = (64 * bytesperpixel)*(tile_col_start >> 3);
1410 lflvl_ptr_base = s->lflvl+(tile_col_start >> 3);
1411
1412 for (tile_row = 0; tile_row < s->s.h.tiling.tile_rows; tile_row++) {
1413 set_tile_offset(&tile_row_start, &tile_row_end,
1414 tile_row, s->s.h.tiling.log2_tile_rows, s->sb_rows);
1415
1416 td->c = &td->c_b[tile_row];
1417 for (row = tile_row_start; row < tile_row_end;
1418 row += 8, yoff += ls_y * 64, uvoff += ls_uv * 64 >> s->ss_v) {
1419 ptrdiff_t yoff2 = yoff, uvoff2 = uvoff;
1420 VP9Filter *lflvl_ptr = lflvl_ptr_base+s->sb_cols*(row >> 3);
1421
1422 memset(td->left_partition_ctx, 0, 8);
1423 memset(td->left_skip_ctx, 0, 8);
1424 if (s->s.h.keyframe || s->s.h.intraonly) {
1425 memset(td->left_mode_ctx, DC_PRED, 16);
1426 } else {
1427 memset(td->left_mode_ctx, NEARESTMV, 8);
1428 }
1429 memset(td->left_y_nnz_ctx, 0, 16);
1430 memset(td->left_uv_nnz_ctx, 0, 32);
1431 memset(td->left_segpred_ctx, 0, 8);
1432
1433 for (col = tile_col_start;
1434 col < tile_col_end;
1435 col += 8, yoff2 += 64 * bytesperpixel,
1436 uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
1437 // FIXME integrate with lf code (i.e. zero after each
1438 // use, similar to invtxfm coefficients, or similar)
1439 memset(lflvl_ptr->mask, 0, sizeof(lflvl_ptr->mask));
1440 decode_sb(td, row, col, lflvl_ptr,
1441 yoff2, uvoff2, BL_64X64);
1442 }
1443
1444 // backup pre-loopfilter reconstruction data for intra
1445 // prediction of next row of sb64s
1446 tile_cols_len = tile_col_end - tile_col_start;
1447 if (row + 8 < s->rows) {
1448 memcpy(s->intra_pred_data[0] + (tile_col_start * 8 * bytesperpixel),
1449 f->data[0] + yoff + 63 * ls_y,
1450 8 * tile_cols_len * bytesperpixel);
1451 memcpy(s->intra_pred_data[1] + (tile_col_start * 8 * bytesperpixel >> s->ss_h),
1452 f->data[1] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
1453 8 * tile_cols_len * bytesperpixel >> s->ss_h);
1454 memcpy(s->intra_pred_data[2] + (tile_col_start * 8 * bytesperpixel >> s->ss_h),
1455 f->data[2] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
1456 8 * tile_cols_len * bytesperpixel >> s->ss_h);
1457 }
1458
1459 vp9_report_tile_progress(s, row >> 3, 1);
1460 }
1461 }
1462 return 0;
1463 }
1464
1465 static av_always_inline
1466 int loopfilter_proc(AVCodecContext *avctx)
1467 {
1468 VP9Context *s = avctx->priv_data;
1469 ptrdiff_t uvoff, yoff, ls_y, ls_uv;
1470 VP9Filter *lflvl_ptr;
1471 int bytesperpixel = s->bytesperpixel, col, i;
1472 AVFrame *f;
1473
1474 f = s->s.frames[CUR_FRAME].tf.f;
1475 ls_y = f->linesize[0];
1476 ls_uv =f->linesize[1];
1477
1478 for (i = 0; i < s->sb_rows; i++) {
1479 vp9_await_tile_progress(s, i, s->s.h.tiling.tile_cols);
1480
1481 if (s->s.h.filter.level) {
1482 yoff = (ls_y * 64)*i;
1483 uvoff = (ls_uv * 64 >> s->ss_v)*i;
1484 lflvl_ptr = s->lflvl+s->sb_cols*i;
1485 for (col = 0; col < s->cols;
1486 col += 8, yoff += 64 * bytesperpixel,
1487 uvoff += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
1488 ff_vp9_loopfilter_sb(avctx, lflvl_ptr, i << 3, col,
1489 yoff, uvoff);
1490 }
1491 }
1492 }
1493 return 0;
1494 }
1495 #endif
1496
1497 6 static int vp9_export_enc_params(VP9Context *s, VP9Frame *frame)
1498 {
1499 AVVideoEncParams *par;
1500 6 unsigned int tile, nb_blocks = 0;
1501
1502
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
6 if (s->s.h.segmentation.enabled) {
1503
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 6 times.
12 for (tile = 0; tile < s->active_tile_cols; tile++)
1504 6 nb_blocks += s->td[tile].nb_block_structure;
1505 }
1506
1507 6 par = av_video_enc_params_create_side_data(frame->tf.f,
1508 AV_VIDEO_ENC_PARAMS_VP9, nb_blocks);
1509
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
6 if (!par)
1510 return AVERROR(ENOMEM);
1511
1512 6 par->qp = s->s.h.yac_qi;
1513 6 par->delta_qp[0][0] = s->s.h.ydc_qdelta;
1514 6 par->delta_qp[1][0] = s->s.h.uvdc_qdelta;
1515 6 par->delta_qp[2][0] = s->s.h.uvdc_qdelta;
1516 6 par->delta_qp[1][1] = s->s.h.uvac_qdelta;
1517 6 par->delta_qp[2][1] = s->s.h.uvac_qdelta;
1518
1519
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
6 if (nb_blocks) {
1520 6 unsigned int block = 0;
1521 unsigned int tile, block_tile;
1522
1523
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 6 times.
12 for (tile = 0; tile < s->active_tile_cols; tile++) {
1524 6 VP9TileData *td = &s->td[tile];
1525
1526
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++) {
1527 1204 AVVideoBlockParams *b = av_video_enc_params_block(par, block++);
1528 1204 unsigned int row = td->block_structure[block_tile].row;
1529 1204 unsigned int col = td->block_structure[block_tile].col;
1530 1204 uint8_t seg_id = frame->segmentation_map[row * 8 * s->sb_cols + col];
1531
1532 1204 b->src_x = col * 8;
1533 1204 b->src_y = row * 8;
1534 1204 b->w = 1 << (3 + td->block_structure[block_tile].block_size_idx_x);
1535 1204 b->h = 1 << (3 + td->block_structure[block_tile].block_size_idx_y);
1536
1537
2/2
✓ Branch 0 taken 977 times.
✓ Branch 1 taken 227 times.
1204 if (s->s.h.segmentation.feat[seg_id].q_enabled) {
1538 977 b->delta_qp = s->s.h.segmentation.feat[seg_id].q_val;
1539
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 977 times.
977 if (s->s.h.segmentation.absolute_vals)
1540 b->delta_qp -= par->qp;
1541 }
1542 }
1543 }
1544 }
1545
1546 6 return 0;
1547 }
1548
1549 2307 static int vp9_decode_frame(AVCodecContext *avctx, void *frame,
1550 int *got_frame, AVPacket *pkt)
1551 {
1552 2307 const uint8_t *data = pkt->data;
1553 2307 int size = pkt->size;
1554 2307 VP9Context *s = avctx->priv_data;
1555 int ret, i, j, ref;
1556
2/2
✓ Branch 0 taken 1596 times.
✓ Branch 1 taken 711 times.
3903 int retain_segmap_ref = s->s.frames[REF_FRAME_SEGMAP].segmentation_map &&
1557
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);
1558 AVFrame *f;
1559
1560
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2307 times.
2307 if ((ret = decode_frame_header(avctx, data, size, &ref)) < 0) {
1561 return ret;
1562
2/2
✓ Branch 0 taken 19 times.
✓ Branch 1 taken 2288 times.
2307 } else if (ret == 0) {
1563
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19 times.
19 if (!s->s.refs[ref].f->buf[0]) {
1564 av_log(avctx, AV_LOG_ERROR, "Requested reference %d not available\n", ref);
1565 return AVERROR_INVALIDDATA;
1566 }
1567
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 19 times.
19 if ((ret = av_frame_ref(frame, s->s.refs[ref].f)) < 0)
1568 return ret;
1569 19 ((AVFrame *)frame)->pts = pkt->pts;
1570 19 ((AVFrame *)frame)->pkt_dts = pkt->dts;
1571
2/2
✓ Branch 0 taken 152 times.
✓ Branch 1 taken 19 times.
171 for (i = 0; i < 8; i++) {
1572
2/2
✓ Branch 0 taken 143 times.
✓ Branch 1 taken 9 times.
152 if (s->next_refs[i].f->buf[0])
1573 143 ff_thread_release_buffer(avctx, &s->next_refs[i]);
1574
3/4
✓ Branch 0 taken 143 times.
✓ Branch 1 taken 9 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 143 times.
295 if (s->s.refs[i].f->buf[0] &&
1575 143 (ret = ff_thread_ref_frame(&s->next_refs[i], &s->s.refs[i])) < 0)
1576 return ret;
1577 }
1578 19 *got_frame = 1;
1579 19 return pkt->size;
1580 }
1581 2288 data += ret;
1582 2288 size -= ret;
1583
1584
4/6
✓ Branch 0 taken 1528 times.
✓ Branch 1 taken 760 times.
✓ Branch 2 taken 1528 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 1528 times.
2288 if (!retain_segmap_ref || s->s.h.keyframe || s->s.h.intraonly) {
1585
2/2
✓ Branch 0 taken 49 times.
✓ Branch 1 taken 711 times.
760 if (s->s.frames[REF_FRAME_SEGMAP].tf.f->buf[0])
1586 49 vp9_frame_unref(avctx, &s->s.frames[REF_FRAME_SEGMAP]);
1587
8/10
✓ Branch 0 taken 293 times.
✓ Branch 1 taken 467 times.
✓ Branch 2 taken 287 times.
✓ Branch 3 taken 6 times.
✓ Branch 4 taken 278 times.
✓ Branch 5 taken 9 times.
✓ Branch 6 taken 278 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✓ Branch 9 taken 278 times.
1038 if (!s->s.h.keyframe && !s->s.h.intraonly && !s->s.h.errorres && s->s.frames[CUR_FRAME].tf.f->buf[0] &&
1588 278 (ret = vp9_frame_ref(avctx, &s->s.frames[REF_FRAME_SEGMAP], &s->s.frames[CUR_FRAME])) < 0)
1589 return ret;
1590 }
1591
2/2
✓ Branch 0 taken 1579 times.
✓ Branch 1 taken 709 times.
2288 if (s->s.frames[REF_FRAME_MVPAIR].tf.f->buf[0])
1592 1579 vp9_frame_unref(avctx, &s->s.frames[REF_FRAME_MVPAIR]);
1593
8/10
✓ Branch 0 taken 2282 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 1815 times.
✓ Branch 3 taken 467 times.
✓ Branch 4 taken 1806 times.
✓ Branch 5 taken 9 times.
✓ Branch 6 taken 1806 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✓ Branch 9 taken 1806 times.
4094 if (!s->s.h.intraonly && !s->s.h.keyframe && !s->s.h.errorres && s->s.frames[CUR_FRAME].tf.f->buf[0] &&
1594 1806 (ret = vp9_frame_ref(avctx, &s->s.frames[REF_FRAME_MVPAIR], &s->s.frames[CUR_FRAME])) < 0)
1595 return ret;
1596
2/2
✓ Branch 0 taken 1821 times.
✓ Branch 1 taken 467 times.
2288 if (s->s.frames[CUR_FRAME].tf.f->buf[0])
1597 1821 vp9_frame_unref(avctx, &s->s.frames[CUR_FRAME]);
1598
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2288 times.
2288 if ((ret = vp9_frame_alloc(avctx, &s->s.frames[CUR_FRAME])) < 0)
1599 return ret;
1600 2288 f = s->s.frames[CUR_FRAME].tf.f;
1601 2288 f->key_frame = s->s.h.keyframe;
1602
4/4
✓ Branch 0 taken 1821 times.
✓ Branch 1 taken 467 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 1815 times.
2288 f->pict_type = (s->s.h.keyframe || s->s.h.intraonly) ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
1603
1604
2/2
✓ Branch 0 taken 1806 times.
✓ Branch 1 taken 482 times.
2288 if (s->s.frames[REF_FRAME_SEGMAP].tf.f->buf[0] &&
1605
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 ||
1606
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)) {
1607 2 vp9_frame_unref(avctx, &s->s.frames[REF_FRAME_SEGMAP]);
1608 }
1609
1610 // ref frame setup
1611
2/2
✓ Branch 0 taken 18304 times.
✓ Branch 1 taken 2288 times.
20592 for (i = 0; i < 8; i++) {
1612
2/2
✓ Branch 0 taken 14522 times.
✓ Branch 1 taken 3782 times.
18304 if (s->next_refs[i].f->buf[0])
1613 14522 ff_thread_release_buffer(avctx, &s->next_refs[i]);
1614
2/2
✓ Branch 0 taken 5584 times.
✓ Branch 1 taken 12720 times.
18304 if (s->s.h.refreshrefmask & (1 << i)) {
1615 5584 ret = ff_thread_ref_frame(&s->next_refs[i], &s->s.frames[CUR_FRAME].tf);
1616
2/2
✓ Branch 0 taken 12667 times.
✓ Branch 1 taken 53 times.
12720 } else if (s->s.refs[i].f->buf[0]) {
1617 12667 ret = ff_thread_ref_frame(&s->next_refs[i], &s->s.refs[i]);
1618 }
1619
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 18304 times.
18304 if (ret < 0)
1620 return ret;
1621 }
1622
1623
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2288 times.
2288 if (avctx->hwaccel) {
1624 ret = avctx->hwaccel->start_frame(avctx, NULL, 0);
1625 if (ret < 0)
1626 return ret;
1627 ret = avctx->hwaccel->decode_slice(avctx, pkt->data, pkt->size);
1628 if (ret < 0)
1629 return ret;
1630 ret = avctx->hwaccel->end_frame(avctx);
1631 if (ret < 0)
1632 return ret;
1633 goto finish;
1634 }
1635
1636 // main tile decode loop
1637 2288 memset(s->above_partition_ctx, 0, s->cols);
1638 2288 memset(s->above_skip_ctx, 0, s->cols);
1639
4/4
✓ Branch 0 taken 1821 times.
✓ Branch 1 taken 467 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 1815 times.
2288 if (s->s.h.keyframe || s->s.h.intraonly) {
1640 473 memset(s->above_mode_ctx, DC_PRED, s->cols * 2);
1641 } else {
1642 1815 memset(s->above_mode_ctx, NEARESTMV, s->cols);
1643 }
1644 2288 memset(s->above_y_nnz_ctx, 0, s->sb_cols * 16);
1645 2288 memset(s->above_uv_nnz_ctx[0], 0, s->sb_cols * 16 >> s->ss_h);
1646 2288 memset(s->above_uv_nnz_ctx[1], 0, s->sb_cols * 16 >> s->ss_h);
1647 2288 memset(s->above_segpred_ctx, 0, s->cols);
1648 2288 s->pass = s->s.frames[CUR_FRAME].uses_2pass =
1649
1/6
✗ Branch 0 not taken.
✓ Branch 1 taken 2288 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
2288 avctx->active_thread_type == FF_THREAD_FRAME && s->s.h.refreshctx && !s->s.h.parallelmode;
1650
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2288 times.
2288 if ((ret = update_block_buffers(avctx)) < 0) {
1651 av_log(avctx, AV_LOG_ERROR,
1652 "Failed to allocate block buffers\n");
1653 return ret;
1654 }
1655
4/4
✓ Branch 0 taken 2277 times.
✓ Branch 1 taken 11 times.
✓ Branch 2 taken 33 times.
✓ Branch 3 taken 2244 times.
2321 if (s->s.h.refreshctx && s->s.h.parallelmode) {
1656 int j, k, l, m;
1657
1658
2/2
✓ Branch 0 taken 90 times.
✓ Branch 1 taken 7 times.
97 for (i = 0; i < 4; i++) {
1659
2/2
✓ Branch 0 taken 180 times.
✓ Branch 1 taken 90 times.
270 for (j = 0; j < 2; j++)
1660
2/2
✓ Branch 0 taken 360 times.
✓ Branch 1 taken 180 times.
540 for (k = 0; k < 2; k++)
1661
2/2
✓ Branch 0 taken 2160 times.
✓ Branch 1 taken 360 times.
2520 for (l = 0; l < 6; l++)
1662
2/2
✓ Branch 0 taken 12960 times.
✓ Branch 1 taken 2160 times.
15120 for (m = 0; m < 6; m++)
1663 12960 memcpy(s->prob_ctx[s->s.h.framectxid].coef[i][j][k][l][m],
1664 12960 s->prob.coef[i][j][k][l][m], 3);
1665
2/2
✓ Branch 0 taken 26 times.
✓ Branch 1 taken 64 times.
90 if (s->s.h.txfmmode == i)
1666 26 break;
1667 }
1668 33 s->prob_ctx[s->s.h.framectxid].p = s->prob.p;
1669 33 ff_thread_finish_setup(avctx);
1670
2/2
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 2244 times.
2255 } else if (!s->s.h.refreshctx) {
1671 11 ff_thread_finish_setup(avctx);
1672 }
1673
1674 #if HAVE_THREADS
1675
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2288 times.
2288 if (avctx->active_thread_type & FF_THREAD_SLICE) {
1676 for (i = 0; i < s->sb_rows; i++)
1677 atomic_store(&s->entries[i], 0);
1678 }
1679 #endif
1680
1681 do {
1682
2/2
✓ Branch 0 taken 2288 times.
✓ Branch 1 taken 2288 times.
4576 for (i = 0; i < s->active_tile_cols; i++) {
1683 2288 s->td[i].b = s->td[i].b_base;
1684 2288 s->td[i].block = s->td[i].block_base;
1685 2288 s->td[i].uvblock[0] = s->td[i].uvblock_base[0];
1686 2288 s->td[i].uvblock[1] = s->td[i].uvblock_base[1];
1687 2288 s->td[i].eob = s->td[i].eob_base;
1688 2288 s->td[i].uveob[0] = s->td[i].uveob_base[0];
1689 2288 s->td[i].uveob[1] = s->td[i].uveob_base[1];
1690 2288 s->td[i].error_info = 0;
1691 }
1692
1693 #if HAVE_THREADS
1694
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2288 times.
2288 if (avctx->active_thread_type == FF_THREAD_SLICE) {
1695 int tile_row, tile_col;
1696
1697 av_assert1(!s->pass);
1698
1699 for (tile_row = 0; tile_row < s->s.h.tiling.tile_rows; tile_row++) {
1700 for (tile_col = 0; tile_col < s->s.h.tiling.tile_cols; tile_col++) {
1701 int64_t tile_size;
1702
1703 if (tile_col == s->s.h.tiling.tile_cols - 1 &&
1704 tile_row == s->s.h.tiling.tile_rows - 1) {
1705 tile_size = size;
1706 } else {
1707 tile_size = AV_RB32(data);
1708 data += 4;
1709 size -= 4;
1710 }
1711 if (tile_size > size)
1712 return AVERROR_INVALIDDATA;
1713 ret = ff_vp56_init_range_decoder(&s->td[tile_col].c_b[tile_row], data, tile_size);
1714 if (ret < 0)
1715 return ret;
1716 if (vp56_rac_get_prob_branchy(&s->td[tile_col].c_b[tile_row], 128)) // marker bit
1717 return AVERROR_INVALIDDATA;
1718 data += tile_size;
1719 size -= tile_size;
1720 }
1721 }
1722
1723 ff_slice_thread_execute_with_mainfunc(avctx, decode_tiles_mt, loopfilter_proc, s->td, NULL, s->s.h.tiling.tile_cols);
1724 } else
1725 #endif
1726 {
1727 2288 ret = decode_tiles(avctx, data, size);
1728
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2288 times.
2288 if (ret < 0) {
1729 ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, INT_MAX, 0);
1730 return ret;
1731 }
1732 }
1733
1734 // Sum all counts fields into td[0].counts for tile threading
1735
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2288 times.
2288 if (avctx->active_thread_type == FF_THREAD_SLICE)
1736 for (i = 1; i < s->s.h.tiling.tile_cols; i++)
1737 for (j = 0; j < sizeof(s->td[i].counts) / sizeof(unsigned); j++)
1738 ((unsigned *)&s->td[0].counts)[j] += ((unsigned *)&s->td[i].counts)[j];
1739
1740
5/6
✓ Branch 0 taken 2288 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2277 times.
✓ Branch 3 taken 11 times.
✓ Branch 4 taken 2244 times.
✓ Branch 5 taken 33 times.
2288 if (s->pass < 2 && s->s.h.refreshctx && !s->s.h.parallelmode) {
1741 2244 ff_vp9_adapt_probs(s);
1742 2244 ff_thread_finish_setup(avctx);
1743 }
1744
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2288 times.
2288 } while (s->pass++ == 1);
1745 2288 ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, INT_MAX, 0);
1746
1747
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2288 times.
2288 if (s->td->error_info < 0) {
1748 av_log(avctx, AV_LOG_ERROR, "Failed to decode tile data\n");
1749 s->td->error_info = 0;
1750 return AVERROR_INVALIDDATA;
1751 }
1752
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 2282 times.
2288 if (avctx->export_side_data & AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS) {
1753 6 ret = vp9_export_enc_params(s, &s->s.frames[CUR_FRAME]);
1754
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
6 if (ret < 0)
1755 return ret;
1756 }
1757
1758 2288 finish:
1759 // ref frame setup
1760
2/2
✓ Branch 0 taken 18304 times.
✓ Branch 1 taken 2288 times.
20592 for (i = 0; i < 8; i++) {
1761
2/2
✓ Branch 0 taken 14522 times.
✓ Branch 1 taken 3782 times.
18304 if (s->s.refs[i].f->buf[0])
1762 14522 ff_thread_release_buffer(avctx, &s->s.refs[i]);
1763
3/4
✓ Branch 0 taken 18251 times.
✓ Branch 1 taken 53 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 18251 times.
36555 if (s->next_refs[i].f->buf[0] &&
1764 18251 (ret = ff_thread_ref_frame(&s->s.refs[i], &s->next_refs[i])) < 0)
1765 return ret;
1766 }
1767
1768
2/2
✓ Branch 0 taken 2223 times.
✓ Branch 1 taken 65 times.
2288 if (!s->s.h.invisible) {
1769
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2223 times.
2223 if ((ret = av_frame_ref(frame, s->s.frames[CUR_FRAME].tf.f)) < 0)
1770 return ret;
1771 2223 *got_frame = 1;
1772 }
1773
1774 2288 return pkt->size;
1775 }
1776
1777 static void vp9_decode_flush(AVCodecContext *avctx)
1778 {
1779 VP9Context *s = avctx->priv_data;
1780 int i;
1781
1782 for (i = 0; i < 3; i++)
1783 vp9_frame_unref(avctx, &s->s.frames[i]);
1784 for (i = 0; i < 8; i++)
1785 ff_thread_release_buffer(avctx, &s->s.refs[i]);
1786 }
1787
1788 469 static av_cold int vp9_decode_init(AVCodecContext *avctx)
1789 {
1790 469 VP9Context *s = avctx->priv_data;
1791 int ret;
1792
1793 469 s->last_bpp = 0;
1794 469 s->s.h.filter.sharpness = -1;
1795
1796 #if HAVE_THREADS
1797
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 469 times.
469 if (avctx->active_thread_type & FF_THREAD_SLICE) {
1798 ret = ff_pthread_init(s, vp9_context_offsets);
1799 if (ret < 0)
1800 return ret;
1801 }
1802 #endif
1803
1804
2/2
✓ Branch 0 taken 1407 times.
✓ Branch 1 taken 469 times.
1876 for (int i = 0; i < 3; i++) {
1805 1407 s->s.frames[i].tf.f = av_frame_alloc();
1806
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1407 times.
1407 if (!s->s.frames[i].tf.f)
1807 return AVERROR(ENOMEM);
1808 }
1809
2/2
✓ Branch 0 taken 3752 times.
✓ Branch 1 taken 469 times.
4221 for (int i = 0; i < 8; i++) {
1810 3752 s->s.refs[i].f = av_frame_alloc();
1811 3752 s->next_refs[i].f = av_frame_alloc();
1812
2/4
✓ Branch 0 taken 3752 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 3752 times.
3752 if (!s->s.refs[i].f || !s->next_refs[i].f)
1813 return AVERROR(ENOMEM);
1814 }
1815 469 return 0;
1816 }
1817
1818 #if HAVE_THREADS
1819 static int vp9_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
1820 {
1821 int i, ret;
1822 VP9Context *s = dst->priv_data, *ssrc = src->priv_data;
1823
1824 for (i = 0; i < 3; i++) {
1825 if (s->s.frames[i].tf.f->buf[0])
1826 vp9_frame_unref(dst, &s->s.frames[i]);
1827 if (ssrc->s.frames[i].tf.f->buf[0]) {
1828 if ((ret = vp9_frame_ref(dst, &s->s.frames[i], &ssrc->s.frames[i])) < 0)
1829 return ret;
1830 }
1831 }
1832 for (i = 0; i < 8; i++) {
1833 if (s->s.refs[i].f->buf[0])
1834 ff_thread_release_buffer(dst, &s->s.refs[i]);
1835 if (ssrc->next_refs[i].f->buf[0]) {
1836 if ((ret = ff_thread_ref_frame(&s->s.refs[i], &ssrc->next_refs[i])) < 0)
1837 return ret;
1838 }
1839 }
1840
1841 s->s.h.invisible = ssrc->s.h.invisible;
1842 s->s.h.keyframe = ssrc->s.h.keyframe;
1843 s->s.h.intraonly = ssrc->s.h.intraonly;
1844 s->ss_v = ssrc->ss_v;
1845 s->ss_h = ssrc->ss_h;
1846 s->s.h.segmentation.enabled = ssrc->s.h.segmentation.enabled;
1847 s->s.h.segmentation.update_map = ssrc->s.h.segmentation.update_map;
1848 s->s.h.segmentation.absolute_vals = ssrc->s.h.segmentation.absolute_vals;
1849 s->bytesperpixel = ssrc->bytesperpixel;
1850 s->gf_fmt = ssrc->gf_fmt;
1851 s->w = ssrc->w;
1852 s->h = ssrc->h;
1853 s->s.h.bpp = ssrc->s.h.bpp;
1854 s->bpp_index = ssrc->bpp_index;
1855 s->pix_fmt = ssrc->pix_fmt;
1856 memcpy(&s->prob_ctx, &ssrc->prob_ctx, sizeof(s->prob_ctx));
1857 memcpy(&s->s.h.lf_delta, &ssrc->s.h.lf_delta, sizeof(s->s.h.lf_delta));
1858 memcpy(&s->s.h.segmentation.feat, &ssrc->s.h.segmentation.feat,
1859 sizeof(s->s.h.segmentation.feat));
1860
1861 return 0;
1862 }
1863 #endif
1864
1865 const AVCodec ff_vp9_decoder = {
1866 .name = "vp9",
1867 .long_name = NULL_IF_CONFIG_SMALL("Google VP9"),
1868 .type = AVMEDIA_TYPE_VIDEO,
1869 .id = AV_CODEC_ID_VP9,
1870 .priv_data_size = sizeof(VP9Context),
1871 .init = vp9_decode_init,
1872 .close = vp9_decode_free,
1873 .decode = vp9_decode_frame,
1874 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS,
1875 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP |
1876 FF_CODEC_CAP_SLICE_THREAD_HAS_MF |
1877 FF_CODEC_CAP_ALLOCATE_PROGRESS,
1878 .flush = vp9_decode_flush,
1879 .update_thread_context = ONLY_IF_THREADS_ENABLED(vp9_decode_update_thread_context),
1880 .profiles = NULL_IF_CONFIG_SMALL(ff_vp9_profiles),
1881 .bsfs = "vp9_superframe_split",
1882 .hw_configs = (const AVCodecHWConfigInternal *const []) {
1883 #if CONFIG_VP9_DXVA2_HWACCEL
1884 HWACCEL_DXVA2(vp9),
1885 #endif
1886 #if CONFIG_VP9_D3D11VA_HWACCEL
1887 HWACCEL_D3D11VA(vp9),
1888 #endif
1889 #if CONFIG_VP9_D3D11VA2_HWACCEL
1890 HWACCEL_D3D11VA2(vp9),
1891 #endif
1892 #if CONFIG_VP9_NVDEC_HWACCEL
1893 HWACCEL_NVDEC(vp9),
1894 #endif
1895 #if CONFIG_VP9_VAAPI_HWACCEL
1896 HWACCEL_VAAPI(vp9),
1897 #endif
1898 #if CONFIG_VP9_VDPAU_HWACCEL
1899 HWACCEL_VDPAU(vp9),
1900 #endif
1901 #if CONFIG_VP9_VIDEOTOOLBOX_HWACCEL
1902 HWACCEL_VIDEOTOOLBOX(vp9),
1903 #endif
1904 NULL
1905 },
1906 };
1907