FFmpeg
vp9.c
Go to the documentation of this file.
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/intreadwrite.h"
47 #include "libavutil/mem.h"
48 #include "libavutil/pixdesc.h"
49 #include "libavutil/video_enc_params.h"
50 
51 #define VP9_SYNCCODE 0x498342
52 
53 #if HAVE_THREADS
54 DEFINE_OFFSET_ARRAY(VP9Context, vp9_context, pthread_init_cnt,
55  (offsetof(VP9Context, progress_mutex)),
56  (offsetof(VP9Context, progress_cond)));
57 
58 static int vp9_alloc_entries(AVCodecContext *avctx, int n) {
59  VP9Context *s = avctx->priv_data;
60 
61  if (avctx->active_thread_type & FF_THREAD_SLICE) {
62  if (s->entries)
63  av_freep(&s->entries);
64 
65  s->entries = av_malloc_array(n, sizeof(atomic_int));
66  if (!s->entries)
67  return AVERROR(ENOMEM);
68  }
69  return 0;
70 }
71 
72 static void vp9_report_tile_progress(VP9Context *s, int field, int n) {
73  pthread_mutex_lock(&s->progress_mutex);
74  atomic_fetch_add_explicit(&s->entries[field], n, memory_order_release);
75  pthread_cond_signal(&s->progress_cond);
76  pthread_mutex_unlock(&s->progress_mutex);
77 }
78 
79 static void vp9_await_tile_progress(VP9Context *s, int field, int n) {
80  if (atomic_load_explicit(&s->entries[field], memory_order_acquire) >= n)
81  return;
82 
83  pthread_mutex_lock(&s->progress_mutex);
84  while (atomic_load_explicit(&s->entries[field], memory_order_relaxed) != n)
85  pthread_cond_wait(&s->progress_cond, &s->progress_mutex);
86  pthread_mutex_unlock(&s->progress_mutex);
87 }
88 #else
89 static int vp9_alloc_entries(AVCodecContext *avctx, int n) { return 0; }
90 #endif
91 
92 static void vp9_tile_data_free(VP9TileData *td)
93 {
94  av_freep(&td->b_base);
95  av_freep(&td->block_base);
96  av_freep(&td->block_structure);
97 }
98 
99 static void vp9_frame_unref(VP9Frame *f)
100 {
101  av_refstruct_unref(&f->hwaccel_picture_private);
102  ff_progress_frame_unref(&f->tf);
103  av_refstruct_unref(&f->header_ref);
104  av_refstruct_unref(&f->extradata);
105  f->segmentation_map = NULL;
106 }
107 
108 static int vp9_frame_alloc(AVCodecContext *avctx, VP9Frame *f)
109 {
110  VP9Context *s = avctx->priv_data;
111  int ret, sz;
112 
113  ret = ff_progress_frame_get_buffer(avctx, &f->tf, AV_GET_BUFFER_FLAG_REF);
114  if (ret < 0)
115  return ret;
116 
117  sz = 64 * s->sb_cols * s->sb_rows;
118  if (sz != s->frame_extradata_pool_size) {
119  av_refstruct_pool_uninit(&s->frame_extradata_pool);
120  s->frame_extradata_pool = av_refstruct_pool_alloc(sz * (1 + sizeof(VP9mvrefPair)),
121  AV_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME);
122  if (!s->frame_extradata_pool) {
123  s->frame_extradata_pool_size = 0;
124  ret = AVERROR(ENOMEM);
125  goto fail;
126  }
127  s->frame_extradata_pool_size = sz;
128  }
129  f->extradata = av_refstruct_pool_get(s->frame_extradata_pool);
130  if (!f->extradata) {
131  ret = AVERROR(ENOMEM);
132  goto fail;
133  }
134 
135  f->segmentation_map = f->extradata;
136  f->mv = (VP9mvrefPair *) ((char*)f->extradata + sz);
137 
138  ret = ff_hwaccel_frame_priv_alloc(avctx, &f->hwaccel_picture_private);
139  if (ret < 0)
140  goto fail;
141 
142  return 0;
143 
144 fail:
145  vp9_frame_unref(f);
146  return ret;
147 }
148 
149 static void vp9_frame_replace(VP9Frame *dst, const VP9Frame *src)
150 {
151  av_refstruct_replace(&dst->header_ref, src->header_ref);
152  dst->frame_header = src->frame_header;
153 
154  ff_progress_frame_replace(&dst->tf, &src->tf);
155 
156  av_refstruct_replace(&dst->extradata, src->extradata);
157 
158  dst->segmentation_map = src->segmentation_map;
159  dst->mv = src->mv;
160  dst->uses_2pass = src->uses_2pass;
161 
162  av_refstruct_replace(&dst->hwaccel_picture_private,
163  src->hwaccel_picture_private);
164 }
165 
166 static int update_size(AVCodecContext *avctx, int w, int h)
167 {
168 #define HWACCEL_MAX (CONFIG_VP9_DXVA2_HWACCEL + \
169  CONFIG_VP9_D3D11VA_HWACCEL * 2 + \
170  CONFIG_VP9_D3D12VA_HWACCEL + \
171  CONFIG_VP9_NVDEC_HWACCEL + \
172  CONFIG_VP9_NVDEC_CUARRAY_HWACCEL + \
173  CONFIG_VP9_VAAPI_HWACCEL + \
174  CONFIG_VP9_VDPAU_HWACCEL + \
175  CONFIG_VP9_VIDEOTOOLBOX_HWACCEL + \
176  CONFIG_VP9_VULKAN_HWACCEL)
177  enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmtp = pix_fmts;
178  VP9Context *s = avctx->priv_data;
179  uint8_t *p;
180  int bytesperpixel = s->bytesperpixel, ret, cols, rows;
181  int lflvl_len, i;
182  int changed = 0;
183 
184  av_assert0(w > 0 && h > 0);
185 
186  if (!(s->pix_fmt == s->gf_fmt && w == s->w && h == s->h)) {
187  changed = 1;
188  if ((ret = ff_set_dimensions(avctx, w, h)) < 0)
189  return ret;
190 
191  switch (s->pix_fmt) {
192  case AV_PIX_FMT_YUV420P:
193  case AV_PIX_FMT_YUV420P10:
194 #if CONFIG_VP9_DXVA2_HWACCEL
195  *fmtp++ = AV_PIX_FMT_DXVA2_VLD;
196 #endif
197 #if CONFIG_VP9_D3D11VA_HWACCEL
198  *fmtp++ = AV_PIX_FMT_D3D11VA_VLD;
199  *fmtp++ = AV_PIX_FMT_D3D11;
200 #endif
201 #if CONFIG_VP9_D3D12VA_HWACCEL
202  *fmtp++ = AV_PIX_FMT_D3D12;
203 #endif
204 #if CONFIG_VP9_NVDEC_HWACCEL
205  *fmtp++ = AV_PIX_FMT_CUDA;
206 #endif
207 #if CONFIG_VP9_NVDEC_CUARRAY_HWACCEL
208  *fmtp++ = AV_PIX_FMT_CUARRAY;
209 #endif
210 #if CONFIG_VP9_VAAPI_HWACCEL
211  *fmtp++ = AV_PIX_FMT_VAAPI;
212 #endif
213 #if CONFIG_VP9_VDPAU_HWACCEL
214  *fmtp++ = AV_PIX_FMT_VDPAU;
215 #endif
216 #if CONFIG_VP9_VIDEOTOOLBOX_HWACCEL
217  *fmtp++ = AV_PIX_FMT_VIDEOTOOLBOX;
218 #endif
219 #if CONFIG_VP9_VULKAN_HWACCEL
220  *fmtp++ = AV_PIX_FMT_VULKAN;
221 #endif
222  break;
223  case AV_PIX_FMT_YUV420P12:
224 #if CONFIG_VP9_NVDEC_HWACCEL
225  *fmtp++ = AV_PIX_FMT_CUDA;
226 #endif
227 #if CONFIG_VP9_NVDEC_CUARRAY_HWACCEL
228  *fmtp++ = AV_PIX_FMT_CUARRAY;
229 #endif
230 #if CONFIG_VP9_VAAPI_HWACCEL
231  *fmtp++ = AV_PIX_FMT_VAAPI;
232 #endif
233 #if CONFIG_VP9_VDPAU_HWACCEL
234  *fmtp++ = AV_PIX_FMT_VDPAU;
235 #endif
236 #if CONFIG_VP9_VULKAN_HWACCEL
237  *fmtp++ = AV_PIX_FMT_VULKAN;
238 #endif
239  break;
240  case AV_PIX_FMT_YUV444P:
241  case AV_PIX_FMT_YUV444P10:
242  case AV_PIX_FMT_YUV444P12:
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  case AV_PIX_FMT_GBRP:
251  case AV_PIX_FMT_GBRP10:
252  case AV_PIX_FMT_GBRP12:
253 #if CONFIG_VP9_VAAPI_HWACCEL
254  *fmtp++ = AV_PIX_FMT_VAAPI;
255 #endif
256 #if CONFIG_VP9_VULKAN_HWACCEL
257  *fmtp++ = AV_PIX_FMT_VULKAN;
258 #endif
259  break;
260  }
261 
262  *fmtp++ = s->pix_fmt;
263  *fmtp = AV_PIX_FMT_NONE;
264 
265  ret = ff_get_format(avctx, pix_fmts);
266  if (ret < 0) {
267  ff_set_dimensions(avctx, s->w, s->h);
268  return ret;
269  }
270 
271  avctx->pix_fmt = ret;
272  s->gf_fmt = s->pix_fmt;
273  s->w = w;
274  s->h = h;
275  }
276 
277  cols = (w + 7) >> 3;
278  rows = (h + 7) >> 3;
279 
280  if (s->intra_pred_data[0] && cols == s->cols && rows == s->rows && s->pix_fmt == s->last_fmt)
281  return changed;
282 
283  s->last_fmt = s->pix_fmt;
284  s->sb_cols = (w + 63) >> 6;
285  s->sb_rows = (h + 63) >> 6;
286  s->cols = (w + 7) >> 3;
287  s->rows = (h + 7) >> 3;
288  lflvl_len = avctx->active_thread_type == FF_THREAD_SLICE ? s->sb_rows : 1;
289 
290 #define assign(var, type, n) var = (type) p; p += s->sb_cols * (n) * sizeof(*var)
291  av_freep(&s->intra_pred_data[0]);
292  // FIXME we slightly over-allocate here for subsampled chroma, but a little
293  // bit of padding shouldn't affect performance...
294  p = av_malloc(s->sb_cols * (128 + 192 * bytesperpixel +
295  lflvl_len * sizeof(*s->lflvl) + 16 * sizeof(*s->above_mv_ctx)));
296  if (!p)
297  return AVERROR(ENOMEM);
298  assign(s->intra_pred_data[0], uint8_t *, 64 * bytesperpixel);
299  assign(s->intra_pred_data[1], uint8_t *, 64 * bytesperpixel);
300  assign(s->intra_pred_data[2], uint8_t *, 64 * bytesperpixel);
301  assign(s->above_y_nnz_ctx, uint8_t *, 16);
302  assign(s->above_mode_ctx, uint8_t *, 16);
303  assign(s->above_mv_ctx, VP9mv(*)[2], 16);
304  assign(s->above_uv_nnz_ctx[0], uint8_t *, 16);
305  assign(s->above_uv_nnz_ctx[1], uint8_t *, 16);
306  assign(s->above_partition_ctx, uint8_t *, 8);
307  assign(s->above_skip_ctx, uint8_t *, 8);
308  assign(s->above_txfm_ctx, uint8_t *, 8);
309  assign(s->above_segpred_ctx, uint8_t *, 8);
310  assign(s->above_intra_ctx, uint8_t *, 8);
311  assign(s->above_comp_ctx, uint8_t *, 8);
312  assign(s->above_ref_ctx, uint8_t *, 8);
313  assign(s->above_filter_ctx, uint8_t *, 8);
314  assign(s->lflvl, VP9Filter *, lflvl_len);
315 #undef assign
316 
317  if (s->td) {
318  for (i = 0; i < s->active_tile_cols; i++)
319  vp9_tile_data_free(&s->td[i]);
320  }
321 
322  if (s->s.h.bpp != s->last_bpp) {
323  ff_vp9dsp_init(&s->dsp, s->s.h.bpp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
324  ff_videodsp_init(&s->vdsp, s->s.h.bpp);
325  s->last_bpp = s->s.h.bpp;
326  changed = 1;
327  }
328 
329  return changed;
330 }
331 
332 static int update_block_buffers(AVCodecContext *avctx)
333 {
334  int i;
335  VP9Context *s = avctx->priv_data;
336  int chroma_blocks, chroma_eobs, bytesperpixel = s->bytesperpixel;
337  VP9TileData *td = &s->td[0];
338 
339  if (td->b_base && td->block_base && s->block_alloc_using_2pass == s->s.frames[CUR_FRAME].uses_2pass)
340  return 0;
341 
342  vp9_tile_data_free(td);
343  chroma_blocks = 64 * 64 >> (s->ss_h + s->ss_v);
344  chroma_eobs = 16 * 16 >> (s->ss_h + s->ss_v);
345  if (s->s.frames[CUR_FRAME].uses_2pass) {
346  int sbs = s->sb_cols * s->sb_rows;
347 
348  td->b_base = av_malloc_array(s->cols * s->rows, sizeof(VP9Block));
349  td->block_base = av_mallocz(((64 * 64 + 2 * chroma_blocks) * bytesperpixel * sizeof(int16_t) +
350  16 * 16 + 2 * chroma_eobs) * sbs);
351  if (!td->b_base || !td->block_base)
352  return AVERROR(ENOMEM);
353  td->uvblock_base[0] = td->block_base + sbs * 64 * 64 * bytesperpixel;
354  td->uvblock_base[1] = td->uvblock_base[0] + sbs * chroma_blocks * bytesperpixel;
355  td->eob_base = (uint8_t *) (td->uvblock_base[1] + sbs * chroma_blocks * bytesperpixel);
356  td->uveob_base[0] = td->eob_base + 16 * 16 * sbs;
357  td->uveob_base[1] = td->uveob_base[0] + chroma_eobs * sbs;
358 
359  if (avctx->export_side_data & AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS) {
360  td->block_structure = av_malloc_array(s->cols * s->rows, sizeof(*td->block_structure));
361  if (!td->block_structure)
362  return AVERROR(ENOMEM);
363  }
364  } else {
365  for (i = 1; i < s->active_tile_cols; i++)
366  vp9_tile_data_free(&s->td[i]);
367 
368  for (i = 0; i < s->active_tile_cols; i++) {
369  s->td[i].b_base = av_malloc(sizeof(VP9Block));
370  s->td[i].block_base = av_mallocz((64 * 64 + 2 * chroma_blocks) * bytesperpixel * sizeof(int16_t) +
371  16 * 16 + 2 * chroma_eobs);
372  if (!s->td[i].b_base || !s->td[i].block_base)
373  return AVERROR(ENOMEM);
374  s->td[i].uvblock_base[0] = s->td[i].block_base + 64 * 64 * bytesperpixel;
375  s->td[i].uvblock_base[1] = s->td[i].uvblock_base[0] + chroma_blocks * bytesperpixel;
376  s->td[i].eob_base = (uint8_t *) (s->td[i].uvblock_base[1] + chroma_blocks * bytesperpixel);
377  s->td[i].uveob_base[0] = s->td[i].eob_base + 16 * 16;
378  s->td[i].uveob_base[1] = s->td[i].uveob_base[0] + chroma_eobs;
379 
380  if (avctx->export_side_data & AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS) {
381  s->td[i].block_structure = av_malloc_array(s->cols * s->rows, sizeof(*td->block_structure));
382  if (!s->td[i].block_structure)
383  return AVERROR(ENOMEM);
384  }
385  }
386  }
387  s->block_alloc_using_2pass = s->s.frames[CUR_FRAME].uses_2pass;
388 
389  return 0;
390 }
391 
392 // The sign bit is at the end, not the start, of a bit sequence
393 static av_always_inline int get_sbits_inv(GetBitContext *gb, int n)
394 {
395  int v = get_bits(gb, n);
396  return get_bits1(gb) ? -v : v;
397 }
398 
399 static av_always_inline int inv_recenter_nonneg(int v, int m)
400 {
401  if (v > 2 * m)
402  return v;
403  if (v & 1)
404  return m - ((v + 1) >> 1);
405  return m + (v >> 1);
406 }
407 
408 // differential forward probability updates
409 static int update_prob(VPXRangeCoder *c, int p)
410 {
411  static const uint8_t inv_map_table[255] = {
412  7, 20, 33, 46, 59, 72, 85, 98, 111, 124, 137, 150, 163, 176,
413  189, 202, 215, 228, 241, 254, 1, 2, 3, 4, 5, 6, 8, 9,
414  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 21, 22, 23, 24,
415  25, 26, 27, 28, 29, 30, 31, 32, 34, 35, 36, 37, 38, 39,
416  40, 41, 42, 43, 44, 45, 47, 48, 49, 50, 51, 52, 53, 54,
417  55, 56, 57, 58, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
418  70, 71, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
419  86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 99, 100,
420  101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 112, 113, 114, 115,
421  116, 117, 118, 119, 120, 121, 122, 123, 125, 126, 127, 128, 129, 130,
422  131, 132, 133, 134, 135, 136, 138, 139, 140, 141, 142, 143, 144, 145,
423  146, 147, 148, 149, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160,
424  161, 162, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
425  177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 190, 191,
426  192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 203, 204, 205, 206,
427  207, 208, 209, 210, 211, 212, 213, 214, 216, 217, 218, 219, 220, 221,
428  222, 223, 224, 225, 226, 227, 229, 230, 231, 232, 233, 234, 235, 236,
429  237, 238, 239, 240, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251,
430  252, 253, 253,
431  };
432  int d;
433 
434  /* This code is trying to do a differential probability update. For a
435  * current probability A in the range [1, 255], the difference to a new
436  * probability of any value can be expressed differentially as 1-A, 255-A
437  * where some part of this (absolute range) exists both in positive as
438  * well as the negative part, whereas another part only exists in one
439  * half. We're trying to code this shared part differentially, i.e.
440  * times two where the value of the lowest bit specifies the sign, and
441  * the single part is then coded on top of this. This absolute difference
442  * then again has a value of [0, 254], but a bigger value in this range
443  * indicates that we're further away from the original value A, so we
444  * can code this as a VLC code, since higher values are increasingly
445  * unlikely. The first 20 values in inv_map_table[] allow 'cheap, rough'
446  * updates vs. the 'fine, exact' updates further down the range, which
447  * adds one extra dimension to this differential update model. */
448 
449  if (!vp89_rac_get(c)) {
450  d = vp89_rac_get_uint(c, 4) + 0;
451  } else if (!vp89_rac_get(c)) {
452  d = vp89_rac_get_uint(c, 4) + 16;
453  } else if (!vp89_rac_get(c)) {
454  d = vp89_rac_get_uint(c, 5) + 32;
455  } else {
456  d = vp89_rac_get_uint(c, 7);
457  if (d >= 65)
458  d = (d << 1) - 65 + vp89_rac_get(c);
459  d += 64;
460  av_assert2(d < FF_ARRAY_ELEMS(inv_map_table));
461  }
462 
463  return p <= 128 ? 1 + inv_recenter_nonneg(inv_map_table[d], p - 1) :
464  255 - inv_recenter_nonneg(inv_map_table[d], 255 - p);
465 }
466 
467 static int read_colorspace_details(AVCodecContext *avctx)
468 {
469  static const enum AVColorSpace colorspaces[8] = {
470  AVCOL_SPC_UNSPECIFIED, AVCOL_SPC_BT470BG, AVCOL_SPC_BT709, AVCOL_SPC_SMPTE170M,
471  AVCOL_SPC_SMPTE240M, AVCOL_SPC_BT2020_NCL, AVCOL_SPC_RESERVED, AVCOL_SPC_RGB,
472  };
473  VP9Context *s = avctx->priv_data;
474  int bits = avctx->profile <= 1 ? 0 : 1 + get_bits1(&s->gb); // 0:8, 1:10, 2:12
475 
476  s->bpp_index = bits;
477  s->s.h.bpp = 8 + bits * 2;
478  s->bytesperpixel = (7 + s->s.h.bpp) >> 3;
479  avctx->colorspace = colorspaces[get_bits(&s->gb, 3)];
480  if (avctx->colorspace == AVCOL_SPC_RGB) { // RGB = profile 1
481  static const enum AVPixelFormat pix_fmt_rgb[3] = {
482  AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12
483  };
484  s->ss_h = s->ss_v = 0;
485  avctx->color_range = AVCOL_RANGE_JPEG;
486  s->pix_fmt = pix_fmt_rgb[bits];
487  if (avctx->profile & 1) {
488  if (get_bits1(&s->gb)) {
489  av_log(avctx, AV_LOG_ERROR, "Reserved bit set in RGB\n");
490  return AVERROR_INVALIDDATA;
491  }
492  } else {
493  av_log(avctx, AV_LOG_ERROR, "RGB not supported in profile %d\n",
494  avctx->profile);
495  return AVERROR_INVALIDDATA;
496  }
497  } else {
498  static const enum AVPixelFormat pix_fmt_for_ss[3][2 /* v */][2 /* h */] = {
499  { { AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P },
500  { AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV420P } },
501  { { AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV422P10 },
502  { AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV420P10 } },
503  { { AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV422P12 },
504  { AV_PIX_FMT_YUV440P12, AV_PIX_FMT_YUV420P12 } }
505  };
506  avctx->color_range = get_bits1(&s->gb) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
507  if (avctx->profile & 1) {
508  s->ss_h = get_bits1(&s->gb);
509  s->ss_v = get_bits1(&s->gb);
510  s->pix_fmt = pix_fmt_for_ss[bits][s->ss_v][s->ss_h];
511  if (s->pix_fmt == AV_PIX_FMT_YUV420P) {
512  av_log(avctx, AV_LOG_ERROR, "YUV 4:2:0 not supported in profile %d\n",
513  avctx->profile);
514  return AVERROR_INVALIDDATA;
515  } else if (get_bits1(&s->gb)) {
516  av_log(avctx, AV_LOG_ERROR, "Profile %d color details reserved bit set\n",
517  avctx->profile);
518  return AVERROR_INVALIDDATA;
519  }
520  } else {
521  s->ss_h = s->ss_v = 1;
522  s->pix_fmt = pix_fmt_for_ss[bits][1][1];
523  }
524  }
525 
526  return 0;
527 }
528 
529 static int decode_frame_header(AVCodecContext *avctx,
530  const uint8_t *data, int size, int *ref)
531 {
532  VP9Context *s = avctx->priv_data;
533  int c, i, j, k, l, m, n, w, h, max, size2, ret, sharp;
534  int last_invisible;
535  const uint8_t *data2;
536  int changed;
537 
538  /* general header */
539  if ((ret = init_get_bits8(&s->gb, data, size)) < 0) {
540  av_log(avctx, AV_LOG_ERROR, "Failed to initialize bitstream reader\n");
541  return ret;
542  }
543  if (get_bits(&s->gb, 2) != 0x2) { // frame marker
544  av_log(avctx, AV_LOG_ERROR, "Invalid frame marker\n");
545  return AVERROR_INVALIDDATA;
546  }
547  avctx->profile = get_bits1(&s->gb);
548  avctx->profile |= get_bits1(&s->gb) << 1;
549  if (avctx->profile == 3) avctx->profile += get_bits1(&s->gb);
550  if (avctx->profile > 3) {
551  av_log(avctx, AV_LOG_ERROR, "Profile %d is not yet supported\n", avctx->profile);
552  return AVERROR_INVALIDDATA;
553  }
554  s->s.h.profile = avctx->profile;
555  if (get_bits1(&s->gb)) {
556  *ref = get_bits(&s->gb, 3);
557  return 0;
558  }
559 
560  s->last_keyframe = s->s.h.keyframe;
561  s->s.h.keyframe = !get_bits1(&s->gb);
562 
563  last_invisible = s->s.h.invisible;
564  s->s.h.invisible = !get_bits1(&s->gb);
565  s->s.h.errorres = get_bits1(&s->gb);
566  s->s.h.use_last_frame_mvs = !s->s.h.errorres && !last_invisible;
567 
568  if (s->s.h.keyframe) {
569  if (get_bits(&s->gb, 24) != VP9_SYNCCODE) { // synccode
570  av_log(avctx, AV_LOG_ERROR, "Invalid sync code\n");
571  return AVERROR_INVALIDDATA;
572  }
573  if ((ret = read_colorspace_details(avctx)) < 0)
574  return ret;
575  // for profile 1, here follows the subsampling bits
576  s->s.h.refreshrefmask = 0xff;
577  w = get_bits(&s->gb, 16) + 1;
578  h = get_bits(&s->gb, 16) + 1;
579  if (get_bits1(&s->gb)) // display size
580  skip_bits(&s->gb, 32);
581  } else {
582  s->s.h.intraonly = s->s.h.invisible ? get_bits1(&s->gb) : 0;
583  s->s.h.resetctx = s->s.h.errorres ? 0 : get_bits(&s->gb, 2);
584  if (s->s.h.intraonly) {
585  if (get_bits(&s->gb, 24) != VP9_SYNCCODE) { // synccode
586  av_log(avctx, AV_LOG_ERROR, "Invalid sync code\n");
587  return AVERROR_INVALIDDATA;
588  }
589  if (avctx->profile >= 1) {
590  if ((ret = read_colorspace_details(avctx)) < 0)
591  return ret;
592  } else {
593  s->ss_h = s->ss_v = 1;
594  s->s.h.bpp = 8;
595  s->bpp_index = 0;
596  s->bytesperpixel = 1;
597  s->pix_fmt = AV_PIX_FMT_YUV420P;
598  avctx->colorspace = AVCOL_SPC_BT470BG;
599  avctx->color_range = AVCOL_RANGE_MPEG;
600  }
601  s->s.h.refreshrefmask = get_bits(&s->gb, 8);
602  w = get_bits(&s->gb, 16) + 1;
603  h = get_bits(&s->gb, 16) + 1;
604  if (get_bits1(&s->gb)) // display size
605  skip_bits(&s->gb, 32);
606  } else {
607  s->s.h.refreshrefmask = get_bits(&s->gb, 8);
608  s->s.h.refidx[0] = get_bits(&s->gb, 3);
609  s->s.h.signbias[0] = get_bits1(&s->gb) && !s->s.h.errorres;
610  s->s.h.refidx[1] = get_bits(&s->gb, 3);
611  s->s.h.signbias[1] = get_bits1(&s->gb) && !s->s.h.errorres;
612  s->s.h.refidx[2] = get_bits(&s->gb, 3);
613  s->s.h.signbias[2] = get_bits1(&s->gb) && !s->s.h.errorres;
614  if (!s->s.refs[s->s.h.refidx[0]].f ||
615  !s->s.refs[s->s.h.refidx[1]].f ||
616  !s->s.refs[s->s.h.refidx[2]].f) {
617  av_log(avctx, AV_LOG_ERROR, "Not all references are available\n");
618  return AVERROR_INVALIDDATA;
619  }
620  if (get_bits1(&s->gb)) {
621  w = s->s.refs[s->s.h.refidx[0]].f->width;
622  h = s->s.refs[s->s.h.refidx[0]].f->height;
623  } else if (get_bits1(&s->gb)) {
624  w = s->s.refs[s->s.h.refidx[1]].f->width;
625  h = s->s.refs[s->s.h.refidx[1]].f->height;
626  } else if (get_bits1(&s->gb)) {
627  w = s->s.refs[s->s.h.refidx[2]].f->width;
628  h = s->s.refs[s->s.h.refidx[2]].f->height;
629  } else {
630  w = get_bits(&s->gb, 16) + 1;
631  h = get_bits(&s->gb, 16) + 1;
632  }
633  // Note that in this code, "CUR_FRAME" is actually before we
634  // have formally allocated a frame, and thus actually represents
635  // the _last_ frame
636  s->s.h.use_last_frame_mvs &= s->s.frames[CUR_FRAME].tf.f &&
637  s->s.frames[CUR_FRAME].tf.f->width == w &&
638  s->s.frames[CUR_FRAME].tf.f->height == h;
639  if (get_bits1(&s->gb)) // display size
640  skip_bits(&s->gb, 32);
641  s->s.h.highprecisionmvs = get_bits1(&s->gb);
642  s->s.h.filtermode = get_bits1(&s->gb) ? FILTER_SWITCHABLE :
643  get_bits(&s->gb, 2);
644  s->s.h.allowcompinter = s->s.h.signbias[0] != s->s.h.signbias[1] ||
645  s->s.h.signbias[0] != s->s.h.signbias[2];
646  if (s->s.h.allowcompinter) {
647  if (s->s.h.signbias[0] == s->s.h.signbias[1]) {
648  s->s.h.fixcompref = 2;
649  s->s.h.varcompref[0] = 0;
650  s->s.h.varcompref[1] = 1;
651  } else if (s->s.h.signbias[0] == s->s.h.signbias[2]) {
652  s->s.h.fixcompref = 1;
653  s->s.h.varcompref[0] = 0;
654  s->s.h.varcompref[1] = 2;
655  } else {
656  s->s.h.fixcompref = 0;
657  s->s.h.varcompref[0] = 1;
658  s->s.h.varcompref[1] = 2;
659  }
660  }
661  }
662  }
663  s->s.h.refreshctx = s->s.h.errorres ? 0 : get_bits1(&s->gb);
664  s->s.h.parallelmode = s->s.h.errorres ? 1 : get_bits1(&s->gb);
665  s->s.h.framectxid = c = get_bits(&s->gb, 2);
666  if (s->s.h.keyframe || s->s.h.intraonly)
667  s->s.h.framectxid = 0; // BUG: libvpx ignores this field in keyframes
668 
669  /* loopfilter header data */
670  if (s->s.h.keyframe || s->s.h.errorres || s->s.h.intraonly) {
671  // reset loopfilter defaults
672  s->s.h.lf_delta.ref[0] = 1;
673  s->s.h.lf_delta.ref[1] = 0;
674  s->s.h.lf_delta.ref[2] = -1;
675  s->s.h.lf_delta.ref[3] = -1;
676  s->s.h.lf_delta.mode[0] = 0;
677  s->s.h.lf_delta.mode[1] = 0;
678  memset(s->s.h.segmentation.feat, 0, sizeof(s->s.h.segmentation.feat));
679  }
680  s->s.h.filter.level = get_bits(&s->gb, 6);
681  sharp = get_bits(&s->gb, 3);
682  // if sharpness changed, reinit lim/mblim LUTs. if it didn't change, keep
683  // the old cache values since they are still valid
684  if (s->s.h.filter.sharpness != sharp) {
685  for (i = 1; i <= 63; i++) {
686  int limit = i;
687 
688  if (sharp > 0) {
689  limit >>= (sharp + 3) >> 2;
690  limit = FFMIN(limit, 9 - sharp);
691  }
692  limit = FFMAX(limit, 1);
693 
694  s->filter_lut.lim_lut[i] = limit;
695  s->filter_lut.mblim_lut[i] = 2 * (i + 2) + limit;
696  }
697  }
698  s->s.h.filter.sharpness = sharp;
699  if ((s->s.h.lf_delta.enabled = get_bits1(&s->gb))) {
700  if ((s->s.h.lf_delta.updated = get_bits1(&s->gb))) {
701  for (i = 0; i < 4; i++)
702  if (get_bits1(&s->gb))
703  s->s.h.lf_delta.ref[i] = get_sbits_inv(&s->gb, 6);
704  for (i = 0; i < 2; i++)
705  if (get_bits1(&s->gb))
706  s->s.h.lf_delta.mode[i] = get_sbits_inv(&s->gb, 6);
707  }
708  }
709 
710  /* quantization header data */
711  s->s.h.yac_qi = get_bits(&s->gb, 8);
712  s->s.h.ydc_qdelta = get_bits1(&s->gb) ? get_sbits_inv(&s->gb, 4) : 0;
713  s->s.h.uvdc_qdelta = get_bits1(&s->gb) ? get_sbits_inv(&s->gb, 4) : 0;
714  s->s.h.uvac_qdelta = get_bits1(&s->gb) ? get_sbits_inv(&s->gb, 4) : 0;
715  s->s.h.lossless = s->s.h.yac_qi == 0 && s->s.h.ydc_qdelta == 0 &&
716  s->s.h.uvdc_qdelta == 0 && s->s.h.uvac_qdelta == 0;
717 
718  /* segmentation header info */
719  if ((s->s.h.segmentation.enabled = get_bits1(&s->gb))) {
720  if ((s->s.h.segmentation.update_map = get_bits1(&s->gb))) {
721  for (i = 0; i < 7; i++)
722  s->s.h.segmentation.prob[i] = get_bits1(&s->gb) ?
723  get_bits(&s->gb, 8) : 255;
724  if ((s->s.h.segmentation.temporal = get_bits1(&s->gb)))
725  for (i = 0; i < 3; i++)
726  s->s.h.segmentation.pred_prob[i] = get_bits1(&s->gb) ?
727  get_bits(&s->gb, 8) : 255;
728  }
729 
730  if (get_bits1(&s->gb)) {
731  s->s.h.segmentation.absolute_vals = get_bits1(&s->gb);
732  for (i = 0; i < 8; i++) {
733  if ((s->s.h.segmentation.feat[i].q_enabled = get_bits1(&s->gb)))
734  s->s.h.segmentation.feat[i].q_val = get_sbits_inv(&s->gb, 8);
735  if ((s->s.h.segmentation.feat[i].lf_enabled = get_bits1(&s->gb)))
736  s->s.h.segmentation.feat[i].lf_val = get_sbits_inv(&s->gb, 6);
737  if ((s->s.h.segmentation.feat[i].ref_enabled = get_bits1(&s->gb)))
738  s->s.h.segmentation.feat[i].ref_val = get_bits(&s->gb, 2);
739  s->s.h.segmentation.feat[i].skip_enabled = get_bits1(&s->gb);
740  }
741  }
742  } else {
743  // Reset fields under segmentation switch if segmentation is disabled.
744  // This is necessary because some hwaccels don't ignore these fields
745  // if segmentation is disabled.
746  s->s.h.segmentation.temporal = 0;
747  s->s.h.segmentation.update_map = 0;
748  }
749 
750  // set qmul[] based on Y/UV, AC/DC and segmentation Q idx deltas
751  for (i = 0; i < (s->s.h.segmentation.enabled ? 8 : 1); i++) {
752  int qyac, qydc, quvac, quvdc, lflvl, sh;
753 
754  if (s->s.h.segmentation.enabled && s->s.h.segmentation.feat[i].q_enabled) {
755  if (s->s.h.segmentation.absolute_vals)
756  qyac = av_clip_uintp2(s->s.h.segmentation.feat[i].q_val, 8);
757  else
758  qyac = av_clip_uintp2(s->s.h.yac_qi + s->s.h.segmentation.feat[i].q_val, 8);
759  } else {
760  qyac = s->s.h.yac_qi;
761  }
762  qydc = av_clip_uintp2(qyac + s->s.h.ydc_qdelta, 8);
763  quvdc = av_clip_uintp2(qyac + s->s.h.uvdc_qdelta, 8);
764  quvac = av_clip_uintp2(qyac + s->s.h.uvac_qdelta, 8);
765  qyac = av_clip_uintp2(qyac, 8);
766 
767  s->s.h.segmentation.feat[i].qmul[0][0] = ff_vp9_dc_qlookup[s->bpp_index][qydc];
768  s->s.h.segmentation.feat[i].qmul[0][1] = ff_vp9_ac_qlookup[s->bpp_index][qyac];
769  s->s.h.segmentation.feat[i].qmul[1][0] = ff_vp9_dc_qlookup[s->bpp_index][quvdc];
770  s->s.h.segmentation.feat[i].qmul[1][1] = ff_vp9_ac_qlookup[s->bpp_index][quvac];
771 
772  sh = s->s.h.filter.level >= 32;
773  if (s->s.h.segmentation.enabled && s->s.h.segmentation.feat[i].lf_enabled) {
774  if (s->s.h.segmentation.absolute_vals)
775  lflvl = av_clip_uintp2(s->s.h.segmentation.feat[i].lf_val, 6);
776  else
777  lflvl = av_clip_uintp2(s->s.h.filter.level + s->s.h.segmentation.feat[i].lf_val, 6);
778  } else {
779  lflvl = s->s.h.filter.level;
780  }
781  if (s->s.h.lf_delta.enabled) {
782  s->s.h.segmentation.feat[i].lflvl[0][0] =
783  s->s.h.segmentation.feat[i].lflvl[0][1] =
784  av_clip_uintp2(lflvl + (s->s.h.lf_delta.ref[0] * (1 << sh)), 6);
785  for (j = 1; j < 4; j++) {
786  s->s.h.segmentation.feat[i].lflvl[j][0] =
787  av_clip_uintp2(lflvl + ((s->s.h.lf_delta.ref[j] +
788  s->s.h.lf_delta.mode[0]) * (1 << sh)), 6);
789  s->s.h.segmentation.feat[i].lflvl[j][1] =
790  av_clip_uintp2(lflvl + ((s->s.h.lf_delta.ref[j] +
791  s->s.h.lf_delta.mode[1]) * (1 << sh)), 6);
792  }
793  } else {
794  memset(s->s.h.segmentation.feat[i].lflvl, lflvl,
795  sizeof(s->s.h.segmentation.feat[i].lflvl));
796  }
797  }
798 
799  /* tiling info */
800  if ((changed = update_size(avctx, w, h)) < 0) {
801  av_log(avctx, AV_LOG_ERROR, "Failed to initialize decoder for %dx%d @ %d\n",
802  w, h, s->pix_fmt);
803  return changed;
804  }
805  for (s->s.h.tiling.log2_tile_cols = 0;
806  s->sb_cols > (64 << s->s.h.tiling.log2_tile_cols);
807  s->s.h.tiling.log2_tile_cols++) ;
808  for (max = 0; (s->sb_cols >> max) >= 4; max++) ;
809  max = FFMAX(0, max - 1);
810  while (max > s->s.h.tiling.log2_tile_cols) {
811  if (get_bits1(&s->gb))
812  s->s.h.tiling.log2_tile_cols++;
813  else
814  break;
815  }
816  s->s.h.tiling.log2_tile_rows = decode012(&s->gb);
817  s->s.h.tiling.tile_rows = 1 << s->s.h.tiling.log2_tile_rows;
818  if (s->s.h.tiling.tile_cols != (1 << s->s.h.tiling.log2_tile_cols) || changed) {
819  int n_range_coders;
820  VPXRangeCoder *rc;
821 
822  if (s->td) {
823  for (i = 0; i < s->active_tile_cols; i++)
824  vp9_tile_data_free(&s->td[i]);
825  av_freep(&s->td);
826  }
827 
828  s->s.h.tiling.tile_cols = 1 << s->s.h.tiling.log2_tile_cols;
829  s->active_tile_cols = avctx->active_thread_type == FF_THREAD_SLICE ?
830  s->s.h.tiling.tile_cols : 1;
831  vp9_alloc_entries(avctx, s->sb_rows);
832  if (avctx->active_thread_type == FF_THREAD_SLICE) {
833  n_range_coders = 4; // max_tile_rows
834  } else {
835  n_range_coders = s->s.h.tiling.tile_cols;
836  }
837  s->td = av_calloc(s->active_tile_cols, sizeof(VP9TileData) +
838  n_range_coders * sizeof(VPXRangeCoder));
839  if (!s->td)
840  return AVERROR(ENOMEM);
841  rc = (VPXRangeCoder *) &s->td[s->active_tile_cols];
842  for (i = 0; i < s->active_tile_cols; i++) {
843  s->td[i].s = s;
844  s->td[i].c_b = rc;
845  rc += n_range_coders;
846  }
847  }
848 
849  /* check reference frames */
850  if (!s->s.h.keyframe && !s->s.h.intraonly) {
851  int valid_ref_frame = 0;
852  for (i = 0; i < 3; i++) {
853  AVFrame *ref = s->s.refs[s->s.h.refidx[i]].f;
854  int refw = ref->width, refh = ref->height;
855 
856  if (ref->format != avctx->pix_fmt) {
857  av_log(avctx, AV_LOG_ERROR,
858  "Ref pixfmt (%s) did not match current frame (%s)",
859  av_get_pix_fmt_name(ref->format),
860  av_get_pix_fmt_name(avctx->pix_fmt));
861  return AVERROR_INVALIDDATA;
862  } else if (refw == w && refh == h) {
863  s->mvscale[i][0] = s->mvscale[i][1] = 0;
864  } else {
865  /* Check to make sure at least one of frames that */
866  /* this frame references has valid dimensions */
867  if (w * 2 < refw || h * 2 < refh || w > 16 * refw || h > 16 * refh) {
868  av_log(avctx, AV_LOG_WARNING,
869  "Invalid ref frame dimensions %dx%d for frame size %dx%d\n",
870  refw, refh, w, h);
871  s->mvscale[i][0] = s->mvscale[i][1] = REF_INVALID_SCALE;
872  continue;
873  }
874  s->mvscale[i][0] = (refw << 14) / w;
875  s->mvscale[i][1] = (refh << 14) / h;
876  s->mvstep[i][0] = 16 * s->mvscale[i][0] >> 14;
877  s->mvstep[i][1] = 16 * s->mvscale[i][1] >> 14;
878  }
879  valid_ref_frame++;
880  }
881  if (!valid_ref_frame) {
882  av_log(avctx, AV_LOG_ERROR, "No valid reference frame is found, bitstream not supported\n");
883  return AVERROR_INVALIDDATA;
884  }
885  }
886 
887  if (s->s.h.keyframe || s->s.h.errorres || (s->s.h.intraonly && s->s.h.resetctx == 3)) {
888  s->prob_ctx[0].p = s->prob_ctx[1].p = s->prob_ctx[2].p =
889  s->prob_ctx[3].p = ff_vp9_default_probs;
890  memcpy(s->prob_ctx[0].coef, ff_vp9_default_coef_probs,
891  sizeof(ff_vp9_default_coef_probs));
892  memcpy(s->prob_ctx[1].coef, ff_vp9_default_coef_probs,
893  sizeof(ff_vp9_default_coef_probs));
894  memcpy(s->prob_ctx[2].coef, ff_vp9_default_coef_probs,
895  sizeof(ff_vp9_default_coef_probs));
896  memcpy(s->prob_ctx[3].coef, ff_vp9_default_coef_probs,
897  sizeof(ff_vp9_default_coef_probs));
898  } else if (s->s.h.intraonly && s->s.h.resetctx == 2) {
899  s->prob_ctx[c].p = ff_vp9_default_probs;
900  memcpy(s->prob_ctx[c].coef, ff_vp9_default_coef_probs,
901  sizeof(ff_vp9_default_coef_probs));
902  }
903 
904  // next 16 bits is size of the rest of the header (arith-coded)
905  s->s.h.compressed_header_size = size2 = get_bits(&s->gb, 16);
906  s->s.h.uncompressed_header_size = (get_bits_count(&s->gb) + 7) / 8;
907 
908  data2 = align_get_bits(&s->gb);
909  if (size2 > size - (data2 - data)) {
910  av_log(avctx, AV_LOG_ERROR, "Invalid compressed header size\n");
911  return AVERROR_INVALIDDATA;
912  }
913  ret = ff_vpx_init_range_decoder(&s->c, data2, size2);
914  if (ret < 0)
915  return ret;
916 
917  if (vpx_rac_get_prob_branchy(&s->c, 128)) { // marker bit
918  av_log(avctx, AV_LOG_ERROR, "Marker bit was set\n");
919  return AVERROR_INVALIDDATA;
920  }
921 
922  for (i = 0; i < s->active_tile_cols; i++) {
923  if (s->s.h.keyframe || s->s.h.intraonly) {
924  memset(s->td[i].counts.coef, 0, sizeof(s->td[0].counts.coef));
925  memset(s->td[i].counts.eob, 0, sizeof(s->td[0].counts.eob));
926  } else {
927  memset(&s->td[i].counts, 0, sizeof(s->td[0].counts));
928  }
929  s->td[i].nb_block_structure = 0;
930  }
931 
932  /* FIXME is it faster to not copy here, but do it down in the fw updates
933  * as explicit copies if the fw update is missing (and skip the copy upon
934  * fw update)? */
935  s->prob.p = s->prob_ctx[c].p;
936 
937  // txfm updates
938  if (s->s.h.lossless) {
939  s->s.h.txfmmode = TX_4X4;
940  } else {
941  s->s.h.txfmmode = vp89_rac_get_uint(&s->c, 2);
942  if (s->s.h.txfmmode == 3)
943  s->s.h.txfmmode += vp89_rac_get(&s->c);
944 
945  if (s->s.h.txfmmode == TX_SWITCHABLE) {
946  for (i = 0; i < 2; i++)
947  if (vpx_rac_get_prob_branchy(&s->c, 252))
948  s->prob.p.tx8p[i] = update_prob(&s->c, s->prob.p.tx8p[i]);
949  for (i = 0; i < 2; i++)
950  for (j = 0; j < 2; j++)
951  if (vpx_rac_get_prob_branchy(&s->c, 252))
952  s->prob.p.tx16p[i][j] =
953  update_prob(&s->c, s->prob.p.tx16p[i][j]);
954  for (i = 0; i < 2; i++)
955  for (j = 0; j < 3; j++)
956  if (vpx_rac_get_prob_branchy(&s->c, 252))
957  s->prob.p.tx32p[i][j] =
958  update_prob(&s->c, s->prob.p.tx32p[i][j]);
959  }
960  }
961 
962  // coef updates
963  for (i = 0; i < 4; i++) {
964  uint8_t (*ref)[2][6][6][3] = s->prob_ctx[c].coef[i];
965  if (vp89_rac_get(&s->c)) {
966  for (j = 0; j < 2; j++)
967  for (k = 0; k < 2; k++)
968  for (l = 0; l < 6; l++)
969  for (m = 0; m < 6; m++) {
970  uint8_t *p = s->prob.coef[i][j][k][l][m];
971  uint8_t *r = ref[j][k][l][m];
972  if (m >= 3 && l == 0) // dc only has 3 pt
973  break;
974  for (n = 0; n < 3; n++) {
975  if (vpx_rac_get_prob_branchy(&s->c, 252))
976  p[n] = update_prob(&s->c, r[n]);
977  else
978  p[n] = r[n];
979  }
980  memcpy(&p[3], ff_vp9_model_pareto8[p[2]], 8);
981  }
982  } else {
983  for (j = 0; j < 2; j++)
984  for (k = 0; k < 2; k++)
985  for (l = 0; l < 6; l++)
986  for (m = 0; m < 6; m++) {
987  uint8_t *p = s->prob.coef[i][j][k][l][m];
988  uint8_t *r = ref[j][k][l][m];
989  if (m > 3 && l == 0) // dc only has 3 pt
990  break;
991  memcpy(p, r, 3);
992  memcpy(&p[3], ff_vp9_model_pareto8[p[2]], 8);
993  }
994  }
995  if (s->s.h.txfmmode == i)
996  break;
997  }
998 
999  // mode updates
1000  for (i = 0; i < 3; i++)
1001  if (vpx_rac_get_prob_branchy(&s->c, 252))
1002  s->prob.p.skip[i] = update_prob(&s->c, s->prob.p.skip[i]);
1003  if (!s->s.h.keyframe && !s->s.h.intraonly) {
1004  for (i = 0; i < 7; i++)
1005  for (j = 0; j < 3; j++)
1006  if (vpx_rac_get_prob_branchy(&s->c, 252))
1007  s->prob.p.mv_mode[i][j] =
1008  update_prob(&s->c, s->prob.p.mv_mode[i][j]);
1009 
1010  if (s->s.h.filtermode == FILTER_SWITCHABLE)
1011  for (i = 0; i < 4; i++)
1012  for (j = 0; j < 2; j++)
1013  if (vpx_rac_get_prob_branchy(&s->c, 252))
1014  s->prob.p.filter[i][j] =
1015  update_prob(&s->c, s->prob.p.filter[i][j]);
1016 
1017  for (i = 0; i < 4; i++)
1018  if (vpx_rac_get_prob_branchy(&s->c, 252))
1019  s->prob.p.intra[i] = update_prob(&s->c, s->prob.p.intra[i]);
1020 
1021  if (s->s.h.allowcompinter) {
1022  s->s.h.comppredmode = vp89_rac_get(&s->c);
1023  if (s->s.h.comppredmode)
1024  s->s.h.comppredmode += vp89_rac_get(&s->c);
1025  if (s->s.h.comppredmode == PRED_SWITCHABLE)
1026  for (i = 0; i < 5; i++)
1027  if (vpx_rac_get_prob_branchy(&s->c, 252))
1028  s->prob.p.comp[i] =
1029  update_prob(&s->c, s->prob.p.comp[i]);
1030  } else {
1031  s->s.h.comppredmode = PRED_SINGLEREF;
1032  }
1033 
1034  if (s->s.h.comppredmode != PRED_COMPREF) {
1035  for (i = 0; i < 5; i++) {
1036  if (vpx_rac_get_prob_branchy(&s->c, 252))
1037  s->prob.p.single_ref[i][0] =
1038  update_prob(&s->c, s->prob.p.single_ref[i][0]);
1039  if (vpx_rac_get_prob_branchy(&s->c, 252))
1040  s->prob.p.single_ref[i][1] =
1041  update_prob(&s->c, s->prob.p.single_ref[i][1]);
1042  }
1043  }
1044 
1045  if (s->s.h.comppredmode != PRED_SINGLEREF) {
1046  for (i = 0; i < 5; i++)
1047  if (vpx_rac_get_prob_branchy(&s->c, 252))
1048  s->prob.p.comp_ref[i] =
1049  update_prob(&s->c, s->prob.p.comp_ref[i]);
1050  }
1051 
1052  for (i = 0; i < 4; i++)
1053  for (j = 0; j < 9; j++)
1054  if (vpx_rac_get_prob_branchy(&s->c, 252))
1055  s->prob.p.y_mode[i][j] =
1056  update_prob(&s->c, s->prob.p.y_mode[i][j]);
1057 
1058  for (i = 0; i < 4; i++)
1059  for (j = 0; j < 4; j++)
1060  for (k = 0; k < 3; k++)
1061  if (vpx_rac_get_prob_branchy(&s->c, 252))
1062  s->prob.p.partition[3 - i][j][k] =
1063  update_prob(&s->c,
1064  s->prob.p.partition[3 - i][j][k]);
1065 
1066  // mv fields don't use the update_prob subexp model for some reason
1067  for (i = 0; i < 3; i++)
1068  if (vpx_rac_get_prob_branchy(&s->c, 252))
1069  s->prob.p.mv_joint[i] = (vp89_rac_get_uint(&s->c, 7) << 1) | 1;
1070 
1071  for (i = 0; i < 2; i++) {
1072  if (vpx_rac_get_prob_branchy(&s->c, 252))
1073  s->prob.p.mv_comp[i].sign =
1074  (vp89_rac_get_uint(&s->c, 7) << 1) | 1;
1075 
1076  for (j = 0; j < 10; j++)
1077  if (vpx_rac_get_prob_branchy(&s->c, 252))
1078  s->prob.p.mv_comp[i].classes[j] =
1079  (vp89_rac_get_uint(&s->c, 7) << 1) | 1;
1080 
1081  if (vpx_rac_get_prob_branchy(&s->c, 252))
1082  s->prob.p.mv_comp[i].class0 =
1083  (vp89_rac_get_uint(&s->c, 7) << 1) | 1;
1084 
1085  for (j = 0; j < 10; j++)
1086  if (vpx_rac_get_prob_branchy(&s->c, 252))
1087  s->prob.p.mv_comp[i].bits[j] =
1088  (vp89_rac_get_uint(&s->c, 7) << 1) | 1;
1089  }
1090 
1091  for (i = 0; i < 2; i++) {
1092  for (j = 0; j < 2; j++)
1093  for (k = 0; k < 3; k++)
1094  if (vpx_rac_get_prob_branchy(&s->c, 252))
1095  s->prob.p.mv_comp[i].class0_fp[j][k] =
1096  (vp89_rac_get_uint(&s->c, 7) << 1) | 1;
1097 
1098  for (j = 0; j < 3; j++)
1099  if (vpx_rac_get_prob_branchy(&s->c, 252))
1100  s->prob.p.mv_comp[i].fp[j] =
1101  (vp89_rac_get_uint(&s->c, 7) << 1) | 1;
1102  }
1103 
1104  if (s->s.h.highprecisionmvs) {
1105  for (i = 0; i < 2; i++) {
1106  if (vpx_rac_get_prob_branchy(&s->c, 252))
1107  s->prob.p.mv_comp[i].class0_hp =
1108  (vp89_rac_get_uint(&s->c, 7) << 1) | 1;
1109 
1110  if (vpx_rac_get_prob_branchy(&s->c, 252))
1111  s->prob.p.mv_comp[i].hp =
1112  (vp89_rac_get_uint(&s->c, 7) << 1) | 1;
1113  }
1114  }
1115  }
1116 
1117  return (data2 - data) + size2;
1118 }
1119 
1120 static void decode_sb(VP9TileData *td, int row, int col, VP9Filter *lflvl,
1121  ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
1122 {
1123  const VP9Context *s = td->s;
1124  int c = ((s->above_partition_ctx[col] >> (3 - bl)) & 1) |
1125  (((td->left_partition_ctx[row & 0x7] >> (3 - bl)) & 1) << 1);
1126  const uint8_t *p = s->s.h.keyframe || s->s.h.intraonly ? ff_vp9_default_kf_partition_probs[bl][c] :
1127  s->prob.p.partition[bl][c];
1128  enum BlockPartition bp;
1129  ptrdiff_t hbs = 4 >> bl;
1130  AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
1131  ptrdiff_t y_stride = f->linesize[0], uv_stride = f->linesize[1];
1132  int bytesperpixel = s->bytesperpixel;
1133 
1134  if (bl == BL_8X8) {
1135  bp = vp89_rac_get_tree(td->c, ff_vp9_partition_tree, p);
1136  ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
1137  } else if (col + hbs < s->cols) { // FIXME why not <=?
1138  if (row + hbs < s->rows) { // FIXME why not <=?
1139  bp = vp89_rac_get_tree(td->c, ff_vp9_partition_tree, p);
1140  switch (bp) {
1141  case PARTITION_NONE:
1142  ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
1143  break;
1144  case PARTITION_H:
1145  ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
1146  yoff += hbs * 8 * y_stride;
1147  uvoff += hbs * 8 * uv_stride >> s->ss_v;
1148  ff_vp9_decode_block(td, row + hbs, col, lflvl, yoff, uvoff, bl, bp);
1149  break;
1150  case PARTITION_V:
1151  ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
1152  yoff += hbs * 8 * bytesperpixel;
1153  uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
1154  ff_vp9_decode_block(td, row, col + hbs, lflvl, yoff, uvoff, bl, bp);
1155  break;
1156  case PARTITION_SPLIT:
1157  decode_sb(td, row, col, lflvl, yoff, uvoff, bl + 1);
1158  decode_sb(td, row, col + hbs, lflvl,
1159  yoff + 8 * hbs * bytesperpixel,
1160  uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
1161  yoff += hbs * 8 * y_stride;
1162  uvoff += hbs * 8 * uv_stride >> s->ss_v;
1163  decode_sb(td, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
1164  decode_sb(td, row + hbs, col + hbs, lflvl,
1165  yoff + 8 * hbs * bytesperpixel,
1166  uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
1167  break;
1168  default:
1169  av_unreachable("ff_vp9_partition_tree only has "
1170  "the four PARTITION_* terminal codes");
1171  }
1172  } else if (vpx_rac_get_prob_branchy(td->c, p[1])) {
1173  bp = PARTITION_SPLIT;
1174  decode_sb(td, row, col, lflvl, yoff, uvoff, bl + 1);
1175  decode_sb(td, row, col + hbs, lflvl,
1176  yoff + 8 * hbs * bytesperpixel,
1177  uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
1178  } else {
1179  bp = PARTITION_H;
1180  ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
1181  }
1182  } else if (row + hbs < s->rows) { // FIXME why not <=?
1183  if (vpx_rac_get_prob_branchy(td->c, p[2])) {
1184  bp = PARTITION_SPLIT;
1185  decode_sb(td, row, col, lflvl, yoff, uvoff, bl + 1);
1186  yoff += hbs * 8 * y_stride;
1187  uvoff += hbs * 8 * uv_stride >> s->ss_v;
1188  decode_sb(td, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
1189  } else {
1190  bp = PARTITION_V;
1191  ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
1192  }
1193  } else {
1194  bp = PARTITION_SPLIT;
1195  decode_sb(td, row, col, lflvl, yoff, uvoff, bl + 1);
1196  }
1197  td->counts.partition[bl][c][bp]++;
1198 }
1199 
1200 static void decode_sb_mem(VP9TileData *td, int row, int col, VP9Filter *lflvl,
1201  ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
1202 {
1203  const VP9Context *s = td->s;
1204  VP9Block *b = td->b;
1205  ptrdiff_t hbs = 4 >> bl;
1206  AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
1207  ptrdiff_t y_stride = f->linesize[0], uv_stride = f->linesize[1];
1208  int bytesperpixel = s->bytesperpixel;
1209 
1210  if (bl == BL_8X8) {
1211  av_assert2(b->bl == BL_8X8);
1212  ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, b->bl, b->bp);
1213  } else if (td->b->bl == bl) {
1214  ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, b->bl, b->bp);
1215  if (b->bp == PARTITION_H && row + hbs < s->rows) {
1216  yoff += hbs * 8 * y_stride;
1217  uvoff += hbs * 8 * uv_stride >> s->ss_v;
1218  ff_vp9_decode_block(td, row + hbs, col, lflvl, yoff, uvoff, b->bl, b->bp);
1219  } else if (b->bp == PARTITION_V && col + hbs < s->cols) {
1220  yoff += hbs * 8 * bytesperpixel;
1221  uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
1222  ff_vp9_decode_block(td, row, col + hbs, lflvl, yoff, uvoff, b->bl, b->bp);
1223  }
1224  } else {
1225  decode_sb_mem(td, row, col, lflvl, yoff, uvoff, bl + 1);
1226  if (col + hbs < s->cols) { // FIXME why not <=?
1227  if (row + hbs < s->rows) {
1228  decode_sb_mem(td, row, col + hbs, lflvl, yoff + 8 * hbs * bytesperpixel,
1229  uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
1230  yoff += hbs * 8 * y_stride;
1231  uvoff += hbs * 8 * uv_stride >> s->ss_v;
1232  decode_sb_mem(td, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
1233  decode_sb_mem(td, row + hbs, col + hbs, lflvl,
1234  yoff + 8 * hbs * bytesperpixel,
1235  uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
1236  } else {
1237  yoff += hbs * 8 * bytesperpixel;
1238  uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
1239  decode_sb_mem(td, row, col + hbs, lflvl, yoff, uvoff, bl + 1);
1240  }
1241  } else if (row + hbs < s->rows) {
1242  yoff += hbs * 8 * y_stride;
1243  uvoff += hbs * 8 * uv_stride >> s->ss_v;
1244  decode_sb_mem(td, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
1245  }
1246  }
1247 }
1248 
1249 static void set_tile_offset(int *start, int *end, int idx, int log2_n, int n)
1250 {
1251  int sb_start = ( idx * n) >> log2_n;
1252  int sb_end = ((idx + 1) * n) >> log2_n;
1253  *start = FFMIN(sb_start, n) << 3;
1254  *end = FFMIN(sb_end, n) << 3;
1255 }
1256 
1257 static void free_buffers(VP9Context *s)
1258 {
1259  int i;
1260 
1261  av_freep(&s->intra_pred_data[0]);
1262  for (i = 0; i < s->active_tile_cols; i++)
1263  vp9_tile_data_free(&s->td[i]);
1264 }
1265 
1266 static av_cold int vp9_decode_free(AVCodecContext *avctx)
1267 {
1268  VP9Context *s = avctx->priv_data;
1269  int i;
1270 
1271  for (int i = 0; i < 3; i++)
1272  vp9_frame_unref(&s->s.frames[i]);
1273  av_refstruct_pool_uninit(&s->frame_extradata_pool);
1274  for (i = 0; i < 8; i++) {
1275  ff_progress_frame_unref(&s->s.refs[i]);
1276  ff_progress_frame_unref(&s->next_refs[i]);
1277  vp9_frame_unref(&s->s.ref_frames[i]);
1278  }
1279 
1280  free_buffers(s);
1281 #if HAVE_THREADS
1282  av_freep(&s->entries);
1283  ff_pthread_free(s, vp9_context_offsets);
1284 #endif
1285 
1286  av_refstruct_unref(&s->header_ref);
1287  ff_cbs_fragment_free(&s->current_frag);
1288  ff_cbs_close(&s->cbc);
1289 
1290  av_freep(&s->td);
1291  return 0;
1292 }
1293 
1294 static int decode_tiles(AVCodecContext *avctx,
1295  const uint8_t *data, int size)
1296 {
1297  VP9Context *s = avctx->priv_data;
1298  VP9TileData *td = &s->td[0];
1299  int row, col, tile_row, tile_col, ret;
1300  int bytesperpixel;
1301  int tile_row_start, tile_row_end, tile_col_start, tile_col_end;
1302  AVFrame *f;
1303  ptrdiff_t yoff, uvoff, ls_y, ls_uv;
1304 
1305  f = s->s.frames[CUR_FRAME].tf.f;
1306  ls_y = f->linesize[0];
1307  ls_uv =f->linesize[1];
1308  bytesperpixel = s->bytesperpixel;
1309 
1310  yoff = uvoff = 0;
1311  for (tile_row = 0; tile_row < s->s.h.tiling.tile_rows; tile_row++) {
1312  set_tile_offset(&tile_row_start, &tile_row_end,
1313  tile_row, s->s.h.tiling.log2_tile_rows, s->sb_rows);
1314 
1315  for (tile_col = 0; tile_col < s->s.h.tiling.tile_cols; tile_col++) {
1316  int64_t tile_size;
1317 
1318  if (tile_col == s->s.h.tiling.tile_cols - 1 &&
1319  tile_row == s->s.h.tiling.tile_rows - 1) {
1320  tile_size = size;
1321  } else {
1322  tile_size = AV_RB32(data);
1323  data += 4;
1324  size -= 4;
1325  }
1326  if (tile_size > size)
1327  return AVERROR_INVALIDDATA;
1328  ret = ff_vpx_init_range_decoder(&td->c_b[tile_col], data, tile_size);
1329  if (ret < 0)
1330  return ret;
1331  if (vpx_rac_get_prob_branchy(&td->c_b[tile_col], 128)) // marker bit
1332  return AVERROR_INVALIDDATA;
1333  data += tile_size;
1334  size -= tile_size;
1335  }
1336 
1337  for (row = tile_row_start; row < tile_row_end;
1338  row += 8, yoff += ls_y * 64, uvoff += ls_uv * 64 >> s->ss_v) {
1339  VP9Filter *lflvl_ptr = s->lflvl;
1340  ptrdiff_t yoff2 = yoff, uvoff2 = uvoff;
1341 
1342  for (tile_col = 0; tile_col < s->s.h.tiling.tile_cols; tile_col++) {
1343  set_tile_offset(&tile_col_start, &tile_col_end,
1344  tile_col, s->s.h.tiling.log2_tile_cols, s->sb_cols);
1345  td->tile_col_start = tile_col_start;
1346  if (s->pass != 2) {
1347  memset(td->left_partition_ctx, 0, 8);
1348  memset(td->left_skip_ctx, 0, 8);
1349  if (s->s.h.keyframe || s->s.h.intraonly) {
1350  memset(td->left_mode_ctx, DC_PRED, 16);
1351  } else {
1352  memset(td->left_mode_ctx, NEARESTMV, 8);
1353  }
1354  memset(td->left_y_nnz_ctx, 0, 16);
1355  memset(td->left_uv_nnz_ctx, 0, 32);
1356  memset(td->left_segpred_ctx, 0, 8);
1357 
1358  td->c = &td->c_b[tile_col];
1359  }
1360 
1361  for (col = tile_col_start;
1362  col < tile_col_end;
1363  col += 8, yoff2 += 64 * bytesperpixel,
1364  uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
1365  // FIXME integrate with lf code (i.e. zero after each
1366  // use, similar to invtxfm coefficients, or similar)
1367  if (s->pass != 1) {
1368  memset(lflvl_ptr->mask, 0, sizeof(lflvl_ptr->mask));
1369  }
1370 
1371  if (s->pass == 2) {
1372  decode_sb_mem(td, row, col, lflvl_ptr,
1373  yoff2, uvoff2, BL_64X64);
1374  } else {
1375  if (vpx_rac_is_end(td->c)) {
1376  return AVERROR_INVALIDDATA;
1377  }
1378  decode_sb(td, row, col, lflvl_ptr,
1379  yoff2, uvoff2, BL_64X64);
1380  }
1381  }
1382  }
1383 
1384  if (s->pass == 1)
1385  continue;
1386 
1387  // backup pre-loopfilter reconstruction data for intra
1388  // prediction of next row of sb64s
1389  if (row + 8 < s->rows) {
1390  memcpy(s->intra_pred_data[0],
1391  f->data[0] + yoff + 63 * ls_y,
1392  8 * s->cols * bytesperpixel);
1393  memcpy(s->intra_pred_data[1],
1394  f->data[1] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
1395  8 * s->cols * bytesperpixel >> s->ss_h);
1396  memcpy(s->intra_pred_data[2],
1397  f->data[2] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
1398  8 * s->cols * bytesperpixel >> s->ss_h);
1399  }
1400 
1401  // loopfilter one row
1402  if (s->s.h.filter.level) {
1403  yoff2 = yoff;
1404  uvoff2 = uvoff;
1405  lflvl_ptr = s->lflvl;
1406  for (col = 0; col < s->cols;
1407  col += 8, yoff2 += 64 * bytesperpixel,
1408  uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
1409  ff_vp9_loopfilter_sb(avctx, lflvl_ptr, row, col,
1410  yoff2, uvoff2);
1411  }
1412  }
1413 
1414  // FIXME maybe we can make this more finegrained by running the
1415  // loopfilter per-block instead of after each sbrow
1416  // In fact that would also make intra pred left preparation easier?
1417  ff_progress_frame_report(&s->s.frames[CUR_FRAME].tf, row >> 3);
1418  }
1419  }
1420  return 0;
1421 }
1422 
1423 #if HAVE_THREADS
1424 static av_always_inline
1425 int decode_tiles_mt(AVCodecContext *avctx, void *tdata, int jobnr,
1426  int threadnr)
1427 {
1428  VP9Context *s = avctx->priv_data;
1429  VP9TileData *td = &s->td[jobnr];
1430  ptrdiff_t uvoff, yoff, ls_y, ls_uv;
1431  int bytesperpixel = s->bytesperpixel, row, col, tile_row;
1432  unsigned tile_cols_len;
1433  int tile_row_start, tile_row_end, tile_col_start, tile_col_end;
1434  VP9Filter *lflvl_ptr_base;
1435  AVFrame *f;
1436 
1437  f = s->s.frames[CUR_FRAME].tf.f;
1438  ls_y = f->linesize[0];
1439  ls_uv =f->linesize[1];
1440 
1441  set_tile_offset(&tile_col_start, &tile_col_end,
1442  jobnr, s->s.h.tiling.log2_tile_cols, s->sb_cols);
1443  td->tile_col_start = tile_col_start;
1444  uvoff = (64 * bytesperpixel >> s->ss_h)*(tile_col_start >> 3);
1445  yoff = (64 * bytesperpixel)*(tile_col_start >> 3);
1446  lflvl_ptr_base = s->lflvl+(tile_col_start >> 3);
1447 
1448  for (tile_row = 0; tile_row < s->s.h.tiling.tile_rows; tile_row++) {
1449  set_tile_offset(&tile_row_start, &tile_row_end,
1450  tile_row, s->s.h.tiling.log2_tile_rows, s->sb_rows);
1451 
1452  td->c = &td->c_b[tile_row];
1453  for (row = tile_row_start; row < tile_row_end;
1454  row += 8, yoff += ls_y * 64, uvoff += ls_uv * 64 >> s->ss_v) {
1455  ptrdiff_t yoff2 = yoff, uvoff2 = uvoff;
1456  VP9Filter *lflvl_ptr = lflvl_ptr_base+s->sb_cols*(row >> 3);
1457 
1458  memset(td->left_partition_ctx, 0, 8);
1459  memset(td->left_skip_ctx, 0, 8);
1460  if (s->s.h.keyframe || s->s.h.intraonly) {
1461  memset(td->left_mode_ctx, DC_PRED, 16);
1462  } else {
1463  memset(td->left_mode_ctx, NEARESTMV, 8);
1464  }
1465  memset(td->left_y_nnz_ctx, 0, 16);
1466  memset(td->left_uv_nnz_ctx, 0, 32);
1467  memset(td->left_segpred_ctx, 0, 8);
1468 
1469  for (col = tile_col_start;
1470  col < tile_col_end;
1471  col += 8, yoff2 += 64 * bytesperpixel,
1472  uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
1473  // FIXME integrate with lf code (i.e. zero after each
1474  // use, similar to invtxfm coefficients, or similar)
1475  memset(lflvl_ptr->mask, 0, sizeof(lflvl_ptr->mask));
1476  decode_sb(td, row, col, lflvl_ptr,
1477  yoff2, uvoff2, BL_64X64);
1478  }
1479 
1480  // backup pre-loopfilter reconstruction data for intra
1481  // prediction of next row of sb64s
1482  tile_cols_len = tile_col_end - tile_col_start;
1483  if (row + 8 < s->rows) {
1484  memcpy(s->intra_pred_data[0] + (tile_col_start * 8 * bytesperpixel),
1485  f->data[0] + yoff + 63 * ls_y,
1486  8 * tile_cols_len * bytesperpixel);
1487  memcpy(s->intra_pred_data[1] + (tile_col_start * 8 * bytesperpixel >> s->ss_h),
1488  f->data[1] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
1489  8 * tile_cols_len * bytesperpixel >> s->ss_h);
1490  memcpy(s->intra_pred_data[2] + (tile_col_start * 8 * bytesperpixel >> s->ss_h),
1491  f->data[2] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
1492  8 * tile_cols_len * bytesperpixel >> s->ss_h);
1493  }
1494 
1495  vp9_report_tile_progress(s, row >> 3, 1);
1496  }
1497  }
1498  return 0;
1499 }
1500 
1501 static av_always_inline
1502 int loopfilter_proc(AVCodecContext *avctx)
1503 {
1504  VP9Context *s = avctx->priv_data;
1505  ptrdiff_t uvoff, yoff, ls_y, ls_uv;
1506  VP9Filter *lflvl_ptr;
1507  int bytesperpixel = s->bytesperpixel, col, i;
1508  AVFrame *f;
1509 
1510  f = s->s.frames[CUR_FRAME].tf.f;
1511  ls_y = f->linesize[0];
1512  ls_uv =f->linesize[1];
1513 
1514  for (i = 0; i < s->sb_rows; i++) {
1515  vp9_await_tile_progress(s, i, s->s.h.tiling.tile_cols);
1516 
1517  if (s->s.h.filter.level) {
1518  yoff = (ls_y * 64)*i;
1519  uvoff = (ls_uv * 64 >> s->ss_v)*i;
1520  lflvl_ptr = s->lflvl+s->sb_cols*i;
1521  for (col = 0; col < s->cols;
1522  col += 8, yoff += 64 * bytesperpixel,
1523  uvoff += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
1524  ff_vp9_loopfilter_sb(avctx, lflvl_ptr, i << 3, col,
1525  yoff, uvoff);
1526  }
1527  }
1528  }
1529  return 0;
1530 }
1531 #endif
1532 
1533 static int vp9_export_enc_params(VP9Context *s, VP9Frame *frame)
1534 {
1535  AVVideoEncParams *par;
1536  unsigned int tile, nb_blocks = 0;
1537 
1538  if (s->s.h.segmentation.enabled) {
1539  for (tile = 0; tile < s->active_tile_cols; tile++)
1540  nb_blocks += s->td[tile].nb_block_structure;
1541  }
1542 
1543  par = av_video_enc_params_create_side_data(frame->tf.f,
1544  AV_VIDEO_ENC_PARAMS_VP9, nb_blocks);
1545  if (!par)
1546  return AVERROR(ENOMEM);
1547 
1548  par->qp = s->s.h.yac_qi;
1549  par->delta_qp[0][0] = s->s.h.ydc_qdelta;
1550  par->delta_qp[1][0] = s->s.h.uvdc_qdelta;
1551  par->delta_qp[2][0] = s->s.h.uvdc_qdelta;
1552  par->delta_qp[1][1] = s->s.h.uvac_qdelta;
1553  par->delta_qp[2][1] = s->s.h.uvac_qdelta;
1554 
1555  if (nb_blocks) {
1556  unsigned int block = 0;
1557  unsigned int tile, block_tile;
1558 
1559  for (tile = 0; tile < s->active_tile_cols; tile++) {
1560  VP9TileData *td = &s->td[tile];
1561 
1562  for (block_tile = 0; block_tile < td->nb_block_structure; block_tile++) {
1563  AVVideoBlockParams *b = av_video_enc_params_block(par, block++);
1564  unsigned int row = td->block_structure[block_tile].row;
1565  unsigned int col = td->block_structure[block_tile].col;
1566  uint8_t seg_id = frame->segmentation_map[row * 8 * s->sb_cols + col];
1567 
1568  b->src_x = col * 8;
1569  b->src_y = row * 8;
1570  b->w = 1 << (3 + td->block_structure[block_tile].block_size_idx_x);
1571  b->h = 1 << (3 + td->block_structure[block_tile].block_size_idx_y);
1572 
1573  if (s->s.h.segmentation.feat[seg_id].q_enabled) {
1574  b->delta_qp = s->s.h.segmentation.feat[seg_id].q_val;
1575  if (s->s.h.segmentation.absolute_vals)
1576  b->delta_qp -= par->qp;
1577  }
1578  }
1579  }
1580  }
1581 
1582  return 0;
1583 }
1584 
1585 static void vp9_warn_unsupported_webm_alpha(AVCodecContext *avctx,
1586  const AVPacket *pkt)
1587 {
1588  VP9Context *s = avctx->priv_data;
1589  const uint8_t *sd;
1590  size_t sd_size;
1591 
1592  sd = av_packet_get_side_data(pkt, AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL,
1593  &sd_size);
1594  if (!sd || sd_size < 8 || AV_RB64(sd) != 1)
1595  return;
1596 
1597  av_log_once(avctx, AV_LOG_WARNING, AV_LOG_DEBUG,
1598  &s->webm_alpha_warned,
1599  "Ignoring unsupported WebM alpha channel side data; use the "
1600  "libvpx-vp9 decoder to decode it.\n");
1601 }
1602 
1603 static int vp9_decode_frame(AVCodecContext *avctx, AVFrame *frame,
1604  int *got_frame, AVPacket *pkt)
1605 {
1606  const uint8_t *data = pkt->data;
1607  int size = pkt->size;
1608  VP9Context *s = avctx->priv_data;
1609  int ret, i, j, ref;
1610  CodedBitstreamUnit *unit;
1611  VP9RawFrame *rf;
1612 
1613  int retain_segmap_ref = s->s.frames[REF_FRAME_SEGMAP].segmentation_map &&
1614  (!s->s.h.segmentation.enabled || !s->s.h.segmentation.update_map);
1615  const VP9Frame *src;
1616  AVFrame *f;
1617 
1618  vp9_warn_unsupported_webm_alpha(avctx, pkt);
1619 
1620  ret = ff_cbs_read_packet(s->cbc, &s->current_frag, pkt);
1621  if (ret < 0) {
1622  ff_cbs_fragment_reset(&s->current_frag);
1623  av_log(avctx, AV_LOG_ERROR, "Failed to read frame header.\n");
1624  return ret;
1625  }
1626 
1627  unit = &s->current_frag.units[0];
1628  rf = unit->content;
1629 
1630  av_refstruct_replace(&s->header_ref, unit->content_ref);
1631  s->frame_header = &rf->header;
1632 
1633  if ((ret = decode_frame_header(avctx, data, size, &ref)) < 0) {
1634  ff_cbs_fragment_reset(&s->current_frag);
1635  return ret;
1636  } else if (ret == 0) {
1637  if (!s->s.refs[ref].f) {
1638  av_log(avctx, AV_LOG_ERROR, "Requested reference %d not available\n", ref);
1639  ff_cbs_fragment_reset(&s->current_frag);
1640  return AVERROR_INVALIDDATA;
1641  }
1642  for (int i = 0; i < 8; i++)
1643  ff_progress_frame_replace(&s->next_refs[i], &s->s.refs[i]);
1644  ff_thread_finish_setup(avctx);
1645  ff_progress_frame_await(&s->s.refs[ref], INT_MAX);
1646  ff_cbs_fragment_reset(&s->current_frag);
1647 
1648  if ((ret = av_frame_ref(frame, s->s.refs[ref].f)) < 0)
1649  return ret;
1650  frame->pts = pkt->pts;
1651  frame->pkt_dts = pkt->dts;
1652  *got_frame = 1;
1653  return pkt->size;
1654  }
1655  data += ret;
1656  size -= ret;
1657 
1658  src = !s->s.h.keyframe && !s->s.h.intraonly && !s->s.h.errorres ?
1659  &s->s.frames[CUR_FRAME] : &s->s.frames[BLANK_FRAME];
1660  if (!retain_segmap_ref || s->s.h.keyframe || s->s.h.intraonly)
1661  vp9_frame_replace(&s->s.frames[REF_FRAME_SEGMAP], src);
1662  vp9_frame_replace(&s->s.frames[REF_FRAME_MVPAIR], src);
1663  vp9_frame_unref(&s->s.frames[CUR_FRAME]);
1664  if ((ret = vp9_frame_alloc(avctx, &s->s.frames[CUR_FRAME])) < 0) {
1665  ff_cbs_fragment_reset(&s->current_frag);
1666  return ret;
1667  }
1668 
1669  s->s.frames[CUR_FRAME].header_ref = av_refstruct_ref(s->header_ref);
1670  s->s.frames[CUR_FRAME].frame_header = s->frame_header;
1671 
1672  f = s->s.frames[CUR_FRAME].tf.f;
1673  if (s->s.h.keyframe)
1674  f->flags |= AV_FRAME_FLAG_KEY;
1675  else
1676  f->flags &= ~AV_FRAME_FLAG_KEY;
1677  if (s->s.h.lossless)
1678  f->flags |= AV_FRAME_FLAG_LOSSLESS;
1679  else
1680  f->flags &= ~AV_FRAME_FLAG_LOSSLESS;
1681  f->pict_type = (s->s.h.keyframe || s->s.h.intraonly) ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
1682 
1683  // Non-existent frames have the implicit dimension 0x0 != CUR_FRAME
1684  if (!s->s.frames[REF_FRAME_MVPAIR].tf.f ||
1685  (s->s.frames[REF_FRAME_MVPAIR].tf.f->width != s->s.frames[CUR_FRAME].tf.f->width ||
1686  s->s.frames[REF_FRAME_MVPAIR].tf.f->height != s->s.frames[CUR_FRAME].tf.f->height)) {
1687  vp9_frame_unref(&s->s.frames[REF_FRAME_SEGMAP]);
1688  }
1689 
1690  // ref frame setup
1691  for (i = 0; i < 8; i++) {
1692  ff_progress_frame_replace(&s->next_refs[i],
1693  s->s.h.refreshrefmask & (1 << i) ?
1694  &s->s.frames[CUR_FRAME].tf : &s->s.refs[i]);
1695  }
1696 
1697  if (avctx->hwaccel) {
1698  const FFHWAccel *hwaccel = ffhwaccel(avctx->hwaccel);
1699  ret = hwaccel->start_frame(avctx, pkt->buf, pkt->data, pkt->size);
1700  if (ret < 0)
1701  return ret;
1702  ret = hwaccel->decode_slice(avctx, pkt->data, pkt->size);
1703  if (ret < 0)
1704  return ret;
1705  ret = hwaccel->end_frame(avctx);
1706  if (ret < 0)
1707  return ret;
1708 
1709  for (i = 0; i < 8; i++) {
1710  vp9_frame_replace(&s->s.ref_frames[i],
1711  s->s.h.refreshrefmask & (1 << i) ?
1712  &s->s.frames[CUR_FRAME] : &s->s.ref_frames[i]);
1713  }
1714 
1715  goto finish;
1716  }
1717 
1718  // main tile decode loop
1719  memset(s->above_partition_ctx, 0, s->cols);
1720  memset(s->above_skip_ctx, 0, s->cols);
1721  if (s->s.h.keyframe || s->s.h.intraonly) {
1722  memset(s->above_mode_ctx, DC_PRED, s->cols * 2);
1723  } else {
1724  memset(s->above_mode_ctx, NEARESTMV, s->cols);
1725  }
1726  memset(s->above_y_nnz_ctx, 0, s->sb_cols * 16);
1727  memset(s->above_uv_nnz_ctx[0], 0, s->sb_cols * 16 >> s->ss_h);
1728  memset(s->above_uv_nnz_ctx[1], 0, s->sb_cols * 16 >> s->ss_h);
1729  memset(s->above_segpred_ctx, 0, s->cols);
1730  s->pass = s->s.frames[CUR_FRAME].uses_2pass =
1731  avctx->active_thread_type == FF_THREAD_FRAME && s->s.h.refreshctx && !s->s.h.parallelmode;
1732  if ((ret = update_block_buffers(avctx)) < 0) {
1733  av_log(avctx, AV_LOG_ERROR,
1734  "Failed to allocate block buffers\n");
1735  return ret;
1736  }
1737  if (s->s.h.refreshctx && s->s.h.parallelmode) {
1738  int j, k, l, m;
1739 
1740  for (i = 0; i < 4; i++) {
1741  for (j = 0; j < 2; j++)
1742  for (k = 0; k < 2; k++)
1743  for (l = 0; l < 6; l++)
1744  for (m = 0; m < 6; m++)
1745  memcpy(s->prob_ctx[s->s.h.framectxid].coef[i][j][k][l][m],
1746  s->prob.coef[i][j][k][l][m], 3);
1747  if (s->s.h.txfmmode == i)
1748  break;
1749  }
1750  s->prob_ctx[s->s.h.framectxid].p = s->prob.p;
1751  ff_thread_finish_setup(avctx);
1752  } else if (!s->s.h.refreshctx) {
1753  ff_thread_finish_setup(avctx);
1754  }
1755 
1756 #if HAVE_THREADS
1757  if (avctx->active_thread_type & FF_THREAD_SLICE) {
1758  for (i = 0; i < s->sb_rows; i++)
1759  atomic_init(&s->entries[i], 0);
1760  }
1761 #endif
1762 
1763  do {
1764  for (i = 0; i < s->active_tile_cols; i++) {
1765  s->td[i].b = s->td[i].b_base;
1766  s->td[i].block = s->td[i].block_base;
1767  s->td[i].uvblock[0] = s->td[i].uvblock_base[0];
1768  s->td[i].uvblock[1] = s->td[i].uvblock_base[1];
1769  s->td[i].eob = s->td[i].eob_base;
1770  s->td[i].uveob[0] = s->td[i].uveob_base[0];
1771  s->td[i].uveob[1] = s->td[i].uveob_base[1];
1772  s->td[i].error_info = 0;
1773  }
1774 
1775 #if HAVE_THREADS
1776  if (avctx->active_thread_type == FF_THREAD_SLICE) {
1777  int tile_row, tile_col;
1778 
1779  av_assert1(!s->pass);
1780 
1781  for (tile_row = 0; tile_row < s->s.h.tiling.tile_rows; tile_row++) {
1782  for (tile_col = 0; tile_col < s->s.h.tiling.tile_cols; tile_col++) {
1783  int64_t tile_size;
1784 
1785  if (tile_col == s->s.h.tiling.tile_cols - 1 &&
1786  tile_row == s->s.h.tiling.tile_rows - 1) {
1787  tile_size = size;
1788  } else {
1789  tile_size = AV_RB32(data);
1790  data += 4;
1791  size -= 4;
1792  }
1793  if (tile_size > size)
1794  return AVERROR_INVALIDDATA;
1795  ret = ff_vpx_init_range_decoder(&s->td[tile_col].c_b[tile_row], data, tile_size);
1796  if (ret < 0)
1797  return ret;
1798  if (vpx_rac_get_prob_branchy(&s->td[tile_col].c_b[tile_row], 128)) // marker bit
1799  return AVERROR_INVALIDDATA;
1800  data += tile_size;
1801  size -= tile_size;
1802  }
1803  }
1804 
1805  ff_slice_thread_execute_with_mainfunc(avctx, decode_tiles_mt, loopfilter_proc, s->td, NULL, s->s.h.tiling.tile_cols);
1806  } else
1807 #endif
1808  {
1809  ret = decode_tiles(avctx, data, size);
1810  if (ret < 0)
1811  goto fail;
1812  }
1813 
1814  // Sum all counts fields into td[0].counts for tile threading
1815  if (avctx->active_thread_type == FF_THREAD_SLICE)
1816  for (i = 1; i < s->s.h.tiling.tile_cols; i++)
1817  for (j = 0; j < sizeof(s->td[i].counts) / sizeof(unsigned); j++)
1818  ((unsigned *)&s->td[0].counts)[j] += ((unsigned *)&s->td[i].counts)[j];
1819 
1820  if (s->pass < 2 && s->s.h.refreshctx && !s->s.h.parallelmode) {
1821  ff_vp9_adapt_probs(s);
1822  ff_thread_finish_setup(avctx);
1823  }
1824  } while (s->pass++ == 1);
1825 
1826  if (s->td->error_info < 0) {
1827  av_log(avctx, AV_LOG_ERROR, "Failed to decode tile data\n");
1828  s->td->error_info = 0;
1829  ret = AVERROR_INVALIDDATA;
1830  goto fail;
1831  }
1832  if (avctx->export_side_data & AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS) {
1833  ret = vp9_export_enc_params(s, &s->s.frames[CUR_FRAME]);
1834  if (ret < 0)
1835  goto fail;
1836  }
1837 
1838 finish:
1839  ff_cbs_fragment_reset(&s->current_frag);
1840 
1841  ff_progress_frame_report(&s->s.frames[CUR_FRAME].tf, INT_MAX);
1842  // ref frame setup
1843  for (int i = 0; i < 8; i++)
1844  ff_progress_frame_replace(&s->s.refs[i], &s->next_refs[i]);
1845 
1846  if (!s->s.h.invisible) {
1847  if ((ret = av_frame_ref(frame, s->s.frames[CUR_FRAME].tf.f)) < 0)
1848  return ret;
1849  *got_frame = 1;
1850  }
1851 
1852  return pkt->size;
1853 fail:
1854  ff_cbs_fragment_reset(&s->current_frag);
1855  ff_progress_frame_report(&s->s.frames[CUR_FRAME].tf, INT_MAX);
1856  return ret;
1857 }
1858 
1859 static av_cold void vp9_decode_flush(AVCodecContext *avctx)
1860 {
1861  VP9Context *s = avctx->priv_data;
1862  int i;
1863 
1864  for (i = 0; i < 3; i++)
1865  vp9_frame_unref(&s->s.frames[i]);
1866 
1867  for (i = 0; i < 8; i++) {
1868  ff_progress_frame_unref(&s->s.refs[i]);
1869  vp9_frame_unref(&s->s.ref_frames[i]);
1870  }
1871 
1872  ff_cbs_fragment_reset(&s->current_frag);
1873  ff_cbs_flush(s->cbc);
1874 
1875  if (FF_HW_HAS_CB(avctx, flush))
1876  FF_HW_SIMPLE_CALL(avctx, flush);
1877 }
1878 
1879 static av_cold int vp9_decode_init(AVCodecContext *avctx)
1880 {
1881  VP9Context *s = avctx->priv_data;
1882  int ret;
1883 
1884  s->last_bpp = 0;
1885  s->s.h.filter.sharpness = -1;
1886 
1887  ret = ff_cbs_init(&s->cbc, AV_CODEC_ID_VP9, avctx);
1888  if (ret < 0)
1889  return ret;
1890 
1891 #if HAVE_THREADS
1892  if (avctx->active_thread_type & FF_THREAD_SLICE) {
1893  ret = ff_pthread_init(s, vp9_context_offsets);
1894  if (ret < 0)
1895  return ret;
1896  }
1897 #endif
1898 
1899  return 0;
1900 }
1901 
1902 #if HAVE_THREADS
1903 static int vp9_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
1904 {
1905  VP9Context *s = dst->priv_data, *ssrc = src->priv_data;
1906 
1907  for (int i = 0; i < 3; i++)
1908  vp9_frame_replace(&s->s.frames[i], &ssrc->s.frames[i]);
1909  for (int i = 0; i < 8; i++)
1910  ff_progress_frame_replace(&s->s.refs[i], &ssrc->next_refs[i]);
1911  av_refstruct_replace(&s->frame_extradata_pool, ssrc->frame_extradata_pool);
1912  s->frame_extradata_pool_size = ssrc->frame_extradata_pool_size;
1913 
1914  av_refstruct_replace(&s->header_ref, ssrc->header_ref);
1915  for (int i = 0; i < 8; i++)
1916  vp9_frame_replace(&s->s.ref_frames[i], &ssrc->s.ref_frames[i]);
1917 
1918  s->frame_header = ssrc->frame_header;
1919  memcpy(s->cbc->priv_data, ssrc->cbc->priv_data, sizeof(CodedBitstreamVP9Context));
1920 
1921  s->s.h.invisible = ssrc->s.h.invisible;
1922  s->s.h.keyframe = ssrc->s.h.keyframe;
1923  s->s.h.intraonly = ssrc->s.h.intraonly;
1924  s->ss_v = ssrc->ss_v;
1925  s->ss_h = ssrc->ss_h;
1926  s->s.h.segmentation.enabled = ssrc->s.h.segmentation.enabled;
1927  s->s.h.segmentation.update_map = ssrc->s.h.segmentation.update_map;
1928  s->s.h.segmentation.absolute_vals = ssrc->s.h.segmentation.absolute_vals;
1929  s->bytesperpixel = ssrc->bytesperpixel;
1930  s->gf_fmt = ssrc->gf_fmt;
1931  s->w = ssrc->w;
1932  s->h = ssrc->h;
1933  s->s.h.bpp = ssrc->s.h.bpp;
1934  s->bpp_index = ssrc->bpp_index;
1935  s->pix_fmt = ssrc->pix_fmt;
1936  s->webm_alpha_warned = ssrc->webm_alpha_warned;
1937  memcpy(&s->prob_ctx, &ssrc->prob_ctx, sizeof(s->prob_ctx));
1938  memcpy(&s->s.h.lf_delta, &ssrc->s.h.lf_delta, sizeof(s->s.h.lf_delta));
1939  memcpy(&s->s.h.segmentation.feat, &ssrc->s.h.segmentation.feat,
1940  sizeof(s->s.h.segmentation.feat));
1941 
1942  return 0;
1943 }
1944 #endif
1945 
1946 const FFCodec ff_vp9_decoder = {
1947  .p.name = "vp9",
1948  CODEC_LONG_NAME("Google VP9"),
1949  .p.type = AVMEDIA_TYPE_VIDEO,
1950  .p.id = AV_CODEC_ID_VP9,
1951  .priv_data_size = sizeof(VP9Context),
1952  .init = vp9_decode_init,
1953  .close = vp9_decode_free,
1954  FF_CODEC_DECODE_CB(vp9_decode_frame),
1955  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS,
1956  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP |
1957  FF_CODEC_CAP_SLICE_THREAD_HAS_MF |
1958  FF_CODEC_CAP_USES_PROGRESSFRAMES,
1959  .flush = vp9_decode_flush,
1960  UPDATE_THREAD_CONTEXT(vp9_decode_update_thread_context),
1961  .p.profiles = NULL_IF_CONFIG_SMALL(ff_vp9_profiles),
1962  .bsfs = "vp9_superframe_split",
1963  .hw_configs = (const AVCodecHWConfigInternal *const []) {
1964 #if CONFIG_VP9_DXVA2_HWACCEL
1965  HWACCEL_DXVA2(vp9),
1966 #endif
1967 #if CONFIG_VP9_D3D11VA_HWACCEL
1968  HWACCEL_D3D11VA(vp9),
1969 #endif
1970 #if CONFIG_VP9_D3D11VA2_HWACCEL
1971  HWACCEL_D3D11VA2(vp9),
1972 #endif
1973 #if CONFIG_VP9_D3D12VA_HWACCEL
1974  HWACCEL_D3D12VA(vp9),
1975 #endif
1976 #if CONFIG_VP9_NVDEC_HWACCEL
1977  HWACCEL_NVDEC(vp9),
1978 #endif
1979 #if CONFIG_VP9_NVDEC_CUARRAY_HWACCEL
1980  HWACCEL_NVDEC_CUARRAY(vp9),
1981 #endif
1982 #if CONFIG_VP9_VAAPI_HWACCEL
1983  HWACCEL_VAAPI(vp9),
1984 #endif
1985 #if CONFIG_VP9_VDPAU_HWACCEL
1986  HWACCEL_VDPAU(vp9),
1987 #endif
1988 #if CONFIG_VP9_VIDEOTOOLBOX_HWACCEL
1989  HWACCEL_VIDEOTOOLBOX(vp9),
1990 #endif
1991 #if CONFIG_VP9_VULKAN_HWACCEL
1992  HWACCEL_VULKAN(vp9),
1993 #endif
1994  NULL
1995  },
1996 };
VP9TileData::left_y_nnz_ctx
uint8_t left_y_nnz_ctx[16]
Definition: vp9dec.h:218
HWACCEL_D3D12VA
#define HWACCEL_D3D12VA(codec)
Definition: hwconfig.h:82
AVVideoEncParams::qp
int32_t qp
Base quantisation parameter for the frame.
Definition: video_enc_params.h:103
hwconfig.h
ff_progress_frame_report
void ff_progress_frame_report(ProgressFrame *f, int n)
Notify later decoding threads when part of their reference frame is ready.
Definition: decode.c:1979
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1423
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
AV_PIX_FMT_CUDA
@ AV_PIX_FMT_CUDA
HW acceleration through CUDA.
Definition: pixfmt.h:260
FF_CODEC_CAP_SLICE_THREAD_HAS_MF
#define FF_CODEC_CAP_SLICE_THREAD_HAS_MF
Codec initializes slice-based threading with a main function.
Definition: codec_internal.h:65
decode_tiles
static int decode_tiles(AVCodecContext *avctx, const uint8_t *data, int size)
Definition: vp9.c:1294
CodedBitstreamUnit::content_ref
void * content_ref
If content is reference counted, a RefStruct reference backing content.
Definition: cbs.h:119
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
vp9_frame_alloc
static int vp9_frame_alloc(AVCodecContext *avctx, VP9Frame *f)
Definition: vp9.c:108
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:43
r
const char * r
Definition: vf_curves.c:127
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
PRED_SWITCHABLE
@ PRED_SWITCHABLE
Definition: vp9shared.h:53
PRED_SINGLEREF
@ PRED_SINGLEREF
Definition: vp9shared.h:51
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:671
VP9TileData::uvblock_base
int16_t * uvblock_base[2]
Definition: vp9dec.h:234
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1229
VP9TileData::partition
unsigned partition[4][4][4]
Definition: vp9dec.h:209
VP9Frame
Definition: vp9shared.h:66
av_clip_uintp2
#define av_clip_uintp2
Definition: common.h:124
HWACCEL_NVDEC_CUARRAY
#define HWACCEL_NVDEC_CUARRAY(codec)
Definition: hwconfig.h:70
ff_vp9_decoder
const FFCodec ff_vp9_decoder
Definition: vp9.c:1946
decode_sb
static void decode_sb(VP9TileData *td, int row, int col, VP9Filter *lflvl, ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
Definition: vp9.c:1120
ff_vp9_adapt_probs
void ff_vp9_adapt_probs(VP9Context *s)
Definition: vp9prob.c:44
CodedBitstreamUnit::content
void * content
Pointer to the decomposed form of this unit.
Definition: cbs.h:114
av_cold
#define av_cold
Definition: attributes.h:119
int64_t
long long int64_t
Definition: coverity.c:34
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:254
VP9TileData::left_skip_ctx
uint8_t left_skip_ctx[8]
Definition: vp9dec.h:223
VP9TileData::row
int row
Definition: vp9dec.h:179
PRED_COMPREF
@ PRED_COMPREF
Definition: vp9shared.h:52
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:472
pixdesc.h
HWACCEL_DXVA2
#define HWACCEL_DXVA2(codec)
Definition: hwconfig.h:64
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:783
BlockPartition
BlockPartition
Definition: vp9shared.h:36
AVPacket::data
uint8_t * data
Definition: packet.h:603
DC_PRED
@ DC_PRED
Definition: vp9.h:48
pthread_mutex_lock
static av_always_inline int pthread_mutex_lock(pthread_mutex_t *mutex)
Definition: os2threads.h:119
HWACCEL_D3D11VA2
#define HWACCEL_D3D11VA2(codec)
Definition: hwconfig.h:66
b
#define b
Definition: input.c:43
ff_progress_frame_get_buffer
int ff_progress_frame_get_buffer(AVCodecContext *avctx, ProgressFrame *f, int flags)
Wrapper around ff_progress_frame_alloc() and ff_thread_get_buffer().
Definition: decode.c:1939
data
const char data[16]
Definition: mxf.c:149
update_size
static int update_size(AVCodecContext *avctx, int w, int h)
Definition: vp9.c:166
decode_sb_mem
static void decode_sb_mem(VP9TileData *td, int row, int col, VP9Filter *lflvl, ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
Definition: vp9.c:1200
REF_FRAME_SEGMAP
#define REF_FRAME_SEGMAP
Definition: vp9shared.h:174
decode_frame_header
static int decode_frame_header(AVCodecContext *avctx, const uint8_t *data, int size, int *ref)
Definition: vp9.c:529
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:545
atomic_int
intptr_t atomic_int
Definition: stdatomic.h:55
AV_PIX_FMT_D3D11VA_VLD
@ AV_PIX_FMT_D3D11VA_VLD
HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView p...
Definition: pixfmt.h:254
FFCodec
Definition: codec_internal.h:127
VP9TileData::c_b
VPXRangeCoder * c_b
Definition: vp9dec.h:177
AVCOL_SPC_RGB
@ AVCOL_SPC_RGB
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1
Definition: pixfmt.h:707
VP9TileData::left_segpred_ctx
uint8_t left_segpred_ctx[8]
Definition: vp9dec.h:225
FF_HW_SIMPLE_CALL
#define FF_HW_SIMPLE_CALL(avctx, function)
Definition: hwaccel_internal.h:176
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:106
max
#define max(a, b)
Definition: cuda_runtime.h:33
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
VP9_SYNCCODE
#define VP9_SYNCCODE
Definition: vp9.c:51
VP9Block::bl
enum BlockLevel bl
Definition: vp9dec.h:91
vp89_rac.h
VP9Filter
Definition: vp9dec.h:79
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Definition: utils.c:91
VP9TileData::b
VP9Block * b
Definition: vp9dec.h:182
VPXRangeCoder
Definition: vpx_rac.h:35
thread.h
ff_pthread_free
av_cold void ff_pthread_free(void *obj, const unsigned offsets[])
Definition: pthread.c:92
AV_PIX_FMT_VULKAN
@ AV_PIX_FMT_VULKAN
Vulkan hardware images.
Definition: pixfmt.h:379
FILTER_SWITCHABLE
@ FILTER_SWITCHABLE
Definition: vp9.h:70
CodedBitstreamUnit
Coded bitstream unit structure.
Definition: cbs.h:77
VP9Block
Definition: vp9dec.h:85
av_always_inline
#define av_always_inline
Definition: attributes.h:76
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:383
close
static av_cold void close(AVCodecParserContext *s)
Definition: apv_parser.c:197
AVCOL_SPC_BT470BG
@ AVCOL_SPC_BT470BG
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
Definition: pixfmt.h:712
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:337
AVCOL_SPC_RESERVED
@ AVCOL_SPC_RESERVED
reserved for future use by ITU-T and ISO/IEC just like 15-255 are
Definition: pixfmt.h:710
TX_SWITCHABLE
@ TX_SWITCHABLE
Definition: vp9.h:33
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
finish
static void finish(void)
Definition: movenc.c:374
FFHWAccel
Definition: hwaccel_internal.h:34
ff_vp9_ac_qlookup
const int16_t ff_vp9_ac_qlookup[3][256]
Definition: vp9data.c:334
AVVideoEncParams::delta_qp
int32_t delta_qp[4][2]
Quantisation parameter offset from the base (per-frame) qp for a given plane (first index) and AC/DC ...
Definition: video_enc_params.h:109
AV_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME
#define AV_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME
If this flag is set, the entries will be zeroed before being returned to the user (after the init or ...
Definition: refstruct.h:221
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:564
GetBitContext
Definition: get_bits.h:109
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:500
HWACCEL_VDPAU
#define HWACCEL_VDPAU(codec)
Definition: hwconfig.h:74
ff_videodsp_init
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:39
PARTITION_NONE
@ PARTITION_NONE
Definition: vp9shared.h:37
vp9_frame_unref
static void vp9_frame_unref(VP9Frame *f)
Definition: vp9.c:99
progressframe.h
refstruct.h
AVVideoEncParams
Video encoding parameters for a given frame.
Definition: video_enc_params.h:73
VP9TileData::col
int col
Definition: vp9dec.h:179
vp9_decode_free
static av_cold int vp9_decode_free(AVCodecContext *avctx)
Definition: vp9.c:1266
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:548
avassert.h
FF_CODEC_CAP_USES_PROGRESSFRAMES
#define FF_CODEC_CAP_USES_PROGRESSFRAMES
The decoder might make use of the ProgressFrame API.
Definition: codec_internal.h:69
ff_vp9_model_pareto8
const uint8_t ff_vp9_model_pareto8[256][8]
Definition: vp9data.c:1176
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:544
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:687
BL_8X8
@ BL_8X8
Definition: vp9shared.h:83
PARTITION_V
@ PARTITION_V
Definition: vp9shared.h:39
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:364
ff_hwaccel_frame_priv_alloc
int ff_hwaccel_frame_priv_alloc(AVCodecContext *avctx, void **hwaccel_picture_private)
Allocate a hwaccel frame private data if the provided avctx uses a hwaccel method that needs it.
Definition: decode.c:2336
intreadwrite.h
AV_PIX_FMT_DXVA2_VLD
@ AV_PIX_FMT_DXVA2_VLD
HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer.
Definition: pixfmt.h:134
pthread_mutex_unlock
static av_always_inline int pthread_mutex_unlock(pthread_mutex_t *mutex)
Definition: os2threads.h:126
AVCOL_SPC_SMPTE170M
@ AVCOL_SPC_SMPTE170M
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above
Definition: pixfmt.h:713
AV_GET_BUFFER_FLAG_REF
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:415
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:217
vp9data.h
bits
uint8_t bits
Definition: vp3data.h:128
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:42
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:296
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
ff_progress_frame_unref
void ff_progress_frame_unref(ProgressFrame *f)
Give up a reference to the underlying frame contained in a ProgressFrame and reset the ProgressFrame,...
Definition: decode.c:1962
ff_progress_frame_await
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before ff_progress_frame_await() has been called on them. reget_buffer() and buffer age optimizations no longer work. *The contents of buffers must not be written to after ff_progress_frame_report() has been called on them. This includes draw_edges(). Porting codecs to frame threading
decode.h
get_bits.h
field
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this field
Definition: writing_filters.txt:78
VP9TileData::block_size_idx_x
unsigned int block_size_idx_x
Definition: vp9dec.h:242
ff_vp9dsp_init
av_cold void ff_vp9dsp_init(VP9DSPContext *dsp, int bpp, int bitexact)
Definition: vp9dsp.c:88
ff_vp9_partition_tree
const int8_t ff_vp9_partition_tree[3][2]
Definition: vp9data.c:35
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
av_mallocz
#define av_mallocz(s)
Definition: tableprint_vlc.h:31
vp9_decode_frame
static int vp9_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt)
Definition: vp9.c:1603
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:349
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:92
fail
#define fail
Definition: test.h:479
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:586
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:681
hwaccel_internal.h
VP9Context
Definition: vp9dec.h:97
av_unreachable
#define av_unreachable(msg)
Asserts that are used as compiler optimization hints depending upon ASSERT_LEVEL and NBDEBUG.
Definition: avassert.h:116
REF_FRAME_MVPAIR
#define REF_FRAME_MVPAIR
Definition: vp9shared.h:173
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:278
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:391
vp89_rac_get_uint
static av_unused int vp89_rac_get_uint(VPXRangeCoder *c, int bits)
Definition: vp89_rac.h:41
profiles.h
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:547
flush
void(* flush)(AVBSFContext *ctx)
Definition: dts2pts.c:610
av_refstruct_pool_get
void * av_refstruct_pool_get(AVRefStructPool *pool)
Get an object from the pool, reusing an old one from the pool when available.
Definition: refstruct.c:297
pthread_internal.h
UPDATE_THREAD_CONTEXT
#define UPDATE_THREAD_CONTEXT(func)
Definition: codec_internal.h:358
attributes.h
AV_PIX_FMT_D3D12
@ AV_PIX_FMT_D3D12
Hardware surfaces for Direct3D 12.
Definition: pixfmt.h:440
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:546
VP9mv
Definition: vp9shared.h:56
PARTITION_SPLIT
@ PARTITION_SPLIT
Definition: vp9shared.h:40
FF_HW_HAS_CB
#define FF_HW_HAS_CB(avctx, function)
Definition: hwaccel_internal.h:179
VP9RawFrame
Definition: cbs_vp9.h:164
atomic_load_explicit
#define atomic_load_explicit(object, order)
Definition: stdatomic.h:96
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
vp9_frame_replace
static void vp9_frame_replace(VP9Frame *dst, const VP9Frame *src)
Definition: vp9.c:149
VP9TileData::block_structure
struct VP9TileData::@346 * block_structure
VP9RawFrame::header
VP9RawFrameHeader header
Definition: cbs_vp9.h:165
av_video_enc_params_create_side_data
AVVideoEncParams * av_video_enc_params_create_side_data(AVFrame *frame, enum AVVideoEncParamsType type, unsigned int nb_blocks)
Allocates memory for AVEncodeInfoFrame plus an array of.
Definition: video_enc_params.c:58
vp9.h
f
f
Definition: af_crystalizer.c:122
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:608
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:49
AVPacket::size
int size
Definition: packet.h:604
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:88
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:278
codec_internal.h
VP9TileData::eob_base
uint8_t * eob_base
Definition: vp9dec.h:235
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
pix_fmt_rgb
static enum AVPixelFormat pix_fmt_rgb[3]
Definition: libdav1d.c:66
i
#define i(width, name, range_min, range_max)
Definition: cbs_h264.c:63
REF_INVALID_SCALE
#define REF_INVALID_SCALE
Definition: vp9dec.h:43
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:424
read_colorspace_details
static int read_colorspace_details(AVCodecContext *avctx)
Definition: vp9.c:467
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:550
VP9TileData::counts
struct VP9TileData::@344 counts
size
int size
Definition: twinvq_data.h:10344
vp9_alloc_entries
static int vp9_alloc_entries(AVCodecContext *avctx, int n)
Definition: vp9.c:89
atomic_fetch_add_explicit
#define atomic_fetch_add_explicit(object, operand, order)
Definition: stdatomic.h:149
VP9TileData::b_base
VP9Block * b_base
Definition: vp9dec.h:182
free_buffers
static void free_buffers(VP9Context *s)
Definition: vp9.c:1257
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:552
FF_THREAD_SLICE
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:1591
av_malloc
#define av_malloc(s)
Definition: ops_static.c:52
AVCodecHWConfigInternal
Definition: hwconfig.h:25
TX_4X4
@ TX_4X4
Definition: vp9.h:28
update_block_buffers
static int update_block_buffers(AVCodecContext *avctx)
Definition: vp9.c:332
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:602
av_refstruct_ref
void * av_refstruct_ref(void *obj)
Create a new reference to an object managed via this API, i.e.
Definition: refstruct.c:140
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:96
CodedBitstreamVP9Context
Definition: cbs_vp9.h:192
HWACCEL_D3D11VA
#define HWACCEL_D3D11VA(codec)
Definition: hwconfig.h:80
AV_PIX_FMT_D3D11
@ AV_PIX_FMT_D3D11
Hardware surfaces for Direct3D11.
Definition: pixfmt.h:336
VP9TileData::block_base
int16_t * block_base
Definition: vp9dec.h:234
inv_recenter_nonneg
static av_always_inline int inv_recenter_nonneg(int v, int m)
Definition: vp9.c:399
HWACCEL_NVDEC
#define HWACCEL_NVDEC(codec)
Definition: hwconfig.h:68
vpx_rac_is_end
static av_always_inline int vpx_rac_is_end(VPXRangeCoder *c)
returns 1 if the end of the stream has been reached, 0 otherwise.
Definition: vpx_rac.h:51
AV_PIX_FMT_VAAPI
@ AV_PIX_FMT_VAAPI
Hardware acceleration through VA-API, data[3] contains a VASurfaceID.
Definition: pixfmt.h:126
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1590
VP9TileData::left_uv_nnz_ctx
uint8_t left_uv_nnz_ctx[2][16]
Definition: vp9dec.h:221
av_refstruct_unref
void av_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:120
AV_PIX_FMT_VDPAU
@ AV_PIX_FMT_VDPAU
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:194
ff_slice_thread_execute_with_mainfunc
int ff_slice_thread_execute_with_mainfunc(AVCodecContext *avctx, action_func2 *func2, main_func *mainfunc, void *arg, int *ret, int job_count)
Definition: pthread_slice.c:104
AVCOL_SPC_SMPTE240M
@ AVCOL_SPC_SMPTE240M
derived from 170M primaries and D65 white point, 170M is derived from BT470 System M's primaries
Definition: pixfmt.h:714
assign
#define assign(var, type, n)
AV_PIX_FMT_VIDEOTOOLBOX
@ AV_PIX_FMT_VIDEOTOOLBOX
hardware decoding through Videotoolbox
Definition: pixfmt.h:305
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:68
update_prob
static int update_prob(VPXRangeCoder *c, int p)
Definition: vp9.c:409
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:596
DEFINE_OFFSET_ARRAY
#define DEFINE_OFFSET_ARRAY(type, name, cnt_variable, mutexes, conds)
Definition: pthread_internal.h:61
AVCOL_SPC_BT2020_NCL
@ AVCOL_SPC_BT2020_NCL
ITU-R BT2020 non-constant luminance system.
Definition: pixfmt.h:717
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)
Get side information from packet.
Definition: packet.c:252
AV_PIX_FMT_CUARRAY
@ AV_PIX_FMT_CUARRAY
hardware decoding through openharmony
Definition: pixfmt.h:506
vpx_rac.h
decode012
static int BS_FUNC() decode012(BSCTX *bc)
Return decoded truncated unary code for the values 0, 1, 2.
Definition: bitstream_template.h:444
VP9TileData::block_size_idx_y
unsigned int block_size_idx_y
Definition: vp9dec.h:243
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:565
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
AVColorSpace
AVColorSpace
YUV colorspace type.
Definition: pixfmt.h:706
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:58
s
uint8_t s
Definition: llvidencdsp.c:39
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
vpx_rac_get_prob_branchy
static av_always_inline int vpx_rac_get_prob_branchy(VPXRangeCoder *c, int prob)
Definition: vpx_rac.h:99
AVVideoBlockParams
Data structure for storing block-level encoding information.
Definition: video_enc_params.h:120
get_sbits_inv
static av_always_inline int get_sbits_inv(GetBitContext *gb, int n)
Definition: vp9.c:393
VP9TileData::left_mode_ctx
uint8_t left_mode_ctx[16]
Definition: vp9dec.h:219
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:176
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:709
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:643
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:766
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
VP9TileData::c
VPXRangeCoder * c
Definition: vp9dec.h:178
HWACCEL_VIDEOTOOLBOX
#define HWACCEL_VIDEOTOOLBOX(codec)
Definition: hwconfig.h:76
avcodec.h
limit
static double limit(double x)
Definition: vf_pseudocolor.c:142
vp89_rac_get_tree
static av_always_inline int vp89_rac_get_tree(VPXRangeCoder *c, const int8_t(*tree)[2], const uint8_t *probs)
Definition: vp89_rac.h:54
VP9TileData::s
const VP9Context * s
Definition: vp9dec.h:176
BL_64X64
@ BL_64X64
Definition: vp9shared.h:80
AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL
@ AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL
Data found in BlockAdditional element of matroska container.
Definition: packet.h:188
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:265
vp9_decode_init
static av_cold int vp9_decode_init(AVCodecContext *avctx)
Definition: vp9.c:1879
tile
static int FUNC() tile(CodedBitstreamContext *ctx, RWContext *rw, APVRawTile *current, int tile_idx, uint32_t tile_size)
Definition: cbs_apv_syntax_template.c:226
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:560
hwaccel
static const char * hwaccel
Definition: ffplay.c:357
ff_vpx_init_range_decoder
int ff_vpx_init_range_decoder(VPXRangeCoder *c, const uint8_t *buf, int buf_size)
Definition: vpx_rac.c:42
av_refstruct_pool_alloc
AVRefStructPool * av_refstruct_pool_alloc(size_t size, unsigned flags)
Equivalent to av_refstruct_pool_alloc(size, flags, NULL, NULL, NULL, NULL, NULL)
Definition: refstruct.c:335
vp9_tile_data_free
static void vp9_tile_data_free(VP9TileData *td)
Definition: vp9.c:92
ff_thread_finish_setup
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call ff_thread_finish_setup() afterwards. If some code can 't be moved
VP9mvrefPair
Definition: vp9shared.h:61
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:549
pthread_cond_signal
static av_always_inline int pthread_cond_signal(pthread_cond_t *cond)
Definition: os2threads.h:152
AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS
#define AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS
Decoding only.
Definition: avcodec.h:399
ff_progress_frame_replace
void ff_progress_frame_replace(ProgressFrame *dst, const ProgressFrame *src)
Do nothing if dst and src already refer to the same AVFrame; otherwise unreference dst and if src is ...
Definition: decode.c:1969
VP9TileData
Definition: vp9dec.h:175
VP9TileData::uveob_base
uint8_t * uveob_base[2]
Definition: vp9dec.h:235
HWACCEL_VULKAN
#define HWACCEL_VULKAN(codec)
Definition: hwconfig.h:78
vp89_rac_get
static av_always_inline int vp89_rac_get(VPXRangeCoder *c)
Definition: vp89_rac.h:36
AVCodecContext
main external API structure.
Definition: avcodec.h:443
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1598
VP9Filter::mask
uint8_t mask[2][2][8][4]
Definition: vp9dec.h:82
av_refstruct_replace
void av_refstruct_replace(void *dstp, const void *src)
Ensure *dstp refers to the same object as src.
Definition: refstruct.c:160
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1636
ffhwaccel
static const FFHWAccel * ffhwaccel(const AVHWAccel *codec)
Definition: hwaccel_internal.h:168
ff_vp9_decode_block
void ff_vp9_decode_block(VP9TileData *td, int row, int col, VP9Filter *lflvl, ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl, enum BlockPartition bp)
Definition: vp9block.c:1264
NEARESTMV
@ NEARESTMV
Definition: vp9shared.h:44
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:117
BlockLevel
BlockLevel
Definition: vp9shared.h:79
AVCodecContext::export_side_data
int export_side_data
Bit set of AV_CODEC_EXPORT_DATA_* flags, which affects the kind of metadata exported in frame,...
Definition: avcodec.h:1779
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
ff_pthread_init
av_cold int ff_pthread_init(void *obj, const unsigned offsets[])
Initialize/destroy a list of mutexes/conditions contained in a structure.
Definition: pthread.c:105
pthread_cond_wait
static av_always_inline int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
Definition: os2threads.h:192
vp9dec.h
av_log_once
void av_log_once(void *avcl, int initial_level, int subsequent_level, int *state, const char *fmt,...)
Definition: log.c:450
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:165
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:279
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
ff_vp9_default_kf_partition_probs
const uint8_t ff_vp9_default_kf_partition_probs[4][4][3]
Definition: vp9data.c:41
AV_VIDEO_ENC_PARAMS_VP9
@ AV_VIDEO_ENC_PARAMS_VP9
VP9 stores:
Definition: video_enc_params.h:44
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
mem.h
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:322
ff_vp9_default_probs
const ProbContext ff_vp9_default_probs
Definition: vp9data.c:1435
CUR_FRAME
#define CUR_FRAME
Definition: vp9shared.h:172
ff_vp9_loopfilter_sb
void ff_vp9_loopfilter_sb(struct AVCodecContext *avctx, VP9Filter *lflvl, int row, int col, ptrdiff_t yoff, ptrdiff_t uvoff)
Definition: vp9lpf.c:179
w
uint8_t w
Definition: llvidencdsp.c:39
av_refstruct_pool_uninit
static void av_refstruct_pool_uninit(AVRefStructPool **poolp)
Mark the pool as being available for freeing.
Definition: refstruct.h:292
vp9_export_enc_params
static int vp9_export_enc_params(VP9Context *s, VP9Frame *frame)
Definition: vp9.c:1533
AVPacket
This structure stores compressed data.
Definition: packet.h:580
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:470
PARTITION_H
@ PARTITION_H
Definition: vp9shared.h:38
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
videodsp.h
BLANK_FRAME
#define BLANK_FRAME
Definition: vp9shared.h:175
HWACCEL_VAAPI
#define HWACCEL_VAAPI(codec)
Definition: hwconfig.h:72
HWACCEL_MAX
#define HWACCEL_MAX
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
vp9_warn_unsupported_webm_alpha
static void vp9_warn_unsupported_webm_alpha(AVCodecContext *avctx, const AVPacket *pkt)
Definition: vp9.c:1585
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
av_video_enc_params_block
static av_always_inline AVVideoBlockParams * av_video_enc_params_block(AVVideoEncParams *par, unsigned int idx)
Get the block at the specified.
Definition: video_enc_params.h:143
AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:551
h
h
Definition: vp9dsp_template.c:2070
pkt
static AVPacket * pkt
Definition: demux_decode.c:55
atomic_init
#define atomic_init(obj, value)
Definition: stdatomic.h:33
VP9TileData::nb_block_structure
unsigned int nb_block_structure
Definition: vp9dec.h:245
AVCOL_SPC_BT709
@ AVCOL_SPC_BT709
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / derived in SMPTE RP 177 Annex B
Definition: pixfmt.h:708
VP9TileData::tile_col_start
unsigned tile_col_start
Definition: vp9dec.h:183
AV_FRAME_FLAG_LOSSLESS
#define AV_FRAME_FLAG_LOSSLESS
A decoder can use this flag to mark frames which were originally encoded losslessly.
Definition: frame.h:708
AV_RB64
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_RB64
Definition: bytestream.h:95
src
#define src
Definition: vp8dsp.c:248
ff_vp9_profiles
const AVProfile ff_vp9_profiles[]
Definition: profiles.c:155
video_enc_params.h
set_tile_offset
static void set_tile_offset(int *start, int *end, int idx, int log2_n, int n)
Definition: vp9.c:1249
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:3380
ff_vp9_dc_qlookup
const int16_t ff_vp9_dc_qlookup[3][256]
Definition: vp9data.c:231
ff_vp9_default_coef_probs
const uint8_t ff_vp9_default_coef_probs[4][2][2][6][6][3]
Definition: vp9data.c:1540
vp9_decode_flush
static av_cold void vp9_decode_flush(AVCodecContext *avctx)
Definition: vp9.c:1859
VP9TileData::left_partition_ctx
uint8_t left_partition_ctx[8]
Definition: vp9dec.h:222
Generated on Wed Aug 12 2026 19:22:41 for FFmpeg by   doxygen 1.8.17