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