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