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 "avcodec.h"
25 #include "get_bits.h"
26 #include "hwaccel.h"
27 #include "internal.h"
28 #include "profiles.h"
29 #include "thread.h"
30 #include "videodsp.h"
31 #include "vp56.h"
32 #include "vp9.h"
33 #include "vp9data.h"
34 #include "vp9dec.h"
35 #include "libavutil/avassert.h"
36 #include "libavutil/pixdesc.h"
37 
38 #define VP9_SYNCCODE 0x498342
39 
40 #if HAVE_THREADS
41 static void vp9_free_entries(AVCodecContext *avctx) {
42  VP9Context *s = avctx->priv_data;
43 
44  if (avctx->active_thread_type & FF_THREAD_SLICE) {
45  pthread_mutex_destroy(&s->progress_mutex);
46  pthread_cond_destroy(&s->progress_cond);
47  av_freep(&s->entries);
48  }
49 }
50 
51 static int vp9_alloc_entries(AVCodecContext *avctx, int n) {
52  VP9Context *s = avctx->priv_data;
53  int i;
54 
55  if (avctx->active_thread_type & FF_THREAD_SLICE) {
56  if (s->entries)
57  av_freep(&s->entries);
58 
59  s->entries = av_malloc_array(n, sizeof(atomic_int));
60 
61  if (!s->entries) {
62  av_freep(&s->entries);
63  return AVERROR(ENOMEM);
64  }
65 
66  for (i = 0; i < n; i++)
67  atomic_init(&s->entries[i], 0);
68 
69  pthread_mutex_init(&s->progress_mutex, NULL);
70  pthread_cond_init(&s->progress_cond, NULL);
71  }
72  return 0;
73 }
74 
75 static void vp9_report_tile_progress(VP9Context *s, int field, int n) {
76  pthread_mutex_lock(&s->progress_mutex);
77  atomic_fetch_add_explicit(&s->entries[field], n, memory_order_release);
78  pthread_cond_signal(&s->progress_cond);
79  pthread_mutex_unlock(&s->progress_mutex);
80 }
81 
82 static void vp9_await_tile_progress(VP9Context *s, int field, int n) {
83  if (atomic_load_explicit(&s->entries[field], memory_order_acquire) >= n)
84  return;
85 
86  pthread_mutex_lock(&s->progress_mutex);
87  while (atomic_load_explicit(&s->entries[field], memory_order_relaxed) != n)
88  pthread_cond_wait(&s->progress_cond, &s->progress_mutex);
89  pthread_mutex_unlock(&s->progress_mutex);
90 }
91 #else
92 static void vp9_free_entries(AVCodecContext *avctx) {}
93 static int vp9_alloc_entries(AVCodecContext *avctx, int n) { return 0; }
94 #endif
95 
97 {
98  ff_thread_release_buffer(avctx, &f->tf);
101  f->segmentation_map = NULL;
103 }
104 
106 {
107  VP9Context *s = avctx->priv_data;
108  int ret, sz;
109 
111  if (ret < 0)
112  return ret;
113 
114  sz = 64 * s->sb_cols * s->sb_rows;
115  if (sz != s->frame_extradata_pool_size) {
117  s->frame_extradata_pool = av_buffer_pool_init(sz * (1 + sizeof(VP9mvrefPair)), NULL);
118  if (!s->frame_extradata_pool) {
120  goto fail;
121  }
123  }
125  if (!f->extradata) {
126  goto fail;
127  }
128  memset(f->extradata->data, 0, f->extradata->size);
129 
131  f->mv = (VP9mvrefPair *) (f->extradata->data + sz);
132 
133  if (avctx->hwaccel) {
134  const AVHWAccel *hwaccel = avctx->hwaccel;
136  if (hwaccel->frame_priv_data_size) {
138  if (!f->hwaccel_priv_buf)
139  goto fail;
141  }
142  }
143 
144  return 0;
145 
146 fail:
147  vp9_frame_unref(avctx, f);
148  return AVERROR(ENOMEM);
149 }
150 
152 {
153  int ret;
154 
155  ret = ff_thread_ref_frame(&dst->tf, &src->tf);
156  if (ret < 0)
157  return ret;
158 
159  dst->extradata = av_buffer_ref(src->extradata);
160  if (!dst->extradata)
161  goto fail;
162 
164  dst->mv = src->mv;
165  dst->uses_2pass = src->uses_2pass;
166 
167  if (src->hwaccel_picture_private) {
169  if (!dst->hwaccel_priv_buf)
170  goto fail;
172  }
173 
174  return 0;
175 
176 fail:
177  vp9_frame_unref(avctx, dst);
178  return AVERROR(ENOMEM);
179 }
180 
181 static int update_size(AVCodecContext *avctx, int w, int h)
182 {
183 #define HWACCEL_MAX (CONFIG_VP9_DXVA2_HWACCEL + \
184  CONFIG_VP9_D3D11VA_HWACCEL * 2 + \
185  CONFIG_VP9_NVDEC_HWACCEL + \
186  CONFIG_VP9_VAAPI_HWACCEL + \
187  CONFIG_VP9_VDPAU_HWACCEL)
188  enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmtp = pix_fmts;
189  VP9Context *s = avctx->priv_data;
190  uint8_t *p;
191  int bytesperpixel = s->bytesperpixel, ret, cols, rows;
192  int lflvl_len, i;
193 
194  av_assert0(w > 0 && h > 0);
195 
196  if (!(s->pix_fmt == s->gf_fmt && w == s->w && h == s->h)) {
197  if ((ret = ff_set_dimensions(avctx, w, h)) < 0)
198  return ret;
199 
200  switch (s->pix_fmt) {
201  case AV_PIX_FMT_YUV420P:
202 #if CONFIG_VP9_VDPAU_HWACCEL
203  *fmtp++ = AV_PIX_FMT_VDPAU;
204 #endif
206 #if CONFIG_VP9_DXVA2_HWACCEL
207  *fmtp++ = AV_PIX_FMT_DXVA2_VLD;
208 #endif
209 #if CONFIG_VP9_D3D11VA_HWACCEL
210  *fmtp++ = AV_PIX_FMT_D3D11VA_VLD;
211  *fmtp++ = AV_PIX_FMT_D3D11;
212 #endif
213 #if CONFIG_VP9_NVDEC_HWACCEL
214  *fmtp++ = AV_PIX_FMT_CUDA;
215 #endif
216 #if CONFIG_VP9_VAAPI_HWACCEL
217  *fmtp++ = AV_PIX_FMT_VAAPI;
218 #endif
219  break;
221 #if CONFIG_VP9_NVDEC_HWACCEL
222  *fmtp++ = AV_PIX_FMT_CUDA;
223 #endif
224 #if CONFIG_VP9_VAAPI_HWACCEL
225  *fmtp++ = AV_PIX_FMT_VAAPI;
226 #endif
227  break;
228  }
229 
230  *fmtp++ = s->pix_fmt;
231  *fmtp = AV_PIX_FMT_NONE;
232 
233  ret = ff_thread_get_format(avctx, pix_fmts);
234  if (ret < 0)
235  return ret;
236 
237  avctx->pix_fmt = ret;
238  s->gf_fmt = s->pix_fmt;
239  s->w = w;
240  s->h = h;
241  }
242 
243  cols = (w + 7) >> 3;
244  rows = (h + 7) >> 3;
245 
246  if (s->intra_pred_data[0] && cols == s->cols && rows == s->rows && s->pix_fmt == s->last_fmt)
247  return 0;
248 
249  s->last_fmt = s->pix_fmt;
250  s->sb_cols = (w + 63) >> 6;
251  s->sb_rows = (h + 63) >> 6;
252  s->cols = (w + 7) >> 3;
253  s->rows = (h + 7) >> 3;
254  lflvl_len = avctx->active_thread_type == FF_THREAD_SLICE ? s->sb_rows : 1;
255 
256 #define assign(var, type, n) var = (type) p; p += s->sb_cols * (n) * sizeof(*var)
257  av_freep(&s->intra_pred_data[0]);
258  // FIXME we slightly over-allocate here for subsampled chroma, but a little
259  // bit of padding shouldn't affect performance...
260  p = av_malloc(s->sb_cols * (128 + 192 * bytesperpixel +
261  lflvl_len * sizeof(*s->lflvl) + 16 * sizeof(*s->above_mv_ctx)));
262  if (!p)
263  return AVERROR(ENOMEM);
264  assign(s->intra_pred_data[0], uint8_t *, 64 * bytesperpixel);
265  assign(s->intra_pred_data[1], uint8_t *, 64 * bytesperpixel);
266  assign(s->intra_pred_data[2], uint8_t *, 64 * bytesperpixel);
267  assign(s->above_y_nnz_ctx, uint8_t *, 16);
268  assign(s->above_mode_ctx, uint8_t *, 16);
269  assign(s->above_mv_ctx, VP56mv(*)[2], 16);
270  assign(s->above_uv_nnz_ctx[0], uint8_t *, 16);
271  assign(s->above_uv_nnz_ctx[1], uint8_t *, 16);
273  assign(s->above_skip_ctx, uint8_t *, 8);
274  assign(s->above_txfm_ctx, uint8_t *, 8);
275  assign(s->above_segpred_ctx, uint8_t *, 8);
276  assign(s->above_intra_ctx, uint8_t *, 8);
277  assign(s->above_comp_ctx, uint8_t *, 8);
278  assign(s->above_ref_ctx, uint8_t *, 8);
279  assign(s->above_filter_ctx, uint8_t *, 8);
280  assign(s->lflvl, VP9Filter *, lflvl_len);
281 #undef assign
282 
283  if (s->td) {
284  for (i = 0; i < s->active_tile_cols; i++) {
285  av_freep(&s->td[i].b_base);
286  av_freep(&s->td[i].block_base);
287  }
288  }
289 
290  if (s->s.h.bpp != s->last_bpp) {
291  ff_vp9dsp_init(&s->dsp, s->s.h.bpp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
292  ff_videodsp_init(&s->vdsp, s->s.h.bpp);
293  s->last_bpp = s->s.h.bpp;
294  }
295 
296  return 0;
297 }
298 
300 {
301  int i;
302  VP9Context *s = avctx->priv_data;
303  int chroma_blocks, chroma_eobs, bytesperpixel = s->bytesperpixel;
304  VP9TileData *td = &s->td[0];
305 
307  return 0;
308 
309  av_free(td->b_base);
310  av_free(td->block_base);
311  chroma_blocks = 64 * 64 >> (s->ss_h + s->ss_v);
312  chroma_eobs = 16 * 16 >> (s->ss_h + s->ss_v);
313  if (s->s.frames[CUR_FRAME].uses_2pass) {
314  int sbs = s->sb_cols * s->sb_rows;
315 
316  td->b_base = av_malloc_array(s->cols * s->rows, sizeof(VP9Block));
317  td->block_base = av_mallocz(((64 * 64 + 2 * chroma_blocks) * bytesperpixel * sizeof(int16_t) +
318  16 * 16 + 2 * chroma_eobs) * sbs);
319  if (!td->b_base || !td->block_base)
320  return AVERROR(ENOMEM);
321  td->uvblock_base[0] = td->block_base + sbs * 64 * 64 * bytesperpixel;
322  td->uvblock_base[1] = td->uvblock_base[0] + sbs * chroma_blocks * bytesperpixel;
323  td->eob_base = (uint8_t *) (td->uvblock_base[1] + sbs * chroma_blocks * bytesperpixel);
324  td->uveob_base[0] = td->eob_base + 16 * 16 * sbs;
325  td->uveob_base[1] = td->uveob_base[0] + chroma_eobs * sbs;
326  } else {
327  for (i = 1; i < s->active_tile_cols; i++) {
328  if (s->td[i].b_base && s->td[i].block_base) {
329  av_free(s->td[i].b_base);
330  av_free(s->td[i].block_base);
331  }
332  }
333  for (i = 0; i < s->active_tile_cols; i++) {
334  s->td[i].b_base = av_malloc(sizeof(VP9Block));
335  s->td[i].block_base = av_mallocz((64 * 64 + 2 * chroma_blocks) * bytesperpixel * sizeof(int16_t) +
336  16 * 16 + 2 * chroma_eobs);
337  if (!s->td[i].b_base || !s->td[i].block_base)
338  return AVERROR(ENOMEM);
339  s->td[i].uvblock_base[0] = s->td[i].block_base + 64 * 64 * bytesperpixel;
340  s->td[i].uvblock_base[1] = s->td[i].uvblock_base[0] + chroma_blocks * bytesperpixel;
341  s->td[i].eob_base = (uint8_t *) (s->td[i].uvblock_base[1] + chroma_blocks * bytesperpixel);
342  s->td[i].uveob_base[0] = s->td[i].eob_base + 16 * 16;
343  s->td[i].uveob_base[1] = s->td[i].uveob_base[0] + chroma_eobs;
344  }
345  }
347 
348  return 0;
349 }
350 
351 // The sign bit is at the end, not the start, of a bit sequence
353 {
354  int v = get_bits(gb, n);
355  return get_bits1(gb) ? -v : v;
356 }
357 
358 static av_always_inline int inv_recenter_nonneg(int v, int m)
359 {
360  if (v > 2 * m)
361  return v;
362  if (v & 1)
363  return m - ((v + 1) >> 1);
364  return m + (v >> 1);
365 }
366 
367 // differential forward probability updates
368 static int update_prob(VP56RangeCoder *c, int p)
369 {
370  static const uint8_t inv_map_table[255] = {
371  7, 20, 33, 46, 59, 72, 85, 98, 111, 124, 137, 150, 163, 176,
372  189, 202, 215, 228, 241, 254, 1, 2, 3, 4, 5, 6, 8, 9,
373  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 21, 22, 23, 24,
374  25, 26, 27, 28, 29, 30, 31, 32, 34, 35, 36, 37, 38, 39,
375  40, 41, 42, 43, 44, 45, 47, 48, 49, 50, 51, 52, 53, 54,
376  55, 56, 57, 58, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
377  70, 71, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
378  86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 99, 100,
379  101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 112, 113, 114, 115,
380  116, 117, 118, 119, 120, 121, 122, 123, 125, 126, 127, 128, 129, 130,
381  131, 132, 133, 134, 135, 136, 138, 139, 140, 141, 142, 143, 144, 145,
382  146, 147, 148, 149, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160,
383  161, 162, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
384  177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 190, 191,
385  192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 203, 204, 205, 206,
386  207, 208, 209, 210, 211, 212, 213, 214, 216, 217, 218, 219, 220, 221,
387  222, 223, 224, 225, 226, 227, 229, 230, 231, 232, 233, 234, 235, 236,
388  237, 238, 239, 240, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251,
389  252, 253, 253,
390  };
391  int d;
392 
393  /* This code is trying to do a differential probability update. For a
394  * current probability A in the range [1, 255], the difference to a new
395  * probability of any value can be expressed differentially as 1-A, 255-A
396  * where some part of this (absolute range) exists both in positive as
397  * well as the negative part, whereas another part only exists in one
398  * half. We're trying to code this shared part differentially, i.e.
399  * times two where the value of the lowest bit specifies the sign, and
400  * the single part is then coded on top of this. This absolute difference
401  * then again has a value of [0, 254], but a bigger value in this range
402  * indicates that we're further away from the original value A, so we
403  * can code this as a VLC code, since higher values are increasingly
404  * unlikely. The first 20 values in inv_map_table[] allow 'cheap, rough'
405  * updates vs. the 'fine, exact' updates further down the range, which
406  * adds one extra dimension to this differential update model. */
407 
408  if (!vp8_rac_get(c)) {
409  d = vp8_rac_get_uint(c, 4) + 0;
410  } else if (!vp8_rac_get(c)) {
411  d = vp8_rac_get_uint(c, 4) + 16;
412  } else if (!vp8_rac_get(c)) {
413  d = vp8_rac_get_uint(c, 5) + 32;
414  } else {
415  d = vp8_rac_get_uint(c, 7);
416  if (d >= 65)
417  d = (d << 1) - 65 + vp8_rac_get(c);
418  d += 64;
419  av_assert2(d < FF_ARRAY_ELEMS(inv_map_table));
420  }
421 
422  return p <= 128 ? 1 + inv_recenter_nonneg(inv_map_table[d], p - 1) :
423  255 - inv_recenter_nonneg(inv_map_table[d], 255 - p);
424 }
425 
427 {
428  static const enum AVColorSpace colorspaces[8] = {
431  };
432  VP9Context *s = avctx->priv_data;
433  int bits = avctx->profile <= 1 ? 0 : 1 + get_bits1(&s->gb); // 0:8, 1:10, 2:12
434 
435  s->bpp_index = bits;
436  s->s.h.bpp = 8 + bits * 2;
437  s->bytesperpixel = (7 + s->s.h.bpp) >> 3;
438  avctx->colorspace = colorspaces[get_bits(&s->gb, 3)];
439  if (avctx->colorspace == AVCOL_SPC_RGB) { // RGB = profile 1
440  static const enum AVPixelFormat pix_fmt_rgb[3] = {
442  };
443  s->ss_h = s->ss_v = 0;
444  avctx->color_range = AVCOL_RANGE_JPEG;
445  s->pix_fmt = pix_fmt_rgb[bits];
446  if (avctx->profile & 1) {
447  if (get_bits1(&s->gb)) {
448  av_log(avctx, AV_LOG_ERROR, "Reserved bit set in RGB\n");
449  return AVERROR_INVALIDDATA;
450  }
451  } else {
452  av_log(avctx, AV_LOG_ERROR, "RGB not supported in profile %d\n",
453  avctx->profile);
454  return AVERROR_INVALIDDATA;
455  }
456  } else {
457  static const enum AVPixelFormat pix_fmt_for_ss[3][2 /* v */][2 /* h */] = {
464  };
466  if (avctx->profile & 1) {
467  s->ss_h = get_bits1(&s->gb);
468  s->ss_v = get_bits1(&s->gb);
469  s->pix_fmt = pix_fmt_for_ss[bits][s->ss_v][s->ss_h];
470  if (s->pix_fmt == AV_PIX_FMT_YUV420P) {
471  av_log(avctx, AV_LOG_ERROR, "YUV 4:2:0 not supported in profile %d\n",
472  avctx->profile);
473  return AVERROR_INVALIDDATA;
474  } else if (get_bits1(&s->gb)) {
475  av_log(avctx, AV_LOG_ERROR, "Profile %d color details reserved bit set\n",
476  avctx->profile);
477  return AVERROR_INVALIDDATA;
478  }
479  } else {
480  s->ss_h = s->ss_v = 1;
481  s->pix_fmt = pix_fmt_for_ss[bits][1][1];
482  }
483  }
484 
485  return 0;
486 }
487 
489  const uint8_t *data, int size, int *ref)
490 {
491  VP9Context *s = avctx->priv_data;
492  int c, i, j, k, l, m, n, w, h, max, size2, ret, sharp;
493  int last_invisible;
494  const uint8_t *data2;
495 
496  /* general header */
497  if ((ret = init_get_bits8(&s->gb, data, size)) < 0) {
498  av_log(avctx, AV_LOG_ERROR, "Failed to initialize bitstream reader\n");
499  return ret;
500  }
501  if (get_bits(&s->gb, 2) != 0x2) { // frame marker
502  av_log(avctx, AV_LOG_ERROR, "Invalid frame marker\n");
503  return AVERROR_INVALIDDATA;
504  }
505  avctx->profile = get_bits1(&s->gb);
506  avctx->profile |= get_bits1(&s->gb) << 1;
507  if (avctx->profile == 3) avctx->profile += get_bits1(&s->gb);
508  if (avctx->profile > 3) {
509  av_log(avctx, AV_LOG_ERROR, "Profile %d is not yet supported\n", avctx->profile);
510  return AVERROR_INVALIDDATA;
511  }
512  s->s.h.profile = avctx->profile;
513  if (get_bits1(&s->gb)) {
514  *ref = get_bits(&s->gb, 3);
515  return 0;
516  }
517 
518  s->last_keyframe = s->s.h.keyframe;
519  s->s.h.keyframe = !get_bits1(&s->gb);
520 
521  last_invisible = s->s.h.invisible;
522  s->s.h.invisible = !get_bits1(&s->gb);
523  s->s.h.errorres = get_bits1(&s->gb);
524  s->s.h.use_last_frame_mvs = !s->s.h.errorres && !last_invisible;
525 
526  if (s->s.h.keyframe) {
527  if (get_bits(&s->gb, 24) != VP9_SYNCCODE) { // synccode
528  av_log(avctx, AV_LOG_ERROR, "Invalid sync code\n");
529  return AVERROR_INVALIDDATA;
530  }
531  if ((ret = read_colorspace_details(avctx)) < 0)
532  return ret;
533  // for profile 1, here follows the subsampling bits
534  s->s.h.refreshrefmask = 0xff;
535  w = get_bits(&s->gb, 16) + 1;
536  h = get_bits(&s->gb, 16) + 1;
537  if (get_bits1(&s->gb)) // display size
538  skip_bits(&s->gb, 32);
539  } else {
540  s->s.h.intraonly = s->s.h.invisible ? get_bits1(&s->gb) : 0;
541  s->s.h.resetctx = s->s.h.errorres ? 0 : get_bits(&s->gb, 2);
542  if (s->s.h.intraonly) {
543  if (get_bits(&s->gb, 24) != VP9_SYNCCODE) { // synccode
544  av_log(avctx, AV_LOG_ERROR, "Invalid sync code\n");
545  return AVERROR_INVALIDDATA;
546  }
547  if (avctx->profile >= 1) {
548  if ((ret = read_colorspace_details(avctx)) < 0)
549  return ret;
550  } else {
551  s->ss_h = s->ss_v = 1;
552  s->s.h.bpp = 8;
553  s->bpp_index = 0;
554  s->bytesperpixel = 1;
555  s->pix_fmt = AV_PIX_FMT_YUV420P;
556  avctx->colorspace = AVCOL_SPC_BT470BG;
557  avctx->color_range = AVCOL_RANGE_MPEG;
558  }
559  s->s.h.refreshrefmask = get_bits(&s->gb, 8);
560  w = get_bits(&s->gb, 16) + 1;
561  h = get_bits(&s->gb, 16) + 1;
562  if (get_bits1(&s->gb)) // display size
563  skip_bits(&s->gb, 32);
564  } else {
565  s->s.h.refreshrefmask = get_bits(&s->gb, 8);
566  s->s.h.refidx[0] = get_bits(&s->gb, 3);
567  s->s.h.signbias[0] = get_bits1(&s->gb) && !s->s.h.errorres;
568  s->s.h.refidx[1] = get_bits(&s->gb, 3);
569  s->s.h.signbias[1] = get_bits1(&s->gb) && !s->s.h.errorres;
570  s->s.h.refidx[2] = get_bits(&s->gb, 3);
571  s->s.h.signbias[2] = get_bits1(&s->gb) && !s->s.h.errorres;
572  if (!s->s.refs[s->s.h.refidx[0]].f->buf[0] ||
573  !s->s.refs[s->s.h.refidx[1]].f->buf[0] ||
574  !s->s.refs[s->s.h.refidx[2]].f->buf[0]) {
575  av_log(avctx, AV_LOG_ERROR, "Not all references are available\n");
576  return AVERROR_INVALIDDATA;
577  }
578  if (get_bits1(&s->gb)) {
579  w = s->s.refs[s->s.h.refidx[0]].f->width;
580  h = s->s.refs[s->s.h.refidx[0]].f->height;
581  } else if (get_bits1(&s->gb)) {
582  w = s->s.refs[s->s.h.refidx[1]].f->width;
583  h = s->s.refs[s->s.h.refidx[1]].f->height;
584  } else if (get_bits1(&s->gb)) {
585  w = s->s.refs[s->s.h.refidx[2]].f->width;
586  h = s->s.refs[s->s.h.refidx[2]].f->height;
587  } else {
588  w = get_bits(&s->gb, 16) + 1;
589  h = get_bits(&s->gb, 16) + 1;
590  }
591  // Note that in this code, "CUR_FRAME" is actually before we
592  // have formally allocated a frame, and thus actually represents
593  // the _last_ frame
594  s->s.h.use_last_frame_mvs &= s->s.frames[CUR_FRAME].tf.f->width == w &&
595  s->s.frames[CUR_FRAME].tf.f->height == h;
596  if (get_bits1(&s->gb)) // display size
597  skip_bits(&s->gb, 32);
598  s->s.h.highprecisionmvs = get_bits1(&s->gb);
600  get_bits(&s->gb, 2);
601  s->s.h.allowcompinter = s->s.h.signbias[0] != s->s.h.signbias[1] ||
602  s->s.h.signbias[0] != s->s.h.signbias[2];
603  if (s->s.h.allowcompinter) {
604  if (s->s.h.signbias[0] == s->s.h.signbias[1]) {
605  s->s.h.fixcompref = 2;
606  s->s.h.varcompref[0] = 0;
607  s->s.h.varcompref[1] = 1;
608  } else if (s->s.h.signbias[0] == s->s.h.signbias[2]) {
609  s->s.h.fixcompref = 1;
610  s->s.h.varcompref[0] = 0;
611  s->s.h.varcompref[1] = 2;
612  } else {
613  s->s.h.fixcompref = 0;
614  s->s.h.varcompref[0] = 1;
615  s->s.h.varcompref[1] = 2;
616  }
617  }
618  }
619  }
620  s->s.h.refreshctx = s->s.h.errorres ? 0 : get_bits1(&s->gb);
621  s->s.h.parallelmode = s->s.h.errorres ? 1 : get_bits1(&s->gb);
622  s->s.h.framectxid = c = get_bits(&s->gb, 2);
623  if (s->s.h.keyframe || s->s.h.intraonly)
624  s->s.h.framectxid = 0; // BUG: libvpx ignores this field in keyframes
625 
626  /* loopfilter header data */
627  if (s->s.h.keyframe || s->s.h.errorres || s->s.h.intraonly) {
628  // reset loopfilter defaults
629  s->s.h.lf_delta.ref[0] = 1;
630  s->s.h.lf_delta.ref[1] = 0;
631  s->s.h.lf_delta.ref[2] = -1;
632  s->s.h.lf_delta.ref[3] = -1;
633  s->s.h.lf_delta.mode[0] = 0;
634  s->s.h.lf_delta.mode[1] = 0;
635  memset(s->s.h.segmentation.feat, 0, sizeof(s->s.h.segmentation.feat));
636  }
637  s->s.h.filter.level = get_bits(&s->gb, 6);
638  sharp = get_bits(&s->gb, 3);
639  // if sharpness changed, reinit lim/mblim LUTs. if it didn't change, keep
640  // the old cache values since they are still valid
641  if (s->s.h.filter.sharpness != sharp) {
642  for (i = 1; i <= 63; i++) {
643  int limit = i;
644 
645  if (sharp > 0) {
646  limit >>= (sharp + 3) >> 2;
647  limit = FFMIN(limit, 9 - sharp);
648  }
649  limit = FFMAX(limit, 1);
650 
651  s->filter_lut.lim_lut[i] = limit;
652  s->filter_lut.mblim_lut[i] = 2 * (i + 2) + limit;
653  }
654  }
655  s->s.h.filter.sharpness = sharp;
656  if ((s->s.h.lf_delta.enabled = get_bits1(&s->gb))) {
657  if ((s->s.h.lf_delta.updated = get_bits1(&s->gb))) {
658  for (i = 0; i < 4; i++)
659  if (get_bits1(&s->gb))
660  s->s.h.lf_delta.ref[i] = get_sbits_inv(&s->gb, 6);
661  for (i = 0; i < 2; i++)
662  if (get_bits1(&s->gb))
663  s->s.h.lf_delta.mode[i] = get_sbits_inv(&s->gb, 6);
664  }
665  }
666 
667  /* quantization header data */
668  s->s.h.yac_qi = get_bits(&s->gb, 8);
669  s->s.h.ydc_qdelta = get_bits1(&s->gb) ? get_sbits_inv(&s->gb, 4) : 0;
670  s->s.h.uvdc_qdelta = get_bits1(&s->gb) ? get_sbits_inv(&s->gb, 4) : 0;
671  s->s.h.uvac_qdelta = get_bits1(&s->gb) ? get_sbits_inv(&s->gb, 4) : 0;
672  s->s.h.lossless = s->s.h.yac_qi == 0 && s->s.h.ydc_qdelta == 0 &&
673  s->s.h.uvdc_qdelta == 0 && s->s.h.uvac_qdelta == 0;
674  if (s->s.h.lossless)
676 
677  /* segmentation header info */
678  if ((s->s.h.segmentation.enabled = get_bits1(&s->gb))) {
679  if ((s->s.h.segmentation.update_map = get_bits1(&s->gb))) {
680  for (i = 0; i < 7; i++)
681  s->s.h.segmentation.prob[i] = get_bits1(&s->gb) ?
682  get_bits(&s->gb, 8) : 255;
683  if ((s->s.h.segmentation.temporal = get_bits1(&s->gb)))
684  for (i = 0; i < 3; i++)
685  s->s.h.segmentation.pred_prob[i] = get_bits1(&s->gb) ?
686  get_bits(&s->gb, 8) : 255;
687  }
688 
689  if (get_bits1(&s->gb)) {
691  for (i = 0; i < 8; i++) {
692  if ((s->s.h.segmentation.feat[i].q_enabled = get_bits1(&s->gb)))
693  s->s.h.segmentation.feat[i].q_val = get_sbits_inv(&s->gb, 8);
694  if ((s->s.h.segmentation.feat[i].lf_enabled = get_bits1(&s->gb)))
695  s->s.h.segmentation.feat[i].lf_val = get_sbits_inv(&s->gb, 6);
696  if ((s->s.h.segmentation.feat[i].ref_enabled = get_bits1(&s->gb)))
697  s->s.h.segmentation.feat[i].ref_val = get_bits(&s->gb, 2);
698  s->s.h.segmentation.feat[i].skip_enabled = get_bits1(&s->gb);
699  }
700  }
701  }
702 
703  // set qmul[] based on Y/UV, AC/DC and segmentation Q idx deltas
704  for (i = 0; i < (s->s.h.segmentation.enabled ? 8 : 1); i++) {
705  int qyac, qydc, quvac, quvdc, lflvl, sh;
706 
707  if (s->s.h.segmentation.enabled && s->s.h.segmentation.feat[i].q_enabled) {
708  if (s->s.h.segmentation.absolute_vals)
709  qyac = av_clip_uintp2(s->s.h.segmentation.feat[i].q_val, 8);
710  else
711  qyac = av_clip_uintp2(s->s.h.yac_qi + s->s.h.segmentation.feat[i].q_val, 8);
712  } else {
713  qyac = s->s.h.yac_qi;
714  }
715  qydc = av_clip_uintp2(qyac + s->s.h.ydc_qdelta, 8);
716  quvdc = av_clip_uintp2(qyac + s->s.h.uvdc_qdelta, 8);
717  quvac = av_clip_uintp2(qyac + s->s.h.uvac_qdelta, 8);
718  qyac = av_clip_uintp2(qyac, 8);
719 
720  s->s.h.segmentation.feat[i].qmul[0][0] = ff_vp9_dc_qlookup[s->bpp_index][qydc];
721  s->s.h.segmentation.feat[i].qmul[0][1] = ff_vp9_ac_qlookup[s->bpp_index][qyac];
722  s->s.h.segmentation.feat[i].qmul[1][0] = ff_vp9_dc_qlookup[s->bpp_index][quvdc];
723  s->s.h.segmentation.feat[i].qmul[1][1] = ff_vp9_ac_qlookup[s->bpp_index][quvac];
724 
725  sh = s->s.h.filter.level >= 32;
726  if (s->s.h.segmentation.enabled && s->s.h.segmentation.feat[i].lf_enabled) {
727  if (s->s.h.segmentation.absolute_vals)
728  lflvl = av_clip_uintp2(s->s.h.segmentation.feat[i].lf_val, 6);
729  else
730  lflvl = av_clip_uintp2(s->s.h.filter.level + s->s.h.segmentation.feat[i].lf_val, 6);
731  } else {
732  lflvl = s->s.h.filter.level;
733  }
734  if (s->s.h.lf_delta.enabled) {
735  s->s.h.segmentation.feat[i].lflvl[0][0] =
736  s->s.h.segmentation.feat[i].lflvl[0][1] =
737  av_clip_uintp2(lflvl + (s->s.h.lf_delta.ref[0] * (1 << sh)), 6);
738  for (j = 1; j < 4; j++) {
739  s->s.h.segmentation.feat[i].lflvl[j][0] =
740  av_clip_uintp2(lflvl + ((s->s.h.lf_delta.ref[j] +
741  s->s.h.lf_delta.mode[0]) * (1 << sh)), 6);
742  s->s.h.segmentation.feat[i].lflvl[j][1] =
743  av_clip_uintp2(lflvl + ((s->s.h.lf_delta.ref[j] +
744  s->s.h.lf_delta.mode[1]) * (1 << sh)), 6);
745  }
746  } else {
747  memset(s->s.h.segmentation.feat[i].lflvl, lflvl,
748  sizeof(s->s.h.segmentation.feat[i].lflvl));
749  }
750  }
751 
752  /* tiling info */
753  if ((ret = update_size(avctx, w, h)) < 0) {
754  av_log(avctx, AV_LOG_ERROR, "Failed to initialize decoder for %dx%d @ %d\n",
755  w, h, s->pix_fmt);
756  return ret;
757  }
758  for (s->s.h.tiling.log2_tile_cols = 0;
759  s->sb_cols > (64 << s->s.h.tiling.log2_tile_cols);
760  s->s.h.tiling.log2_tile_cols++) ;
761  for (max = 0; (s->sb_cols >> max) >= 4; max++) ;
762  max = FFMAX(0, max - 1);
763  while (max > s->s.h.tiling.log2_tile_cols) {
764  if (get_bits1(&s->gb))
765  s->s.h.tiling.log2_tile_cols++;
766  else
767  break;
768  }
769  s->s.h.tiling.log2_tile_rows = decode012(&s->gb);
770  s->s.h.tiling.tile_rows = 1 << s->s.h.tiling.log2_tile_rows;
771  if (s->s.h.tiling.tile_cols != (1 << s->s.h.tiling.log2_tile_cols)) {
772  int n_range_coders;
773  VP56RangeCoder *rc;
774 
775  if (s->td) {
776  for (i = 0; i < s->active_tile_cols; i++) {
777  av_free(s->td[i].b_base);
778  av_free(s->td[i].block_base);
779  }
780  av_free(s->td);
781  }
782 
783  s->s.h.tiling.tile_cols = 1 << s->s.h.tiling.log2_tile_cols;
784  vp9_free_entries(avctx);
786  s->s.h.tiling.tile_cols : 1;
787  vp9_alloc_entries(avctx, s->sb_rows);
788  if (avctx->active_thread_type == FF_THREAD_SLICE) {
789  n_range_coders = 4; // max_tile_rows
790  } else {
791  n_range_coders = s->s.h.tiling.tile_cols;
792  }
794  n_range_coders * sizeof(VP56RangeCoder));
795  if (!s->td)
796  return AVERROR(ENOMEM);
797  rc = (VP56RangeCoder *) &s->td[s->active_tile_cols];
798  for (i = 0; i < s->active_tile_cols; i++) {
799  s->td[i].s = s;
800  s->td[i].c_b = rc;
801  rc += n_range_coders;
802  }
803  }
804 
805  /* check reference frames */
806  if (!s->s.h.keyframe && !s->s.h.intraonly) {
807  for (i = 0; i < 3; i++) {
808  AVFrame *ref = s->s.refs[s->s.h.refidx[i]].f;
809  int refw = ref->width, refh = ref->height;
810 
811  if (ref->format != avctx->pix_fmt) {
812  av_log(avctx, AV_LOG_ERROR,
813  "Ref pixfmt (%s) did not match current frame (%s)",
815  av_get_pix_fmt_name(avctx->pix_fmt));
816  return AVERROR_INVALIDDATA;
817  } else if (refw == w && refh == h) {
818  s->mvscale[i][0] = s->mvscale[i][1] = 0;
819  } else {
820  if (w * 2 < refw || h * 2 < refh || w > 16 * refw || h > 16 * refh) {
821  av_log(avctx, AV_LOG_ERROR,
822  "Invalid ref frame dimensions %dx%d for frame size %dx%d\n",
823  refw, refh, w, h);
824  return AVERROR_INVALIDDATA;
825  }
826  s->mvscale[i][0] = (refw << 14) / w;
827  s->mvscale[i][1] = (refh << 14) / h;
828  s->mvstep[i][0] = 16 * s->mvscale[i][0] >> 14;
829  s->mvstep[i][1] = 16 * s->mvscale[i][1] >> 14;
830  }
831  }
832  }
833 
834  if (s->s.h.keyframe || s->s.h.errorres || (s->s.h.intraonly && s->s.h.resetctx == 3)) {
835  s->prob_ctx[0].p = s->prob_ctx[1].p = s->prob_ctx[2].p =
838  sizeof(ff_vp9_default_coef_probs));
840  sizeof(ff_vp9_default_coef_probs));
842  sizeof(ff_vp9_default_coef_probs));
844  sizeof(ff_vp9_default_coef_probs));
845  } else if (s->s.h.intraonly && s->s.h.resetctx == 2) {
848  sizeof(ff_vp9_default_coef_probs));
849  }
850 
851  // next 16 bits is size of the rest of the header (arith-coded)
852  s->s.h.compressed_header_size = size2 = get_bits(&s->gb, 16);
853  s->s.h.uncompressed_header_size = (get_bits_count(&s->gb) + 7) / 8;
854 
855  data2 = align_get_bits(&s->gb);
856  if (size2 > size - (data2 - data)) {
857  av_log(avctx, AV_LOG_ERROR, "Invalid compressed header size\n");
858  return AVERROR_INVALIDDATA;
859  }
860  ret = ff_vp56_init_range_decoder(&s->c, data2, size2);
861  if (ret < 0)
862  return ret;
863 
864  if (vp56_rac_get_prob_branchy(&s->c, 128)) { // marker bit
865  av_log(avctx, AV_LOG_ERROR, "Marker bit was set\n");
866  return AVERROR_INVALIDDATA;
867  }
868 
869  for (i = 0; i < s->active_tile_cols; i++) {
870  if (s->s.h.keyframe || s->s.h.intraonly) {
871  memset(s->td[i].counts.coef, 0, sizeof(s->td[0].counts.coef));
872  memset(s->td[i].counts.eob, 0, sizeof(s->td[0].counts.eob));
873  } else {
874  memset(&s->td[i].counts, 0, sizeof(s->td[0].counts));
875  }
876  }
877 
878  /* FIXME is it faster to not copy here, but do it down in the fw updates
879  * as explicit copies if the fw update is missing (and skip the copy upon
880  * fw update)? */
881  s->prob.p = s->prob_ctx[c].p;
882 
883  // txfm updates
884  if (s->s.h.lossless) {
885  s->s.h.txfmmode = TX_4X4;
886  } else {
887  s->s.h.txfmmode = vp8_rac_get_uint(&s->c, 2);
888  if (s->s.h.txfmmode == 3)
889  s->s.h.txfmmode += vp8_rac_get(&s->c);
890 
891  if (s->s.h.txfmmode == TX_SWITCHABLE) {
892  for (i = 0; i < 2; i++)
893  if (vp56_rac_get_prob_branchy(&s->c, 252))
894  s->prob.p.tx8p[i] = update_prob(&s->c, s->prob.p.tx8p[i]);
895  for (i = 0; i < 2; i++)
896  for (j = 0; j < 2; j++)
897  if (vp56_rac_get_prob_branchy(&s->c, 252))
898  s->prob.p.tx16p[i][j] =
899  update_prob(&s->c, s->prob.p.tx16p[i][j]);
900  for (i = 0; i < 2; i++)
901  for (j = 0; j < 3; j++)
902  if (vp56_rac_get_prob_branchy(&s->c, 252))
903  s->prob.p.tx32p[i][j] =
904  update_prob(&s->c, s->prob.p.tx32p[i][j]);
905  }
906  }
907 
908  // coef updates
909  for (i = 0; i < 4; i++) {
910  uint8_t (*ref)[2][6][6][3] = s->prob_ctx[c].coef[i];
911  if (vp8_rac_get(&s->c)) {
912  for (j = 0; j < 2; j++)
913  for (k = 0; k < 2; k++)
914  for (l = 0; l < 6; l++)
915  for (m = 0; m < 6; m++) {
916  uint8_t *p = s->prob.coef[i][j][k][l][m];
917  uint8_t *r = ref[j][k][l][m];
918  if (m >= 3 && l == 0) // dc only has 3 pt
919  break;
920  for (n = 0; n < 3; n++) {
921  if (vp56_rac_get_prob_branchy(&s->c, 252))
922  p[n] = update_prob(&s->c, r[n]);
923  else
924  p[n] = r[n];
925  }
926  memcpy(&p[3], ff_vp9_model_pareto8[p[2]], 8);
927  }
928  } else {
929  for (j = 0; j < 2; j++)
930  for (k = 0; k < 2; k++)
931  for (l = 0; l < 6; l++)
932  for (m = 0; m < 6; m++) {
933  uint8_t *p = s->prob.coef[i][j][k][l][m];
934  uint8_t *r = ref[j][k][l][m];
935  if (m > 3 && l == 0) // dc only has 3 pt
936  break;
937  memcpy(p, r, 3);
938  memcpy(&p[3], ff_vp9_model_pareto8[p[2]], 8);
939  }
940  }
941  if (s->s.h.txfmmode == i)
942  break;
943  }
944 
945  // mode updates
946  for (i = 0; i < 3; i++)
947  if (vp56_rac_get_prob_branchy(&s->c, 252))
948  s->prob.p.skip[i] = update_prob(&s->c, s->prob.p.skip[i]);
949  if (!s->s.h.keyframe && !s->s.h.intraonly) {
950  for (i = 0; i < 7; i++)
951  for (j = 0; j < 3; j++)
952  if (vp56_rac_get_prob_branchy(&s->c, 252))
953  s->prob.p.mv_mode[i][j] =
954  update_prob(&s->c, s->prob.p.mv_mode[i][j]);
955 
956  if (s->s.h.filtermode == FILTER_SWITCHABLE)
957  for (i = 0; i < 4; i++)
958  for (j = 0; j < 2; j++)
959  if (vp56_rac_get_prob_branchy(&s->c, 252))
960  s->prob.p.filter[i][j] =
961  update_prob(&s->c, s->prob.p.filter[i][j]);
962 
963  for (i = 0; i < 4; i++)
964  if (vp56_rac_get_prob_branchy(&s->c, 252))
965  s->prob.p.intra[i] = update_prob(&s->c, s->prob.p.intra[i]);
966 
967  if (s->s.h.allowcompinter) {
968  s->s.h.comppredmode = vp8_rac_get(&s->c);
969  if (s->s.h.comppredmode)
970  s->s.h.comppredmode += vp8_rac_get(&s->c);
971  if (s->s.h.comppredmode == PRED_SWITCHABLE)
972  for (i = 0; i < 5; i++)
973  if (vp56_rac_get_prob_branchy(&s->c, 252))
974  s->prob.p.comp[i] =
975  update_prob(&s->c, s->prob.p.comp[i]);
976  } else {
978  }
979 
980  if (s->s.h.comppredmode != PRED_COMPREF) {
981  for (i = 0; i < 5; i++) {
982  if (vp56_rac_get_prob_branchy(&s->c, 252))
983  s->prob.p.single_ref[i][0] =
984  update_prob(&s->c, s->prob.p.single_ref[i][0]);
985  if (vp56_rac_get_prob_branchy(&s->c, 252))
986  s->prob.p.single_ref[i][1] =
987  update_prob(&s->c, s->prob.p.single_ref[i][1]);
988  }
989  }
990 
991  if (s->s.h.comppredmode != PRED_SINGLEREF) {
992  for (i = 0; i < 5; i++)
993  if (vp56_rac_get_prob_branchy(&s->c, 252))
994  s->prob.p.comp_ref[i] =
995  update_prob(&s->c, s->prob.p.comp_ref[i]);
996  }
997 
998  for (i = 0; i < 4; i++)
999  for (j = 0; j < 9; j++)
1000  if (vp56_rac_get_prob_branchy(&s->c, 252))
1001  s->prob.p.y_mode[i][j] =
1002  update_prob(&s->c, s->prob.p.y_mode[i][j]);
1003 
1004  for (i = 0; i < 4; i++)
1005  for (j = 0; j < 4; j++)
1006  for (k = 0; k < 3; k++)
1007  if (vp56_rac_get_prob_branchy(&s->c, 252))
1008  s->prob.p.partition[3 - i][j][k] =
1009  update_prob(&s->c,
1010  s->prob.p.partition[3 - i][j][k]);
1011 
1012  // mv fields don't use the update_prob subexp model for some reason
1013  for (i = 0; i < 3; i++)
1014  if (vp56_rac_get_prob_branchy(&s->c, 252))
1015  s->prob.p.mv_joint[i] = (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1016 
1017  for (i = 0; i < 2; i++) {
1018  if (vp56_rac_get_prob_branchy(&s->c, 252))
1019  s->prob.p.mv_comp[i].sign =
1020  (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1021 
1022  for (j = 0; j < 10; j++)
1023  if (vp56_rac_get_prob_branchy(&s->c, 252))
1024  s->prob.p.mv_comp[i].classes[j] =
1025  (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1026 
1027  if (vp56_rac_get_prob_branchy(&s->c, 252))
1028  s->prob.p.mv_comp[i].class0 =
1029  (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1030 
1031  for (j = 0; j < 10; j++)
1032  if (vp56_rac_get_prob_branchy(&s->c, 252))
1033  s->prob.p.mv_comp[i].bits[j] =
1034  (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1035  }
1036 
1037  for (i = 0; i < 2; i++) {
1038  for (j = 0; j < 2; j++)
1039  for (k = 0; k < 3; k++)
1040  if (vp56_rac_get_prob_branchy(&s->c, 252))
1041  s->prob.p.mv_comp[i].class0_fp[j][k] =
1042  (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1043 
1044  for (j = 0; j < 3; j++)
1045  if (vp56_rac_get_prob_branchy(&s->c, 252))
1046  s->prob.p.mv_comp[i].fp[j] =
1047  (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1048  }
1049 
1050  if (s->s.h.highprecisionmvs) {
1051  for (i = 0; i < 2; i++) {
1052  if (vp56_rac_get_prob_branchy(&s->c, 252))
1053  s->prob.p.mv_comp[i].class0_hp =
1054  (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1055 
1056  if (vp56_rac_get_prob_branchy(&s->c, 252))
1057  s->prob.p.mv_comp[i].hp =
1058  (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1059  }
1060  }
1061  }
1062 
1063  return (data2 - data) + size2;
1064 }
1065 
1066 static void decode_sb(VP9TileData *td, int row, int col, VP9Filter *lflvl,
1067  ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
1068 {
1069  const VP9Context *s = td->s;
1070  int c = ((s->above_partition_ctx[col] >> (3 - bl)) & 1) |
1071  (((td->left_partition_ctx[row & 0x7] >> (3 - bl)) & 1) << 1);
1072  const uint8_t *p = s->s.h.keyframe || s->s.h.intraonly ? ff_vp9_default_kf_partition_probs[bl][c] :
1073  s->prob.p.partition[bl][c];
1074  enum BlockPartition bp;
1075  ptrdiff_t hbs = 4 >> bl;
1076  AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
1077  ptrdiff_t y_stride = f->linesize[0], uv_stride = f->linesize[1];
1078  int bytesperpixel = s->bytesperpixel;
1079 
1080  if (bl == BL_8X8) {
1082  ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
1083  } else if (col + hbs < s->cols) { // FIXME why not <=?
1084  if (row + hbs < s->rows) { // FIXME why not <=?
1086  switch (bp) {
1087  case PARTITION_NONE:
1088  ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
1089  break;
1090  case PARTITION_H:
1091  ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
1092  yoff += hbs * 8 * y_stride;
1093  uvoff += hbs * 8 * uv_stride >> s->ss_v;
1094  ff_vp9_decode_block(td, row + hbs, col, lflvl, yoff, uvoff, bl, bp);
1095  break;
1096  case PARTITION_V:
1097  ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
1098  yoff += hbs * 8 * bytesperpixel;
1099  uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
1100  ff_vp9_decode_block(td, row, col + hbs, lflvl, yoff, uvoff, bl, bp);
1101  break;
1102  case PARTITION_SPLIT:
1103  decode_sb(td, row, col, lflvl, yoff, uvoff, bl + 1);
1104  decode_sb(td, row, col + hbs, lflvl,
1105  yoff + 8 * hbs * bytesperpixel,
1106  uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
1107  yoff += hbs * 8 * y_stride;
1108  uvoff += hbs * 8 * uv_stride >> s->ss_v;
1109  decode_sb(td, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
1110  decode_sb(td, row + hbs, col + hbs, lflvl,
1111  yoff + 8 * hbs * bytesperpixel,
1112  uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
1113  break;
1114  default:
1115  av_assert0(0);
1116  }
1117  } else if (vp56_rac_get_prob_branchy(td->c, p[1])) {
1118  bp = PARTITION_SPLIT;
1119  decode_sb(td, row, col, lflvl, yoff, uvoff, bl + 1);
1120  decode_sb(td, row, col + hbs, lflvl,
1121  yoff + 8 * hbs * bytesperpixel,
1122  uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
1123  } else {
1124  bp = PARTITION_H;
1125  ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
1126  }
1127  } else if (row + hbs < s->rows) { // FIXME why not <=?
1128  if (vp56_rac_get_prob_branchy(td->c, p[2])) {
1129  bp = PARTITION_SPLIT;
1130  decode_sb(td, row, col, lflvl, yoff, uvoff, bl + 1);
1131  yoff += hbs * 8 * y_stride;
1132  uvoff += hbs * 8 * uv_stride >> s->ss_v;
1133  decode_sb(td, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
1134  } else {
1135  bp = PARTITION_V;
1136  ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
1137  }
1138  } else {
1139  bp = PARTITION_SPLIT;
1140  decode_sb(td, row, col, lflvl, yoff, uvoff, bl + 1);
1141  }
1142  td->counts.partition[bl][c][bp]++;
1143 }
1144 
1145 static void decode_sb_mem(VP9TileData *td, int row, int col, VP9Filter *lflvl,
1146  ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
1147 {
1148  const VP9Context *s = td->s;
1149  VP9Block *b = td->b;
1150  ptrdiff_t hbs = 4 >> bl;
1151  AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
1152  ptrdiff_t y_stride = f->linesize[0], uv_stride = f->linesize[1];
1153  int bytesperpixel = s->bytesperpixel;
1154 
1155  if (bl == BL_8X8) {
1156  av_assert2(b->bl == BL_8X8);
1157  ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, b->bl, b->bp);
1158  } else if (td->b->bl == bl) {
1159  ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, b->bl, b->bp);
1160  if (b->bp == PARTITION_H && row + hbs < s->rows) {
1161  yoff += hbs * 8 * y_stride;
1162  uvoff += hbs * 8 * uv_stride >> s->ss_v;
1163  ff_vp9_decode_block(td, row + hbs, col, lflvl, yoff, uvoff, b->bl, b->bp);
1164  } else if (b->bp == PARTITION_V && col + hbs < s->cols) {
1165  yoff += hbs * 8 * bytesperpixel;
1166  uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
1167  ff_vp9_decode_block(td, row, col + hbs, lflvl, yoff, uvoff, b->bl, b->bp);
1168  }
1169  } else {
1170  decode_sb_mem(td, row, col, lflvl, yoff, uvoff, bl + 1);
1171  if (col + hbs < s->cols) { // FIXME why not <=?
1172  if (row + hbs < s->rows) {
1173  decode_sb_mem(td, row, col + hbs, lflvl, yoff + 8 * hbs * bytesperpixel,
1174  uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
1175  yoff += hbs * 8 * y_stride;
1176  uvoff += hbs * 8 * uv_stride >> s->ss_v;
1177  decode_sb_mem(td, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
1178  decode_sb_mem(td, row + hbs, col + hbs, lflvl,
1179  yoff + 8 * hbs * bytesperpixel,
1180  uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
1181  } else {
1182  yoff += hbs * 8 * bytesperpixel;
1183  uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
1184  decode_sb_mem(td, row, col + hbs, lflvl, yoff, uvoff, bl + 1);
1185  }
1186  } else if (row + hbs < s->rows) {
1187  yoff += hbs * 8 * y_stride;
1188  uvoff += hbs * 8 * uv_stride >> s->ss_v;
1189  decode_sb_mem(td, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
1190  }
1191  }
1192 }
1193 
1194 static void set_tile_offset(int *start, int *end, int idx, int log2_n, int n)
1195 {
1196  int sb_start = ( idx * n) >> log2_n;
1197  int sb_end = ((idx + 1) * n) >> log2_n;
1198  *start = FFMIN(sb_start, n) << 3;
1199  *end = FFMIN(sb_end, n) << 3;
1200 }
1201 
1202 static void free_buffers(VP9Context *s)
1203 {
1204  int i;
1205 
1206  av_freep(&s->intra_pred_data[0]);
1207  for (i = 0; i < s->active_tile_cols; i++) {
1208  av_freep(&s->td[i].b_base);
1209  av_freep(&s->td[i].block_base);
1210  }
1211 }
1212 
1214 {
1215  VP9Context *s = avctx->priv_data;
1216  int i;
1217 
1218  for (i = 0; i < 3; i++) {
1219  if (s->s.frames[i].tf.f->buf[0])
1220  vp9_frame_unref(avctx, &s->s.frames[i]);
1221  av_frame_free(&s->s.frames[i].tf.f);
1222  }
1224  for (i = 0; i < 8; i++) {
1225  if (s->s.refs[i].f->buf[0])
1226  ff_thread_release_buffer(avctx, &s->s.refs[i]);
1227  av_frame_free(&s->s.refs[i].f);
1228  if (s->next_refs[i].f->buf[0])
1229  ff_thread_release_buffer(avctx, &s->next_refs[i]);
1230  av_frame_free(&s->next_refs[i].f);
1231  }
1232 
1233  free_buffers(s);
1234  vp9_free_entries(avctx);
1235  av_freep(&s->td);
1236  return 0;
1237 }
1238 
1239 static int decode_tiles(AVCodecContext *avctx,
1240  const uint8_t *data, int size)
1241 {
1242  VP9Context *s = avctx->priv_data;
1243  VP9TileData *td = &s->td[0];
1244  int row, col, tile_row, tile_col, ret;
1245  int bytesperpixel;
1246  int tile_row_start, tile_row_end, tile_col_start, tile_col_end;
1247  AVFrame *f;
1248  ptrdiff_t yoff, uvoff, ls_y, ls_uv;
1249 
1250  f = s->s.frames[CUR_FRAME].tf.f;
1251  ls_y = f->linesize[0];
1252  ls_uv =f->linesize[1];
1253  bytesperpixel = s->bytesperpixel;
1254 
1255  yoff = uvoff = 0;
1256  for (tile_row = 0; tile_row < s->s.h.tiling.tile_rows; tile_row++) {
1257  set_tile_offset(&tile_row_start, &tile_row_end,
1258  tile_row, s->s.h.tiling.log2_tile_rows, s->sb_rows);
1259 
1260  for (tile_col = 0; tile_col < s->s.h.tiling.tile_cols; tile_col++) {
1261  int64_t tile_size;
1262 
1263  if (tile_col == s->s.h.tiling.tile_cols - 1 &&
1264  tile_row == s->s.h.tiling.tile_rows - 1) {
1265  tile_size = size;
1266  } else {
1267  tile_size = AV_RB32(data);
1268  data += 4;
1269  size -= 4;
1270  }
1271  if (tile_size > size) {
1272  ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, INT_MAX, 0);
1273  return AVERROR_INVALIDDATA;
1274  }
1275  ret = ff_vp56_init_range_decoder(&td->c_b[tile_col], data, tile_size);
1276  if (ret < 0)
1277  return ret;
1278  if (vp56_rac_get_prob_branchy(&td->c_b[tile_col], 128)) { // marker bit
1279  ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, INT_MAX, 0);
1280  return AVERROR_INVALIDDATA;
1281  }
1282  data += tile_size;
1283  size -= tile_size;
1284  }
1285 
1286  for (row = tile_row_start; row < tile_row_end;
1287  row += 8, yoff += ls_y * 64, uvoff += ls_uv * 64 >> s->ss_v) {
1288  VP9Filter *lflvl_ptr = s->lflvl;
1289  ptrdiff_t yoff2 = yoff, uvoff2 = uvoff;
1290 
1291  for (tile_col = 0; tile_col < s->s.h.tiling.tile_cols; tile_col++) {
1292  set_tile_offset(&tile_col_start, &tile_col_end,
1293  tile_col, s->s.h.tiling.log2_tile_cols, s->sb_cols);
1294  td->tile_col_start = tile_col_start;
1295  if (s->pass != 2) {
1296  memset(td->left_partition_ctx, 0, 8);
1297  memset(td->left_skip_ctx, 0, 8);
1298  if (s->s.h.keyframe || s->s.h.intraonly) {
1299  memset(td->left_mode_ctx, DC_PRED, 16);
1300  } else {
1301  memset(td->left_mode_ctx, NEARESTMV, 8);
1302  }
1303  memset(td->left_y_nnz_ctx, 0, 16);
1304  memset(td->left_uv_nnz_ctx, 0, 32);
1305  memset(td->left_segpred_ctx, 0, 8);
1306 
1307  td->c = &td->c_b[tile_col];
1308  }
1309 
1310  for (col = tile_col_start;
1311  col < tile_col_end;
1312  col += 8, yoff2 += 64 * bytesperpixel,
1313  uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
1314  // FIXME integrate with lf code (i.e. zero after each
1315  // use, similar to invtxfm coefficients, or similar)
1316  if (s->pass != 1) {
1317  memset(lflvl_ptr->mask, 0, sizeof(lflvl_ptr->mask));
1318  }
1319 
1320  if (s->pass == 2) {
1321  decode_sb_mem(td, row, col, lflvl_ptr,
1322  yoff2, uvoff2, BL_64X64);
1323  } else {
1324  if (vpX_rac_is_end(td->c)) {
1325  return AVERROR_INVALIDDATA;
1326  }
1327  decode_sb(td, row, col, lflvl_ptr,
1328  yoff2, uvoff2, BL_64X64);
1329  }
1330  }
1331  }
1332 
1333  if (s->pass == 1)
1334  continue;
1335 
1336  // backup pre-loopfilter reconstruction data for intra
1337  // prediction of next row of sb64s
1338  if (row + 8 < s->rows) {
1339  memcpy(s->intra_pred_data[0],
1340  f->data[0] + yoff + 63 * ls_y,
1341  8 * s->cols * bytesperpixel);
1342  memcpy(s->intra_pred_data[1],
1343  f->data[1] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
1344  8 * s->cols * bytesperpixel >> s->ss_h);
1345  memcpy(s->intra_pred_data[2],
1346  f->data[2] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
1347  8 * s->cols * bytesperpixel >> s->ss_h);
1348  }
1349 
1350  // loopfilter one row
1351  if (s->s.h.filter.level) {
1352  yoff2 = yoff;
1353  uvoff2 = uvoff;
1354  lflvl_ptr = s->lflvl;
1355  for (col = 0; col < s->cols;
1356  col += 8, yoff2 += 64 * bytesperpixel,
1357  uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
1358  ff_vp9_loopfilter_sb(avctx, lflvl_ptr, row, col,
1359  yoff2, uvoff2);
1360  }
1361  }
1362 
1363  // FIXME maybe we can make this more finegrained by running the
1364  // loopfilter per-block instead of after each sbrow
1365  // In fact that would also make intra pred left preparation easier?
1366  ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, row >> 3, 0);
1367  }
1368  }
1369  return 0;
1370 }
1371 
1372 #if HAVE_THREADS
1373 static av_always_inline
1374 int decode_tiles_mt(AVCodecContext *avctx, void *tdata, int jobnr,
1375  int threadnr)
1376 {
1377  VP9Context *s = avctx->priv_data;
1378  VP9TileData *td = &s->td[jobnr];
1379  ptrdiff_t uvoff, yoff, ls_y, ls_uv;
1380  int bytesperpixel = s->bytesperpixel, row, col, tile_row;
1381  unsigned tile_cols_len;
1382  int tile_row_start, tile_row_end, tile_col_start, tile_col_end;
1383  VP9Filter *lflvl_ptr_base;
1384  AVFrame *f;
1385 
1386  f = s->s.frames[CUR_FRAME].tf.f;
1387  ls_y = f->linesize[0];
1388  ls_uv =f->linesize[1];
1389 
1390  set_tile_offset(&tile_col_start, &tile_col_end,
1391  jobnr, s->s.h.tiling.log2_tile_cols, s->sb_cols);
1392  td->tile_col_start = tile_col_start;
1393  uvoff = (64 * bytesperpixel >> s->ss_h)*(tile_col_start >> 3);
1394  yoff = (64 * bytesperpixel)*(tile_col_start >> 3);
1395  lflvl_ptr_base = s->lflvl+(tile_col_start >> 3);
1396 
1397  for (tile_row = 0; tile_row < s->s.h.tiling.tile_rows; tile_row++) {
1398  set_tile_offset(&tile_row_start, &tile_row_end,
1399  tile_row, s->s.h.tiling.log2_tile_rows, s->sb_rows);
1400 
1401  td->c = &td->c_b[tile_row];
1402  for (row = tile_row_start; row < tile_row_end;
1403  row += 8, yoff += ls_y * 64, uvoff += ls_uv * 64 >> s->ss_v) {
1404  ptrdiff_t yoff2 = yoff, uvoff2 = uvoff;
1405  VP9Filter *lflvl_ptr = lflvl_ptr_base+s->sb_cols*(row >> 3);
1406 
1407  memset(td->left_partition_ctx, 0, 8);
1408  memset(td->left_skip_ctx, 0, 8);
1409  if (s->s.h.keyframe || s->s.h.intraonly) {
1410  memset(td->left_mode_ctx, DC_PRED, 16);
1411  } else {
1412  memset(td->left_mode_ctx, NEARESTMV, 8);
1413  }
1414  memset(td->left_y_nnz_ctx, 0, 16);
1415  memset(td->left_uv_nnz_ctx, 0, 32);
1416  memset(td->left_segpred_ctx, 0, 8);
1417 
1418  for (col = tile_col_start;
1419  col < tile_col_end;
1420  col += 8, yoff2 += 64 * bytesperpixel,
1421  uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
1422  // FIXME integrate with lf code (i.e. zero after each
1423  // use, similar to invtxfm coefficients, or similar)
1424  memset(lflvl_ptr->mask, 0, sizeof(lflvl_ptr->mask));
1425  decode_sb(td, row, col, lflvl_ptr,
1426  yoff2, uvoff2, BL_64X64);
1427  }
1428 
1429  // backup pre-loopfilter reconstruction data for intra
1430  // prediction of next row of sb64s
1431  tile_cols_len = tile_col_end - tile_col_start;
1432  if (row + 8 < s->rows) {
1433  memcpy(s->intra_pred_data[0] + (tile_col_start * 8 * bytesperpixel),
1434  f->data[0] + yoff + 63 * ls_y,
1435  8 * tile_cols_len * bytesperpixel);
1436  memcpy(s->intra_pred_data[1] + (tile_col_start * 8 * bytesperpixel >> s->ss_h),
1437  f->data[1] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
1438  8 * tile_cols_len * bytesperpixel >> s->ss_h);
1439  memcpy(s->intra_pred_data[2] + (tile_col_start * 8 * bytesperpixel >> s->ss_h),
1440  f->data[2] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
1441  8 * tile_cols_len * bytesperpixel >> s->ss_h);
1442  }
1443 
1444  vp9_report_tile_progress(s, row >> 3, 1);
1445  }
1446  }
1447  return 0;
1448 }
1449 
1450 static av_always_inline
1451 int loopfilter_proc(AVCodecContext *avctx)
1452 {
1453  VP9Context *s = avctx->priv_data;
1454  ptrdiff_t uvoff, yoff, ls_y, ls_uv;
1455  VP9Filter *lflvl_ptr;
1456  int bytesperpixel = s->bytesperpixel, col, i;
1457  AVFrame *f;
1458 
1459  f = s->s.frames[CUR_FRAME].tf.f;
1460  ls_y = f->linesize[0];
1461  ls_uv =f->linesize[1];
1462 
1463  for (i = 0; i < s->sb_rows; i++) {
1464  vp9_await_tile_progress(s, i, s->s.h.tiling.tile_cols);
1465 
1466  if (s->s.h.filter.level) {
1467  yoff = (ls_y * 64)*i;
1468  uvoff = (ls_uv * 64 >> s->ss_v)*i;
1469  lflvl_ptr = s->lflvl+s->sb_cols*i;
1470  for (col = 0; col < s->cols;
1471  col += 8, yoff += 64 * bytesperpixel,
1472  uvoff += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
1473  ff_vp9_loopfilter_sb(avctx, lflvl_ptr, i << 3, col,
1474  yoff, uvoff);
1475  }
1476  }
1477  }
1478  return 0;
1479 }
1480 #endif
1481 
1482 static int vp9_decode_frame(AVCodecContext *avctx, void *frame,
1483  int *got_frame, AVPacket *pkt)
1484 {
1485  const uint8_t *data = pkt->data;
1486  int size = pkt->size;
1487  VP9Context *s = avctx->priv_data;
1488  int ret, i, j, ref;
1489  int retain_segmap_ref = s->s.frames[REF_FRAME_SEGMAP].segmentation_map &&
1491  AVFrame *f;
1492 
1493  if ((ret = decode_frame_header(avctx, data, size, &ref)) < 0) {
1494  return ret;
1495  } else if (ret == 0) {
1496  if (!s->s.refs[ref].f->buf[0]) {
1497  av_log(avctx, AV_LOG_ERROR, "Requested reference %d not available\n", ref);
1498  return AVERROR_INVALIDDATA;
1499  }
1500  if ((ret = av_frame_ref(frame, s->s.refs[ref].f)) < 0)
1501  return ret;
1502  ((AVFrame *)frame)->pts = pkt->pts;
1503 #if FF_API_PKT_PTS
1505  ((AVFrame *)frame)->pkt_pts = pkt->pts;
1507 #endif
1508  ((AVFrame *)frame)->pkt_dts = pkt->dts;
1509  for (i = 0; i < 8; i++) {
1510  if (s->next_refs[i].f->buf[0])
1511  ff_thread_release_buffer(avctx, &s->next_refs[i]);
1512  if (s->s.refs[i].f->buf[0] &&
1513  (ret = ff_thread_ref_frame(&s->next_refs[i], &s->s.refs[i])) < 0)
1514  return ret;
1515  }
1516  *got_frame = 1;
1517  return pkt->size;
1518  }
1519  data += ret;
1520  size -= ret;
1521 
1522  if (!retain_segmap_ref || s->s.h.keyframe || s->s.h.intraonly) {
1523  if (s->s.frames[REF_FRAME_SEGMAP].tf.f->buf[0])
1525  if (!s->s.h.keyframe && !s->s.h.intraonly && !s->s.h.errorres && s->s.frames[CUR_FRAME].tf.f->buf[0] &&
1526  (ret = vp9_frame_ref(avctx, &s->s.frames[REF_FRAME_SEGMAP], &s->s.frames[CUR_FRAME])) < 0)
1527  return ret;
1528  }
1529  if (s->s.frames[REF_FRAME_MVPAIR].tf.f->buf[0])
1531  if (!s->s.h.intraonly && !s->s.h.keyframe && !s->s.h.errorres && s->s.frames[CUR_FRAME].tf.f->buf[0] &&
1532  (ret = vp9_frame_ref(avctx, &s->s.frames[REF_FRAME_MVPAIR], &s->s.frames[CUR_FRAME])) < 0)
1533  return ret;
1534  if (s->s.frames[CUR_FRAME].tf.f->buf[0])
1535  vp9_frame_unref(avctx, &s->s.frames[CUR_FRAME]);
1536  if ((ret = vp9_frame_alloc(avctx, &s->s.frames[CUR_FRAME])) < 0)
1537  return ret;
1538  f = s->s.frames[CUR_FRAME].tf.f;
1539  f->key_frame = s->s.h.keyframe;
1541 
1542  if (s->s.frames[REF_FRAME_SEGMAP].tf.f->buf[0] &&
1546  }
1547 
1548  // ref frame setup
1549  for (i = 0; i < 8; i++) {
1550  if (s->next_refs[i].f->buf[0])
1551  ff_thread_release_buffer(avctx, &s->next_refs[i]);
1552  if (s->s.h.refreshrefmask & (1 << i)) {
1553  ret = ff_thread_ref_frame(&s->next_refs[i], &s->s.frames[CUR_FRAME].tf);
1554  } else if (s->s.refs[i].f->buf[0]) {
1555  ret = ff_thread_ref_frame(&s->next_refs[i], &s->s.refs[i]);
1556  }
1557  if (ret < 0)
1558  return ret;
1559  }
1560 
1561  if (avctx->hwaccel) {
1562  ret = avctx->hwaccel->start_frame(avctx, NULL, 0);
1563  if (ret < 0)
1564  return ret;
1565  ret = avctx->hwaccel->decode_slice(avctx, pkt->data, pkt->size);
1566  if (ret < 0)
1567  return ret;
1568  ret = avctx->hwaccel->end_frame(avctx);
1569  if (ret < 0)
1570  return ret;
1571  goto finish;
1572  }
1573 
1574  // main tile decode loop
1575  memset(s->above_partition_ctx, 0, s->cols);
1576  memset(s->above_skip_ctx, 0, s->cols);
1577  if (s->s.h.keyframe || s->s.h.intraonly) {
1578  memset(s->above_mode_ctx, DC_PRED, s->cols * 2);
1579  } else {
1580  memset(s->above_mode_ctx, NEARESTMV, s->cols);
1581  }
1582  memset(s->above_y_nnz_ctx, 0, s->sb_cols * 16);
1583  memset(s->above_uv_nnz_ctx[0], 0, s->sb_cols * 16 >> s->ss_h);
1584  memset(s->above_uv_nnz_ctx[1], 0, s->sb_cols * 16 >> s->ss_h);
1585  memset(s->above_segpred_ctx, 0, s->cols);
1586  s->pass = s->s.frames[CUR_FRAME].uses_2pass =
1588  if ((ret = update_block_buffers(avctx)) < 0) {
1589  av_log(avctx, AV_LOG_ERROR,
1590  "Failed to allocate block buffers\n");
1591  return ret;
1592  }
1593  if (s->s.h.refreshctx && s->s.h.parallelmode) {
1594  int j, k, l, m;
1595 
1596  for (i = 0; i < 4; i++) {
1597  for (j = 0; j < 2; j++)
1598  for (k = 0; k < 2; k++)
1599  for (l = 0; l < 6; l++)
1600  for (m = 0; m < 6; m++)
1601  memcpy(s->prob_ctx[s->s.h.framectxid].coef[i][j][k][l][m],
1602  s->prob.coef[i][j][k][l][m], 3);
1603  if (s->s.h.txfmmode == i)
1604  break;
1605  }
1606  s->prob_ctx[s->s.h.framectxid].p = s->prob.p;
1607  ff_thread_finish_setup(avctx);
1608  } else if (!s->s.h.refreshctx) {
1609  ff_thread_finish_setup(avctx);
1610  }
1611 
1612 #if HAVE_THREADS
1613  if (avctx->active_thread_type & FF_THREAD_SLICE) {
1614  for (i = 0; i < s->sb_rows; i++)
1615  atomic_store(&s->entries[i], 0);
1616  }
1617 #endif
1618 
1619  do {
1620  for (i = 0; i < s->active_tile_cols; i++) {
1621  s->td[i].b = s->td[i].b_base;
1622  s->td[i].block = s->td[i].block_base;
1623  s->td[i].uvblock[0] = s->td[i].uvblock_base[0];
1624  s->td[i].uvblock[1] = s->td[i].uvblock_base[1];
1625  s->td[i].eob = s->td[i].eob_base;
1626  s->td[i].uveob[0] = s->td[i].uveob_base[0];
1627  s->td[i].uveob[1] = s->td[i].uveob_base[1];
1628  }
1629 
1630 #if HAVE_THREADS
1631  if (avctx->active_thread_type == FF_THREAD_SLICE) {
1632  int tile_row, tile_col;
1633 
1634  av_assert1(!s->pass);
1635 
1636  for (tile_row = 0; tile_row < s->s.h.tiling.tile_rows; tile_row++) {
1637  for (tile_col = 0; tile_col < s->s.h.tiling.tile_cols; tile_col++) {
1638  int64_t tile_size;
1639 
1640  if (tile_col == s->s.h.tiling.tile_cols - 1 &&
1641  tile_row == s->s.h.tiling.tile_rows - 1) {
1642  tile_size = size;
1643  } else {
1644  tile_size = AV_RB32(data);
1645  data += 4;
1646  size -= 4;
1647  }
1648  if (tile_size > size)
1649  return AVERROR_INVALIDDATA;
1650  ret = ff_vp56_init_range_decoder(&s->td[tile_col].c_b[tile_row], data, tile_size);
1651  if (ret < 0)
1652  return ret;
1653  if (vp56_rac_get_prob_branchy(&s->td[tile_col].c_b[tile_row], 128)) // marker bit
1654  return AVERROR_INVALIDDATA;
1655  data += tile_size;
1656  size -= tile_size;
1657  }
1658  }
1659 
1660  ff_slice_thread_execute_with_mainfunc(avctx, decode_tiles_mt, loopfilter_proc, s->td, NULL, s->s.h.tiling.tile_cols);
1661  } else
1662 #endif
1663  {
1664  ret = decode_tiles(avctx, data, size);
1665  if (ret < 0) {
1666  ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, INT_MAX, 0);
1667  return ret;
1668  }
1669  }
1670 
1671  // Sum all counts fields into td[0].counts for tile threading
1672  if (avctx->active_thread_type == FF_THREAD_SLICE)
1673  for (i = 1; i < s->s.h.tiling.tile_cols; i++)
1674  for (j = 0; j < sizeof(s->td[i].counts) / sizeof(unsigned); j++)
1675  ((unsigned *)&s->td[0].counts)[j] += ((unsigned *)&s->td[i].counts)[j];
1676 
1677  if (s->pass < 2 && s->s.h.refreshctx && !s->s.h.parallelmode) {
1678  ff_vp9_adapt_probs(s);
1679  ff_thread_finish_setup(avctx);
1680  }
1681  } while (s->pass++ == 1);
1682  ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, INT_MAX, 0);
1683 
1684 finish:
1685  // ref frame setup
1686  for (i = 0; i < 8; i++) {
1687  if (s->s.refs[i].f->buf[0])
1688  ff_thread_release_buffer(avctx, &s->s.refs[i]);
1689  if (s->next_refs[i].f->buf[0] &&
1690  (ret = ff_thread_ref_frame(&s->s.refs[i], &s->next_refs[i])) < 0)
1691  return ret;
1692  }
1693 
1694  if (!s->s.h.invisible) {
1695  if ((ret = av_frame_ref(frame, s->s.frames[CUR_FRAME].tf.f)) < 0)
1696  return ret;
1697  *got_frame = 1;
1698  }
1699 
1700  return pkt->size;
1701 }
1702 
1704 {
1705  VP9Context *s = avctx->priv_data;
1706  int i;
1707 
1708  for (i = 0; i < 3; i++)
1709  vp9_frame_unref(avctx, &s->s.frames[i]);
1710  for (i = 0; i < 8; i++)
1711  ff_thread_release_buffer(avctx, &s->s.refs[i]);
1712 }
1713 
1714 static int init_frames(AVCodecContext *avctx)
1715 {
1716  VP9Context *s = avctx->priv_data;
1717  int i;
1718 
1719  for (i = 0; i < 3; i++) {
1720  s->s.frames[i].tf.f = av_frame_alloc();
1721  if (!s->s.frames[i].tf.f) {
1722  vp9_decode_free(avctx);
1723  av_log(avctx, AV_LOG_ERROR, "Failed to allocate frame buffer %d\n", i);
1724  return AVERROR(ENOMEM);
1725  }
1726  }
1727  for (i = 0; i < 8; i++) {
1728  s->s.refs[i].f = av_frame_alloc();
1729  s->next_refs[i].f = av_frame_alloc();
1730  if (!s->s.refs[i].f || !s->next_refs[i].f) {
1731  vp9_decode_free(avctx);
1732  av_log(avctx, AV_LOG_ERROR, "Failed to allocate frame buffer %d\n", i);
1733  return AVERROR(ENOMEM);
1734  }
1735  }
1736 
1737  return 0;
1738 }
1739 
1741 {
1742  VP9Context *s = avctx->priv_data;
1743 
1744  avctx->internal->allocate_progress = 1;
1745  s->last_bpp = 0;
1746  s->s.h.filter.sharpness = -1;
1747 
1748  return init_frames(avctx);
1749 }
1750 
1751 #if HAVE_THREADS
1752 static av_cold int vp9_decode_init_thread_copy(AVCodecContext *avctx)
1753 {
1754  return init_frames(avctx);
1755 }
1756 
1757 static int vp9_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
1758 {
1759  int i, ret;
1760  VP9Context *s = dst->priv_data, *ssrc = src->priv_data;
1761 
1762  for (i = 0; i < 3; i++) {
1763  if (s->s.frames[i].tf.f->buf[0])
1764  vp9_frame_unref(dst, &s->s.frames[i]);
1765  if (ssrc->s.frames[i].tf.f->buf[0]) {
1766  if ((ret = vp9_frame_ref(dst, &s->s.frames[i], &ssrc->s.frames[i])) < 0)
1767  return ret;
1768  }
1769  }
1770  for (i = 0; i < 8; i++) {
1771  if (s->s.refs[i].f->buf[0])
1772  ff_thread_release_buffer(dst, &s->s.refs[i]);
1773  if (ssrc->next_refs[i].f->buf[0]) {
1774  if ((ret = ff_thread_ref_frame(&s->s.refs[i], &ssrc->next_refs[i])) < 0)
1775  return ret;
1776  }
1777  }
1778 
1779  s->s.h.invisible = ssrc->s.h.invisible;
1780  s->s.h.keyframe = ssrc->s.h.keyframe;
1781  s->s.h.intraonly = ssrc->s.h.intraonly;
1782  s->ss_v = ssrc->ss_v;
1783  s->ss_h = ssrc->ss_h;
1784  s->s.h.segmentation.enabled = ssrc->s.h.segmentation.enabled;
1785  s->s.h.segmentation.update_map = ssrc->s.h.segmentation.update_map;
1786  s->s.h.segmentation.absolute_vals = ssrc->s.h.segmentation.absolute_vals;
1787  s->bytesperpixel = ssrc->bytesperpixel;
1788  s->gf_fmt = ssrc->gf_fmt;
1789  s->w = ssrc->w;
1790  s->h = ssrc->h;
1791  s->s.h.bpp = ssrc->s.h.bpp;
1792  s->bpp_index = ssrc->bpp_index;
1793  s->pix_fmt = ssrc->pix_fmt;
1794  memcpy(&s->prob_ctx, &ssrc->prob_ctx, sizeof(s->prob_ctx));
1795  memcpy(&s->s.h.lf_delta, &ssrc->s.h.lf_delta, sizeof(s->s.h.lf_delta));
1796  memcpy(&s->s.h.segmentation.feat, &ssrc->s.h.segmentation.feat,
1797  sizeof(s->s.h.segmentation.feat));
1798 
1799  return 0;
1800 }
1801 #endif
1802 
1804  .name = "vp9",
1805  .long_name = NULL_IF_CONFIG_SMALL("Google VP9"),
1806  .type = AVMEDIA_TYPE_VIDEO,
1807  .id = AV_CODEC_ID_VP9,
1808  .priv_data_size = sizeof(VP9Context),
1809  .init = vp9_decode_init,
1810  .close = vp9_decode_free,
1813  .caps_internal = FF_CODEC_CAP_SLICE_THREAD_HAS_MF,
1815  .init_thread_copy = ONLY_IF_THREADS_ENABLED(vp9_decode_init_thread_copy),
1816  .update_thread_context = ONLY_IF_THREADS_ENABLED(vp9_decode_update_thread_context),
1818  .bsfs = "vp9_superframe_split",
1819  .hw_configs = (const AVCodecHWConfigInternal*[]) {
1820 #if CONFIG_VP9_DXVA2_HWACCEL
1821  HWACCEL_DXVA2(vp9),
1822 #endif
1823 #if CONFIG_VP9_D3D11VA_HWACCEL
1824  HWACCEL_D3D11VA(vp9),
1825 #endif
1826 #if CONFIG_VP9_D3D11VA2_HWACCEL
1827  HWACCEL_D3D11VA2(vp9),
1828 #endif
1829 #if CONFIG_VP9_NVDEC_HWACCEL
1830  HWACCEL_NVDEC(vp9),
1831 #endif
1832 #if CONFIG_VP9_VAAPI_HWACCEL
1833  HWACCEL_VAAPI(vp9),
1834 #endif
1835 #if CONFIG_VP9_VDPAU_HWACCEL
1836  HWACCEL_VDPAU(vp9),
1837 #endif
1838  NULL
1839  },
1840 };
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
Definition: pixfmt.h:511
ThreadFrame tf
Definition: vp9shared.h:60
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:38
#define NULL
Definition: coverity.c:32
uint8_t left_uv_nnz_ctx[2][16]
Definition: vp9dec.h:209
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
uint8_t * segmentation_map
Definition: vp9shared.h:62
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:399
static av_always_inline int pthread_mutex_destroy(pthread_mutex_t *mutex)
Definition: os2threads.h:112
uint8_t parallelmode
Definition: vp9shared.h:108
const uint8_t ff_vp9_default_kf_partition_probs[4][4][3]
Definition: vp9data.c:41
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
Definition: buffer.c:126
static void vp9_decode_flush(AVCodecContext *avctx)
Definition: vp9.c:1703
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
static void set_tile_offset(int *start, int *end, int idx, int log2_n, int n)
Definition: vp9.c:1194
#define pthread_mutex_lock(a)
Definition: ffprobe.c:61
#define HWACCEL_D3D11VA2(codec)
Definition: hwaccel.h:69
static av_always_inline int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
Definition: os2threads.h:192
#define atomic_store(object, desired)
Definition: stdatomic.h:85
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
uint8_t allowcompinter
Definition: vp9shared.h:106
static void flush(AVCodecContext *avctx)
uint8_t mblim_lut[64]
Definition: vp9dec.h:121
VP5 and VP6 compatible video decoder (common features)
uint8_t update_map
Definition: vp9shared.h:133
static av_always_inline int get_sbits_inv(GetBitContext *gb, int n)
Definition: vp9.c:352
#define HWACCEL_NVDEC(codec)
Definition: hwaccel.h:71
uint8_t * above_skip_ctx
Definition: vp9dec.h:138
uint8_t mvstep[3][2]
Definition: vp9dec.h:154
VP9Context * s
Definition: vp9dec.h:164
struct VP9TileData::@197 counts
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
AVFrame * f
Definition: thread.h:35
static av_always_inline int vp8_rac_get_tree(VP56RangeCoder *c, const int8_t(*tree)[2], const uint8_t *probs)
Definition: vp56.h:394
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:104
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:486
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
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 have add an init_thread_copy() which re-allocates them for other threads.Add AV_CODEC_CAP_FRAME_THREADS to the codec capabilities.There will be very little speed gain at this point but it should work.If there are inter-frame dependencies
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601 ...
Definition: pixfmt.h:515
VP9BitstreamHeader h
Definition: vp9shared.h:160
VideoDSPContext vdsp
Definition: vp9dec.h:96
static av_cold int vp9_decode_init(AVCodecContext *avctx)
Definition: vp9.c:1740
ProbContext p
Definition: vp9dec.h:124
uint8_t last_keyframe
Definition: vp9dec.h:109
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2256
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
uint8_t ss_v
Definition: vp9dec.h:107
int size
Definition: avcodec.h:1534
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:413
uint8_t prob[7]
Definition: vp9shared.h:134
uint8_t tx32p[2][3]
Definition: vp9dec.h:55
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
Definition: pixfmt.h:516
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1831
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:401
uint8_t framectxid
Definition: vp9shared.h:109
const int16_t ff_vp9_dc_qlookup[3][256]
Definition: vp9data.c:231
unsigned coef[4][2][2][6][6][3]
Definition: vp9dec.h:198
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
int16_t * block_base
Definition: vp9dec.h:222
VP9Filter * lflvl
Definition: vp9dec.h:149
static AVPacket pkt
#define HWACCEL_D3D11VA(codec)
Definition: hwaccel.h:79
uint8_t left_segpred_ctx[8]
Definition: vp9dec.h:213
intptr_t atomic_int
Definition: stdatomic.h:55
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:2785
unsigned cols
Definition: vp9dec.h:116
#define src
Definition: vp8dsp.c:254
int profile
profile
Definition: avcodec.h:2954
AVCodec.
Definition: avcodec.h:3555
uint8_t comp_ref[5]
Definition: vp9dec.h:54
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
Definition: pixfmt.h:510
static av_always_inline int pthread_cond_destroy(pthread_cond_t *cond)
Definition: os2threads.h:144
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
struct VP9BitstreamHeader::@202 segmentation
const int16_t ff_vp9_ac_qlookup[3][256]
Definition: vp9data.c:334
uint8_t left_mode_ctx[16]
Definition: vp9dec.h:207
functionally identical to above
Definition: pixfmt.h:517
unsigned log2_tile_rows
Definition: vp9shared.h:151
uint8_t * intra_pred_data[3]
Definition: vp9dec.h:148
int uncompressed_header_size
Definition: vp9shared.h:155
enum FilterMode filtermode
Definition: vp9shared.h:105
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
uint8_t coef[4][2][2][6][6][3]
Definition: vp9dec.h:125
unsigned partition[4][4][4]
Definition: vp9dec.h:197
#define VP9_SYNCCODE
Definition: vp9.c:38
uint8_t
const int8_t ff_vp9_partition_tree[3][2]
Definition: vp9data.c:35
#define av_cold
Definition: attributes.h:82
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
static void vp9_free_entries(AVCodecContext *avctx)
Definition: vp9.c:92
uint8_t absolute_vals
Definition: vp9shared.h:132
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
uint8_t varcompref[2]
Definition: vp9shared.h:114
AVColorSpace
YUV colorspace type.
Definition: pixfmt.h:509
void ff_vp9_adapt_probs(VP9Context *s)
Definition: vp9prob.c:46
#define f(width, name)
Definition: cbs_vp9.c:255
static void free_buffers(VP9Context *s)
Definition: vp9.c:1202
VP9Frame frames[3]
Definition: vp9shared.h:166
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
uint8_t * eob_base
Definition: vp9dec.h:223
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
Multithreading support functions.
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:444
#define FF_CODEC_PROPERTY_LOSSLESS
Definition: avcodec.h:3284
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:87
VP9Block * b_base
Definition: vp9dec.h:170
uint8_t * uveob[2]
Definition: vp9dec.h:223
struct VP9BitstreamHeader::@201 lf_delta
static int update_size(AVCodecContext *avctx, int w, int h)
Definition: vp9.c:181
AVBufferRef * hwaccel_priv_buf
Definition: vp9shared.h:66
static void finish(void)
Definition: movenc.c:345
uint8_t * data
Definition: avcodec.h:1533
static enum AVPixelFormat pix_fmt_rgb[3]
Definition: libdav1d.c:54
#define HWACCEL_DXVA2(codec)
Definition: hwaccel.h:67
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
AVBufferRef * extradata
Definition: vp9shared.h:61
int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
Definition: utils.c:1827
uint8_t left_partition_ctx[8]
Definition: vp9dec.h:210
VP56RangeCoder * c_b
Definition: vp9dec.h:165
uint8_t skip[3]
Definition: vp9dec.h:58
bitstream reader API header.
static av_always_inline int vpX_rac_is_end(VP56RangeCoder *c)
vp5689 returns 1 if the end of the stream has been reached, 0 otherwise.
Definition: vp56.h:237
uint8_t * above_uv_nnz_ctx[2]
Definition: vp9dec.h:137
VP9DSPContext dsp
Definition: vp9dec.h:95
static av_always_inline int pthread_cond_signal(pthread_cond_t *cond)
Definition: os2threads.h:152
uint8_t lim_lut[64]
Definition: vp9dec.h:120
#define max(a, b)
Definition: cuda_runtime.h:33
ptrdiff_t size
Definition: opengl_enc.c:100
enum CompPredMode comppredmode
Definition: vp9shared.h:149
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:402
unsigned log2_tile_cols
Definition: vp9shared.h:151
uint16_t mvscale[3][2]
Definition: vp9dec.h:153
uint8_t refidx[3]
Definition: vp9shared.h:111
uint8_t * above_txfm_ctx
Definition: vp9dec.h:139
av_cold void ff_vp9dsp_init(VP9DSPContext *dsp, int bpp, int bitexact)
Definition: vp9dsp.c:84
int h
Definition: vp9dec.h:114
#define av_log(a,...)
uint8_t bytesperpixel
Definition: vp9dec.h:108
void ff_vp9_loopfilter_sb(AVCodecContext *avctx, VP9Filter *lflvl, int row, int col, ptrdiff_t yoff, ptrdiff_t uvoff)
Definition: vp9lpf.c:178
uint8_t mask[2][2][8][4]
Definition: vp9dec.h:76
static av_cold int vp9_decode_free(AVCodecContext *avctx)
Definition: vp9.c:1213
Definition: vp9.h:28
uint8_t partition[4][4][3]
Definition: vp9dec.h:70
uint8_t hp
Definition: vp9dec.h:68
unsigned tile_col_start
Definition: vp9dec.h:171
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
int width
Definition: frame.h:353
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define td
Definition: regdef.h:70
uint8_t sign
Definition: vp9dec.h:61
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:1145
static int decode_frame_header(AVCodecContext *avctx, const uint8_t *data, int size, int *ref)
Definition: vp9.c:488
unsigned tile_cols
Definition: vp9shared.h:152
GetBitContext gb
Definition: vp9dec.h:97
uint8_t fp[3]
Definition: vp9dec.h:66
uint8_t signbias[3]
Definition: vp9shared.h:112
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
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
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:2899
uint8_t refreshctx
Definition: vp9shared.h:107
int frame_extradata_pool_size
Definition: vp9dec.h:158
const char * r
Definition: vf_curves.c:114
uint8_t bpp_index
Definition: vp9dec.h:108
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1701
void * hwaccel_picture_private
Definition: vp9shared.h:67
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
Definition: avcodec.h:3562
uint8_t intra[4]
Definition: vp9dec.h:51
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:400
VP56RangeCoder * c
Definition: vp9dec.h:166
uint8_t bits
Definition: vp3data.h:202
#define FFMAX(a, b)
Definition: common.h:94
#define fail()
Definition: checkasm.h:122
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1055
uint8_t * above_filter_ctx
Definition: vp9dec.h:144
struct VP9Context::@196 prob
#define REF_FRAME_MVPAIR
Definition: vp9shared.h:164
const uint8_t ff_vp9_model_pareto8[256][8]
Definition: vp9data.c:1176
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:225
uint8_t comp[5]
Definition: vp9dec.h:52
int ff_vp56_init_range_decoder(VP56RangeCoder *c, const uint8_t *buf, int buf_size)
Definition: vp56rac.c:40
uint8_t left_y_nnz_ctx[16]
Definition: vp9dec.h:206
#define b
Definition: input.c:41
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
int uses_2pass
Definition: vp9shared.h:64
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:926
VP9TileData * td
Definition: vp9dec.h:93
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:2891
#define FFMIN(a, b)
Definition: common.h:96
struct VP9Context::@195 prob_ctx[4]
enum TxfmMode txfmmode
Definition: vp9shared.h:148
uint8_t keyframe
Definition: vp9shared.h:98
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
unsigned tile_rows
Definition: vp9shared.h:152
uint8_t w
Definition: llviddspenc.c:38
struct VP9BitstreamHeader::@202::@204 feat[MAX_SEGMENT]
ITU-R BT2020 non-constant luminance system.
Definition: pixfmt.h:520
uint8_t tx16p[2][2]
Definition: vp9dec.h:56
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
#define atomic_load_explicit(object, order)
Definition: stdatomic.h:96
uint8_t class0_hp
Definition: vp9dec.h:67
static av_always_inline int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
Definition: os2threads.h:104
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
#define s(width, name)
Definition: cbs_vp9.c:257
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:2892
VP9SharedContext s
Definition: vp9dec.h:92
uint8_t * above_partition_ctx
Definition: vp9dec.h:133
int n
Definition: avisynth_c.h:760
uint8_t mv_mode[7][3]
Definition: vp9dec.h:50
uint8_t fixcompref
Definition: vp9shared.h:113
#define pthread_mutex_unlock(a)
Definition: ffprobe.c:65
int16_t * block
Definition: vp9dec.h:222
HW acceleration through CUDA.
Definition: pixfmt.h:235
uint8_t * above_segpred_ctx
Definition: vp9dec.h:140
#define FF_ARRAY_ELEMS(a)
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:535
unsigned rows
Definition: vp9dec.h:116
unsigned sb_cols
Definition: vp9dec.h:116
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:1059
#define atomic_fetch_add_explicit(object, operand, order)
Definition: stdatomic.h:149
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:368
static av_always_inline int vp56_rac_get_prob_branchy(VP56RangeCoder *c, int prob)
Definition: vp56.h:285
static int init_frames(AVCodecContext *avctx)
Definition: vp9.c:1714
VP56mv(* above_mv_ctx)[2]
Definition: vp9dec.h:145
Libavcodec external API header.
BlockLevel
Definition: vp9shared.h:70
uint8_t filter[4][2]
Definition: vp9dec.h:49
int(* end_frame)(AVCodecContext *avctx)
Called at the end of each frame or field picture.
Definition: avcodec.h:3829
uint8_t class0_fp[2][3]
Definition: vp9dec.h:65
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 have add an so the codec calls ff_thread_report set AVCodecInternal allocate_progress The frames must then be freed with ff_thread_release_buffer().Otherwise leave it at zero and decode directly into the user-supplied frames.Call ff_thread_report_progress() after some part of the current picture has decoded.A good place to put this is where draw_horiz_band() is called-add this if it isn't called anywhere
uint8_t * uveob_base[2]
Definition: vp9dec.h:223
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
int pass
Definition: vp9dec.h:99
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
main external API structure.
Definition: avcodec.h:1621
uint8_t * data
The data buffer.
Definition: buffer.h:89
#define REF_FRAME_SEGMAP
Definition: vp9shared.h:165
int8_t mode[2]
Definition: vp9shared.h:122
#define CUR_FRAME
Definition: vp9shared.h:163
static int update_block_buffers(AVCodecContext *avctx)
Definition: vp9.c:299
static int vp9_frame_ref(AVCodecContext *avctx, VP9Frame *dst, VP9Frame *src)
Definition: vp9.c:151
AVBufferRef * av_buffer_allocz(int size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:84
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:397
uint8_t * above_y_nnz_ctx
Definition: vp9dec.h:136
int16_t * uvblock_base[2]
Definition: vp9dec.h:222
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:276
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2249
uint8_t tx8p[2]
Definition: vp9dec.h:57
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:197
uint8_t ss_h
Definition: vp9dec.h:107
uint8_t y_mode[4][9]
Definition: vp9dec.h:47
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:403
enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Wrapper around get_format() for frame-multithreaded codecs.
struct ProbContext::@193 mv_comp[2]
int16_t * uvblock[2]
Definition: vp9dec.h:222
uint8_t last_bpp
Definition: vp9dec.h:108
static int read_colorspace_details(AVCodecContext *avctx)
Definition: vp9.c:426
uint8_t * above_intra_ctx
Definition: vp9dec.h:141
int allocate_progress
Whether to allocate progress for frame threading.
Definition: internal.h:157
static int vp9_alloc_entries(AVCodecContext *avctx, int n)
Definition: vp9.c:93
struct VP9BitstreamHeader::@203 tiling
HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer. ...
Definition: pixfmt.h:137
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
enum BlockPartition bp
Definition: vp9dec.h:86
static int vp8_rac_get_uint(VP56RangeCoder *c, int bits)
Definition: vp56.h:338
int size
Size of data in bytes.
Definition: buffer.h:93
#define FF_CODEC_CAP_SLICE_THREAD_HAS_MF
Codec initializes slice-based threading with a main function.
Definition: internal.h:70
#define HWACCEL_VAAPI(codec)
Definition: hwaccel.h:73
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:414
uint8_t * above_mode_ctx
Definition: vp9dec.h:134
uint8_t single_ref[5][2]
Definition: vp9dec.h:53
Definition: vp56.h:66
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:398
static void vp9_frame_unref(AVCodecContext *avctx, VP9Frame *f)
Definition: vp9.c:96
static int vp9_decode_frame(AVCodecContext *avctx, void *frame, int *got_frame, AVPacket *pkt)
Definition: vp9.c:1482
int(* decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Callback for each slice.
Definition: avcodec.h:3818
uint8_t bits[10]
Definition: vp9dec.h:64
ThreadFrame next_refs[8]
Definition: vp9dec.h:117
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:404
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
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:1263
Definition: vp9.h:48
unsigned eob[4][2][2][6][6][2]
Definition: vp9dec.h:199
Hardware surfaces for Direct3D11.
Definition: pixfmt.h:313
the normal 219*2^(n-8) "MPEG" YUV ranges
Definition: pixfmt.h:534
int(* start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Called at the beginning of each frame or field picture.
Definition: avcodec.h:3790
static int decode_tiles(AVCodecContext *avctx, const uint8_t *data, int size)
Definition: vp9.c:1239
static av_always_inline int inv_recenter_nonneg(int v, int m)
Definition: vp9.c:358
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
AVBufferPool * av_buffer_pool_init(int size, AVBufferRef *(*alloc)(int size))
Allocate and initialize a buffer pool.
Definition: buffer.c:239
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
#define assign(var, type, n)
int w
Definition: vp9dec.h:114
int ff_slice_thread_execute_with_mainfunc(AVCodecContext *avctx, action_func2 *func2, main_func *mainfunc, void *arg, int *ret, int job_count)
enum AVPixelFormat pix_fmt last_fmt gf_fmt
Definition: vp9dec.h:115
AVCodec ff_vp9_decoder
Definition: vp9.c:1803
unsigned sb_rows
Definition: vp9dec.h:116
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:94
static av_always_inline int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)
Definition: os2threads.h:133
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:3283
static av_always_inline int vp8_rac_get(VP56RangeCoder *c)
Definition: vp56.h:322
Core video DSP helper functions.
uint8_t mv_joint[3]
Definition: vp9dec.h:59
enum BlockLevel bl
Definition: vp9dec.h:85
void * priv_data
Definition: avcodec.h:1648
#define HWACCEL_MAX
uint8_t class0
Definition: vp9dec.h:63
#define av_free(p)
static int vp9_frame_alloc(AVCodecContext *avctx, VP9Frame *f)
Definition: vp9.c:105
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
int frame_priv_data_size
Size of per-frame hardware accelerator private data.
Definition: avcodec.h:3838
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:1656
static int decode012(GetBitContext *gb)
Definition: get_bits.h:831
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:373
VP9mvrefPair * mv
Definition: vp9shared.h:63
struct VP9BitstreamHeader::@200 filter
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:693
uint8_t invisible
Definition: vp9shared.h:99
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1532
uint8_t use_last_frame_mvs
Definition: vp9shared.h:110
int height
Definition: frame.h:353
ThreadFrame refs[8]
Definition: vp9shared.h:162
uint8_t pred_prob[3]
Definition: vp9shared.h:135
#define atomic_init(obj, value)
Definition: stdatomic.h:33
#define av_freep(p)
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
#define HWACCEL_VDPAU(codec)
Definition: hwaccel.h:75
void INT64 start
Definition: avisynth_c.h:766
VP9Block * b
Definition: vp9dec.h:170
#define av_always_inline
Definition: attributes.h:39
HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView p...
Definition: pixfmt.h:229
static void decode_sb(VP9TileData *td, int row, int col, VP9Filter *lflvl, ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
Definition: vp9.c:1066
static int update_prob(VP56RangeCoder *c, int p)
Definition: vp9.c:368
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
Definition: buffer.c:335
#define av_malloc_array(a, b)
const ProbContext ff_vp9_default_probs
Definition: vp9data.c:1435
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:2465
const AVProfile ff_vp9_profiles[]
Definition: profiles.c:134
uint8_t * above_ref_ctx
Definition: vp9dec.h:143
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
BlockPartition
Definition: vp9shared.h:34
struct VP9Context::@194 filter_lut
uint8_t classes[10]
Definition: vp9dec.h:62
const uint8_t ff_vp9_default_coef_probs[4][2][2][6][6][3]
Definition: vp9data.c:1540
uint8_t highprecisionmvs
Definition: vp9shared.h:104
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1510
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:1219
uint8_t * above_comp_ctx
Definition: vp9dec.h:142
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:999
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1526
for(j=16;j >0;--j)
int block_alloc_using_2pass
Definition: vp9dec.h:152
Predicted.
Definition: avutil.h:275
int compressed_header_size
Definition: vp9shared.h:156
AVBufferPool * frame_extradata_pool
Definition: vp9dec.h:157
uint8_t refreshrefmask
Definition: vp9shared.h:103
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191
uint8_t left_skip_ctx[8]
Definition: vp9dec.h:211
int active_tile_cols
Definition: vp9dec.h:99
VP56RangeCoder c
Definition: vp9dec.h:98