FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 "internal.h"
27 #include "thread.h"
28 #include "videodsp.h"
29 #include "vp56.h"
30 #include "vp9.h"
31 #include "vp9data.h"
32 #include "vp9dsp.h"
33 #include "libavutil/avassert.h"
34 #include "libavutil/pixdesc.h"
35 
36 #define VP9_SYNCCODE 0x498342
37 
38 enum CompPredMode {
39  PRED_SINGLEREF,
40  PRED_COMPREF,
41  PRED_SWITCHABLE,
42 };
43 
44 enum BlockLevel {
45  BL_64X64,
46  BL_32X32,
47  BL_16X16,
48  BL_8X8,
49 };
50 
51 enum BlockSize {
52  BS_64x64,
53  BS_64x32,
54  BS_32x64,
55  BS_32x32,
56  BS_32x16,
57  BS_16x32,
58  BS_16x16,
59  BS_16x8,
60  BS_8x16,
61  BS_8x8,
62  BS_8x4,
63  BS_4x8,
64  BS_4x4,
65  N_BS_SIZES,
66 };
67 
68 struct VP9mvrefPair {
69  VP56mv mv[2];
70  int8_t ref[2];
71 };
72 
73 typedef struct VP9Frame {
74  ThreadFrame tf;
75  AVBufferRef *extradata;
76  uint8_t *segmentation_map;
77  struct VP9mvrefPair *mv;
78  int uses_2pass;
79 } VP9Frame;
80 
81 struct VP9Filter {
82  uint8_t level[8 * 8];
83  uint8_t /* bit=col */ mask[2 /* 0=y, 1=uv */][2 /* 0=col, 1=row */]
84  [8 /* rows */][4 /* 0=16, 1=8, 2=4, 3=inner4 */];
85 };
86 
87 typedef struct VP9Block {
88  uint8_t seg_id, intra, comp, ref[2], mode[4], uvmode, skip;
89  enum FilterMode filter;
90  VP56mv mv[4 /* b_idx */][2 /* ref */];
91  enum BlockSize bs;
92  enum TxfmMode tx, uvtx;
93  enum BlockLevel bl;
94  enum BlockPartition bp;
95 } VP9Block;
96 
97 typedef struct VP9Context {
98  VP9DSPContext dsp;
99  VideoDSPContext vdsp;
100  GetBitContext gb;
101  VP56RangeCoder c;
102  VP56RangeCoder *c_b;
103  unsigned c_b_size;
104  VP9Block *b_base, *b;
105  int pass;
106  int row, row7, col, col7;
107  uint8_t *dst[3];
108  ptrdiff_t y_stride, uv_stride;
109 
110  // bitstream header
111  uint8_t keyframe, last_keyframe;
112  uint8_t last_bpp, bpp, bpp_index, bytesperpixel;
113  uint8_t invisible;
114  uint8_t use_last_frame_mvs;
115  uint8_t errorres;
116  uint8_t ss_h, ss_v;
117  uint8_t intraonly;
118  uint8_t resetctx;
119  uint8_t refreshrefmask;
120  uint8_t highprecisionmvs;
121  enum FilterMode filtermode;
122  uint8_t allowcompinter;
123  uint8_t fixcompref;
124  uint8_t refreshctx;
125  uint8_t parallelmode;
126  uint8_t framectxid;
127  uint8_t refidx[3];
128  uint8_t signbias[3];
129  uint8_t varcompref[2];
130  ThreadFrame refs[8], next_refs[8];
131 #define CUR_FRAME 0
132 #define REF_FRAME_MVPAIR 1
133 #define REF_FRAME_SEGMAP 2
134  VP9Frame frames[3];
135 
136  struct {
137  uint8_t level;
138  int8_t sharpness;
139  uint8_t lim_lut[64];
140  uint8_t mblim_lut[64];
141  } filter;
142  struct {
143  uint8_t enabled;
144  int8_t mode[2];
145  int8_t ref[4];
146  } lf_delta;
147  uint8_t yac_qi;
148  int8_t ydc_qdelta, uvdc_qdelta, uvac_qdelta;
149  uint8_t lossless;
150 #define MAX_SEGMENT 8
151  struct {
152  uint8_t enabled;
153  uint8_t temporal;
154  uint8_t absolute_vals;
155  uint8_t update_map;
156  uint8_t ignore_refmap;
157  struct {
158  uint8_t q_enabled;
159  uint8_t lf_enabled;
160  uint8_t ref_enabled;
161  uint8_t skip_enabled;
162  uint8_t ref_val;
163  int16_t q_val;
164  int8_t lf_val;
165  int16_t qmul[2][2];
166  uint8_t lflvl[4][2];
167  } feat[MAX_SEGMENT];
168  } segmentation;
169  struct {
170  unsigned log2_tile_cols, log2_tile_rows;
171  unsigned tile_cols, tile_rows;
172  unsigned tile_row_start, tile_row_end, tile_col_start, tile_col_end;
173  } tiling;
174  unsigned sb_cols, sb_rows, rows, cols;
175  struct {
176  prob_context p;
177  uint8_t coef[4][2][2][6][6][3];
178  } prob_ctx[4];
179  struct {
180  prob_context p;
181  uint8_t coef[4][2][2][6][6][11];
182  uint8_t seg[7];
183  uint8_t segpred[3];
184  } prob;
185  struct {
186  unsigned y_mode[4][10];
187  unsigned uv_mode[10][10];
188  unsigned filter[4][3];
189  unsigned mv_mode[7][4];
190  unsigned intra[4][2];
191  unsigned comp[5][2];
192  unsigned single_ref[5][2][2];
193  unsigned comp_ref[5][2];
194  unsigned tx32p[2][4];
195  unsigned tx16p[2][3];
196  unsigned tx8p[2][2];
197  unsigned skip[3][2];
198  unsigned mv_joint[4];
199  struct {
200  unsigned sign[2];
201  unsigned classes[11];
202  unsigned class0[2];
203  unsigned bits[10][2];
204  unsigned class0_fp[2][4];
205  unsigned fp[4];
206  unsigned class0_hp[2];
207  unsigned hp[2];
208  } mv_comp[2];
209  unsigned partition[4][4][4];
210  unsigned coef[4][2][2][6][6][3];
211  unsigned eob[4][2][2][6][6][2];
212  } counts;
213  enum TxfmMode txfmmode;
214  enum CompPredMode comppredmode;
215 
216  // contextual (left/above) cache
217  DECLARE_ALIGNED(16, uint8_t, left_y_nnz_ctx)[16];
218  DECLARE_ALIGNED(16, uint8_t, left_mode_ctx)[16];
219  DECLARE_ALIGNED(16, VP56mv, left_mv_ctx)[16][2];
220  DECLARE_ALIGNED(16, uint8_t, left_uv_nnz_ctx)[2][16];
221  DECLARE_ALIGNED(8, uint8_t, left_partition_ctx)[8];
222  DECLARE_ALIGNED(8, uint8_t, left_skip_ctx)[8];
223  DECLARE_ALIGNED(8, uint8_t, left_txfm_ctx)[8];
224  DECLARE_ALIGNED(8, uint8_t, left_segpred_ctx)[8];
225  DECLARE_ALIGNED(8, uint8_t, left_intra_ctx)[8];
226  DECLARE_ALIGNED(8, uint8_t, left_comp_ctx)[8];
227  DECLARE_ALIGNED(8, uint8_t, left_ref_ctx)[8];
228  DECLARE_ALIGNED(8, uint8_t, left_filter_ctx)[8];
229  uint8_t *above_partition_ctx;
230  uint8_t *above_mode_ctx;
231  // FIXME maybe merge some of the below in a flags field?
232  uint8_t *above_y_nnz_ctx;
233  uint8_t *above_uv_nnz_ctx[2];
234  uint8_t *above_skip_ctx; // 1bit
235  uint8_t *above_txfm_ctx; // 2bit
236  uint8_t *above_segpred_ctx; // 1bit
237  uint8_t *above_intra_ctx; // 1bit
238  uint8_t *above_comp_ctx; // 1bit
239  uint8_t *above_ref_ctx; // 2bit
240  uint8_t *above_filter_ctx;
241  VP56mv (*above_mv_ctx)[2];
242 
243  // whole-frame cache
244  uint8_t *intra_pred_data[3];
245  struct VP9Filter *lflvl;
246  DECLARE_ALIGNED(32, uint8_t, edge_emu_buffer)[135 * 144 * 2];
247 
248  // block reconstruction intermediates
249  int block_alloc_using_2pass;
250  int16_t *block_base, *block, *uvblock_base[2], *uvblock[2];
251  uint8_t *eob_base, *uveob_base[2], *eob, *uveob[2];
252  struct { int x, y; } min_mv, max_mv;
253  DECLARE_ALIGNED(32, uint8_t, tmp_y)[64 * 64 * 2];
254  DECLARE_ALIGNED(32, uint8_t, tmp_uv)[2][64 * 64 * 2];
255  uint16_t mvscale[3][2];
256  uint8_t mvstep[3][2];
257 } VP9Context;
258 
259 static const uint8_t bwh_tab[2][N_BS_SIZES][2] = {
260  {
261  { 16, 16 }, { 16, 8 }, { 8, 16 }, { 8, 8 }, { 8, 4 }, { 4, 8 },
262  { 4, 4 }, { 4, 2 }, { 2, 4 }, { 2, 2 }, { 2, 1 }, { 1, 2 }, { 1, 1 },
263  }, {
264  { 8, 8 }, { 8, 4 }, { 4, 8 }, { 4, 4 }, { 4, 2 }, { 2, 4 },
265  { 2, 2 }, { 2, 1 }, { 1, 2 }, { 1, 1 }, { 1, 1 }, { 1, 1 }, { 1, 1 },
266  }
267 };
268 
269 static int vp9_alloc_frame(AVCodecContext *ctx, VP9Frame *f)
270 {
271  VP9Context *s = ctx->priv_data;
272  int ret, sz;
273 
274  if ((ret = ff_thread_get_buffer(ctx, &f->tf, AV_GET_BUFFER_FLAG_REF)) < 0)
275  return ret;
276  sz = 64 * s->sb_cols * s->sb_rows;
277  if (!(f->extradata = av_buffer_allocz(sz * (1 + sizeof(struct VP9mvrefPair))))) {
278  ff_thread_release_buffer(ctx, &f->tf);
279  return AVERROR(ENOMEM);
280  }
281 
282  f->segmentation_map = f->extradata->data;
283  f->mv = (struct VP9mvrefPair *) (f->extradata->data + sz);
284 
285  return 0;
286 }
287 
288 static void vp9_unref_frame(AVCodecContext *ctx, VP9Frame *f)
289 {
290  ff_thread_release_buffer(ctx, &f->tf);
291  av_buffer_unref(&f->extradata);
292  f->segmentation_map = NULL;
293 }
294 
295 static int vp9_ref_frame(AVCodecContext *ctx, VP9Frame *dst, VP9Frame *src)
296 {
297  int res;
298 
299  if ((res = ff_thread_ref_frame(&dst->tf, &src->tf)) < 0) {
300  return res;
301  } else if (!(dst->extradata = av_buffer_ref(src->extradata))) {
302  vp9_unref_frame(ctx, dst);
303  return AVERROR(ENOMEM);
304  }
305 
306  dst->segmentation_map = src->segmentation_map;
307  dst->mv = src->mv;
308  dst->uses_2pass = src->uses_2pass;
309 
310  return 0;
311 }
312 
313 static int update_size(AVCodecContext *ctx, int w, int h, enum AVPixelFormat fmt)
314 {
315  VP9Context *s = ctx->priv_data;
316  uint8_t *p;
317  int bytesperpixel = s->bytesperpixel;
318 
319  av_assert0(w > 0 && h > 0);
320 
321  if (s->intra_pred_data[0] && w == ctx->width && h == ctx->height && ctx->pix_fmt == fmt)
322  return 0;
323 
324  ctx->width = w;
325  ctx->height = h;
326  ctx->pix_fmt = fmt;
327  s->sb_cols = (w + 63) >> 6;
328  s->sb_rows = (h + 63) >> 6;
329  s->cols = (w + 7) >> 3;
330  s->rows = (h + 7) >> 3;
331 
332 #define assign(var, type, n) var = (type) p; p += s->sb_cols * (n) * sizeof(*var)
333  av_freep(&s->intra_pred_data[0]);
334  // FIXME we slightly over-allocate here for subsampled chroma, but a little
335  // bit of padding shouldn't affect performance...
336  p = av_malloc(s->sb_cols * (128 + 192 * bytesperpixel +
337  sizeof(*s->lflvl) + 16 * sizeof(*s->above_mv_ctx)));
338  if (!p)
339  return AVERROR(ENOMEM);
340  assign(s->intra_pred_data[0], uint8_t *, 64 * bytesperpixel);
341  assign(s->intra_pred_data[1], uint8_t *, 64 * bytesperpixel);
342  assign(s->intra_pred_data[2], uint8_t *, 64 * bytesperpixel);
343  assign(s->above_y_nnz_ctx, uint8_t *, 16);
344  assign(s->above_mode_ctx, uint8_t *, 16);
345  assign(s->above_mv_ctx, VP56mv(*)[2], 16);
346  assign(s->above_uv_nnz_ctx[0], uint8_t *, 16);
347  assign(s->above_uv_nnz_ctx[1], uint8_t *, 16);
348  assign(s->above_partition_ctx, uint8_t *, 8);
349  assign(s->above_skip_ctx, uint8_t *, 8);
350  assign(s->above_txfm_ctx, uint8_t *, 8);
351  assign(s->above_segpred_ctx, uint8_t *, 8);
352  assign(s->above_intra_ctx, uint8_t *, 8);
353  assign(s->above_comp_ctx, uint8_t *, 8);
354  assign(s->above_ref_ctx, uint8_t *, 8);
355  assign(s->above_filter_ctx, uint8_t *, 8);
356  assign(s->lflvl, struct VP9Filter *, 1);
357 #undef assign
358 
359  // these will be re-allocated a little later
360  av_freep(&s->b_base);
361  av_freep(&s->block_base);
362 
363  if (s->bpp != s->last_bpp) {
364  ff_vp9dsp_init(&s->dsp, s->bpp);
365  ff_videodsp_init(&s->vdsp, s->bpp);
366  s->last_bpp = s->bpp;
367  }
368 
369  return 0;
370 }
371 
372 static int update_block_buffers(AVCodecContext *ctx)
373 {
374  VP9Context *s = ctx->priv_data;
375  int chroma_blocks, chroma_eobs, bytesperpixel = s->bytesperpixel;
376 
377  if (s->b_base && s->block_base && s->block_alloc_using_2pass == s->frames[CUR_FRAME].uses_2pass)
378  return 0;
379 
380  av_free(s->b_base);
381  av_free(s->block_base);
382  chroma_blocks = 64 * 64 >> (s->ss_h + s->ss_v);
383  chroma_eobs = 16 * 16 >> (s->ss_h + s->ss_v);
384  if (s->frames[CUR_FRAME].uses_2pass) {
385  int sbs = s->sb_cols * s->sb_rows;
386 
387  s->b_base = av_malloc_array(s->cols * s->rows, sizeof(VP9Block));
388  s->block_base = av_mallocz(((64 * 64 + 2 * chroma_blocks) * bytesperpixel * sizeof(int16_t) +
389  16 * 16 + 2 * chroma_eobs) * sbs);
390  if (!s->b_base || !s->block_base)
391  return AVERROR(ENOMEM);
392  s->uvblock_base[0] = s->block_base + sbs * 64 * 64 * bytesperpixel;
393  s->uvblock_base[1] = s->uvblock_base[0] + sbs * chroma_blocks * bytesperpixel;
394  s->eob_base = (uint8_t *) (s->uvblock_base[1] + sbs * chroma_blocks * bytesperpixel);
395  s->uveob_base[0] = s->eob_base + 16 * 16 * sbs;
396  s->uveob_base[1] = s->uveob_base[0] + chroma_eobs * sbs;
397  } else {
398  s->b_base = av_malloc(sizeof(VP9Block));
399  s->block_base = av_mallocz((64 * 64 + 2 * chroma_blocks) * bytesperpixel * sizeof(int16_t) +
400  16 * 16 + 2 * chroma_eobs);
401  if (!s->b_base || !s->block_base)
402  return AVERROR(ENOMEM);
403  s->uvblock_base[0] = s->block_base + 64 * 64 * bytesperpixel;
404  s->uvblock_base[1] = s->uvblock_base[0] + chroma_blocks * bytesperpixel;
405  s->eob_base = (uint8_t *) (s->uvblock_base[1] + chroma_blocks * bytesperpixel);
406  s->uveob_base[0] = s->eob_base + 16 * 16;
407  s->uveob_base[1] = s->uveob_base[0] + chroma_eobs;
408  }
409  s->block_alloc_using_2pass = s->frames[CUR_FRAME].uses_2pass;
410 
411  return 0;
412 }
413 
414 // for some reason the sign bit is at the end, not the start, of a bit sequence
415 static av_always_inline int get_sbits_inv(GetBitContext *gb, int n)
416 {
417  int v = get_bits(gb, n);
418  return get_bits1(gb) ? -v : v;
419 }
420 
421 static av_always_inline int inv_recenter_nonneg(int v, int m)
422 {
423  return v > 2 * m ? v : v & 1 ? m - ((v + 1) >> 1) : m + (v >> 1);
424 }
425 
426 // differential forward probability updates
427 static int update_prob(VP56RangeCoder *c, int p)
428 {
429  static const int inv_map_table[255] = {
430  7, 20, 33, 46, 59, 72, 85, 98, 111, 124, 137, 150, 163, 176,
431  189, 202, 215, 228, 241, 254, 1, 2, 3, 4, 5, 6, 8, 9,
432  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 21, 22, 23, 24,
433  25, 26, 27, 28, 29, 30, 31, 32, 34, 35, 36, 37, 38, 39,
434  40, 41, 42, 43, 44, 45, 47, 48, 49, 50, 51, 52, 53, 54,
435  55, 56, 57, 58, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
436  70, 71, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
437  86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 99, 100,
438  101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 112, 113, 114, 115,
439  116, 117, 118, 119, 120, 121, 122, 123, 125, 126, 127, 128, 129, 130,
440  131, 132, 133, 134, 135, 136, 138, 139, 140, 141, 142, 143, 144, 145,
441  146, 147, 148, 149, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160,
442  161, 162, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
443  177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 190, 191,
444  192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 203, 204, 205, 206,
445  207, 208, 209, 210, 211, 212, 213, 214, 216, 217, 218, 219, 220, 221,
446  222, 223, 224, 225, 226, 227, 229, 230, 231, 232, 233, 234, 235, 236,
447  237, 238, 239, 240, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251,
448  252, 253, 253,
449  };
450  int d;
451 
452  /* This code is trying to do a differential probability update. For a
453  * current probability A in the range [1, 255], the difference to a new
454  * probability of any value can be expressed differentially as 1-A,255-A
455  * where some part of this (absolute range) exists both in positive as
456  * well as the negative part, whereas another part only exists in one
457  * half. We're trying to code this shared part differentially, i.e.
458  * times two where the value of the lowest bit specifies the sign, and
459  * the single part is then coded on top of this. This absolute difference
460  * then again has a value of [0,254], but a bigger value in this range
461  * indicates that we're further away from the original value A, so we
462  * can code this as a VLC code, since higher values are increasingly
463  * unlikely. The first 20 values in inv_map_table[] allow 'cheap, rough'
464  * updates vs. the 'fine, exact' updates further down the range, which
465  * adds one extra dimension to this differential update model. */
466 
467  if (!vp8_rac_get(c)) {
468  d = vp8_rac_get_uint(c, 4) + 0;
469  } else if (!vp8_rac_get(c)) {
470  d = vp8_rac_get_uint(c, 4) + 16;
471  } else if (!vp8_rac_get(c)) {
472  d = vp8_rac_get_uint(c, 5) + 32;
473  } else {
474  d = vp8_rac_get_uint(c, 7);
475  if (d >= 65)
476  d = (d << 1) - 65 + vp8_rac_get(c);
477  d += 64;
478  av_assert2(d < FF_ARRAY_ELEMS(inv_map_table));
479  }
480 
481  return p <= 128 ? 1 + inv_recenter_nonneg(inv_map_table[d], p - 1) :
482  255 - inv_recenter_nonneg(inv_map_table[d], 255 - p);
483 }
484 
485 static enum AVPixelFormat read_colorspace_details(AVCodecContext *ctx)
486 {
487  static const enum AVColorSpace colorspaces[8] = {
488  AVCOL_SPC_UNSPECIFIED, AVCOL_SPC_BT470BG, AVCOL_SPC_BT709, AVCOL_SPC_SMPTE170M,
489  AVCOL_SPC_SMPTE240M, AVCOL_SPC_BT2020_NCL, AVCOL_SPC_RESERVED, AVCOL_SPC_RGB,
490  };
491  VP9Context *s = ctx->priv_data;
492  enum AVPixelFormat res;
493  int bits = ctx->profile <= 1 ? 0 : 1 + get_bits1(&s->gb); // 0:8, 1:10, 2:12
494 
495  s->bpp_index = bits;
496  s->bpp = 8 + bits * 2;
497  s->bytesperpixel = (7 + s->bpp) >> 3;
498  ctx->colorspace = colorspaces[get_bits(&s->gb, 3)];
499  if (ctx->colorspace == AVCOL_SPC_RGB) { // RGB = profile 1
500  static const enum AVPixelFormat pix_fmt_rgb[3] = {
501  AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12
502  };
503  if (ctx->profile & 1) {
504  s->ss_h = s->ss_v = 0;
505  res = pix_fmt_rgb[bits];
506  ctx->color_range = AVCOL_RANGE_JPEG;
507  if (get_bits1(&s->gb)) {
508  av_log(ctx, AV_LOG_ERROR, "Reserved bit set in RGB\n");
509  return AVERROR_INVALIDDATA;
510  }
511  } else {
512  av_log(ctx, AV_LOG_ERROR, "RGB not supported in profile %d\n",
513  ctx->profile);
514  return AVERROR_INVALIDDATA;
515  }
516  } else {
517  static const enum AVPixelFormat pix_fmt_for_ss[3][2 /* v */][2 /* h */] = {
518  { { AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P },
519  { AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV420P } },
520  { { AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV422P10 },
521  { AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV420P10 } },
522  { { AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV422P12 },
523  { AV_PIX_FMT_YUV440P12, AV_PIX_FMT_YUV420P12 } }
524  };
525  ctx->color_range = get_bits1(&s->gb) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
526  if (ctx->profile & 1) {
527  s->ss_h = get_bits1(&s->gb);
528  s->ss_v = get_bits1(&s->gb);
529  if ((res = pix_fmt_for_ss[bits][s->ss_v][s->ss_h]) == AV_PIX_FMT_YUV420P) {
530  av_log(ctx, AV_LOG_ERROR, "YUV 4:2:0 not supported in profile %d\n",
531  ctx->profile);
532  return AVERROR_INVALIDDATA;
533  } else if (get_bits1(&s->gb)) {
534  av_log(ctx, AV_LOG_ERROR, "Profile %d color details reserved bit set\n",
535  ctx->profile);
536  return AVERROR_INVALIDDATA;
537  }
538  } else {
539  s->ss_h = s->ss_v = 1;
540  res = pix_fmt_for_ss[bits][1][1];
541  }
542  }
543 
544  return res;
545 }
546 
547 static int decode_frame_header(AVCodecContext *ctx,
548  const uint8_t *data, int size, int *ref)
549 {
550  VP9Context *s = ctx->priv_data;
551  int c, i, j, k, l, m, n, w, h, max, size2, res, sharp;
552  enum AVPixelFormat fmt = ctx->pix_fmt;
553  int last_invisible;
554  const uint8_t *data2;
555 
556  /* general header */
557  if ((res = init_get_bits8(&s->gb, data, size)) < 0) {
558  av_log(ctx, AV_LOG_ERROR, "Failed to initialize bitstream reader\n");
559  return res;
560  }
561  if (get_bits(&s->gb, 2) != 0x2) { // frame marker
562  av_log(ctx, AV_LOG_ERROR, "Invalid frame marker\n");
563  return AVERROR_INVALIDDATA;
564  }
565  ctx->profile = get_bits1(&s->gb);
566  ctx->profile |= get_bits1(&s->gb) << 1;
567  if (ctx->profile == 3) ctx->profile += get_bits1(&s->gb);
568  if (ctx->profile > 3) {
569  av_log(ctx, AV_LOG_ERROR, "Profile %d is not yet supported\n", ctx->profile);
570  return AVERROR_INVALIDDATA;
571  }
572  if (get_bits1(&s->gb)) {
573  *ref = get_bits(&s->gb, 3);
574  return 0;
575  }
576  s->last_keyframe = s->keyframe;
577  s->keyframe = !get_bits1(&s->gb);
578  last_invisible = s->invisible;
579  s->invisible = !get_bits1(&s->gb);
580  s->errorres = get_bits1(&s->gb);
581  s->use_last_frame_mvs = !s->errorres && !last_invisible;
582  if (s->keyframe) {
583  if (get_bits_long(&s->gb, 24) != VP9_SYNCCODE) { // synccode
584  av_log(ctx, AV_LOG_ERROR, "Invalid sync code\n");
585  return AVERROR_INVALIDDATA;
586  }
587  if ((fmt = read_colorspace_details(ctx)) < 0)
588  return fmt;
589  // for profile 1, here follows the subsampling bits
590  s->refreshrefmask = 0xff;
591  w = get_bits(&s->gb, 16) + 1;
592  h = get_bits(&s->gb, 16) + 1;
593  if (get_bits1(&s->gb)) // display size
594  skip_bits(&s->gb, 32);
595  } else {
596  s->intraonly = s->invisible ? get_bits1(&s->gb) : 0;
597  s->resetctx = s->errorres ? 0 : get_bits(&s->gb, 2);
598  if (s->intraonly) {
599  if (get_bits_long(&s->gb, 24) != VP9_SYNCCODE) { // synccode
600  av_log(ctx, AV_LOG_ERROR, "Invalid sync code\n");
601  return AVERROR_INVALIDDATA;
602  }
603  if (ctx->profile >= 1) {
604  if ((fmt = read_colorspace_details(ctx)) < 0)
605  return fmt;
606  } else {
607  s->ss_h = s->ss_v = 1;
608  s->bpp = 8;
609  s->bpp_index = 0;
610  s->bytesperpixel = 1;
611  fmt = AV_PIX_FMT_YUV420P;
612  ctx->colorspace = AVCOL_SPC_BT470BG;
613  ctx->color_range = AVCOL_RANGE_JPEG;
614  }
615  s->refreshrefmask = get_bits(&s->gb, 8);
616  w = get_bits(&s->gb, 16) + 1;
617  h = get_bits(&s->gb, 16) + 1;
618  if (get_bits1(&s->gb)) // display size
619  skip_bits(&s->gb, 32);
620  } else {
621  s->refreshrefmask = get_bits(&s->gb, 8);
622  s->refidx[0] = get_bits(&s->gb, 3);
623  s->signbias[0] = get_bits1(&s->gb) && !s->errorres;
624  s->refidx[1] = get_bits(&s->gb, 3);
625  s->signbias[1] = get_bits1(&s->gb) && !s->errorres;
626  s->refidx[2] = get_bits(&s->gb, 3);
627  s->signbias[2] = get_bits1(&s->gb) && !s->errorres;
628  if (!s->refs[s->refidx[0]].f->data[0] ||
629  !s->refs[s->refidx[1]].f->data[0] ||
630  !s->refs[s->refidx[2]].f->data[0]) {
631  av_log(ctx, AV_LOG_ERROR, "Not all references are available\n");
632  return AVERROR_INVALIDDATA;
633  }
634  if (get_bits1(&s->gb)) {
635  w = s->refs[s->refidx[0]].f->width;
636  h = s->refs[s->refidx[0]].f->height;
637  } else if (get_bits1(&s->gb)) {
638  w = s->refs[s->refidx[1]].f->width;
639  h = s->refs[s->refidx[1]].f->height;
640  } else if (get_bits1(&s->gb)) {
641  w = s->refs[s->refidx[2]].f->width;
642  h = s->refs[s->refidx[2]].f->height;
643  } else {
644  w = get_bits(&s->gb, 16) + 1;
645  h = get_bits(&s->gb, 16) + 1;
646  }
647  // Note that in this code, "CUR_FRAME" is actually before we
648  // have formally allocated a frame, and thus actually represents
649  // the _last_ frame
650  s->use_last_frame_mvs &= s->frames[CUR_FRAME].tf.f->width == w &&
651  s->frames[CUR_FRAME].tf.f->height == h;
652  if (get_bits1(&s->gb)) // display size
653  skip_bits(&s->gb, 32);
654  s->highprecisionmvs = get_bits1(&s->gb);
655  s->filtermode = get_bits1(&s->gb) ? FILTER_SWITCHABLE :
656  get_bits(&s->gb, 2);
657  s->allowcompinter = (s->signbias[0] != s->signbias[1] ||
658  s->signbias[0] != s->signbias[2]);
659  if (s->allowcompinter) {
660  if (s->signbias[0] == s->signbias[1]) {
661  s->fixcompref = 2;
662  s->varcompref[0] = 0;
663  s->varcompref[1] = 1;
664  } else if (s->signbias[0] == s->signbias[2]) {
665  s->fixcompref = 1;
666  s->varcompref[0] = 0;
667  s->varcompref[1] = 2;
668  } else {
669  s->fixcompref = 0;
670  s->varcompref[0] = 1;
671  s->varcompref[1] = 2;
672  }
673  }
674 
675  for (i = 0; i < 3; i++) {
676  AVFrame *ref = s->refs[s->refidx[i]].f;
677  int refw = ref->width, refh = ref->height;
678 
679  if (ref->format != fmt) {
680  av_log(ctx, AV_LOG_ERROR,
681  "Ref pixfmt (%s) did not match current frame (%s)",
682  av_get_pix_fmt_name(ref->format),
683  av_get_pix_fmt_name(fmt));
684  return AVERROR_INVALIDDATA;
685  } else if (refw == w && refh == h) {
686  s->mvscale[i][0] = s->mvscale[i][1] = 0;
687  } else {
688  if (w * 2 < refw || h * 2 < refh || w > 16 * refw || h > 16 * refh) {
689  av_log(ctx, AV_LOG_ERROR,
690  "Invalid ref frame dimensions %dx%d for frame size %dx%d\n",
691  refw, refh, w, h);
692  return AVERROR_INVALIDDATA;
693  }
694  s->mvscale[i][0] = (refw << 14) / w;
695  s->mvscale[i][1] = (refh << 14) / h;
696  s->mvstep[i][0] = 16 * s->mvscale[i][0] >> 14;
697  s->mvstep[i][1] = 16 * s->mvscale[i][1] >> 14;
698  }
699  }
700  }
701  }
702  s->refreshctx = s->errorres ? 0 : get_bits1(&s->gb);
703  s->parallelmode = s->errorres ? 1 : get_bits1(&s->gb);
704  s->framectxid = c = get_bits(&s->gb, 2);
705 
706  /* loopfilter header data */
707  if (s->keyframe || s->errorres || s->intraonly) {
708  // reset loopfilter defaults
709  s->lf_delta.ref[0] = 1;
710  s->lf_delta.ref[1] = 0;
711  s->lf_delta.ref[2] = -1;
712  s->lf_delta.ref[3] = -1;
713  s->lf_delta.mode[0] = 0;
714  s->lf_delta.mode[1] = 0;
715  memset(s->segmentation.feat, 0, sizeof(s->segmentation.feat));
716  }
717  s->filter.level = get_bits(&s->gb, 6);
718  sharp = get_bits(&s->gb, 3);
719  // if sharpness changed, reinit lim/mblim LUTs. if it didn't change, keep
720  // the old cache values since they are still valid
721  if (s->filter.sharpness != sharp)
722  memset(s->filter.lim_lut, 0, sizeof(s->filter.lim_lut));
723  s->filter.sharpness = sharp;
724  if ((s->lf_delta.enabled = get_bits1(&s->gb))) {
725  if (get_bits1(&s->gb)) {
726  for (i = 0; i < 4; i++)
727  if (get_bits1(&s->gb))
728  s->lf_delta.ref[i] = get_sbits_inv(&s->gb, 6);
729  for (i = 0; i < 2; i++)
730  if (get_bits1(&s->gb))
731  s->lf_delta.mode[i] = get_sbits_inv(&s->gb, 6);
732  }
733  }
734 
735  /* quantization header data */
736  s->yac_qi = get_bits(&s->gb, 8);
737  s->ydc_qdelta = get_bits1(&s->gb) ? get_sbits_inv(&s->gb, 4) : 0;
738  s->uvdc_qdelta = get_bits1(&s->gb) ? get_sbits_inv(&s->gb, 4) : 0;
739  s->uvac_qdelta = get_bits1(&s->gb) ? get_sbits_inv(&s->gb, 4) : 0;
740  s->lossless = s->yac_qi == 0 && s->ydc_qdelta == 0 &&
741  s->uvdc_qdelta == 0 && s->uvac_qdelta == 0;
742  if (s->lossless)
743  ctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
744 
745  /* segmentation header info */
746  s->segmentation.ignore_refmap = 0;
747  if ((s->segmentation.enabled = get_bits1(&s->gb))) {
748  if ((s->segmentation.update_map = get_bits1(&s->gb))) {
749  for (i = 0; i < 7; i++)
750  s->prob.seg[i] = get_bits1(&s->gb) ?
751  get_bits(&s->gb, 8) : 255;
752  if ((s->segmentation.temporal = get_bits1(&s->gb))) {
753  for (i = 0; i < 3; i++)
754  s->prob.segpred[i] = get_bits1(&s->gb) ?
755  get_bits(&s->gb, 8) : 255;
756  }
757  }
758  if ((!s->segmentation.update_map || s->segmentation.temporal) &&
759  (w != s->frames[CUR_FRAME].tf.f->width ||
760  h != s->frames[CUR_FRAME].tf.f->height)) {
761  av_log(ctx, AV_LOG_WARNING,
762  "Reference segmap (temp=%d,update=%d) enabled on size-change!\n",
763  s->segmentation.temporal, s->segmentation.update_map);
764  s->segmentation.ignore_refmap = 1;
765  //return AVERROR_INVALIDDATA;
766  }
767 
768  if (get_bits1(&s->gb)) {
769  s->segmentation.absolute_vals = get_bits1(&s->gb);
770  for (i = 0; i < 8; i++) {
771  if ((s->segmentation.feat[i].q_enabled = get_bits1(&s->gb)))
772  s->segmentation.feat[i].q_val = get_sbits_inv(&s->gb, 8);
773  if ((s->segmentation.feat[i].lf_enabled = get_bits1(&s->gb)))
774  s->segmentation.feat[i].lf_val = get_sbits_inv(&s->gb, 6);
775  if ((s->segmentation.feat[i].ref_enabled = get_bits1(&s->gb)))
776  s->segmentation.feat[i].ref_val = get_bits(&s->gb, 2);
777  s->segmentation.feat[i].skip_enabled = get_bits1(&s->gb);
778  }
779  }
780  }
781 
782  // set qmul[] based on Y/UV, AC/DC and segmentation Q idx deltas
783  for (i = 0; i < (s->segmentation.enabled ? 8 : 1); i++) {
784  int qyac, qydc, quvac, quvdc, lflvl, sh;
785 
786  if (s->segmentation.enabled && s->segmentation.feat[i].q_enabled) {
787  if (s->segmentation.absolute_vals)
788  qyac = av_clip_uintp2(s->segmentation.feat[i].q_val, 8);
789  else
790  qyac = av_clip_uintp2(s->yac_qi + s->segmentation.feat[i].q_val, 8);
791  } else {
792  qyac = s->yac_qi;
793  }
794  qydc = av_clip_uintp2(qyac + s->ydc_qdelta, 8);
795  quvdc = av_clip_uintp2(qyac + s->uvdc_qdelta, 8);
796  quvac = av_clip_uintp2(qyac + s->uvac_qdelta, 8);
797  qyac = av_clip_uintp2(qyac, 8);
798 
799  s->segmentation.feat[i].qmul[0][0] = vp9_dc_qlookup[s->bpp_index][qydc];
800  s->segmentation.feat[i].qmul[0][1] = vp9_ac_qlookup[s->bpp_index][qyac];
801  s->segmentation.feat[i].qmul[1][0] = vp9_dc_qlookup[s->bpp_index][quvdc];
802  s->segmentation.feat[i].qmul[1][1] = vp9_ac_qlookup[s->bpp_index][quvac];
803 
804  sh = s->filter.level >= 32;
805  if (s->segmentation.enabled && s->segmentation.feat[i].lf_enabled) {
806  if (s->segmentation.absolute_vals)
807  lflvl = av_clip_uintp2(s->segmentation.feat[i].lf_val, 6);
808  else
809  lflvl = av_clip_uintp2(s->filter.level + s->segmentation.feat[i].lf_val, 6);
810  } else {
811  lflvl = s->filter.level;
812  }
813  if (s->lf_delta.enabled) {
814  s->segmentation.feat[i].lflvl[0][0] =
815  s->segmentation.feat[i].lflvl[0][1] =
816  av_clip_uintp2(lflvl + (s->lf_delta.ref[0] << sh), 6);
817  for (j = 1; j < 4; j++) {
818  s->segmentation.feat[i].lflvl[j][0] =
819  av_clip_uintp2(lflvl + ((s->lf_delta.ref[j] +
820  s->lf_delta.mode[0]) * (1 << sh)), 6);
821  s->segmentation.feat[i].lflvl[j][1] =
822  av_clip_uintp2(lflvl + ((s->lf_delta.ref[j] +
823  s->lf_delta.mode[1]) * (1 << sh)), 6);
824  }
825  } else {
826  memset(s->segmentation.feat[i].lflvl, lflvl,
827  sizeof(s->segmentation.feat[i].lflvl));
828  }
829  }
830 
831  /* tiling info */
832  if ((res = update_size(ctx, w, h, fmt)) < 0) {
833  av_log(ctx, AV_LOG_ERROR, "Failed to initialize decoder for %dx%d @ %d\n", w, h, fmt);
834  return res;
835  }
836  for (s->tiling.log2_tile_cols = 0;
837  (s->sb_cols >> s->tiling.log2_tile_cols) > 64;
838  s->tiling.log2_tile_cols++) ;
839  for (max = 0; (s->sb_cols >> max) >= 4; max++) ;
840  max = FFMAX(0, max - 1);
841  while (max > s->tiling.log2_tile_cols) {
842  if (get_bits1(&s->gb))
843  s->tiling.log2_tile_cols++;
844  else
845  break;
846  }
847  s->tiling.log2_tile_rows = decode012(&s->gb);
848  s->tiling.tile_rows = 1 << s->tiling.log2_tile_rows;
849  if (s->tiling.tile_cols != (1 << s->tiling.log2_tile_cols)) {
850  s->tiling.tile_cols = 1 << s->tiling.log2_tile_cols;
851  s->c_b = av_fast_realloc(s->c_b, &s->c_b_size,
852  sizeof(VP56RangeCoder) * s->tiling.tile_cols);
853  if (!s->c_b) {
854  av_log(ctx, AV_LOG_ERROR, "Ran out of memory during range coder init\n");
855  return AVERROR(ENOMEM);
856  }
857  }
858 
859  if (s->keyframe || s->errorres || (s->intraonly && s->resetctx == 3)) {
860  s->prob_ctx[0].p = s->prob_ctx[1].p = s->prob_ctx[2].p =
861  s->prob_ctx[3].p = vp9_default_probs;
862  memcpy(s->prob_ctx[0].coef, vp9_default_coef_probs,
863  sizeof(vp9_default_coef_probs));
864  memcpy(s->prob_ctx[1].coef, vp9_default_coef_probs,
865  sizeof(vp9_default_coef_probs));
866  memcpy(s->prob_ctx[2].coef, vp9_default_coef_probs,
867  sizeof(vp9_default_coef_probs));
868  memcpy(s->prob_ctx[3].coef, vp9_default_coef_probs,
869  sizeof(vp9_default_coef_probs));
870  } else if (s->intraonly && s->resetctx == 2) {
871  s->prob_ctx[c].p = vp9_default_probs;
872  memcpy(s->prob_ctx[c].coef, vp9_default_coef_probs,
873  sizeof(vp9_default_coef_probs));
874  }
875 
876  // next 16 bits is size of the rest of the header (arith-coded)
877  size2 = get_bits(&s->gb, 16);
878  data2 = align_get_bits(&s->gb);
879  if (size2 > size - (data2 - data)) {
880  av_log(ctx, AV_LOG_ERROR, "Invalid compressed header size\n");
881  return AVERROR_INVALIDDATA;
882  }
883  ff_vp56_init_range_decoder(&s->c, data2, size2);
884  if (vp56_rac_get_prob_branchy(&s->c, 128)) { // marker bit
885  av_log(ctx, AV_LOG_ERROR, "Marker bit was set\n");
886  return AVERROR_INVALIDDATA;
887  }
888 
889  if (s->keyframe || s->intraonly) {
890  memset(s->counts.coef, 0, sizeof(s->counts.coef));
891  memset(s->counts.eob, 0, sizeof(s->counts.eob));
892  } else {
893  memset(&s->counts, 0, sizeof(s->counts));
894  }
895  // FIXME is it faster to not copy here, but do it down in the fw updates
896  // as explicit copies if the fw update is missing (and skip the copy upon
897  // fw update)?
898  s->prob.p = s->prob_ctx[c].p;
899 
900  // txfm updates
901  if (s->lossless) {
902  s->txfmmode = TX_4X4;
903  } else {
904  s->txfmmode = vp8_rac_get_uint(&s->c, 2);
905  if (s->txfmmode == 3)
906  s->txfmmode += vp8_rac_get(&s->c);
907 
908  if (s->txfmmode == TX_SWITCHABLE) {
909  for (i = 0; i < 2; i++)
910  if (vp56_rac_get_prob_branchy(&s->c, 252))
911  s->prob.p.tx8p[i] = update_prob(&s->c, s->prob.p.tx8p[i]);
912  for (i = 0; i < 2; i++)
913  for (j = 0; j < 2; j++)
914  if (vp56_rac_get_prob_branchy(&s->c, 252))
915  s->prob.p.tx16p[i][j] =
916  update_prob(&s->c, s->prob.p.tx16p[i][j]);
917  for (i = 0; i < 2; i++)
918  for (j = 0; j < 3; j++)
919  if (vp56_rac_get_prob_branchy(&s->c, 252))
920  s->prob.p.tx32p[i][j] =
921  update_prob(&s->c, s->prob.p.tx32p[i][j]);
922  }
923  }
924 
925  // coef updates
926  for (i = 0; i < 4; i++) {
927  uint8_t (*ref)[2][6][6][3] = s->prob_ctx[c].coef[i];
928  if (vp8_rac_get(&s->c)) {
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  for (n = 0; n < 3; n++) {
938  if (vp56_rac_get_prob_branchy(&s->c, 252)) {
939  p[n] = update_prob(&s->c, r[n]);
940  } else {
941  p[n] = r[n];
942  }
943  }
944  p[3] = 0;
945  }
946  } else {
947  for (j = 0; j < 2; j++)
948  for (k = 0; k < 2; k++)
949  for (l = 0; l < 6; l++)
950  for (m = 0; m < 6; m++) {
951  uint8_t *p = s->prob.coef[i][j][k][l][m];
952  uint8_t *r = ref[j][k][l][m];
953  if (m > 3 && l == 0) // dc only has 3 pt
954  break;
955  memcpy(p, r, 3);
956  p[3] = 0;
957  }
958  }
959  if (s->txfmmode == i)
960  break;
961  }
962 
963  // mode updates
964  for (i = 0; i < 3; i++)
965  if (vp56_rac_get_prob_branchy(&s->c, 252))
966  s->prob.p.skip[i] = update_prob(&s->c, s->prob.p.skip[i]);
967  if (!s->keyframe && !s->intraonly) {
968  for (i = 0; i < 7; i++)
969  for (j = 0; j < 3; j++)
970  if (vp56_rac_get_prob_branchy(&s->c, 252))
971  s->prob.p.mv_mode[i][j] =
972  update_prob(&s->c, s->prob.p.mv_mode[i][j]);
973 
974  if (s->filtermode == FILTER_SWITCHABLE)
975  for (i = 0; i < 4; i++)
976  for (j = 0; j < 2; j++)
977  if (vp56_rac_get_prob_branchy(&s->c, 252))
978  s->prob.p.filter[i][j] =
979  update_prob(&s->c, s->prob.p.filter[i][j]);
980 
981  for (i = 0; i < 4; i++)
982  if (vp56_rac_get_prob_branchy(&s->c, 252))
983  s->prob.p.intra[i] = update_prob(&s->c, s->prob.p.intra[i]);
984 
985  if (s->allowcompinter) {
986  s->comppredmode = vp8_rac_get(&s->c);
987  if (s->comppredmode)
988  s->comppredmode += vp8_rac_get(&s->c);
989  if (s->comppredmode == PRED_SWITCHABLE)
990  for (i = 0; i < 5; i++)
991  if (vp56_rac_get_prob_branchy(&s->c, 252))
992  s->prob.p.comp[i] =
993  update_prob(&s->c, s->prob.p.comp[i]);
994  } else {
995  s->comppredmode = PRED_SINGLEREF;
996  }
997 
998  if (s->comppredmode != PRED_COMPREF) {
999  for (i = 0; i < 5; i++) {
1000  if (vp56_rac_get_prob_branchy(&s->c, 252))
1001  s->prob.p.single_ref[i][0] =
1002  update_prob(&s->c, s->prob.p.single_ref[i][0]);
1003  if (vp56_rac_get_prob_branchy(&s->c, 252))
1004  s->prob.p.single_ref[i][1] =
1005  update_prob(&s->c, s->prob.p.single_ref[i][1]);
1006  }
1007  }
1008 
1009  if (s->comppredmode != PRED_SINGLEREF) {
1010  for (i = 0; i < 5; i++)
1011  if (vp56_rac_get_prob_branchy(&s->c, 252))
1012  s->prob.p.comp_ref[i] =
1013  update_prob(&s->c, s->prob.p.comp_ref[i]);
1014  }
1015 
1016  for (i = 0; i < 4; i++)
1017  for (j = 0; j < 9; j++)
1018  if (vp56_rac_get_prob_branchy(&s->c, 252))
1019  s->prob.p.y_mode[i][j] =
1020  update_prob(&s->c, s->prob.p.y_mode[i][j]);
1021 
1022  for (i = 0; i < 4; i++)
1023  for (j = 0; j < 4; j++)
1024  for (k = 0; k < 3; k++)
1025  if (vp56_rac_get_prob_branchy(&s->c, 252))
1026  s->prob.p.partition[3 - i][j][k] =
1027  update_prob(&s->c, s->prob.p.partition[3 - i][j][k]);
1028 
1029  // mv fields don't use the update_prob subexp model for some reason
1030  for (i = 0; i < 3; i++)
1031  if (vp56_rac_get_prob_branchy(&s->c, 252))
1032  s->prob.p.mv_joint[i] = (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1033 
1034  for (i = 0; i < 2; i++) {
1035  if (vp56_rac_get_prob_branchy(&s->c, 252))
1036  s->prob.p.mv_comp[i].sign = (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1037 
1038  for (j = 0; j < 10; j++)
1039  if (vp56_rac_get_prob_branchy(&s->c, 252))
1040  s->prob.p.mv_comp[i].classes[j] =
1041  (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1042 
1043  if (vp56_rac_get_prob_branchy(&s->c, 252))
1044  s->prob.p.mv_comp[i].class0 = (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1045 
1046  for (j = 0; j < 10; j++)
1047  if (vp56_rac_get_prob_branchy(&s->c, 252))
1048  s->prob.p.mv_comp[i].bits[j] =
1049  (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1050  }
1051 
1052  for (i = 0; i < 2; i++) {
1053  for (j = 0; j < 2; j++)
1054  for (k = 0; k < 3; k++)
1055  if (vp56_rac_get_prob_branchy(&s->c, 252))
1056  s->prob.p.mv_comp[i].class0_fp[j][k] =
1057  (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1058 
1059  for (j = 0; j < 3; j++)
1060  if (vp56_rac_get_prob_branchy(&s->c, 252))
1061  s->prob.p.mv_comp[i].fp[j] =
1062  (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1063  }
1064 
1065  if (s->highprecisionmvs) {
1066  for (i = 0; i < 2; i++) {
1067  if (vp56_rac_get_prob_branchy(&s->c, 252))
1068  s->prob.p.mv_comp[i].class0_hp =
1069  (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1070 
1071  if (vp56_rac_get_prob_branchy(&s->c, 252))
1072  s->prob.p.mv_comp[i].hp =
1073  (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
1074  }
1075  }
1076  }
1077 
1078  return (data2 - data) + size2;
1079 }
1080 
1081 static av_always_inline void clamp_mv(VP56mv *dst, const VP56mv *src,
1082  VP9Context *s)
1083 {
1084  dst->x = av_clip(src->x, s->min_mv.x, s->max_mv.x);
1085  dst->y = av_clip(src->y, s->min_mv.y, s->max_mv.y);
1086 }
1087 
1088 static void find_ref_mvs(VP9Context *s,
1089  VP56mv *pmv, int ref, int z, int idx, int sb)
1090 {
1091  static const int8_t mv_ref_blk_off[N_BS_SIZES][8][2] = {
1092  [BS_64x64] = {{ 3, -1 }, { -1, 3 }, { 4, -1 }, { -1, 4 },
1093  { -1, -1 }, { 0, -1 }, { -1, 0 }, { 6, -1 }},
1094  [BS_64x32] = {{ 0, -1 }, { -1, 0 }, { 4, -1 }, { -1, 2 },
1095  { -1, -1 }, { 0, -3 }, { -3, 0 }, { 2, -1 }},
1096  [BS_32x64] = {{ -1, 0 }, { 0, -1 }, { -1, 4 }, { 2, -1 },
1097  { -1, -1 }, { -3, 0 }, { 0, -3 }, { -1, 2 }},
1098  [BS_32x32] = {{ 1, -1 }, { -1, 1 }, { 2, -1 }, { -1, 2 },
1099  { -1, -1 }, { 0, -3 }, { -3, 0 }, { -3, -3 }},
1100  [BS_32x16] = {{ 0, -1 }, { -1, 0 }, { 2, -1 }, { -1, -1 },
1101  { -1, 1 }, { 0, -3 }, { -3, 0 }, { -3, -3 }},
1102  [BS_16x32] = {{ -1, 0 }, { 0, -1 }, { -1, 2 }, { -1, -1 },
1103  { 1, -1 }, { -3, 0 }, { 0, -3 }, { -3, -3 }},
1104  [BS_16x16] = {{ 0, -1 }, { -1, 0 }, { 1, -1 }, { -1, 1 },
1105  { -1, -1 }, { 0, -3 }, { -3, 0 }, { -3, -3 }},
1106  [BS_16x8] = {{ 0, -1 }, { -1, 0 }, { 1, -1 }, { -1, -1 },
1107  { 0, -2 }, { -2, 0 }, { -2, -1 }, { -1, -2 }},
1108  [BS_8x16] = {{ -1, 0 }, { 0, -1 }, { -1, 1 }, { -1, -1 },
1109  { -2, 0 }, { 0, -2 }, { -1, -2 }, { -2, -1 }},
1110  [BS_8x8] = {{ 0, -1 }, { -1, 0 }, { -1, -1 }, { 0, -2 },
1111  { -2, 0 }, { -1, -2 }, { -2, -1 }, { -2, -2 }},
1112  [BS_8x4] = {{ 0, -1 }, { -1, 0 }, { -1, -1 }, { 0, -2 },
1113  { -2, 0 }, { -1, -2 }, { -2, -1 }, { -2, -2 }},
1114  [BS_4x8] = {{ 0, -1 }, { -1, 0 }, { -1, -1 }, { 0, -2 },
1115  { -2, 0 }, { -1, -2 }, { -2, -1 }, { -2, -2 }},
1116  [BS_4x4] = {{ 0, -1 }, { -1, 0 }, { -1, -1 }, { 0, -2 },
1117  { -2, 0 }, { -1, -2 }, { -2, -1 }, { -2, -2 }},
1118  };
1119  VP9Block *b = s->b;
1120  int row = s->row, col = s->col, row7 = s->row7;
1121  const int8_t (*p)[2] = mv_ref_blk_off[b->bs];
1122 #define INVALID_MV 0x80008000U
1123  uint32_t mem = INVALID_MV, mem_sub8x8 = INVALID_MV;
1124  int i;
1125 
1126 #define RETURN_DIRECT_MV(mv) \
1127  do { \
1128  uint32_t m = AV_RN32A(&mv); \
1129  if (!idx) { \
1130  AV_WN32A(pmv, m); \
1131  return; \
1132  } else if (mem == INVALID_MV) { \
1133  mem = m; \
1134  } else if (m != mem) { \
1135  AV_WN32A(pmv, m); \
1136  return; \
1137  } \
1138  } while (0)
1139 
1140  if (sb >= 0) {
1141  if (sb == 2 || sb == 1) {
1142  RETURN_DIRECT_MV(b->mv[0][z]);
1143  } else if (sb == 3) {
1144  RETURN_DIRECT_MV(b->mv[2][z]);
1145  RETURN_DIRECT_MV(b->mv[1][z]);
1146  RETURN_DIRECT_MV(b->mv[0][z]);
1147  }
1148 
1149 #define RETURN_MV(mv) \
1150  do { \
1151  if (sb > 0) { \
1152  VP56mv tmp; \
1153  uint32_t m; \
1154  av_assert2(idx == 1); \
1155  av_assert2(mem != INVALID_MV); \
1156  if (mem_sub8x8 == INVALID_MV) { \
1157  clamp_mv(&tmp, &mv, s); \
1158  m = AV_RN32A(&tmp); \
1159  if (m != mem) { \
1160  AV_WN32A(pmv, m); \
1161  return; \
1162  } \
1163  mem_sub8x8 = AV_RN32A(&mv); \
1164  } else if (mem_sub8x8 != AV_RN32A(&mv)) { \
1165  clamp_mv(&tmp, &mv, s); \
1166  m = AV_RN32A(&tmp); \
1167  if (m != mem) { \
1168  AV_WN32A(pmv, m); \
1169  } else { \
1170  /* BUG I'm pretty sure this isn't the intention */ \
1171  AV_WN32A(pmv, 0); \
1172  } \
1173  return; \
1174  } \
1175  } else { \
1176  uint32_t m = AV_RN32A(&mv); \
1177  if (!idx) { \
1178  clamp_mv(pmv, &mv, s); \
1179  return; \
1180  } else if (mem == INVALID_MV) { \
1181  mem = m; \
1182  } else if (m != mem) { \
1183  clamp_mv(pmv, &mv, s); \
1184  return; \
1185  } \
1186  } \
1187  } while (0)
1188 
1189  if (row > 0) {
1190  struct VP9mvrefPair *mv = &s->frames[CUR_FRAME].mv[(row - 1) * s->sb_cols * 8 + col];
1191  if (mv->ref[0] == ref) {
1192  RETURN_MV(s->above_mv_ctx[2 * col + (sb & 1)][0]);
1193  } else if (mv->ref[1] == ref) {
1194  RETURN_MV(s->above_mv_ctx[2 * col + (sb & 1)][1]);
1195  }
1196  }
1197  if (col > s->tiling.tile_col_start) {
1198  struct VP9mvrefPair *mv = &s->frames[CUR_FRAME].mv[row * s->sb_cols * 8 + col - 1];
1199  if (mv->ref[0] == ref) {
1200  RETURN_MV(s->left_mv_ctx[2 * row7 + (sb >> 1)][0]);
1201  } else if (mv->ref[1] == ref) {
1202  RETURN_MV(s->left_mv_ctx[2 * row7 + (sb >> 1)][1]);
1203  }
1204  }
1205  i = 2;
1206  } else {
1207  i = 0;
1208  }
1209 
1210  // previously coded MVs in this neighbourhood, using same reference frame
1211  for (; i < 8; i++) {
1212  int c = p[i][0] + col, r = p[i][1] + row;
1213 
1214  if (c >= s->tiling.tile_col_start && c < s->cols && r >= 0 && r < s->rows) {
1215  struct VP9mvrefPair *mv = &s->frames[CUR_FRAME].mv[r * s->sb_cols * 8 + c];
1216 
1217  if (mv->ref[0] == ref) {
1218  RETURN_MV(mv->mv[0]);
1219  } else if (mv->ref[1] == ref) {
1220  RETURN_MV(mv->mv[1]);
1221  }
1222  }
1223  }
1224 
1225  // MV at this position in previous frame, using same reference frame
1226  if (s->use_last_frame_mvs) {
1227  struct VP9mvrefPair *mv = &s->frames[REF_FRAME_MVPAIR].mv[row * s->sb_cols * 8 + col];
1228 
1229  if (!s->frames[REF_FRAME_MVPAIR].uses_2pass)
1230  ff_thread_await_progress(&s->frames[REF_FRAME_MVPAIR].tf, row >> 3, 0);
1231  if (mv->ref[0] == ref) {
1232  RETURN_MV(mv->mv[0]);
1233  } else if (mv->ref[1] == ref) {
1234  RETURN_MV(mv->mv[1]);
1235  }
1236  }
1237 
1238 #define RETURN_SCALE_MV(mv, scale) \
1239  do { \
1240  if (scale) { \
1241  VP56mv mv_temp = { -mv.x, -mv.y }; \
1242  RETURN_MV(mv_temp); \
1243  } else { \
1244  RETURN_MV(mv); \
1245  } \
1246  } while (0)
1247 
1248  // previously coded MVs in this neighbourhood, using different reference frame
1249  for (i = 0; i < 8; i++) {
1250  int c = p[i][0] + col, r = p[i][1] + row;
1251 
1252  if (c >= s->tiling.tile_col_start && c < s->cols && r >= 0 && r < s->rows) {
1253  struct VP9mvrefPair *mv = &s->frames[CUR_FRAME].mv[r * s->sb_cols * 8 + c];
1254 
1255  if (mv->ref[0] != ref && mv->ref[0] >= 0) {
1256  RETURN_SCALE_MV(mv->mv[0], s->signbias[mv->ref[0]] != s->signbias[ref]);
1257  }
1258  if (mv->ref[1] != ref && mv->ref[1] >= 0 &&
1259  // BUG - libvpx has this condition regardless of whether
1260  // we used the first ref MV and pre-scaling
1261  AV_RN32A(&mv->mv[0]) != AV_RN32A(&mv->mv[1])) {
1262  RETURN_SCALE_MV(mv->mv[1], s->signbias[mv->ref[1]] != s->signbias[ref]);
1263  }
1264  }
1265  }
1266 
1267  // MV at this position in previous frame, using different reference frame
1268  if (s->use_last_frame_mvs) {
1269  struct VP9mvrefPair *mv = &s->frames[REF_FRAME_MVPAIR].mv[row * s->sb_cols * 8 + col];
1270 
1271  // no need to await_progress, because we already did that above
1272  if (mv->ref[0] != ref && mv->ref[0] >= 0) {
1273  RETURN_SCALE_MV(mv->mv[0], s->signbias[mv->ref[0]] != s->signbias[ref]);
1274  }
1275  if (mv->ref[1] != ref && mv->ref[1] >= 0 &&
1276  // BUG - libvpx has this condition regardless of whether
1277  // we used the first ref MV and pre-scaling
1278  AV_RN32A(&mv->mv[0]) != AV_RN32A(&mv->mv[1])) {
1279  RETURN_SCALE_MV(mv->mv[1], s->signbias[mv->ref[1]] != s->signbias[ref]);
1280  }
1281  }
1282 
1283  AV_ZERO32(pmv);
1284  clamp_mv(pmv, pmv, s);
1285 #undef INVALID_MV
1286 #undef RETURN_MV
1287 #undef RETURN_SCALE_MV
1288 }
1289 
1290 static av_always_inline int read_mv_component(VP9Context *s, int idx, int hp)
1291 {
1292  int bit, sign = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].sign);
1293  int n, c = vp8_rac_get_tree(&s->c, vp9_mv_class_tree,
1294  s->prob.p.mv_comp[idx].classes);
1295 
1296  s->counts.mv_comp[idx].sign[sign]++;
1297  s->counts.mv_comp[idx].classes[c]++;
1298  if (c) {
1299  int m;
1300 
1301  for (n = 0, m = 0; m < c; m++) {
1302  bit = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].bits[m]);
1303  n |= bit << m;
1304  s->counts.mv_comp[idx].bits[m][bit]++;
1305  }
1306  n <<= 3;
1307  bit = vp8_rac_get_tree(&s->c, vp9_mv_fp_tree, s->prob.p.mv_comp[idx].fp);
1308  n |= bit << 1;
1309  s->counts.mv_comp[idx].fp[bit]++;
1310  if (hp) {
1311  bit = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].hp);
1312  s->counts.mv_comp[idx].hp[bit]++;
1313  n |= bit;
1314  } else {
1315  n |= 1;
1316  // bug in libvpx - we count for bw entropy purposes even if the
1317  // bit wasn't coded
1318  s->counts.mv_comp[idx].hp[1]++;
1319  }
1320  n += 8 << c;
1321  } else {
1322  n = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].class0);
1323  s->counts.mv_comp[idx].class0[n]++;
1324  bit = vp8_rac_get_tree(&s->c, vp9_mv_fp_tree,
1325  s->prob.p.mv_comp[idx].class0_fp[n]);
1326  s->counts.mv_comp[idx].class0_fp[n][bit]++;
1327  n = (n << 3) | (bit << 1);
1328  if (hp) {
1329  bit = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].class0_hp);
1330  s->counts.mv_comp[idx].class0_hp[bit]++;
1331  n |= bit;
1332  } else {
1333  n |= 1;
1334  // bug in libvpx - we count for bw entropy purposes even if the
1335  // bit wasn't coded
1336  s->counts.mv_comp[idx].class0_hp[1]++;
1337  }
1338  }
1339 
1340  return sign ? -(n + 1) : (n + 1);
1341 }
1342 
1343 static void fill_mv(VP9Context *s,
1344  VP56mv *mv, int mode, int sb)
1345 {
1346  VP9Block *b = s->b;
1347 
1348  if (mode == ZEROMV) {
1349  AV_ZERO64(mv);
1350  } else {
1351  int hp;
1352 
1353  // FIXME cache this value and reuse for other subblocks
1354  find_ref_mvs(s, &mv[0], b->ref[0], 0, mode == NEARMV,
1355  mode == NEWMV ? -1 : sb);
1356  // FIXME maybe move this code into find_ref_mvs()
1357  if ((mode == NEWMV || sb == -1) &&
1358  !(hp = s->highprecisionmvs && abs(mv[0].x) < 64 && abs(mv[0].y) < 64)) {
1359  if (mv[0].y & 1) {
1360  if (mv[0].y < 0)
1361  mv[0].y++;
1362  else
1363  mv[0].y--;
1364  }
1365  if (mv[0].x & 1) {
1366  if (mv[0].x < 0)
1367  mv[0].x++;
1368  else
1369  mv[0].x--;
1370  }
1371  }
1372  if (mode == NEWMV) {
1373  enum MVJoint j = vp8_rac_get_tree(&s->c, vp9_mv_joint_tree,
1374  s->prob.p.mv_joint);
1375 
1376  s->counts.mv_joint[j]++;
1377  if (j >= MV_JOINT_V)
1378  mv[0].y += read_mv_component(s, 0, hp);
1379  if (j & 1)
1380  mv[0].x += read_mv_component(s, 1, hp);
1381  }
1382 
1383  if (b->comp) {
1384  // FIXME cache this value and reuse for other subblocks
1385  find_ref_mvs(s, &mv[1], b->ref[1], 1, mode == NEARMV,
1386  mode == NEWMV ? -1 : sb);
1387  if ((mode == NEWMV || sb == -1) &&
1388  !(hp = s->highprecisionmvs && abs(mv[1].x) < 64 && abs(mv[1].y) < 64)) {
1389  if (mv[1].y & 1) {
1390  if (mv[1].y < 0)
1391  mv[1].y++;
1392  else
1393  mv[1].y--;
1394  }
1395  if (mv[1].x & 1) {
1396  if (mv[1].x < 0)
1397  mv[1].x++;
1398  else
1399  mv[1].x--;
1400  }
1401  }
1402  if (mode == NEWMV) {
1403  enum MVJoint j = vp8_rac_get_tree(&s->c, vp9_mv_joint_tree,
1404  s->prob.p.mv_joint);
1405 
1406  s->counts.mv_joint[j]++;
1407  if (j >= MV_JOINT_V)
1408  mv[1].y += read_mv_component(s, 0, hp);
1409  if (j & 1)
1410  mv[1].x += read_mv_component(s, 1, hp);
1411  }
1412  }
1413  }
1414 }
1415 
1416 static av_always_inline void setctx_2d(uint8_t *ptr, int w, int h,
1417  ptrdiff_t stride, int v)
1418 {
1419  switch (w) {
1420  case 1:
1421  do {
1422  *ptr = v;
1423  ptr += stride;
1424  } while (--h);
1425  break;
1426  case 2: {
1427  int v16 = v * 0x0101;
1428  do {
1429  AV_WN16A(ptr, v16);
1430  ptr += stride;
1431  } while (--h);
1432  break;
1433  }
1434  case 4: {
1435  uint32_t v32 = v * 0x01010101;
1436  do {
1437  AV_WN32A(ptr, v32);
1438  ptr += stride;
1439  } while (--h);
1440  break;
1441  }
1442  case 8: {
1443 #if HAVE_FAST_64BIT
1444  uint64_t v64 = v * 0x0101010101010101ULL;
1445  do {
1446  AV_WN64A(ptr, v64);
1447  ptr += stride;
1448  } while (--h);
1449 #else
1450  uint32_t v32 = v * 0x01010101;
1451  do {
1452  AV_WN32A(ptr, v32);
1453  AV_WN32A(ptr + 4, v32);
1454  ptr += stride;
1455  } while (--h);
1456 #endif
1457  break;
1458  }
1459  }
1460 }
1461 
1462 static void decode_mode(AVCodecContext *ctx)
1463 {
1464  static const uint8_t left_ctx[N_BS_SIZES] = {
1465  0x0, 0x8, 0x0, 0x8, 0xc, 0x8, 0xc, 0xe, 0xc, 0xe, 0xf, 0xe, 0xf
1466  };
1467  static const uint8_t above_ctx[N_BS_SIZES] = {
1468  0x0, 0x0, 0x8, 0x8, 0x8, 0xc, 0xc, 0xc, 0xe, 0xe, 0xe, 0xf, 0xf
1469  };
1470  static const uint8_t max_tx_for_bl_bp[N_BS_SIZES] = {
1471  TX_32X32, TX_32X32, TX_32X32, TX_32X32, TX_16X16, TX_16X16,
1472  TX_16X16, TX_8X8, TX_8X8, TX_8X8, TX_4X4, TX_4X4, TX_4X4
1473  };
1474  VP9Context *s = ctx->priv_data;
1475  VP9Block *b = s->b;
1476  int row = s->row, col = s->col, row7 = s->row7;
1477  enum TxfmMode max_tx = max_tx_for_bl_bp[b->bs];
1478  int bw4 = bwh_tab[1][b->bs][0], w4 = FFMIN(s->cols - col, bw4);
1479  int bh4 = bwh_tab[1][b->bs][1], h4 = FFMIN(s->rows - row, bh4), y;
1480  int have_a = row > 0, have_l = col > s->tiling.tile_col_start;
1481  int vref, filter_id;
1482 
1483  if (!s->segmentation.enabled) {
1484  b->seg_id = 0;
1485  } else if (s->keyframe || s->intraonly) {
1486  b->seg_id = !s->segmentation.update_map ? 0 :
1487  vp8_rac_get_tree(&s->c, vp9_segmentation_tree, s->prob.seg);
1488  } else if (!s->segmentation.update_map ||
1489  (s->segmentation.temporal &&
1490  vp56_rac_get_prob_branchy(&s->c,
1491  s->prob.segpred[s->above_segpred_ctx[col] +
1492  s->left_segpred_ctx[row7]]))) {
1493  if (!s->errorres && !s->segmentation.ignore_refmap) {
1494  int pred = 8, x;
1495  uint8_t *refsegmap = s->frames[REF_FRAME_SEGMAP].segmentation_map;
1496 
1497  if (!s->frames[REF_FRAME_SEGMAP].uses_2pass)
1498  ff_thread_await_progress(&s->frames[REF_FRAME_SEGMAP].tf, row >> 3, 0);
1499  for (y = 0; y < h4; y++) {
1500  int idx_base = (y + row) * 8 * s->sb_cols + col;
1501  for (x = 0; x < w4; x++)
1502  pred = FFMIN(pred, refsegmap[idx_base + x]);
1503  }
1504  av_assert1(pred < 8);
1505  b->seg_id = pred;
1506  } else {
1507  b->seg_id = 0;
1508  }
1509 
1510  memset(&s->above_segpred_ctx[col], 1, w4);
1511  memset(&s->left_segpred_ctx[row7], 1, h4);
1512  } else {
1513  b->seg_id = vp8_rac_get_tree(&s->c, vp9_segmentation_tree,
1514  s->prob.seg);
1515 
1516  memset(&s->above_segpred_ctx[col], 0, w4);
1517  memset(&s->left_segpred_ctx[row7], 0, h4);
1518  }
1519  if (s->segmentation.enabled &&
1520  (s->segmentation.update_map || s->keyframe || s->intraonly)) {
1521  setctx_2d(&s->frames[CUR_FRAME].segmentation_map[row * 8 * s->sb_cols + col],
1522  bw4, bh4, 8 * s->sb_cols, b->seg_id);
1523  }
1524 
1525  b->skip = s->segmentation.enabled &&
1526  s->segmentation.feat[b->seg_id].skip_enabled;
1527  if (!b->skip) {
1528  int c = s->left_skip_ctx[row7] + s->above_skip_ctx[col];
1529  b->skip = vp56_rac_get_prob(&s->c, s->prob.p.skip[c]);
1530  s->counts.skip[c][b->skip]++;
1531  }
1532 
1533  if (s->keyframe || s->intraonly) {
1534  b->intra = 1;
1535  } else if (s->segmentation.enabled && s->segmentation.feat[b->seg_id].ref_enabled) {
1536  b->intra = !s->segmentation.feat[b->seg_id].ref_val;
1537  } else {
1538  int c, bit;
1539 
1540  if (have_a && have_l) {
1541  c = s->above_intra_ctx[col] + s->left_intra_ctx[row7];
1542  c += (c == 2);
1543  } else {
1544  c = have_a ? 2 * s->above_intra_ctx[col] :
1545  have_l ? 2 * s->left_intra_ctx[row7] : 0;
1546  }
1547  bit = vp56_rac_get_prob(&s->c, s->prob.p.intra[c]);
1548  s->counts.intra[c][bit]++;
1549  b->intra = !bit;
1550  }
1551 
1552  if ((b->intra || !b->skip) && s->txfmmode == TX_SWITCHABLE) {
1553  int c;
1554  if (have_a) {
1555  if (have_l) {
1556  c = (s->above_skip_ctx[col] ? max_tx :
1557  s->above_txfm_ctx[col]) +
1558  (s->left_skip_ctx[row7] ? max_tx :
1559  s->left_txfm_ctx[row7]) > max_tx;
1560  } else {
1561  c = s->above_skip_ctx[col] ? 1 :
1562  (s->above_txfm_ctx[col] * 2 > max_tx);
1563  }
1564  } else if (have_l) {
1565  c = s->left_skip_ctx[row7] ? 1 :
1566  (s->left_txfm_ctx[row7] * 2 > max_tx);
1567  } else {
1568  c = 1;
1569  }
1570  switch (max_tx) {
1571  case TX_32X32:
1572  b->tx = vp56_rac_get_prob(&s->c, s->prob.p.tx32p[c][0]);
1573  if (b->tx) {
1574  b->tx += vp56_rac_get_prob(&s->c, s->prob.p.tx32p[c][1]);
1575  if (b->tx == 2)
1576  b->tx += vp56_rac_get_prob(&s->c, s->prob.p.tx32p[c][2]);
1577  }
1578  s->counts.tx32p[c][b->tx]++;
1579  break;
1580  case TX_16X16:
1581  b->tx = vp56_rac_get_prob(&s->c, s->prob.p.tx16p[c][0]);
1582  if (b->tx)
1583  b->tx += vp56_rac_get_prob(&s->c, s->prob.p.tx16p[c][1]);
1584  s->counts.tx16p[c][b->tx]++;
1585  break;
1586  case TX_8X8:
1587  b->tx = vp56_rac_get_prob(&s->c, s->prob.p.tx8p[c]);
1588  s->counts.tx8p[c][b->tx]++;
1589  break;
1590  case TX_4X4:
1591  b->tx = TX_4X4;
1592  break;
1593  }
1594  } else {
1595  b->tx = FFMIN(max_tx, s->txfmmode);
1596  }
1597 
1598  if (s->keyframe || s->intraonly) {
1599  uint8_t *a = &s->above_mode_ctx[col * 2];
1600  uint8_t *l = &s->left_mode_ctx[(row7) << 1];
1601 
1602  b->comp = 0;
1603  if (b->bs > BS_8x8) {
1604  // FIXME the memory storage intermediates here aren't really
1605  // necessary, they're just there to make the code slightly
1606  // simpler for now
1607  b->mode[0] = a[0] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
1608  vp9_default_kf_ymode_probs[a[0]][l[0]]);
1609  if (b->bs != BS_8x4) {
1610  b->mode[1] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
1611  vp9_default_kf_ymode_probs[a[1]][b->mode[0]]);
1612  l[0] = a[1] = b->mode[1];
1613  } else {
1614  l[0] = a[1] = b->mode[1] = b->mode[0];
1615  }
1616  if (b->bs != BS_4x8) {
1617  b->mode[2] = a[0] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
1618  vp9_default_kf_ymode_probs[a[0]][l[1]]);
1619  if (b->bs != BS_8x4) {
1620  b->mode[3] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
1621  vp9_default_kf_ymode_probs[a[1]][b->mode[2]]);
1622  l[1] = a[1] = b->mode[3];
1623  } else {
1624  l[1] = a[1] = b->mode[3] = b->mode[2];
1625  }
1626  } else {
1627  b->mode[2] = b->mode[0];
1628  l[1] = a[1] = b->mode[3] = b->mode[1];
1629  }
1630  } else {
1631  b->mode[0] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
1632  vp9_default_kf_ymode_probs[*a][*l]);
1633  b->mode[3] = b->mode[2] = b->mode[1] = b->mode[0];
1634  // FIXME this can probably be optimized
1635  memset(a, b->mode[0], bwh_tab[0][b->bs][0]);
1636  memset(l, b->mode[0], bwh_tab[0][b->bs][1]);
1637  }
1638  b->uvmode = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
1639  vp9_default_kf_uvmode_probs[b->mode[3]]);
1640  } else if (b->intra) {
1641  b->comp = 0;
1642  if (b->bs > BS_8x8) {
1643  b->mode[0] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
1644  s->prob.p.y_mode[0]);
1645  s->counts.y_mode[0][b->mode[0]]++;
1646  if (b->bs != BS_8x4) {
1647  b->mode[1] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
1648  s->prob.p.y_mode[0]);
1649  s->counts.y_mode[0][b->mode[1]]++;
1650  } else {
1651  b->mode[1] = b->mode[0];
1652  }
1653  if (b->bs != BS_4x8) {
1654  b->mode[2] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
1655  s->prob.p.y_mode[0]);
1656  s->counts.y_mode[0][b->mode[2]]++;
1657  if (b->bs != BS_8x4) {
1658  b->mode[3] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
1659  s->prob.p.y_mode[0]);
1660  s->counts.y_mode[0][b->mode[3]]++;
1661  } else {
1662  b->mode[3] = b->mode[2];
1663  }
1664  } else {
1665  b->mode[2] = b->mode[0];
1666  b->mode[3] = b->mode[1];
1667  }
1668  } else {
1669  static const uint8_t size_group[10] = {
1670  3, 3, 3, 3, 2, 2, 2, 1, 1, 1
1671  };
1672  int sz = size_group[b->bs];
1673 
1674  b->mode[0] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
1675  s->prob.p.y_mode[sz]);
1676  b->mode[1] = b->mode[2] = b->mode[3] = b->mode[0];
1677  s->counts.y_mode[sz][b->mode[3]]++;
1678  }
1679  b->uvmode = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
1680  s->prob.p.uv_mode[b->mode[3]]);
1681  s->counts.uv_mode[b->mode[3]][b->uvmode]++;
1682  } else {
1683  static const uint8_t inter_mode_ctx_lut[14][14] = {
1684  { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
1685  { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
1686  { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
1687  { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
1688  { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
1689  { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
1690  { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
1691  { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
1692  { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
1693  { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
1694  { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 2, 2, 1, 3 },
1695  { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 2, 2, 1, 3 },
1696  { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 1, 1, 0, 3 },
1697  { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3, 3, 3, 4 },
1698  };
1699 
1700  if (s->segmentation.enabled && s->segmentation.feat[b->seg_id].ref_enabled) {
1701  av_assert2(s->segmentation.feat[b->seg_id].ref_val != 0);
1702  b->comp = 0;
1703  b->ref[0] = s->segmentation.feat[b->seg_id].ref_val - 1;
1704  } else {
1705  // read comp_pred flag
1706  if (s->comppredmode != PRED_SWITCHABLE) {
1707  b->comp = s->comppredmode == PRED_COMPREF;
1708  } else {
1709  int c;
1710 
1711  // FIXME add intra as ref=0xff (or -1) to make these easier?
1712  if (have_a) {
1713  if (have_l) {
1714  if (s->above_comp_ctx[col] && s->left_comp_ctx[row7]) {
1715  c = 4;
1716  } else if (s->above_comp_ctx[col]) {
1717  c = 2 + (s->left_intra_ctx[row7] ||
1718  s->left_ref_ctx[row7] == s->fixcompref);
1719  } else if (s->left_comp_ctx[row7]) {
1720  c = 2 + (s->above_intra_ctx[col] ||
1721  s->above_ref_ctx[col] == s->fixcompref);
1722  } else {
1723  c = (!s->above_intra_ctx[col] &&
1724  s->above_ref_ctx[col] == s->fixcompref) ^
1725  (!s->left_intra_ctx[row7] &&
1726  s->left_ref_ctx[row & 7] == s->fixcompref);
1727  }
1728  } else {
1729  c = s->above_comp_ctx[col] ? 3 :
1730  (!s->above_intra_ctx[col] && s->above_ref_ctx[col] == s->fixcompref);
1731  }
1732  } else if (have_l) {
1733  c = s->left_comp_ctx[row7] ? 3 :
1734  (!s->left_intra_ctx[row7] && s->left_ref_ctx[row7] == s->fixcompref);
1735  } else {
1736  c = 1;
1737  }
1738  b->comp = vp56_rac_get_prob(&s->c, s->prob.p.comp[c]);
1739  s->counts.comp[c][b->comp]++;
1740  }
1741 
1742  // read actual references
1743  // FIXME probably cache a few variables here to prevent repetitive
1744  // memory accesses below
1745  if (b->comp) /* two references */ {
1746  int fix_idx = s->signbias[s->fixcompref], var_idx = !fix_idx, c, bit;
1747 
1748  b->ref[fix_idx] = s->fixcompref;
1749  // FIXME can this codeblob be replaced by some sort of LUT?
1750  if (have_a) {
1751  if (have_l) {
1752  if (s->above_intra_ctx[col]) {
1753  if (s->left_intra_ctx[row7]) {
1754  c = 2;
1755  } else {
1756  c = 1 + 2 * (s->left_ref_ctx[row7] != s->varcompref[1]);
1757  }
1758  } else if (s->left_intra_ctx[row7]) {
1759  c = 1 + 2 * (s->above_ref_ctx[col] != s->varcompref[1]);
1760  } else {
1761  int refl = s->left_ref_ctx[row7], refa = s->above_ref_ctx[col];
1762 
1763  if (refl == refa && refa == s->varcompref[1]) {
1764  c = 0;
1765  } else if (!s->left_comp_ctx[row7] && !s->above_comp_ctx[col]) {
1766  if ((refa == s->fixcompref && refl == s->varcompref[0]) ||
1767  (refl == s->fixcompref && refa == s->varcompref[0])) {
1768  c = 4;
1769  } else {
1770  c = (refa == refl) ? 3 : 1;
1771  }
1772  } else if (!s->left_comp_ctx[row7]) {
1773  if (refa == s->varcompref[1] && refl != s->varcompref[1]) {
1774  c = 1;
1775  } else {
1776  c = (refl == s->varcompref[1] &&
1777  refa != s->varcompref[1]) ? 2 : 4;
1778  }
1779  } else if (!s->above_comp_ctx[col]) {
1780  if (refl == s->varcompref[1] && refa != s->varcompref[1]) {
1781  c = 1;
1782  } else {
1783  c = (refa == s->varcompref[1] &&
1784  refl != s->varcompref[1]) ? 2 : 4;
1785  }
1786  } else {
1787  c = (refl == refa) ? 4 : 2;
1788  }
1789  }
1790  } else {
1791  if (s->above_intra_ctx[col]) {
1792  c = 2;
1793  } else if (s->above_comp_ctx[col]) {
1794  c = 4 * (s->above_ref_ctx[col] != s->varcompref[1]);
1795  } else {
1796  c = 3 * (s->above_ref_ctx[col] != s->varcompref[1]);
1797  }
1798  }
1799  } else if (have_l) {
1800  if (s->left_intra_ctx[row7]) {
1801  c = 2;
1802  } else if (s->left_comp_ctx[row7]) {
1803  c = 4 * (s->left_ref_ctx[row7] != s->varcompref[1]);
1804  } else {
1805  c = 3 * (s->left_ref_ctx[row7] != s->varcompref[1]);
1806  }
1807  } else {
1808  c = 2;
1809  }
1810  bit = vp56_rac_get_prob(&s->c, s->prob.p.comp_ref[c]);
1811  b->ref[var_idx] = s->varcompref[bit];
1812  s->counts.comp_ref[c][bit]++;
1813  } else /* single reference */ {
1814  int bit, c;
1815 
1816  if (have_a && !s->above_intra_ctx[col]) {
1817  if (have_l && !s->left_intra_ctx[row7]) {
1818  if (s->left_comp_ctx[row7]) {
1819  if (s->above_comp_ctx[col]) {
1820  c = 1 + (!s->fixcompref || !s->left_ref_ctx[row7] ||
1821  !s->above_ref_ctx[col]);
1822  } else {
1823  c = (3 * !s->above_ref_ctx[col]) +
1824  (!s->fixcompref || !s->left_ref_ctx[row7]);
1825  }
1826  } else if (s->above_comp_ctx[col]) {
1827  c = (3 * !s->left_ref_ctx[row7]) +
1828  (!s->fixcompref || !s->above_ref_ctx[col]);
1829  } else {
1830  c = 2 * !s->left_ref_ctx[row7] + 2 * !s->above_ref_ctx[col];
1831  }
1832  } else if (s->above_intra_ctx[col]) {
1833  c = 2;
1834  } else if (s->above_comp_ctx[col]) {
1835  c = 1 + (!s->fixcompref || !s->above_ref_ctx[col]);
1836  } else {
1837  c = 4 * (!s->above_ref_ctx[col]);
1838  }
1839  } else if (have_l && !s->left_intra_ctx[row7]) {
1840  if (s->left_intra_ctx[row7]) {
1841  c = 2;
1842  } else if (s->left_comp_ctx[row7]) {
1843  c = 1 + (!s->fixcompref || !s->left_ref_ctx[row7]);
1844  } else {
1845  c = 4 * (!s->left_ref_ctx[row7]);
1846  }
1847  } else {
1848  c = 2;
1849  }
1850  bit = vp56_rac_get_prob(&s->c, s->prob.p.single_ref[c][0]);
1851  s->counts.single_ref[c][0][bit]++;
1852  if (!bit) {
1853  b->ref[0] = 0;
1854  } else {
1855  // FIXME can this codeblob be replaced by some sort of LUT?
1856  if (have_a) {
1857  if (have_l) {
1858  if (s->left_intra_ctx[row7]) {
1859  if (s->above_intra_ctx[col]) {
1860  c = 2;
1861  } else if (s->above_comp_ctx[col]) {
1862  c = 1 + 2 * (s->fixcompref == 1 ||
1863  s->above_ref_ctx[col] == 1);
1864  } else if (!s->above_ref_ctx[col]) {
1865  c = 3;
1866  } else {
1867  c = 4 * (s->above_ref_ctx[col] == 1);
1868  }
1869  } else if (s->above_intra_ctx[col]) {
1870  if (s->left_intra_ctx[row7]) {
1871  c = 2;
1872  } else if (s->left_comp_ctx[row7]) {
1873  c = 1 + 2 * (s->fixcompref == 1 ||
1874  s->left_ref_ctx[row7] == 1);
1875  } else if (!s->left_ref_ctx[row7]) {
1876  c = 3;
1877  } else {
1878  c = 4 * (s->left_ref_ctx[row7] == 1);
1879  }
1880  } else if (s->above_comp_ctx[col]) {
1881  if (s->left_comp_ctx[row7]) {
1882  if (s->left_ref_ctx[row7] == s->above_ref_ctx[col]) {
1883  c = 3 * (s->fixcompref == 1 ||
1884  s->left_ref_ctx[row7] == 1);
1885  } else {
1886  c = 2;
1887  }
1888  } else if (!s->left_ref_ctx[row7]) {
1889  c = 1 + 2 * (s->fixcompref == 1 ||
1890  s->above_ref_ctx[col] == 1);
1891  } else {
1892  c = 3 * (s->left_ref_ctx[row7] == 1) +
1893  (s->fixcompref == 1 || s->above_ref_ctx[col] == 1);
1894  }
1895  } else if (s->left_comp_ctx[row7]) {
1896  if (!s->above_ref_ctx[col]) {
1897  c = 1 + 2 * (s->fixcompref == 1 ||
1898  s->left_ref_ctx[row7] == 1);
1899  } else {
1900  c = 3 * (s->above_ref_ctx[col] == 1) +
1901  (s->fixcompref == 1 || s->left_ref_ctx[row7] == 1);
1902  }
1903  } else if (!s->above_ref_ctx[col]) {
1904  if (!s->left_ref_ctx[row7]) {
1905  c = 3;
1906  } else {
1907  c = 4 * (s->left_ref_ctx[row7] == 1);
1908  }
1909  } else if (!s->left_ref_ctx[row7]) {
1910  c = 4 * (s->above_ref_ctx[col] == 1);
1911  } else {
1912  c = 2 * (s->left_ref_ctx[row7] == 1) +
1913  2 * (s->above_ref_ctx[col] == 1);
1914  }
1915  } else {
1916  if (s->above_intra_ctx[col] ||
1917  (!s->above_comp_ctx[col] && !s->above_ref_ctx[col])) {
1918  c = 2;
1919  } else if (s->above_comp_ctx[col]) {
1920  c = 3 * (s->fixcompref == 1 || s->above_ref_ctx[col] == 1);
1921  } else {
1922  c = 4 * (s->above_ref_ctx[col] == 1);
1923  }
1924  }
1925  } else if (have_l) {
1926  if (s->left_intra_ctx[row7] ||
1927  (!s->left_comp_ctx[row7] && !s->left_ref_ctx[row7])) {
1928  c = 2;
1929  } else if (s->left_comp_ctx[row7]) {
1930  c = 3 * (s->fixcompref == 1 || s->left_ref_ctx[row7] == 1);
1931  } else {
1932  c = 4 * (s->left_ref_ctx[row7] == 1);
1933  }
1934  } else {
1935  c = 2;
1936  }
1937  bit = vp56_rac_get_prob(&s->c, s->prob.p.single_ref[c][1]);
1938  s->counts.single_ref[c][1][bit]++;
1939  b->ref[0] = 1 + bit;
1940  }
1941  }
1942  }
1943 
1944  if (b->bs <= BS_8x8) {
1945  if (s->segmentation.enabled && s->segmentation.feat[b->seg_id].skip_enabled) {
1946  b->mode[0] = b->mode[1] = b->mode[2] = b->mode[3] = ZEROMV;
1947  } else {
1948  static const uint8_t off[10] = {
1949  3, 0, 0, 1, 0, 0, 0, 0, 0, 0
1950  };
1951 
1952  // FIXME this needs to use the LUT tables from find_ref_mvs
1953  // because not all are -1,0/0,-1
1954  int c = inter_mode_ctx_lut[s->above_mode_ctx[col + off[b->bs]]]
1955  [s->left_mode_ctx[row7 + off[b->bs]]];
1956 
1957  b->mode[0] = vp8_rac_get_tree(&s->c, vp9_inter_mode_tree,
1958  s->prob.p.mv_mode[c]);
1959  b->mode[1] = b->mode[2] = b->mode[3] = b->mode[0];
1960  s->counts.mv_mode[c][b->mode[0] - 10]++;
1961  }
1962  }
1963 
1964  if (s->filtermode == FILTER_SWITCHABLE) {
1965  int c;
1966 
1967  if (have_a && s->above_mode_ctx[col] >= NEARESTMV) {
1968  if (have_l && s->left_mode_ctx[row7] >= NEARESTMV) {
1969  c = s->above_filter_ctx[col] == s->left_filter_ctx[row7] ?
1970  s->left_filter_ctx[row7] : 3;
1971  } else {
1972  c = s->above_filter_ctx[col];
1973  }
1974  } else if (have_l && s->left_mode_ctx[row7] >= NEARESTMV) {
1975  c = s->left_filter_ctx[row7];
1976  } else {
1977  c = 3;
1978  }
1979 
1980  filter_id = vp8_rac_get_tree(&s->c, vp9_filter_tree,
1981  s->prob.p.filter[c]);
1982  s->counts.filter[c][filter_id]++;
1983  b->filter = vp9_filter_lut[filter_id];
1984  } else {
1985  b->filter = s->filtermode;
1986  }
1987 
1988  if (b->bs > BS_8x8) {
1989  int c = inter_mode_ctx_lut[s->above_mode_ctx[col]][s->left_mode_ctx[row7]];
1990 
1991  b->mode[0] = vp8_rac_get_tree(&s->c, vp9_inter_mode_tree,
1992  s->prob.p.mv_mode[c]);
1993  s->counts.mv_mode[c][b->mode[0] - 10]++;
1994  fill_mv(s, b->mv[0], b->mode[0], 0);
1995 
1996  if (b->bs != BS_8x4) {
1997  b->mode[1] = vp8_rac_get_tree(&s->c, vp9_inter_mode_tree,
1998  s->prob.p.mv_mode[c]);
1999  s->counts.mv_mode[c][b->mode[1] - 10]++;
2000  fill_mv(s, b->mv[1], b->mode[1], 1);
2001  } else {
2002  b->mode[1] = b->mode[0];
2003  AV_COPY32(&b->mv[1][0], &b->mv[0][0]);
2004  AV_COPY32(&b->mv[1][1], &b->mv[0][1]);
2005  }
2006 
2007  if (b->bs != BS_4x8) {
2008  b->mode[2] = vp8_rac_get_tree(&s->c, vp9_inter_mode_tree,
2009  s->prob.p.mv_mode[c]);
2010  s->counts.mv_mode[c][b->mode[2] - 10]++;
2011  fill_mv(s, b->mv[2], b->mode[2], 2);
2012 
2013  if (b->bs != BS_8x4) {
2014  b->mode[3] = vp8_rac_get_tree(&s->c, vp9_inter_mode_tree,
2015  s->prob.p.mv_mode[c]);
2016  s->counts.mv_mode[c][b->mode[3] - 10]++;
2017  fill_mv(s, b->mv[3], b->mode[3], 3);
2018  } else {
2019  b->mode[3] = b->mode[2];
2020  AV_COPY32(&b->mv[3][0], &b->mv[2][0]);
2021  AV_COPY32(&b->mv[3][1], &b->mv[2][1]);
2022  }
2023  } else {
2024  b->mode[2] = b->mode[0];
2025  AV_COPY32(&b->mv[2][0], &b->mv[0][0]);
2026  AV_COPY32(&b->mv[2][1], &b->mv[0][1]);
2027  b->mode[3] = b->mode[1];
2028  AV_COPY32(&b->mv[3][0], &b->mv[1][0]);
2029  AV_COPY32(&b->mv[3][1], &b->mv[1][1]);
2030  }
2031  } else {
2032  fill_mv(s, b->mv[0], b->mode[0], -1);
2033  AV_COPY32(&b->mv[1][0], &b->mv[0][0]);
2034  AV_COPY32(&b->mv[2][0], &b->mv[0][0]);
2035  AV_COPY32(&b->mv[3][0], &b->mv[0][0]);
2036  AV_COPY32(&b->mv[1][1], &b->mv[0][1]);
2037  AV_COPY32(&b->mv[2][1], &b->mv[0][1]);
2038  AV_COPY32(&b->mv[3][1], &b->mv[0][1]);
2039  }
2040 
2041  vref = b->ref[b->comp ? s->signbias[s->varcompref[0]] : 0];
2042  }
2043 
2044 #if HAVE_FAST_64BIT
2045 #define SPLAT_CTX(var, val, n) \
2046  switch (n) { \
2047  case 1: var = val; break; \
2048  case 2: AV_WN16A(&var, val * 0x0101); break; \
2049  case 4: AV_WN32A(&var, val * 0x01010101); break; \
2050  case 8: AV_WN64A(&var, val * 0x0101010101010101ULL); break; \
2051  case 16: { \
2052  uint64_t v64 = val * 0x0101010101010101ULL; \
2053  AV_WN64A( &var, v64); \
2054  AV_WN64A(&((uint8_t *) &var)[8], v64); \
2055  break; \
2056  } \
2057  }
2058 #else
2059 #define SPLAT_CTX(var, val, n) \
2060  switch (n) { \
2061  case 1: var = val; break; \
2062  case 2: AV_WN16A(&var, val * 0x0101); break; \
2063  case 4: AV_WN32A(&var, val * 0x01010101); break; \
2064  case 8: { \
2065  uint32_t v32 = val * 0x01010101; \
2066  AV_WN32A( &var, v32); \
2067  AV_WN32A(&((uint8_t *) &var)[4], v32); \
2068  break; \
2069  } \
2070  case 16: { \
2071  uint32_t v32 = val * 0x01010101; \
2072  AV_WN32A( &var, v32); \
2073  AV_WN32A(&((uint8_t *) &var)[4], v32); \
2074  AV_WN32A(&((uint8_t *) &var)[8], v32); \
2075  AV_WN32A(&((uint8_t *) &var)[12], v32); \
2076  break; \
2077  } \
2078  }
2079 #endif
2080 
2081  switch (bwh_tab[1][b->bs][0]) {
2082 #define SET_CTXS(dir, off, n) \
2083  do { \
2084  SPLAT_CTX(s->dir##_skip_ctx[off], b->skip, n); \
2085  SPLAT_CTX(s->dir##_txfm_ctx[off], b->tx, n); \
2086  SPLAT_CTX(s->dir##_partition_ctx[off], dir##_ctx[b->bs], n); \
2087  if (!s->keyframe && !s->intraonly) { \
2088  SPLAT_CTX(s->dir##_intra_ctx[off], b->intra, n); \
2089  SPLAT_CTX(s->dir##_comp_ctx[off], b->comp, n); \
2090  SPLAT_CTX(s->dir##_mode_ctx[off], b->mode[3], n); \
2091  if (!b->intra) { \
2092  SPLAT_CTX(s->dir##_ref_ctx[off], vref, n); \
2093  if (s->filtermode == FILTER_SWITCHABLE) { \
2094  SPLAT_CTX(s->dir##_filter_ctx[off], filter_id, n); \
2095  } \
2096  } \
2097  } \
2098  } while (0)
2099  case 1: SET_CTXS(above, col, 1); break;
2100  case 2: SET_CTXS(above, col, 2); break;
2101  case 4: SET_CTXS(above, col, 4); break;
2102  case 8: SET_CTXS(above, col, 8); break;
2103  }
2104  switch (bwh_tab[1][b->bs][1]) {
2105  case 1: SET_CTXS(left, row7, 1); break;
2106  case 2: SET_CTXS(left, row7, 2); break;
2107  case 4: SET_CTXS(left, row7, 4); break;
2108  case 8: SET_CTXS(left, row7, 8); break;
2109  }
2110 #undef SPLAT_CTX
2111 #undef SET_CTXS
2112 
2113  if (!s->keyframe && !s->intraonly) {
2114  if (b->bs > BS_8x8) {
2115  int mv0 = AV_RN32A(&b->mv[3][0]), mv1 = AV_RN32A(&b->mv[3][1]);
2116 
2117  AV_COPY32(&s->left_mv_ctx[row7 * 2 + 0][0], &b->mv[1][0]);
2118  AV_COPY32(&s->left_mv_ctx[row7 * 2 + 0][1], &b->mv[1][1]);
2119  AV_WN32A(&s->left_mv_ctx[row7 * 2 + 1][0], mv0);
2120  AV_WN32A(&s->left_mv_ctx[row7 * 2 + 1][1], mv1);
2121  AV_COPY32(&s->above_mv_ctx[col * 2 + 0][0], &b->mv[2][0]);
2122  AV_COPY32(&s->above_mv_ctx[col * 2 + 0][1], &b->mv[2][1]);
2123  AV_WN32A(&s->above_mv_ctx[col * 2 + 1][0], mv0);
2124  AV_WN32A(&s->above_mv_ctx[col * 2 + 1][1], mv1);
2125  } else {
2126  int n, mv0 = AV_RN32A(&b->mv[3][0]), mv1 = AV_RN32A(&b->mv[3][1]);
2127 
2128  for (n = 0; n < w4 * 2; n++) {
2129  AV_WN32A(&s->above_mv_ctx[col * 2 + n][0], mv0);
2130  AV_WN32A(&s->above_mv_ctx[col * 2 + n][1], mv1);
2131  }
2132  for (n = 0; n < h4 * 2; n++) {
2133  AV_WN32A(&s->left_mv_ctx[row7 * 2 + n][0], mv0);
2134  AV_WN32A(&s->left_mv_ctx[row7 * 2 + n][1], mv1);
2135  }
2136  }
2137  }
2138 
2139  // FIXME kinda ugly
2140  for (y = 0; y < h4; y++) {
2141  int x, o = (row + y) * s->sb_cols * 8 + col;
2142  struct VP9mvrefPair *mv = &s->frames[CUR_FRAME].mv[o];
2143 
2144  if (b->intra) {
2145  for (x = 0; x < w4; x++) {
2146  mv[x].ref[0] =
2147  mv[x].ref[1] = -1;
2148  }
2149  } else if (b->comp) {
2150  for (x = 0; x < w4; x++) {
2151  mv[x].ref[0] = b->ref[0];
2152  mv[x].ref[1] = b->ref[1];
2153  AV_COPY32(&mv[x].mv[0], &b->mv[3][0]);
2154  AV_COPY32(&mv[x].mv[1], &b->mv[3][1]);
2155  }
2156  } else {
2157  for (x = 0; x < w4; x++) {
2158  mv[x].ref[0] = b->ref[0];
2159  mv[x].ref[1] = -1;
2160  AV_COPY32(&mv[x].mv[0], &b->mv[3][0]);
2161  }
2162  }
2163  }
2164 }
2165 
2166 // FIXME merge cnt/eob arguments?
2167 static av_always_inline int
2168 decode_coeffs_b_generic(VP56RangeCoder *c, int16_t *coef, int n_coeffs,
2169  int is_tx32x32, int is8bitsperpixel, int bpp, unsigned (*cnt)[6][3],
2170  unsigned (*eob)[6][2], uint8_t (*p)[6][11],
2171  int nnz, const int16_t *scan, const int16_t (*nb)[2],
2172  const int16_t *band_counts, const int16_t *qmul)
2173 {
2174  int i = 0, band = 0, band_left = band_counts[band];
2175  uint8_t *tp = p[0][nnz];
2176  uint8_t cache[1024];
2177 
2178  do {
2179  int val, rc;
2180 
2181  val = vp56_rac_get_prob_branchy(c, tp[0]); // eob
2182  eob[band][nnz][val]++;
2183  if (!val)
2184  break;
2185 
2186  skip_eob:
2187  if (!vp56_rac_get_prob_branchy(c, tp[1])) { // zero
2188  cnt[band][nnz][0]++;
2189  if (!--band_left)
2190  band_left = band_counts[++band];
2191  cache[scan[i]] = 0;
2192  nnz = (1 + cache[nb[i][0]] + cache[nb[i][1]]) >> 1;
2193  tp = p[band][nnz];
2194  if (++i == n_coeffs)
2195  break; //invalid input; blocks should end with EOB
2196  goto skip_eob;
2197  }
2198 
2199  rc = scan[i];
2200  if (!vp56_rac_get_prob_branchy(c, tp[2])) { // one
2201  cnt[band][nnz][1]++;
2202  val = 1;
2203  cache[rc] = 1;
2204  } else {
2205  // fill in p[3-10] (model fill) - only once per frame for each pos
2206  if (!tp[3])
2207  memcpy(&tp[3], vp9_model_pareto8[tp[2]], 8);
2208 
2209  cnt[band][nnz][2]++;
2210  if (!vp56_rac_get_prob_branchy(c, tp[3])) { // 2, 3, 4
2211  if (!vp56_rac_get_prob_branchy(c, tp[4])) {
2212  cache[rc] = val = 2;
2213  } else {
2214  val = 3 + vp56_rac_get_prob(c, tp[5]);
2215  cache[rc] = 3;
2216  }
2217  } else if (!vp56_rac_get_prob_branchy(c, tp[6])) { // cat1/2
2218  cache[rc] = 4;
2219  if (!vp56_rac_get_prob_branchy(c, tp[7])) {
2220  val = 5 + vp56_rac_get_prob(c, 159);
2221  } else {
2222  val = 7 + (vp56_rac_get_prob(c, 165) << 1);
2223  val += vp56_rac_get_prob(c, 145);
2224  }
2225  } else { // cat 3-6
2226  cache[rc] = 5;
2227  if (!vp56_rac_get_prob_branchy(c, tp[8])) {
2228  if (!vp56_rac_get_prob_branchy(c, tp[9])) {
2229  val = 11 + (vp56_rac_get_prob(c, 173) << 2);
2230  val += (vp56_rac_get_prob(c, 148) << 1);
2231  val += vp56_rac_get_prob(c, 140);
2232  } else {
2233  val = 19 + (vp56_rac_get_prob(c, 176) << 3);
2234  val += (vp56_rac_get_prob(c, 155) << 2);
2235  val += (vp56_rac_get_prob(c, 140) << 1);
2236  val += vp56_rac_get_prob(c, 135);
2237  }
2238  } else if (!vp56_rac_get_prob_branchy(c, tp[10])) {
2239  val = 35 + (vp56_rac_get_prob(c, 180) << 4);
2240  val += (vp56_rac_get_prob(c, 157) << 3);
2241  val += (vp56_rac_get_prob(c, 141) << 2);
2242  val += (vp56_rac_get_prob(c, 134) << 1);
2243  val += vp56_rac_get_prob(c, 130);
2244  } else {
2245  val = 67;
2246  if (!is8bitsperpixel) {
2247  if (bpp == 12) {
2248  val += vp56_rac_get_prob(c, 255) << 17;
2249  val += vp56_rac_get_prob(c, 255) << 16;
2250  }
2251  val += (vp56_rac_get_prob(c, 255) << 15);
2252  val += (vp56_rac_get_prob(c, 255) << 14);
2253  }
2254  val += (vp56_rac_get_prob(c, 254) << 13);
2255  val += (vp56_rac_get_prob(c, 254) << 12);
2256  val += (vp56_rac_get_prob(c, 254) << 11);
2257  val += (vp56_rac_get_prob(c, 252) << 10);
2258  val += (vp56_rac_get_prob(c, 249) << 9);
2259  val += (vp56_rac_get_prob(c, 243) << 8);
2260  val += (vp56_rac_get_prob(c, 230) << 7);
2261  val += (vp56_rac_get_prob(c, 196) << 6);
2262  val += (vp56_rac_get_prob(c, 177) << 5);
2263  val += (vp56_rac_get_prob(c, 153) << 4);
2264  val += (vp56_rac_get_prob(c, 140) << 3);
2265  val += (vp56_rac_get_prob(c, 133) << 2);
2266  val += (vp56_rac_get_prob(c, 130) << 1);
2267  val += vp56_rac_get_prob(c, 129);
2268  }
2269  }
2270  }
2271 #define STORE_COEF(c, i, v) do { \
2272  if (is8bitsperpixel) { \
2273  c[i] = v; \
2274  } else { \
2275  AV_WN32A(&c[i * 2], v); \
2276  } \
2277 } while (0)
2278  if (!--band_left)
2279  band_left = band_counts[++band];
2280  if (is_tx32x32)
2281  STORE_COEF(coef, rc, ((vp8_rac_get(c) ? -val : val) * qmul[!!i]) / 2);
2282  else
2283  STORE_COEF(coef, rc, (vp8_rac_get(c) ? -val : val) * qmul[!!i]);
2284  nnz = (1 + cache[nb[i][0]] + cache[nb[i][1]]) >> 1;
2285  tp = p[band][nnz];
2286  } while (++i < n_coeffs);
2287 
2288  return i;
2289 }
2290 
2291 static int decode_coeffs_b_8bpp(VP9Context *s, int16_t *coef, int n_coeffs,
2292  unsigned (*cnt)[6][3], unsigned (*eob)[6][2],
2293  uint8_t (*p)[6][11], int nnz, const int16_t *scan,
2294  const int16_t (*nb)[2], const int16_t *band_counts,
2295  const int16_t *qmul)
2296 {
2297  return decode_coeffs_b_generic(&s->c, coef, n_coeffs, 0, 1, 8, cnt, eob, p,
2298  nnz, scan, nb, band_counts, qmul);
2299 }
2300 
2301 static int decode_coeffs_b32_8bpp(VP9Context *s, int16_t *coef, int n_coeffs,
2302  unsigned (*cnt)[6][3], unsigned (*eob)[6][2],
2303  uint8_t (*p)[6][11], int nnz, const int16_t *scan,
2304  const int16_t (*nb)[2], const int16_t *band_counts,
2305  const int16_t *qmul)
2306 {
2307  return decode_coeffs_b_generic(&s->c, coef, n_coeffs, 1, 1, 8, cnt, eob, p,
2308  nnz, scan, nb, band_counts, qmul);
2309 }
2310 
2311 static int decode_coeffs_b_16bpp(VP9Context *s, int16_t *coef, int n_coeffs,
2312  unsigned (*cnt)[6][3], unsigned (*eob)[6][2],
2313  uint8_t (*p)[6][11], int nnz, const int16_t *scan,
2314  const int16_t (*nb)[2], const int16_t *band_counts,
2315  const int16_t *qmul)
2316 {
2317  return decode_coeffs_b_generic(&s->c, coef, n_coeffs, 0, 0, s->bpp, cnt, eob, p,
2318  nnz, scan, nb, band_counts, qmul);
2319 }
2320 
2321 static int decode_coeffs_b32_16bpp(VP9Context *s, int16_t *coef, int n_coeffs,
2322  unsigned (*cnt)[6][3], unsigned (*eob)[6][2],
2323  uint8_t (*p)[6][11], int nnz, const int16_t *scan,
2324  const int16_t (*nb)[2], const int16_t *band_counts,
2325  const int16_t *qmul)
2326 {
2327  return decode_coeffs_b_generic(&s->c, coef, n_coeffs, 1, 0, s->bpp, cnt, eob, p,
2328  nnz, scan, nb, band_counts, qmul);
2329 }
2330 
2331 static av_always_inline int decode_coeffs(AVCodecContext *ctx, int is8bitsperpixel)
2332 {
2333  VP9Context *s = ctx->priv_data;
2334  VP9Block *b = s->b;
2335  int row = s->row, col = s->col;
2336  uint8_t (*p)[6][11] = s->prob.coef[b->tx][0 /* y */][!b->intra];
2337  unsigned (*c)[6][3] = s->counts.coef[b->tx][0 /* y */][!b->intra];
2338  unsigned (*e)[6][2] = s->counts.eob[b->tx][0 /* y */][!b->intra];
2339  int w4 = bwh_tab[1][b->bs][0] << 1, h4 = bwh_tab[1][b->bs][1] << 1;
2340  int end_x = FFMIN(2 * (s->cols - col), w4);
2341  int end_y = FFMIN(2 * (s->rows - row), h4);
2342  int n, pl, x, y, res;
2343  int16_t (*qmul)[2] = s->segmentation.feat[b->seg_id].qmul;
2344  int tx = 4 * s->lossless + b->tx;
2345  const int16_t * const *yscans = vp9_scans[tx];
2346  const int16_t (* const *ynbs)[2] = vp9_scans_nb[tx];
2347  const int16_t *uvscan = vp9_scans[b->uvtx][DCT_DCT];
2348  const int16_t (*uvnb)[2] = vp9_scans_nb[b->uvtx][DCT_DCT];
2349  uint8_t *a = &s->above_y_nnz_ctx[col * 2];
2350  uint8_t *l = &s->left_y_nnz_ctx[(row & 7) << 1];
2351  static const int16_t band_counts[4][8] = {
2352  { 1, 2, 3, 4, 3, 16 - 13 },
2353  { 1, 2, 3, 4, 11, 64 - 21 },
2354  { 1, 2, 3, 4, 11, 256 - 21 },
2355  { 1, 2, 3, 4, 11, 1024 - 21 },
2356  };
2357  const int16_t *y_band_counts = band_counts[b->tx];
2358  const int16_t *uv_band_counts = band_counts[b->uvtx];
2359  int bytesperpixel = is8bitsperpixel ? 1 : 2;
2360  int total_coeff = 0;
2361 
2362 #define MERGE(la, end, step, rd) \
2363  for (n = 0; n < end; n += step) \
2364  la[n] = !!rd(&la[n])
2365 #define MERGE_CTX(step, rd) \
2366  do { \
2367  MERGE(l, end_y, step, rd); \
2368  MERGE(a, end_x, step, rd); \
2369  } while (0)
2370 
2371 #define DECODE_Y_COEF_LOOP(step, mode_index, v) \
2372  for (n = 0, y = 0; y < end_y; y += step) { \
2373  for (x = 0; x < end_x; x += step, n += step * step) { \
2374  enum TxfmType txtp = vp9_intra_txfm_type[b->mode[mode_index]]; \
2375  res = (is8bitsperpixel ? decode_coeffs_b##v##_8bpp : decode_coeffs_b##v##_16bpp) \
2376  (s, s->block + 16 * n * bytesperpixel, 16 * step * step, \
2377  c, e, p, a[x] + l[y], yscans[txtp], \
2378  ynbs[txtp], y_band_counts, qmul[0]); \
2379  a[x] = l[y] = !!res; \
2380  total_coeff |= !!res; \
2381  if (step >= 4) { \
2382  AV_WN16A(&s->eob[n], res); \
2383  } else { \
2384  s->eob[n] = res; \
2385  } \
2386  } \
2387  }
2388 
2389 #define SPLAT(la, end, step, cond) \
2390  if (step == 2) { \
2391  for (n = 1; n < end; n += step) \
2392  la[n] = la[n - 1]; \
2393  } else if (step == 4) { \
2394  if (cond) { \
2395  for (n = 0; n < end; n += step) \
2396  AV_WN32A(&la[n], la[n] * 0x01010101); \
2397  } else { \
2398  for (n = 0; n < end; n += step) \
2399  memset(&la[n + 1], la[n], FFMIN(end - n - 1, 3)); \
2400  } \
2401  } else /* step == 8 */ { \
2402  if (cond) { \
2403  if (HAVE_FAST_64BIT) { \
2404  for (n = 0; n < end; n += step) \
2405  AV_WN64A(&la[n], la[n] * 0x0101010101010101ULL); \
2406  } else { \
2407  for (n = 0; n < end; n += step) { \
2408  uint32_t v32 = la[n] * 0x01010101; \
2409  AV_WN32A(&la[n], v32); \
2410  AV_WN32A(&la[n + 4], v32); \
2411  } \
2412  } \
2413  } else { \
2414  for (n = 0; n < end; n += step) \
2415  memset(&la[n + 1], la[n], FFMIN(end - n - 1, 7)); \
2416  } \
2417  }
2418 #define SPLAT_CTX(step) \
2419  do { \
2420  SPLAT(a, end_x, step, end_x == w4); \
2421  SPLAT(l, end_y, step, end_y == h4); \
2422  } while (0)
2423 
2424  /* y tokens */
2425  switch (b->tx) {
2426  case TX_4X4:
2427  DECODE_Y_COEF_LOOP(1, b->bs > BS_8x8 ? n : 0,);
2428  break;
2429  case TX_8X8:
2430  MERGE_CTX(2, AV_RN16A);
2431  DECODE_Y_COEF_LOOP(2, 0,);
2432  SPLAT_CTX(2);
2433  break;
2434  case TX_16X16:
2435  MERGE_CTX(4, AV_RN32A);
2436  DECODE_Y_COEF_LOOP(4, 0,);
2437  SPLAT_CTX(4);
2438  break;
2439  case TX_32X32:
2440  MERGE_CTX(8, AV_RN64A);
2441  DECODE_Y_COEF_LOOP(8, 0, 32);
2442  SPLAT_CTX(8);
2443  break;
2444  }
2445 
2446 #define DECODE_UV_COEF_LOOP(step, v) \
2447  for (n = 0, y = 0; y < end_y; y += step) { \
2448  for (x = 0; x < end_x; x += step, n += step * step) { \
2449  res = (is8bitsperpixel ? decode_coeffs_b##v##_8bpp : decode_coeffs_b##v##_16bpp) \
2450  (s, s->uvblock[pl] + 16 * n * bytesperpixel, \
2451  16 * step * step, c, e, p, a[x] + l[y], \
2452  uvscan, uvnb, uv_band_counts, qmul[1]); \
2453  a[x] = l[y] = !!res; \
2454  total_coeff |= !!res; \
2455  if (step >= 4) { \
2456  AV_WN16A(&s->uveob[pl][n], res); \
2457  } else { \
2458  s->uveob[pl][n] = res; \
2459  } \
2460  } \
2461  }
2462 
2463  p = s->prob.coef[b->uvtx][1 /* uv */][!b->intra];
2464  c = s->counts.coef[b->uvtx][1 /* uv */][!b->intra];
2465  e = s->counts.eob[b->uvtx][1 /* uv */][!b->intra];
2466  w4 >>= s->ss_h;
2467  end_x >>= s->ss_h;
2468  h4 >>= s->ss_v;
2469  end_y >>= s->ss_v;
2470  for (pl = 0; pl < 2; pl++) {
2471  a = &s->above_uv_nnz_ctx[pl][col << !s->ss_h];
2472  l = &s->left_uv_nnz_ctx[pl][(row & 7) << !s->ss_v];
2473  switch (b->uvtx) {
2474  case TX_4X4:
2475  DECODE_UV_COEF_LOOP(1,);
2476  break;
2477  case TX_8X8:
2478  MERGE_CTX(2, AV_RN16A);
2479  DECODE_UV_COEF_LOOP(2,);
2480  SPLAT_CTX(2);
2481  break;
2482  case TX_16X16:
2483  MERGE_CTX(4, AV_RN32A);
2484  DECODE_UV_COEF_LOOP(4,);
2485  SPLAT_CTX(4);
2486  break;
2487  case TX_32X32:
2488  MERGE_CTX(8, AV_RN64A);
2489  DECODE_UV_COEF_LOOP(8, 32);
2490  SPLAT_CTX(8);
2491  break;
2492  }
2493  }
2494 
2495  return total_coeff;
2496 }
2497 
2498 static int decode_coeffs_8bpp(AVCodecContext *ctx)
2499 {
2500  return decode_coeffs(ctx, 1);
2501 }
2502 
2503 static int decode_coeffs_16bpp(AVCodecContext *ctx)
2504 {
2505  return decode_coeffs(ctx, 0);
2506 }
2507 
2508 static av_always_inline int check_intra_mode(VP9Context *s, int mode, uint8_t **a,
2509  uint8_t *dst_edge, ptrdiff_t stride_edge,
2510  uint8_t *dst_inner, ptrdiff_t stride_inner,
2511  uint8_t *l, int col, int x, int w,
2512  int row, int y, enum TxfmMode tx,
2513  int p, int ss_h, int ss_v, int bytesperpixel)
2514 {
2515  int have_top = row > 0 || y > 0;
2516  int have_left = col > s->tiling.tile_col_start || x > 0;
2517  int have_right = x < w - 1;
2518  int bpp = s->bpp;
2519  static const uint8_t mode_conv[10][2 /* have_left */][2 /* have_top */] = {
2520  [VERT_PRED] = { { DC_127_PRED, VERT_PRED },
2521  { DC_127_PRED, VERT_PRED } },
2522  [HOR_PRED] = { { DC_129_PRED, DC_129_PRED },
2523  { HOR_PRED, HOR_PRED } },
2524  [DC_PRED] = { { DC_128_PRED, TOP_DC_PRED },
2525  { LEFT_DC_PRED, DC_PRED } },
2526  [DIAG_DOWN_LEFT_PRED] = { { DC_127_PRED, DIAG_DOWN_LEFT_PRED },
2527  { DC_127_PRED, DIAG_DOWN_LEFT_PRED } },
2528  [DIAG_DOWN_RIGHT_PRED] = { { DIAG_DOWN_RIGHT_PRED, DIAG_DOWN_RIGHT_PRED },
2529  { DIAG_DOWN_RIGHT_PRED, DIAG_DOWN_RIGHT_PRED } },
2530  [VERT_RIGHT_PRED] = { { VERT_RIGHT_PRED, VERT_RIGHT_PRED },
2531  { VERT_RIGHT_PRED, VERT_RIGHT_PRED } },
2532  [HOR_DOWN_PRED] = { { HOR_DOWN_PRED, HOR_DOWN_PRED },
2533  { HOR_DOWN_PRED, HOR_DOWN_PRED } },
2534  [VERT_LEFT_PRED] = { { DC_127_PRED, VERT_LEFT_PRED },
2535  { DC_127_PRED, VERT_LEFT_PRED } },
2536  [HOR_UP_PRED] = { { DC_129_PRED, DC_129_PRED },
2537  { HOR_UP_PRED, HOR_UP_PRED } },
2538  [TM_VP8_PRED] = { { DC_129_PRED, VERT_PRED },
2539  { HOR_PRED, TM_VP8_PRED } },
2540  };
2541  static const struct {
2542  uint8_t needs_left:1;
2543  uint8_t needs_top:1;
2544  uint8_t needs_topleft:1;
2545  uint8_t needs_topright:1;
2546  uint8_t invert_left:1;
2547  } edges[N_INTRA_PRED_MODES] = {
2548  [VERT_PRED] = { .needs_top = 1 },
2549  [HOR_PRED] = { .needs_left = 1 },
2550  [DC_PRED] = { .needs_top = 1, .needs_left = 1 },
2551  [DIAG_DOWN_LEFT_PRED] = { .needs_top = 1, .needs_topright = 1 },
2552  [DIAG_DOWN_RIGHT_PRED] = { .needs_left = 1, .needs_top = 1, .needs_topleft = 1 },
2553  [VERT_RIGHT_PRED] = { .needs_left = 1, .needs_top = 1, .needs_topleft = 1 },
2554  [HOR_DOWN_PRED] = { .needs_left = 1, .needs_top = 1, .needs_topleft = 1 },
2555  [VERT_LEFT_PRED] = { .needs_top = 1, .needs_topright = 1 },
2556  [HOR_UP_PRED] = { .needs_left = 1, .invert_left = 1 },
2557  [TM_VP8_PRED] = { .needs_left = 1, .needs_top = 1, .needs_topleft = 1 },
2558  [LEFT_DC_PRED] = { .needs_left = 1 },
2559  [TOP_DC_PRED] = { .needs_top = 1 },
2560  [DC_128_PRED] = { 0 },
2561  [DC_127_PRED] = { 0 },
2562  [DC_129_PRED] = { 0 }
2563  };
2564 
2565  av_assert2(mode >= 0 && mode < 10);
2566  mode = mode_conv[mode][have_left][have_top];
2567  if (edges[mode].needs_top) {
2568  uint8_t *top, *topleft;
2569  int n_px_need = 4 << tx, n_px_have = (((s->cols - col) << !ss_h) - x) * 4;
2570  int n_px_need_tr = 0;
2571 
2572  if (tx == TX_4X4 && edges[mode].needs_topright && have_right)
2573  n_px_need_tr = 4;
2574 
2575  // if top of sb64-row, use s->intra_pred_data[] instead of
2576  // dst[-stride] for intra prediction (it contains pre- instead of
2577  // post-loopfilter data)
2578  if (have_top) {
2579  top = !(row & 7) && !y ?
2580  s->intra_pred_data[p] + (col * (8 >> ss_h) + x * 4) * bytesperpixel :
2581  y == 0 ? &dst_edge[-stride_edge] : &dst_inner[-stride_inner];
2582  if (have_left)
2583  topleft = !(row & 7) && !y ?
2584  s->intra_pred_data[p] + (col * (8 >> ss_h) + x * 4) * bytesperpixel :
2585  y == 0 || x == 0 ? &dst_edge[-stride_edge] :
2586  &dst_inner[-stride_inner];
2587  }
2588 
2589  if (have_top &&
2590  (!edges[mode].needs_topleft || (have_left && top == topleft)) &&
2591  (tx != TX_4X4 || !edges[mode].needs_topright || have_right) &&
2592  n_px_need + n_px_need_tr <= n_px_have) {
2593  *a = top;
2594  } else {
2595  if (have_top) {
2596  if (n_px_need <= n_px_have) {
2597  memcpy(*a, top, n_px_need * bytesperpixel);
2598  } else {
2599 #define memset_bpp(c, i1, v, i2, num) do { \
2600  if (bytesperpixel == 1) { \
2601  memset(&(c)[(i1)], (v)[(i2)], (num)); \
2602  } else { \
2603  int n, val = AV_RN16A(&(v)[(i2) * 2]); \
2604  for (n = 0; n < (num); n++) { \
2605  AV_WN16A(&(c)[((i1) + n) * 2], val); \
2606  } \
2607  } \
2608 } while (0)
2609  memcpy(*a, top, n_px_have * bytesperpixel);
2610  memset_bpp(*a, n_px_have, (*a), n_px_have - 1, n_px_need - n_px_have);
2611  }
2612  } else {
2613 #define memset_val(c, val, num) do { \
2614  if (bytesperpixel == 1) { \
2615  memset((c), (val), (num)); \
2616  } else { \
2617  int n; \
2618  for (n = 0; n < (num); n++) { \
2619  AV_WN16A(&(c)[n * 2], (val)); \
2620  } \
2621  } \
2622 } while (0)
2623  memset_val(*a, (128 << (bpp - 8)) - 1, n_px_need);
2624  }
2625  if (edges[mode].needs_topleft) {
2626  if (have_left && have_top) {
2627 #define assign_bpp(c, i1, v, i2) do { \
2628  if (bytesperpixel == 1) { \
2629  (c)[(i1)] = (v)[(i2)]; \
2630  } else { \
2631  AV_COPY16(&(c)[(i1) * 2], &(v)[(i2) * 2]); \
2632  } \
2633 } while (0)
2634  assign_bpp(*a, -1, topleft, -1);
2635  } else {
2636 #define assign_val(c, i, v) do { \
2637  if (bytesperpixel == 1) { \
2638  (c)[(i)] = (v); \
2639  } else { \
2640  AV_WN16A(&(c)[(i) * 2], (v)); \
2641  } \
2642 } while (0)
2643  assign_val((*a), -1, (128 << (bpp - 8)) + (have_top ? +1 : -1));
2644  }
2645  }
2646  if (tx == TX_4X4 && edges[mode].needs_topright) {
2647  if (have_top && have_right &&
2648  n_px_need + n_px_need_tr <= n_px_have) {
2649  memcpy(&(*a)[4 * bytesperpixel], &top[4 * bytesperpixel], 4 * bytesperpixel);
2650  } else {
2651  memset_bpp(*a, 4, *a, 3, 4);
2652  }
2653  }
2654  }
2655  }
2656  if (edges[mode].needs_left) {
2657  if (have_left) {
2658  int n_px_need = 4 << tx, i, n_px_have = (((s->rows - row) << !ss_v) - y) * 4;
2659  uint8_t *dst = x == 0 ? dst_edge : dst_inner;
2660  ptrdiff_t stride = x == 0 ? stride_edge : stride_inner;
2661 
2662  if (edges[mode].invert_left) {
2663  if (n_px_need <= n_px_have) {
2664  for (i = 0; i < n_px_need; i++)
2665  assign_bpp(l, i, &dst[i * stride], -1);
2666  } else {
2667  for (i = 0; i < n_px_have; i++)
2668  assign_bpp(l, i, &dst[i * stride], -1);
2669  memset_bpp(l, n_px_have, l, n_px_have - 1, n_px_need - n_px_have);
2670  }
2671  } else {
2672  if (n_px_need <= n_px_have) {
2673  for (i = 0; i < n_px_need; i++)
2674  assign_bpp(l, n_px_need - 1 - i, &dst[i * stride], -1);
2675  } else {
2676  for (i = 0; i < n_px_have; i++)
2677  assign_bpp(l, n_px_need - 1 - i, &dst[i * stride], -1);
2678  memset_bpp(l, 0, l, n_px_need - n_px_have, n_px_need - n_px_have);
2679  }
2680  }
2681  } else {
2682  memset_val(l, (128 << (bpp - 8)) + 1, 4 << tx);
2683  }
2684  }
2685 
2686  return mode;
2687 }
2688 
2689 static av_always_inline void intra_recon(AVCodecContext *ctx, ptrdiff_t y_off,
2690  ptrdiff_t uv_off, int bytesperpixel)
2691 {
2692  VP9Context *s = ctx->priv_data;
2693  VP9Block *b = s->b;
2694  int row = s->row, col = s->col;
2695  int w4 = bwh_tab[1][b->bs][0] << 1, step1d = 1 << b->tx, n;
2696  int h4 = bwh_tab[1][b->bs][1] << 1, x, y, step = 1 << (b->tx * 2);
2697  int end_x = FFMIN(2 * (s->cols - col), w4);
2698  int end_y = FFMIN(2 * (s->rows - row), h4);
2699  int tx = 4 * s->lossless + b->tx, uvtx = b->uvtx + 4 * s->lossless;
2700  int uvstep1d = 1 << b->uvtx, p;
2701  uint8_t *dst = s->dst[0], *dst_r = s->frames[CUR_FRAME].tf.f->data[0] + y_off;
2702  LOCAL_ALIGNED_32(uint8_t, a_buf, [96]);
2703  LOCAL_ALIGNED_32(uint8_t, l, [64]);
2704 
2705  for (n = 0, y = 0; y < end_y; y += step1d) {
2706  uint8_t *ptr = dst, *ptr_r = dst_r;
2707  for (x = 0; x < end_x; x += step1d, ptr += 4 * step1d * bytesperpixel,
2708  ptr_r += 4 * step1d * bytesperpixel, n += step) {
2709  int mode = b->mode[b->bs > BS_8x8 && b->tx == TX_4X4 ?
2710  y * 2 + x : 0];
2711  uint8_t *a = &a_buf[32];
2712  enum TxfmType txtp = vp9_intra_txfm_type[mode];
2713  int eob = b->skip ? 0 : b->tx > TX_8X8 ? AV_RN16A(&s->eob[n]) : s->eob[n];
2714 
2715  mode = check_intra_mode(s, mode, &a, ptr_r,
2716  s->frames[CUR_FRAME].tf.f->linesize[0],
2717  ptr, s->y_stride, l,
2718  col, x, w4, row, y, b->tx, 0, 0, 0, bytesperpixel);
2719  s->dsp.intra_pred[b->tx][mode](ptr, s->y_stride, l, a);
2720  if (eob)
2721  s->dsp.itxfm_add[tx][txtp](ptr, s->y_stride,
2722  s->block + 16 * n * bytesperpixel, eob);
2723  }
2724  dst_r += 4 * step1d * s->frames[CUR_FRAME].tf.f->linesize[0];
2725  dst += 4 * step1d * s->y_stride;
2726  }
2727 
2728  // U/V
2729  w4 >>= s->ss_h;
2730  end_x >>= s->ss_h;
2731  end_y >>= s->ss_v;
2732  step = 1 << (b->uvtx * 2);
2733  for (p = 0; p < 2; p++) {
2734  dst = s->dst[1 + p];
2735  dst_r = s->frames[CUR_FRAME].tf.f->data[1 + p] + uv_off;
2736  for (n = 0, y = 0; y < end_y; y += uvstep1d) {
2737  uint8_t *ptr = dst, *ptr_r = dst_r;
2738  for (x = 0; x < end_x; x += uvstep1d, ptr += 4 * uvstep1d * bytesperpixel,
2739  ptr_r += 4 * uvstep1d * bytesperpixel, n += step) {
2740  int mode = b->uvmode;
2741  uint8_t *a = &a_buf[32];
2742  int eob = b->skip ? 0 : b->uvtx > TX_8X8 ? AV_RN16A(&s->uveob[p][n]) : s->uveob[p][n];
2743 
2744  mode = check_intra_mode(s, mode, &a, ptr_r,
2745  s->frames[CUR_FRAME].tf.f->linesize[1],
2746  ptr, s->uv_stride, l, col, x, w4, row, y,
2747  b->uvtx, p + 1, s->ss_h, s->ss_v, bytesperpixel);
2748  s->dsp.intra_pred[b->uvtx][mode](ptr, s->uv_stride, l, a);
2749  if (eob)
2750  s->dsp.itxfm_add[uvtx][DCT_DCT](ptr, s->uv_stride,
2751  s->uvblock[p] + 16 * n * bytesperpixel, eob);
2752  }
2753  dst_r += 4 * uvstep1d * s->frames[CUR_FRAME].tf.f->linesize[1];
2754  dst += 4 * uvstep1d * s->uv_stride;
2755  }
2756  }
2757 }
2758 
2759 static void intra_recon_8bpp(AVCodecContext *ctx, ptrdiff_t y_off, ptrdiff_t uv_off)
2760 {
2761  intra_recon(ctx, y_off, uv_off, 1);
2762 }
2763 
2764 static void intra_recon_16bpp(AVCodecContext *ctx, ptrdiff_t y_off, ptrdiff_t uv_off)
2765 {
2766  intra_recon(ctx, y_off, uv_off, 2);
2767 }
2768 
2769 static av_always_inline void mc_luma_scaled(VP9Context *s, vp9_scaled_mc_func smc,
2770  uint8_t *dst, ptrdiff_t dst_stride,
2771  const uint8_t *ref, ptrdiff_t ref_stride,
2772  ThreadFrame *ref_frame,
2773  ptrdiff_t y, ptrdiff_t x, const VP56mv *in_mv,
2774  int px, int py, int pw, int ph,
2775  int bw, int bh, int w, int h, int bytesperpixel,
2776  const uint16_t *scale, const uint8_t *step)
2777 {
2778 #define scale_mv(n, dim) (((int64_t)(n) * scale[dim]) >> 14)
2779  int mx, my;
2780  int refbw_m1, refbh_m1;
2781  int th;
2782  VP56mv mv;
2783 
2784  mv.x = av_clip(in_mv->x, -(x + pw - px + 4) << 3, (s->cols * 8 - x + px + 3) << 3);
2785  mv.y = av_clip(in_mv->y, -(y + ph - py + 4) << 3, (s->rows * 8 - y + py + 3) << 3);
2786  // BUG libvpx seems to scale the two components separately. This introduces
2787  // rounding errors but we have to reproduce them to be exactly compatible
2788  // with the output from libvpx...
2789  mx = scale_mv(mv.x * 2, 0) + scale_mv(x * 16, 0);
2790  my = scale_mv(mv.y * 2, 1) + scale_mv(y * 16, 1);
2791 
2792  y = my >> 4;
2793  x = mx >> 4;
2794  ref += y * ref_stride + x * bytesperpixel;
2795  mx &= 15;
2796  my &= 15;
2797  refbw_m1 = ((bw - 1) * step[0] + mx) >> 4;
2798  refbh_m1 = ((bh - 1) * step[1] + my) >> 4;
2799  // FIXME bilinear filter only needs 0/1 pixels, not 3/4
2800  // we use +7 because the last 7 pixels of each sbrow can be changed in
2801  // the longest loopfilter of the next sbrow
2802  th = (y + refbh_m1 + 4 + 7) >> 6;
2803  ff_thread_await_progress(ref_frame, FFMAX(th, 0), 0);
2804  if (x < 3 || y < 3 || x + 4 >= w - refbw_m1 || y + 4 >= h - refbh_m1) {
2805  s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
2806  ref - 3 * ref_stride - 3 * bytesperpixel,
2807  288, ref_stride,
2808  refbw_m1 + 8, refbh_m1 + 8,
2809  x - 3, y - 3, w, h);
2810  ref = s->edge_emu_buffer + 3 * 288 + 3 * bytesperpixel;
2811  ref_stride = 288;
2812  }
2813  smc(dst, dst_stride, ref, ref_stride, bh, mx, my, step[0], step[1]);
2814 }
2815 
2816 static av_always_inline void mc_chroma_scaled(VP9Context *s, vp9_scaled_mc_func smc,
2817  uint8_t *dst_u, uint8_t *dst_v,
2818  ptrdiff_t dst_stride,
2819  const uint8_t *ref_u, ptrdiff_t src_stride_u,
2820  const uint8_t *ref_v, ptrdiff_t src_stride_v,
2821  ThreadFrame *ref_frame,
2822  ptrdiff_t y, ptrdiff_t x, const VP56mv *in_mv,
2823  int px, int py, int pw, int ph,
2824  int bw, int bh, int w, int h, int bytesperpixel,
2825  const uint16_t *scale, const uint8_t *step)
2826 {
2827  int mx, my;
2828  int refbw_m1, refbh_m1;
2829  int th;
2830  VP56mv mv;
2831 
2832  if (s->ss_h) {
2833  // BUG https://code.google.com/p/webm/issues/detail?id=820
2834  mv.x = av_clip(in_mv->x, -(x + pw - px + 4) << 4, (s->cols * 4 - x + px + 3) << 4);
2835  mx = scale_mv(mv.x, 0) + (scale_mv(x * 16, 0) & ~15) + (scale_mv(x * 32, 0) & 15);
2836  } else {
2837  mv.x = av_clip(in_mv->x, -(x + pw - px + 4) << 3, (s->cols * 8 - x + px + 3) << 3);
2838  mx = scale_mv(mv.x << 1, 0) + scale_mv(x * 16, 0);
2839  }
2840  if (s->ss_v) {
2841  // BUG https://code.google.com/p/webm/issues/detail?id=820
2842  mv.y = av_clip(in_mv->y, -(y + ph - py + 4) << 4, (s->rows * 4 - y + py + 3) << 4);
2843  my = scale_mv(mv.y, 1) + (scale_mv(y * 16, 1) & ~15) + (scale_mv(y * 32, 1) & 15);
2844  } else {
2845  mv.y = av_clip(in_mv->y, -(y + ph - py + 4) << 3, (s->rows * 8 - y + py + 3) << 3);
2846  my = scale_mv(mv.y << 1, 1) + scale_mv(y * 16, 1);
2847  }
2848 #undef scale_mv
2849  y = my >> 4;
2850  x = mx >> 4;
2851  ref_u += y * src_stride_u + x * bytesperpixel;
2852  ref_v += y * src_stride_v + x * bytesperpixel;
2853  mx &= 15;
2854  my &= 15;
2855  refbw_m1 = ((bw - 1) * step[0] + mx) >> 4;
2856  refbh_m1 = ((bh - 1) * step[1] + my) >> 4;
2857  // FIXME bilinear filter only needs 0/1 pixels, not 3/4
2858  // we use +7 because the last 7 pixels of each sbrow can be changed in
2859  // the longest loopfilter of the next sbrow
2860  th = (y + refbh_m1 + 4 + 7) >> (6 - s->ss_v);
2861  ff_thread_await_progress(ref_frame, FFMAX(th, 0), 0);
2862  if (x < 3 || y < 3 || x + 4 >= w - refbw_m1 || y + 4 >= h - refbh_m1) {
2863  s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
2864  ref_u - 3 * src_stride_u - 3 * bytesperpixel,
2865  288, src_stride_u,
2866  refbw_m1 + 8, refbh_m1 + 8,
2867  x - 3, y - 3, w, h);
2868  ref_u = s->edge_emu_buffer + 3 * 288 + 3 * bytesperpixel;
2869  smc(dst_u, dst_stride, ref_u, 288, bh, mx, my, step[0], step[1]);
2870 
2871  s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
2872  ref_v - 3 * src_stride_v - 3 * bytesperpixel,
2873  288, src_stride_v,
2874  refbw_m1 + 8, refbh_m1 + 8,
2875  x - 3, y - 3, w, h);
2876  ref_v = s->edge_emu_buffer + 3 * 288 + 3 * bytesperpixel;
2877  smc(dst_v, dst_stride, ref_v, 288, bh, mx, my, step[0], step[1]);
2878  } else {
2879  smc(dst_u, dst_stride, ref_u, src_stride_u, bh, mx, my, step[0], step[1]);
2880  smc(dst_v, dst_stride, ref_v, src_stride_v, bh, mx, my, step[0], step[1]);
2881  }
2882 }
2883 
2884 #define mc_luma_dir(s, mc, dst, dst_ls, src, src_ls, tref, row, col, mv, \
2885  px, py, pw, ph, bw, bh, w, h, i) \
2886  mc_luma_scaled(s, s->dsp.s##mc, dst, dst_ls, src, src_ls, tref, row, col, \
2887  mv, px, py, pw, ph, bw, bh, w, h, bytesperpixel, \
2888  s->mvscale[b->ref[i]], s->mvstep[b->ref[i]])
2889 #define mc_chroma_dir(s, mc, dstu, dstv, dst_ls, srcu, srcu_ls, srcv, srcv_ls, tref, \
2890  row, col, mv, px, py, pw, ph, bw, bh, w, h, i) \
2891  mc_chroma_scaled(s, s->dsp.s##mc, dstu, dstv, dst_ls, srcu, srcu_ls, srcv, srcv_ls, tref, \
2892  row, col, mv, px, py, pw, ph, bw, bh, w, h, bytesperpixel, \
2893  s->mvscale[b->ref[i]], s->mvstep[b->ref[i]])
2894 #define SCALED 1
2895 #define FN(x) x##_scaled_8bpp
2896 #define BYTES_PER_PIXEL 1
2897 #include "vp9_mc_template.c"
2898 #undef FN
2899 #undef BYTES_PER_PIXEL
2900 #define FN(x) x##_scaled_16bpp
2901 #define BYTES_PER_PIXEL 2
2902 #include "vp9_mc_template.c"
2903 #undef mc_luma_dir
2904 #undef mc_chroma_dir
2905 #undef FN
2906 #undef BYTES_PER_PIXEL
2907 #undef SCALED
2908 
2909 static av_always_inline void mc_luma_unscaled(VP9Context *s, vp9_mc_func (*mc)[2],
2910  uint8_t *dst, ptrdiff_t dst_stride,
2911  const uint8_t *ref, ptrdiff_t ref_stride,
2912  ThreadFrame *ref_frame,
2913  ptrdiff_t y, ptrdiff_t x, const VP56mv *mv,
2914  int bw, int bh, int w, int h, int bytesperpixel)
2915 {
2916  int mx = mv->x, my = mv->y, th;
2917 
2918  y += my >> 3;
2919  x += mx >> 3;
2920  ref += y * ref_stride + x * bytesperpixel;
2921  mx &= 7;
2922  my &= 7;
2923  // FIXME bilinear filter only needs 0/1 pixels, not 3/4
2924  // we use +7 because the last 7 pixels of each sbrow can be changed in
2925  // the longest loopfilter of the next sbrow
2926  th = (y + bh + 4 * !!my + 7) >> 6;
2927  ff_thread_await_progress(ref_frame, FFMAX(th, 0), 0);
2928  if (x < !!mx * 3 || y < !!my * 3 ||
2929  x + !!mx * 4 > w - bw || y + !!my * 4 > h - bh) {
2930  s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
2931  ref - !!my * 3 * ref_stride - !!mx * 3 * bytesperpixel,
2932  160, ref_stride,
2933  bw + !!mx * 7, bh + !!my * 7,
2934  x - !!mx * 3, y - !!my * 3, w, h);
2935  ref = s->edge_emu_buffer + !!my * 3 * 160 + !!mx * 3 * bytesperpixel;
2936  ref_stride = 160;
2937  }
2938  mc[!!mx][!!my](dst, dst_stride, ref, ref_stride, bh, mx << 1, my << 1);
2939 }
2940 
2941 static av_always_inline void mc_chroma_unscaled(VP9Context *s, vp9_mc_func (*mc)[2],
2942  uint8_t *dst_u, uint8_t *dst_v,
2943  ptrdiff_t dst_stride,
2944  const uint8_t *ref_u, ptrdiff_t src_stride_u,
2945  const uint8_t *ref_v, ptrdiff_t src_stride_v,
2946  ThreadFrame *ref_frame,
2947  ptrdiff_t y, ptrdiff_t x, const VP56mv *mv,
2948  int bw, int bh, int w, int h, int bytesperpixel)
2949 {
2950  int mx = mv->x << !s->ss_h, my = mv->y << !s->ss_v, th;
2951 
2952  y += my >> 4;
2953  x += mx >> 4;
2954  ref_u += y * src_stride_u + x * bytesperpixel;
2955  ref_v += y * src_stride_v + x * bytesperpixel;
2956  mx &= 15;
2957  my &= 15;
2958  // FIXME bilinear filter only needs 0/1 pixels, not 3/4
2959  // we use +7 because the last 7 pixels of each sbrow can be changed in
2960  // the longest loopfilter of the next sbrow
2961  th = (y + bh + 4 * !!my + 7) >> (6 - s->ss_v);
2962  ff_thread_await_progress(ref_frame, FFMAX(th, 0), 0);
2963  if (x < !!mx * 3 || y < !!my * 3 ||
2964  x + !!mx * 4 > w - bw || y + !!my * 4 > h - bh) {
2965  s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
2966  ref_u - !!my * 3 * src_stride_u - !!mx * 3 * bytesperpixel,
2967  160, src_stride_u,
2968  bw + !!mx * 7, bh + !!my * 7,
2969  x - !!mx * 3, y - !!my * 3, w, h);
2970  ref_u = s->edge_emu_buffer + !!my * 3 * 160 + !!mx * 3 * bytesperpixel;
2971  mc[!!mx][!!my](dst_u, dst_stride, ref_u, 160, bh, mx, my);
2972 
2973  s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
2974  ref_v - !!my * 3 * src_stride_v - !!mx * 3 * bytesperpixel,
2975  160, src_stride_v,
2976  bw + !!mx * 7, bh + !!my * 7,
2977  x - !!mx * 3, y - !!my * 3, w, h);
2978  ref_v = s->edge_emu_buffer + !!my * 3 * 160 + !!mx * 3 * bytesperpixel;
2979  mc[!!mx][!!my](dst_v, dst_stride, ref_v, 160, bh, mx, my);
2980  } else {
2981  mc[!!mx][!!my](dst_u, dst_stride, ref_u, src_stride_u, bh, mx, my);
2982  mc[!!mx][!!my](dst_v, dst_stride, ref_v, src_stride_v, bh, mx, my);
2983  }
2984 }
2985 
2986 #define mc_luma_dir(s, mc, dst, dst_ls, src, src_ls, tref, row, col, mv, \
2987  px, py, pw, ph, bw, bh, w, h, i) \
2988  mc_luma_unscaled(s, s->dsp.mc, dst, dst_ls, src, src_ls, tref, row, col, \
2989  mv, bw, bh, w, h, bytesperpixel)
2990 #define mc_chroma_dir(s, mc, dstu, dstv, dst_ls, srcu, srcu_ls, srcv, srcv_ls, tref, \
2991  row, col, mv, px, py, pw, ph, bw, bh, w, h, i) \
2992  mc_chroma_unscaled(s, s->dsp.mc, dstu, dstv, dst_ls, srcu, srcu_ls, srcv, srcv_ls, tref, \
2993  row, col, mv, bw, bh, w, h, bytesperpixel)
2994 #define SCALED 0
2995 #define FN(x) x##_8bpp
2996 #define BYTES_PER_PIXEL 1
2997 #include "vp9_mc_template.c"
2998 #undef FN
2999 #undef BYTES_PER_PIXEL
3000 #define FN(x) x##_16bpp
3001 #define BYTES_PER_PIXEL 2
3002 #include "vp9_mc_template.c"
3003 #undef mc_luma_dir_dir
3004 #undef mc_chroma_dir_dir
3005 #undef FN
3006 #undef BYTES_PER_PIXEL
3007 #undef SCALED
3008 
3009 static av_always_inline void inter_recon(AVCodecContext *ctx, int bytesperpixel)
3010 {
3011  VP9Context *s = ctx->priv_data;
3012  VP9Block *b = s->b;
3013  int row = s->row, col = s->col;
3014 
3015  if (s->mvscale[b->ref[0]][0] || (b->comp && s->mvscale[b->ref[1]][0])) {
3016  if (bytesperpixel == 1) {
3017  inter_pred_scaled_8bpp(ctx);
3018  } else {
3019  inter_pred_scaled_16bpp(ctx);
3020  }
3021  } else {
3022  if (bytesperpixel == 1) {
3023  inter_pred_8bpp(ctx);
3024  } else {
3025  inter_pred_16bpp(ctx);
3026  }
3027  }
3028  if (!b->skip) {
3029  /* mostly copied intra_recon() */
3030 
3031  int w4 = bwh_tab[1][b->bs][0] << 1, step1d = 1 << b->tx, n;
3032  int h4 = bwh_tab[1][b->bs][1] << 1, x, y, step = 1 << (b->tx * 2);
3033  int end_x = FFMIN(2 * (s->cols - col), w4);
3034  int end_y = FFMIN(2 * (s->rows - row), h4);
3035  int tx = 4 * s->lossless + b->tx, uvtx = b->uvtx + 4 * s->lossless;
3036  int uvstep1d = 1 << b->uvtx, p;
3037  uint8_t *dst = s->dst[0];
3038 
3039  // y itxfm add
3040  for (n = 0, y = 0; y < end_y; y += step1d) {
3041  uint8_t *ptr = dst;
3042  for (x = 0; x < end_x; x += step1d,
3043  ptr += 4 * step1d * bytesperpixel, n += step) {
3044  int eob = b->tx > TX_8X8 ? AV_RN16A(&s->eob[n]) : s->eob[n];
3045 
3046  if (eob)
3047  s->dsp.itxfm_add[tx][DCT_DCT](ptr, s->y_stride,
3048  s->block + 16 * n * bytesperpixel, eob);
3049  }
3050  dst += 4 * s->y_stride * step1d;
3051  }
3052 
3053  // uv itxfm add
3054  end_x >>= s->ss_h;
3055  end_y >>= s->ss_v;
3056  step = 1 << (b->uvtx * 2);
3057  for (p = 0; p < 2; p++) {
3058  dst = s->dst[p + 1];
3059  for (n = 0, y = 0; y < end_y; y += uvstep1d) {
3060  uint8_t *ptr = dst;
3061  for (x = 0; x < end_x; x += uvstep1d,
3062  ptr += 4 * uvstep1d * bytesperpixel, n += step) {
3063  int eob = b->uvtx > TX_8X8 ? AV_RN16A(&s->uveob[p][n]) : s->uveob[p][n];
3064 
3065  if (eob)
3066  s->dsp.itxfm_add[uvtx][DCT_DCT](ptr, s->uv_stride,
3067  s->uvblock[p] + 16 * n * bytesperpixel, eob);
3068  }
3069  dst += 4 * uvstep1d * s->uv_stride;
3070  }
3071  }
3072  }
3073 }
3074 
3075 static void inter_recon_8bpp(AVCodecContext *ctx)
3076 {
3077  inter_recon(ctx, 1);
3078 }
3079 
3080 static void inter_recon_16bpp(AVCodecContext *ctx)
3081 {
3082  inter_recon(ctx, 2);
3083 }
3084 
3085 static av_always_inline void mask_edges(uint8_t (*mask)[8][4], int ss_h, int ss_v,
3086  int row_and_7, int col_and_7,
3087  int w, int h, int col_end, int row_end,
3088  enum TxfmMode tx, int skip_inter)
3089 {
3090  static const unsigned wide_filter_col_mask[2] = { 0x11, 0x01 };
3091  static const unsigned wide_filter_row_mask[2] = { 0x03, 0x07 };
3092 
3093  // FIXME I'm pretty sure all loops can be replaced by a single LUT if
3094  // we make VP9Filter.mask uint64_t (i.e. row/col all single variable)
3095  // and make the LUT 5-indexed (bl, bp, is_uv, tx and row/col), and then
3096  // use row_and_7/col_and_7 as shifts (1*col_and_7+8*row_and_7)
3097 
3098  // the intended behaviour of the vp9 loopfilter is to work on 8-pixel
3099  // edges. This means that for UV, we work on two subsampled blocks at
3100  // a time, and we only use the topleft block's mode information to set
3101  // things like block strength. Thus, for any block size smaller than
3102  // 16x16, ignore the odd portion of the block.
3103  if (tx == TX_4X4 && (ss_v | ss_h)) {
3104  if (h == ss_v) {
3105  if (row_and_7 & 1)
3106  return;
3107  if (!row_end)
3108  h += 1;
3109  }
3110  if (w == ss_h) {
3111  if (col_and_7 & 1)
3112  return;
3113  if (!col_end)
3114  w += 1;
3115  }
3116  }
3117 
3118  if (tx == TX_4X4 && !skip_inter) {
3119  int t = 1 << col_and_7, m_col = (t << w) - t, y;
3120  // on 32-px edges, use the 8-px wide loopfilter; else, use 4-px wide
3121  int m_row_8 = m_col & wide_filter_col_mask[ss_h], m_row_4 = m_col - m_row_8;
3122 
3123  for (y = row_and_7; y < h + row_and_7; y++) {
3124  int col_mask_id = 2 - !(y & wide_filter_row_mask[ss_v]);
3125 
3126  mask[0][y][1] |= m_row_8;
3127  mask[0][y][2] |= m_row_4;
3128  // for odd lines, if the odd col is not being filtered,
3129  // skip odd row also:
3130  // .---. <-- a
3131  // | |
3132  // |___| <-- b
3133  // ^ ^
3134  // c d
3135  //
3136  // if a/c are even row/col and b/d are odd, and d is skipped,
3137  // e.g. right edge of size-66x66.webm, then skip b also (bug)
3138  if ((ss_h & ss_v) && (col_end & 1) && (y & 1)) {
3139  mask[1][y][col_mask_id] |= (t << (w - 1)) - t;
3140  } else {
3141  mask[1][y][col_mask_id] |= m_col;
3142  }
3143  if (!ss_h)
3144  mask[0][y][3] |= m_col;
3145  if (!ss_v) {
3146  if (ss_h && (col_end & 1))
3147  mask[1][y][3] |= (t << (w - 1)) - t;
3148  else
3149  mask[1][y][3] |= m_col;
3150  }
3151  }
3152  } else {
3153  int y, t = 1 << col_and_7, m_col = (t << w) - t;
3154 
3155  if (!skip_inter) {
3156  int mask_id = (tx == TX_8X8);
3157  static const unsigned masks[4] = { 0xff, 0x55, 0x11, 0x01 };
3158  int l2 = tx + ss_h - 1, step1d;
3159  int m_row = m_col & masks[l2];
3160 
3161  // at odd UV col/row edges tx16/tx32 loopfilter edges, force
3162  // 8wd loopfilter to prevent going off the visible edge.
3163  if (ss_h && tx > TX_8X8 && (w ^ (w - 1)) == 1) {
3164  int m_row_16 = ((t << (w - 1)) - t) & masks[l2];
3165  int m_row_8 = m_row - m_row_16;
3166 
3167  for (y = row_and_7; y < h + row_and_7; y++) {
3168  mask[0][y][0] |= m_row_16;
3169  mask[0][y][1] |= m_row_8;
3170  }
3171  } else {
3172  for (y = row_and_7; y < h + row_and_7; y++)
3173  mask[0][y][mask_id] |= m_row;
3174  }
3175 
3176  l2 = tx + ss_v - 1;
3177  step1d = 1 << l2;
3178  if (ss_v && tx > TX_8X8 && (h ^ (h - 1)) == 1) {
3179  for (y = row_and_7; y < h + row_and_7 - 1; y += step1d)
3180  mask[1][y][0] |= m_col;
3181  if (y - row_and_7 == h - 1)
3182  mask[1][y][1] |= m_col;
3183  } else {
3184  for (y = row_and_7; y < h + row_and_7; y += step1d)
3185  mask[1][y][mask_id] |= m_col;
3186  }
3187  } else if (tx != TX_4X4) {
3188  int mask_id;
3189 
3190  mask_id = (tx == TX_8X8) || (h == ss_v);
3191  mask[1][row_and_7][mask_id] |= m_col;
3192  mask_id = (tx == TX_8X8) || (w == ss_h);
3193  for (y = row_and_7; y < h + row_and_7; y++)
3194  mask[0][y][mask_id] |= t;
3195  } else {
3196  int t8 = t & wide_filter_col_mask[ss_h], t4 = t - t8;
3197 
3198  for (y = row_and_7; y < h + row_and_7; y++) {
3199  mask[0][y][2] |= t4;
3200  mask[0][y][1] |= t8;
3201  }
3202  mask[1][row_and_7][2 - !(row_and_7 & wide_filter_row_mask[ss_v])] |= m_col;
3203  }
3204  }
3205 }
3206 
3207 static void decode_b(AVCodecContext *ctx, int row, int col,
3208  struct VP9Filter *lflvl, ptrdiff_t yoff, ptrdiff_t uvoff,
3209  enum BlockLevel bl, enum BlockPartition bp)
3210 {
3211  VP9Context *s = ctx->priv_data;
3212  VP9Block *b = s->b;
3213  enum BlockSize bs = bl * 3 + bp;
3214  int bytesperpixel = s->bytesperpixel;
3215  int w4 = bwh_tab[1][bs][0], h4 = bwh_tab[1][bs][1], lvl;
3216  int emu[2];
3217  AVFrame *f = s->frames[CUR_FRAME].tf.f;
3218 
3219  s->row = row;
3220  s->row7 = row & 7;
3221  s->col = col;
3222  s->col7 = col & 7;
3223  s->min_mv.x = -(128 + col * 64);
3224  s->min_mv.y = -(128 + row * 64);
3225  s->max_mv.x = 128 + (s->cols - col - w4) * 64;
3226  s->max_mv.y = 128 + (s->rows - row - h4) * 64;
3227  if (s->pass < 2) {
3228  b->bs = bs;
3229  b->bl = bl;
3230  b->bp = bp;
3231  decode_mode(ctx);
3232  b->uvtx = b->tx - ((s->ss_h && w4 * 2 == (1 << b->tx)) ||
3233  (s->ss_v && h4 * 2 == (1 << b->tx)));
3234 
3235  if (!b->skip) {
3236  int has_coeffs;
3237 
3238  if (bytesperpixel == 1) {
3239  has_coeffs = decode_coeffs_8bpp(ctx);
3240  } else {
3241  has_coeffs = decode_coeffs_16bpp(ctx);
3242  }
3243  if (!has_coeffs && b->bs <= BS_8x8 && !b->intra) {
3244  b->skip = 1;
3245  memset(&s->above_skip_ctx[col], 1, w4);
3246  memset(&s->left_skip_ctx[s->row7], 1, h4);
3247  }
3248  } else {
3249  int row7 = s->row7;
3250 
3251 #define SPLAT_ZERO_CTX(v, n) \
3252  switch (n) { \
3253  case 1: v = 0; break; \
3254  case 2: AV_ZERO16(&v); break; \
3255  case 4: AV_ZERO32(&v); break; \
3256  case 8: AV_ZERO64(&v); break; \
3257  case 16: AV_ZERO128(&v); break; \
3258  }
3259 #define SPLAT_ZERO_YUV(dir, var, off, n, dir2) \
3260  do { \
3261  SPLAT_ZERO_CTX(s->dir##_y_##var[off * 2], n * 2); \
3262  if (s->ss_##dir2) { \
3263  SPLAT_ZERO_CTX(s->dir##_uv_##var[0][off], n); \
3264  SPLAT_ZERO_CTX(s->dir##_uv_##var[1][off], n); \
3265  } else { \
3266  SPLAT_ZERO_CTX(s->dir##_uv_##var[0][off * 2], n * 2); \
3267  SPLAT_ZERO_CTX(s->dir##_uv_##var[1][off * 2], n * 2); \
3268  } \
3269  } while (0)
3270 
3271  switch (w4) {
3272  case 1: SPLAT_ZERO_YUV(above, nnz_ctx, col, 1, h); break;
3273  case 2: SPLAT_ZERO_YUV(above, nnz_ctx, col, 2, h); break;
3274  case 4: SPLAT_ZERO_YUV(above, nnz_ctx, col, 4, h); break;
3275  case 8: SPLAT_ZERO_YUV(above, nnz_ctx, col, 8, h); break;
3276  }
3277  switch (h4) {
3278  case 1: SPLAT_ZERO_YUV(left, nnz_ctx, row7, 1, v); break;
3279  case 2: SPLAT_ZERO_YUV(left, nnz_ctx, row7, 2, v); break;
3280  case 4: SPLAT_ZERO_YUV(left, nnz_ctx, row7, 4, v); break;
3281  case 8: SPLAT_ZERO_YUV(left, nnz_ctx, row7, 8, v); break;
3282  }
3283  }
3284  if (s->pass == 1) {
3285  s->b++;
3286  s->block += w4 * h4 * 64 * bytesperpixel;
3287  s->uvblock[0] += w4 * h4 * 64 * bytesperpixel >> (s->ss_h + s->ss_v);
3288  s->uvblock[1] += w4 * h4 * 64 * bytesperpixel >> (s->ss_h + s->ss_v);
3289  s->eob += 4 * w4 * h4;
3290  s->uveob[0] += 4 * w4 * h4 >> (s->ss_h + s->ss_v);
3291  s->uveob[1] += 4 * w4 * h4 >> (s->ss_h + s->ss_v);
3292 
3293  return;
3294  }
3295  }
3296 
3297  // emulated overhangs if the stride of the target buffer can't hold. This
3298  // makes it possible to support emu-edge and so on even if we have large block
3299  // overhangs
3300  emu[0] = (col + w4) * 8 > f->linesize[0] ||
3301  (row + h4) > s->rows;
3302  emu[1] = (col + w4) * 4 > f->linesize[1] ||
3303  (row + h4) > s->rows;
3304  if (emu[0]) {
3305  s->dst[0] = s->tmp_y;
3306  s->y_stride = 128;
3307  } else {
3308  s->dst[0] = f->data[0] + yoff;
3309  s->y_stride = f->linesize[0];
3310  }
3311  if (emu[1]) {
3312  s->dst[1] = s->tmp_uv[0];
3313  s->dst[2] = s->tmp_uv[1];
3314  s->uv_stride = 128;
3315  } else {
3316  s->dst[1] = f->data[1] + uvoff;
3317  s->dst[2] = f->data[2] + uvoff;
3318  s->uv_stride = f->linesize[1];
3319  }
3320  if (b->intra) {
3321  if (s->bpp > 8) {
3322  intra_recon_16bpp(ctx, yoff, uvoff);
3323  } else {
3324  intra_recon_8bpp(ctx, yoff, uvoff);
3325  }
3326  } else {
3327  if (s->bpp > 8) {
3328  inter_recon_16bpp(ctx);
3329  } else {
3330  inter_recon_8bpp(ctx);
3331  }
3332  }
3333  if (emu[0]) {
3334  int w = FFMIN(s->cols - col, w4) * 8, h = FFMIN(s->rows - row, h4) * 8, n, o = 0;
3335 
3336  for (n = 0; o < w; n++) {
3337  int bw = 64 >> n;
3338 
3339  av_assert2(n <= 4);
3340  if (w & bw) {
3341  s->dsp.mc[n][0][0][0][0](f->data[0] + yoff + o, f->linesize[0],
3342  s->tmp_y + o, 128, h, 0, 0);
3343  o += bw * bytesperpixel;
3344  }
3345  }
3346  }
3347  if (emu[1]) {
3348  int w = FFMIN(s->cols - col, w4) * 8 >> s->ss_h;
3349  int h = FFMIN(s->rows - row, h4) * 8 >> s->ss_v, n, o = 0;
3350 
3351  for (n = s->ss_h; o < w; n++) {
3352  int bw = 64 >> n;
3353 
3354  av_assert2(n <= 4);
3355  if (w & bw) {
3356  s->dsp.mc[n][0][0][0][0](f->data[1] + uvoff + o, f->linesize[1],
3357  s->tmp_uv[0] + o, 128, h, 0, 0);
3358  s->dsp.mc[n][0][0][0][0](f->data[2] + uvoff + o, f->linesize[2],
3359  s->tmp_uv[1] + o, 128, h, 0, 0);
3360  o += bw * bytesperpixel;
3361  }
3362  }
3363  }
3364 
3365  // pick filter level and find edges to apply filter to
3366  if (s->filter.level &&
3367  (lvl = s->segmentation.feat[b->seg_id].lflvl[b->intra ? 0 : b->ref[0] + 1]
3368  [b->mode[3] != ZEROMV]) > 0) {
3369  int x_end = FFMIN(s->cols - col, w4), y_end = FFMIN(s->rows - row, h4);
3370  int skip_inter = !b->intra && b->skip, col7 = s->col7, row7 = s->row7;
3371 
3372  setctx_2d(&lflvl->level[row7 * 8 + col7], w4, h4, 8, lvl);
3373  mask_edges(lflvl->mask[0], 0, 0, row7, col7, x_end, y_end, 0, 0, b->tx, skip_inter);
3374  if (s->ss_h || s->ss_v)
3375  mask_edges(lflvl->mask[1], s->ss_h, s->ss_v, row7, col7, x_end, y_end,
3376  s->cols & 1 && col + w4 >= s->cols ? s->cols & 7 : 0,
3377  s->rows & 1 && row + h4 >= s->rows ? s->rows & 7 : 0,
3378  b->uvtx, skip_inter);
3379 
3380  if (!s->filter.lim_lut[lvl]) {
3381  int sharp = s->filter.sharpness;
3382  int limit = lvl;
3383 
3384  if (sharp > 0) {
3385  limit >>= (sharp + 3) >> 2;
3386  limit = FFMIN(limit, 9 - sharp);
3387  }
3388  limit = FFMAX(limit, 1);
3389 
3390  s->filter.lim_lut[lvl] = limit;
3391  s->filter.mblim_lut[lvl] = 2 * (lvl + 2) + limit;
3392  }
3393  }
3394 
3395  if (s->pass == 2) {
3396  s->b++;
3397  s->block += w4 * h4 * 64 * bytesperpixel;
3398  s->uvblock[0] += w4 * h4 * 64 * bytesperpixel >> (s->ss_v + s->ss_h);
3399  s->uvblock[1] += w4 * h4 * 64 * bytesperpixel >> (s->ss_v + s->ss_h);
3400  s->eob += 4 * w4 * h4;
3401  s->uveob[0] += 4 * w4 * h4 >> (s->ss_v + s->ss_h);
3402  s->uveob[1] += 4 * w4 * h4 >> (s->ss_v + s->ss_h);
3403  }
3404 }
3405 
3406 static void decode_sb(AVCodecContext *ctx, int row, int col, struct VP9Filter *lflvl,
3407  ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
3408 {
3409  VP9Context *s = ctx->priv_data;
3410  int c = ((s->above_partition_ctx[col] >> (3 - bl)) & 1) |
3411  (((s->left_partition_ctx[row & 0x7] >> (3 - bl)) & 1) << 1);
3412  const uint8_t *p = s->keyframe || s->intraonly ? vp9_default_kf_partition_probs[bl][c] :
3413  s->prob.p.partition[bl][c];
3414  enum BlockPartition bp;
3415  ptrdiff_t hbs = 4 >> bl;
3416  AVFrame *f = s->frames[CUR_FRAME].tf.f;
3417  ptrdiff_t y_stride = f->linesize[0], uv_stride = f->linesize[1];
3418  int bytesperpixel = s->bytesperpixel;
3419 
3420  if (bl == BL_8X8) {
3421  bp = vp8_rac_get_tree(&s->c, vp9_partition_tree, p);
3422  decode_b(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
3423  } else if (col + hbs < s->cols) { // FIXME why not <=?
3424  if (row + hbs < s->rows) { // FIXME why not <=?
3425  bp = vp8_rac_get_tree(&s->c, vp9_partition_tree, p);
3426  switch (bp) {
3427  case PARTITION_NONE:
3428  decode_b(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
3429  break;
3430  case PARTITION_H:
3431  decode_b(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
3432  yoff += hbs * 8 * y_stride;
3433  uvoff += hbs * 8 * uv_stride >> s->ss_v;
3434  decode_b(ctx, row + hbs, col, lflvl, yoff, uvoff, bl, bp);
3435  break;
3436  case PARTITION_V:
3437  decode_b(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
3438  yoff += hbs * 8 * bytesperpixel;
3439  uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
3440  decode_b(ctx, row, col + hbs, lflvl, yoff, uvoff, bl, bp);
3441  break;
3442  case PARTITION_SPLIT:
3443  decode_sb(ctx, row, col, lflvl, yoff, uvoff, bl + 1);
3444  decode_sb(ctx, row, col + hbs, lflvl,
3445  yoff + 8 * hbs * bytesperpixel,
3446  uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
3447  yoff += hbs * 8 * y_stride;
3448  uvoff += hbs * 8 * uv_stride >> s->ss_v;
3449  decode_sb(ctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
3450  decode_sb(ctx, row + hbs, col + hbs, lflvl,
3451  yoff + 8 * hbs * bytesperpixel,
3452  uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
3453  break;
3454  default:
3455  av_assert0(0);
3456  }
3457  } else if (vp56_rac_get_prob_branchy(&s->c, p[1])) {
3458  bp = PARTITION_SPLIT;
3459  decode_sb(ctx, row, col, lflvl, yoff, uvoff, bl + 1);
3460  decode_sb(ctx, row, col + hbs, lflvl,
3461  yoff + 8 * hbs * bytesperpixel,
3462  uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
3463  } else {
3464  bp = PARTITION_H;
3465  decode_b(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
3466  }
3467  } else if (row + hbs < s->rows) { // FIXME why not <=?
3468  if (vp56_rac_get_prob_branchy(&s->c, p[2])) {
3469  bp = PARTITION_SPLIT;
3470  decode_sb(ctx, row, col, lflvl, yoff, uvoff, bl + 1);
3471  yoff += hbs * 8 * y_stride;
3472  uvoff += hbs * 8 * uv_stride >> s->ss_v;
3473  decode_sb(ctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
3474  } else {
3475  bp = PARTITION_V;
3476  decode_b(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
3477  }
3478  } else {
3479  bp = PARTITION_SPLIT;
3480  decode_sb(ctx, row, col, lflvl, yoff, uvoff, bl + 1);
3481  }
3482  s->counts.partition[bl][c][bp]++;
3483 }
3484 
3485 static void decode_sb_mem(AVCodecContext *ctx, int row, int col, struct VP9Filter *lflvl,
3486  ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
3487 {
3488  VP9Context *s = ctx->priv_data;
3489  VP9Block *b = s->b;
3490  ptrdiff_t hbs = 4 >> bl;
3491  AVFrame *f = s->frames[CUR_FRAME].tf.f;
3492  ptrdiff_t y_stride = f->linesize[0], uv_stride = f->linesize[1];
3493  int bytesperpixel = s->bytesperpixel;
3494 
3495  if (bl == BL_8X8) {
3496  av_assert2(b->bl == BL_8X8);
3497  decode_b(ctx, row, col, lflvl, yoff, uvoff, b->bl, b->bp);
3498  } else if (s->b->bl == bl) {
3499  decode_b(ctx, row, col, lflvl, yoff, uvoff, b->bl, b->bp);
3500  if (b->bp == PARTITION_H && row + hbs < s->rows) {
3501  yoff += hbs * 8 * y_stride;
3502  uvoff += hbs * 8 * uv_stride >> s->ss_v;
3503  decode_b(ctx, row + hbs, col, lflvl, yoff, uvoff, b->bl, b->bp);
3504  } else if (b->bp == PARTITION_V && col + hbs < s->cols) {
3505  yoff += hbs * 8 * bytesperpixel;
3506  uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
3507  decode_b(ctx, row, col + hbs, lflvl, yoff, uvoff, b->bl, b->bp);
3508  }
3509  } else {
3510  decode_sb_mem(ctx, row, col, lflvl, yoff, uvoff, bl + 1);
3511  if (col + hbs < s->cols) { // FIXME why not <=?
3512  if (row + hbs < s->rows) {
3513  decode_sb_mem(ctx, row, col + hbs, lflvl, yoff + 8 * hbs * bytesperpixel,
3514  uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
3515  yoff += hbs * 8 * y_stride;
3516  uvoff += hbs * 8 * uv_stride >> s->ss_v;
3517  decode_sb_mem(ctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
3518  decode_sb_mem(ctx, row + hbs, col + hbs, lflvl,
3519  yoff + 8 * hbs * bytesperpixel,
3520  uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
3521  } else {
3522  yoff += hbs * 8 * bytesperpixel;
3523  uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
3524  decode_sb_mem(ctx, row, col + hbs, lflvl, yoff, uvoff, bl + 1);
3525  }
3526  } else if (row + hbs < s->rows) {
3527  yoff += hbs * 8 * y_stride;
3528  uvoff += hbs * 8 * uv_stride >> s->ss_v;
3529  decode_sb_mem(ctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
3530  }
3531  }
3532 }
3533 
3534 static av_always_inline void filter_plane_cols(VP9Context *s, int col, int ss_h, int ss_v,
3535  uint8_t *lvl, uint8_t (*mask)[4],
3536  uint8_t *dst, ptrdiff_t ls)
3537 {
3538  int y, x, bytesperpixel = s->bytesperpixel;
3539 
3540  // filter edges between columns (e.g. block1 | block2)
3541  for (y = 0; y < 8; y += 2 << ss_v, dst += 16 * ls, lvl += 16 << ss_v) {
3542  uint8_t *ptr = dst, *l = lvl, *hmask1 = mask[y], *hmask2 = mask[y + 1 + ss_v];
3543  unsigned hm1 = hmask1[0] | hmask1[1] | hmask1[2], hm13 = hmask1[3];
3544  unsigned hm2 = hmask2[1] | hmask2[2], hm23 = hmask2[3];
3545  unsigned hm = hm1 | hm2 | hm13 | hm23;
3546 
3547  for (x = 1; hm & ~(x - 1); x <<= 1, ptr += 8 * bytesperpixel >> ss_h) {
3548  if (col || x > 1) {
3549  if (hm1 & x) {
3550  int L = *l, H = L >> 4;
3551  int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
3552 
3553  if (hmask1[0] & x) {
3554  if (hmask2[0] & x) {
3555  av_assert2(l[8 << ss_v] == L);
3556  s->dsp.loop_filter_16[0](ptr, ls, E, I, H);
3557  } else {
3558  s->dsp.loop_filter_8[2][0](ptr, ls, E, I, H);
3559  }
3560  } else if (hm2 & x) {
3561  L = l[8 << ss_v];
3562  H |= (L >> 4) << 8;
3563  E |= s->filter.mblim_lut[L] << 8;
3564  I |= s->filter.lim_lut[L] << 8;
3565  s->dsp.loop_filter_mix2[!!(hmask1[1] & x)]
3566  [!!(hmask2[1] & x)]
3567  [0](ptr, ls, E, I, H);
3568  } else {
3569  s->dsp.loop_filter_8[!!(hmask1[1] & x)]
3570  [0](ptr, ls, E, I, H);
3571  }
3572  } else if (hm2 & x) {
3573  int L = l[8 << ss_v], H = L >> 4;
3574  int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
3575 
3576  s->dsp.loop_filter_8[!!(hmask2[1] & x)]
3577  [0](ptr + 8 * ls, ls, E, I, H);
3578  }
3579  }
3580  if (ss_h) {
3581  if (x & 0xAA)
3582  l += 2;
3583  } else {
3584  if (hm13 & x) {
3585  int L = *l, H = L >> 4;
3586  int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
3587 
3588  if (hm23 & x) {
3589  L = l[8 << ss_v];
3590  H |= (L >> 4) << 8;
3591  E |= s->filter.mblim_lut[L] << 8;
3592  I |= s->filter.lim_lut[L] << 8;
3593  s->dsp.loop_filter_mix2[0][0][0](ptr + 4 * bytesperpixel, ls, E, I, H);
3594  } else {
3595  s->dsp.loop_filter_8[0][0](ptr + 4 * bytesperpixel, ls, E, I, H);
3596  }
3597  } else if (hm23 & x) {
3598  int L = l[8 << ss_v], H = L >> 4;
3599  int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
3600 
3601  s->dsp.loop_filter_8[0][0](ptr + 8 * ls + 4 * bytesperpixel, ls, E, I, H);
3602  }
3603  l++;
3604  }
3605  }
3606  }
3607 }
3608 
3609 static av_always_inline void filter_plane_rows(VP9Context *s, int row, int ss_h, int ss_v,
3610  uint8_t *lvl, uint8_t (*mask)[4],
3611  uint8_t *dst, ptrdiff_t ls)
3612 {
3613  int y, x, bytesperpixel = s->bytesperpixel;
3614 
3615  // block1
3616  // filter edges between rows (e.g. ------)
3617  // block2
3618  for (y = 0; y < 8; y++, dst += 8 * ls >> ss_v) {
3619  uint8_t *ptr = dst, *l = lvl, *vmask = mask[y];
3620  unsigned vm = vmask[0] | vmask[1] | vmask[2], vm3 = vmask[3];
3621 
3622  for (x = 1; vm & ~(x - 1); x <<= (2 << ss_h), ptr += 16 * bytesperpixel, l += 2 << ss_h) {
3623  if (row || y) {
3624  if (vm & x) {
3625  int L = *l, H = L >> 4;
3626  int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
3627 
3628  if (vmask[0] & x) {
3629  if (vmask[0] & (x << (1 + ss_h))) {
3630  av_assert2(l[1 + ss_h] == L);
3631  s->dsp.loop_filter_16[1](ptr, ls, E, I, H);
3632  } else {
3633  s->dsp.loop_filter_8[2][1](ptr, ls, E, I, H);
3634  }
3635  } else if (vm & (x << (1 + ss_h))) {
3636  L = l[1 + ss_h];
3637  H |= (L >> 4) << 8;
3638  E |= s->filter.mblim_lut[L] << 8;
3639  I |= s->filter.lim_lut[L] << 8;
3640  s->dsp.loop_filter_mix2[!!(vmask[1] & x)]
3641  [!!(vmask[1] & (x << (1 + ss_h)))]
3642  [1](ptr, ls, E, I, H);
3643  } else {
3644  s->dsp.loop_filter_8[!!(vmask[1] & x)]
3645  [1](ptr, ls, E, I, H);
3646  }
3647  } else if (vm & (x << (1 + ss_h))) {
3648  int L = l[1 + ss_h], H = L >> 4;
3649  int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
3650 
3651  s->dsp.loop_filter_8[!!(vmask[1] & (x << (1 + ss_h)))]
3652  [1](ptr + 8 * bytesperpixel, ls, E, I, H);
3653  }
3654  }
3655  if (!ss_v) {
3656  if (vm3 & x) {
3657  int L = *l, H = L >> 4;
3658  int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
3659 
3660  if (vm3 & (x << (1 + ss_h))) {
3661  L = l[1 + ss_h];
3662  H |= (L >> 4) << 8;
3663  E |= s->filter.mblim_lut[L] << 8;
3664  I |= s->filter.lim_lut[L] << 8;
3665  s->dsp.loop_filter_mix2[0][0][1](ptr + ls * 4, ls, E, I, H);
3666  } else {
3667  s->dsp.loop_filter_8[0][1](ptr + ls * 4, ls, E, I, H);
3668  }
3669  } else if (vm3 & (x << (1 + ss_h))) {
3670  int L = l[1 + ss_h], H = L >> 4;
3671  int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
3672 
3673  s->dsp.loop_filter_8[0][1](ptr + ls * 4 + 8 * bytesperpixel, ls, E, I, H);
3674  }
3675  }
3676  }
3677  if (ss_v) {
3678  if (y & 1)
3679  lvl += 16;
3680  } else {
3681  lvl += 8;
3682  }
3683  }
3684 }
3685 
3686 static void loopfilter_sb(AVCodecContext *ctx, struct VP9Filter *lflvl,
3687  int row, int col, ptrdiff_t yoff, ptrdiff_t uvoff)
3688 {
3689  VP9Context *s = ctx->priv_data;
3690  AVFrame *f = s->frames[CUR_FRAME].tf.f;
3691  uint8_t *dst = f->data[0] + yoff;
3692  ptrdiff_t ls_y = f->linesize[0], ls_uv = f->linesize[1];
3693  uint8_t (*uv_masks)[8][4] = lflvl->mask[s->ss_h | s->ss_v];
3694  int p;
3695 
3696  // FIXME in how far can we interleave the v/h loopfilter calls? E.g.
3697  // if you think of them as acting on a 8x8 block max, we can interleave
3698  // each v/h within the single x loop, but that only works if we work on
3699  // 8 pixel blocks, and we won't always do that (we want at least 16px
3700  // to use SSE2 optimizations, perhaps 32 for AVX2)
3701 
3702  filter_plane_cols(s, col, 0, 0, lflvl->level, lflvl->mask[0][0], dst, ls_y);
3703  filter_plane_rows(s, row, 0, 0, lflvl->level, lflvl->mask[0][1], dst, ls_y);
3704 
3705  for (p = 0; p < 2; p++) {
3706  dst = f->data[1 + p] + uvoff;
3707  filter_plane_cols(s, col, s->ss_h, s->ss_v, lflvl->level, uv_masks[0], dst, ls_uv);
3708  filter_plane_rows(s, row, s->ss_h, s->ss_v, lflvl->level, uv_masks[1], dst, ls_uv);
3709  }
3710 }
3711 
3712 static void set_tile_offset(int *start, int *end, int idx, int log2_n, int n)
3713 {
3714  int sb_start = ( idx * n) >> log2_n;
3715  int sb_end = ((idx + 1) * n) >> log2_n;
3716  *start = FFMIN(sb_start, n) << 3;
3717  *end = FFMIN(sb_end, n) << 3;
3718 }
3719 
3720 static av_always_inline void adapt_prob(uint8_t *p, unsigned ct0, unsigned ct1,
3721  int max_count, int update_factor)
3722 {
3723  unsigned ct = ct0 + ct1, p2, p1;
3724 
3725  if (!ct)
3726  return;
3727 
3728  p1 = *p;
3729  p2 = ((ct0 << 8) + (ct >> 1)) / ct;
3730  p2 = av_clip(p2, 1, 255);
3731  ct = FFMIN(ct, max_count);
3732  update_factor = FASTDIV(update_factor * ct, max_count);
3733 
3734  // (p1 * (256 - update_factor) + p2 * update_factor + 128) >> 8
3735  *p = p1 + (((p2 - p1) * update_factor + 128) >> 8);
3736 }
3737 
3738 static void adapt_probs(VP9Context *s)
3739 {
3740  int i, j, k, l, m;
3741  prob_context *p = &s->prob_ctx[s->framectxid].p;
3742  int uf = (s->keyframe || s->intraonly || !s->last_keyframe) ? 112 : 128;
3743 
3744  // coefficients
3745  for (i = 0; i < 4; i++)
3746  for (j = 0; j < 2; j++)
3747  for (k = 0; k < 2; k++)
3748  for (l = 0; l < 6; l++)
3749  for (m = 0; m < 6; m++) {
3750  uint8_t *pp = s->prob_ctx[s->framectxid].coef[i][j][k][l][m];
3751  unsigned *e = s->counts.eob[i][j][k][l][m];
3752  unsigned *c = s->counts.coef[i][j][k][l][m];
3753 
3754  if (l == 0 && m >= 3) // dc only has 3 pt
3755  break;
3756 
3757  adapt_prob(&pp[0], e[0], e[1], 24, uf);
3758  adapt_prob(&pp[1], c[0], c[1] + c[2], 24, uf);
3759  adapt_prob(&pp[2], c[1], c[2], 24, uf);
3760  }
3761 
3762  if (s->keyframe || s->intraonly) {
3763  memcpy(p->skip, s->prob.p.skip, sizeof(p->skip));
3764  memcpy(p->tx32p, s->prob.p.tx32p, sizeof(p->tx32p));
3765  memcpy(p->tx16p, s->prob.p.tx16p, sizeof(p->tx16p));
3766  memcpy(p->tx8p, s->prob.p.tx8p, sizeof(p->tx8p));
3767  return;
3768  }
3769 
3770  // skip flag
3771  for (i = 0; i < 3; i++)
3772  adapt_prob(&p->skip[i], s->counts.skip[i][0], s->counts.skip[i][1], 20, 128);
3773 
3774  // intra/inter flag
3775  for (i = 0; i < 4; i++)
3776  adapt_prob(&p->intra[i], s->counts.intra[i][0], s->counts.intra[i][1], 20, 128);
3777 
3778  // comppred flag
3779  if (s->comppredmode == PRED_SWITCHABLE) {
3780  for (i = 0; i < 5; i++)
3781  adapt_prob(&p->comp[i], s->counts.comp[i][0], s->counts.comp[i][1], 20, 128);
3782  }
3783 
3784  // reference frames
3785  if (s->comppredmode != PRED_SINGLEREF) {
3786  for (i = 0; i < 5; i++)
3787  adapt_prob(&p->comp_ref[i], s->counts.comp_ref[i][0],
3788  s->counts.comp_ref[i][1], 20, 128);
3789  }
3790 
3791  if (s->comppredmode != PRED_COMPREF) {
3792  for (i = 0; i < 5; i++) {
3793  uint8_t *pp = p->single_ref[i];
3794  unsigned (*c)[2] = s->counts.single_ref[i];
3795 
3796  adapt_prob(&pp[0], c[0][0], c[0][1], 20, 128);
3797  adapt_prob(&pp[1], c[1][0], c[1][1], 20, 128);
3798  }
3799  }
3800 
3801  // block partitioning
3802  for (i = 0; i < 4; i++)
3803  for (j = 0; j < 4; j++) {
3804  uint8_t *pp = p->partition[i][j];
3805  unsigned *c = s->counts.partition[i][j];
3806 
3807  adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
3808  adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
3809  adapt_prob(&pp[2], c[2], c[3], 20, 128);
3810  }
3811 
3812  // tx size
3813  if (s->txfmmode == TX_SWITCHABLE) {
3814  for (i = 0; i < 2; i++) {
3815  unsigned *c16 = s->counts.tx16p[i], *c32 = s->counts.tx32p[i];
3816 
3817  adapt_prob(&p->tx8p[i], s->counts.tx8p[i][0], s->counts.tx8p[i][1], 20, 128);
3818  adapt_prob(&p->tx16p[i][0], c16[0], c16[1] + c16[2], 20, 128);
3819  adapt_prob(&p->tx16p[i][1], c16[1], c16[2], 20, 128);
3820  adapt_prob(&p->tx32p[i][0], c32[0], c32[1] + c32[2] + c32[3], 20, 128);
3821  adapt_prob(&p->tx32p[i][1], c32[1], c32[2] + c32[3], 20, 128);
3822  adapt_prob(&p->tx32p[i][2], c32[2], c32[3], 20, 128);
3823  }
3824  }
3825 
3826  // interpolation filter
3827  if (s->filtermode == FILTER_SWITCHABLE) {
3828  for (i = 0; i < 4; i++) {
3829  uint8_t *pp = p->filter[i];
3830  unsigned *c = s->counts.filter[i];
3831 
3832  adapt_prob(&pp[0], c[0], c[1] + c[2], 20, 128);
3833  adapt_prob(&pp[1], c[1], c[2], 20, 128);
3834  }
3835  }
3836 
3837  // inter modes
3838  for (i = 0; i < 7; i++) {
3839  uint8_t *pp = p->mv_mode[i];
3840  unsigned *c = s->counts.mv_mode[i];
3841 
3842  adapt_prob(&pp[0], c[2], c[1] + c[0] + c[3], 20, 128);
3843  adapt_prob(&pp[1], c[0], c[1] + c[3], 20, 128);
3844  adapt_prob(&pp[2], c[1], c[3], 20, 128);
3845  }
3846 
3847  // mv joints
3848  {
3849  uint8_t *pp = p->mv_joint;
3850  unsigned *c = s->counts.mv_joint;
3851 
3852  adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
3853  adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
3854  adapt_prob(&pp[2], c[2], c[3], 20, 128);
3855  }
3856 
3857  // mv components
3858  for (i = 0; i < 2; i++) {
3859  uint8_t *pp;
3860  unsigned *c, (*c2)[2], sum;
3861 
3862  adapt_prob(&p->mv_comp[i].sign, s->counts.mv_comp[i].sign[0],
3863  s->counts.mv_comp[i].sign[1], 20, 128);
3864 
3865  pp = p->mv_comp[i].classes;
3866  c = s->counts.mv_comp[i].classes;
3867  sum = c[1] + c[2] + c[3] + c[4] + c[5] + c[6] + c[7] + c[8] + c[9] + c[10];
3868  adapt_prob(&pp[0], c[0], sum, 20, 128);
3869  sum -= c[1];
3870  adapt_prob(&pp[1], c[1], sum, 20, 128);
3871  sum -= c[2] + c[3];
3872  adapt_prob(&pp[2], c[2] + c[3], sum, 20, 128);
3873  adapt_prob(&pp[3], c[2], c[3], 20, 128);
3874  sum -= c[4] + c[5];
3875  adapt_prob(&pp[4], c[4] + c[5], sum, 20, 128);
3876  adapt_prob(&pp[5], c[4], c[5], 20, 128);
3877  sum -= c[6];
3878  adapt_prob(&pp[6], c[6], sum, 20, 128);
3879  adapt_prob(&pp[7], c[7] + c[8], c[9] + c[10], 20, 128);
3880  adapt_prob(&pp[8], c[7], c[8], 20, 128);
3881  adapt_prob(&pp[9], c[9], c[10], 20, 128);
3882 
3883  adapt_prob(&p->mv_comp[i].class0, s->counts.mv_comp[i].class0[0],
3884  s->counts.mv_comp[i].class0[1], 20, 128);
3885  pp = p->mv_comp[i].bits;
3886  c2 = s->counts.mv_comp[i].bits;
3887  for (j = 0; j < 10; j++)
3888  adapt_prob(&pp[j], c2[j][0], c2[j][1], 20, 128);
3889 
3890  for (j = 0; j < 2; j++) {
3891  pp = p->mv_comp[i].class0_fp[j];
3892  c = s->counts.mv_comp[i].class0_fp[j];
3893  adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
3894  adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
3895  adapt_prob(&pp[2], c[2], c[3], 20, 128);
3896  }
3897  pp = p->mv_comp[i].fp;
3898  c = s->counts.mv_comp[i].fp;
3899  adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
3900  adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
3901  adapt_prob(&pp[2], c[2], c[3], 20, 128);
3902 
3903  if (s->highprecisionmvs) {
3904  adapt_prob(&p->mv_comp[i].class0_hp, s->counts.mv_comp[i].class0_hp[0],
3905  s->counts.mv_comp[i].class0_hp[1], 20, 128);
3906  adapt_prob(&p->mv_comp[i].hp, s->counts.mv_comp[i].hp[0],
3907  s->counts.mv_comp[i].hp[1], 20, 128);
3908  }
3909  }
3910 
3911  // y intra modes
3912  for (i = 0; i < 4; i++) {
3913  uint8_t *pp = p->y_mode[i];
3914  unsigned *c = s->counts.y_mode[i], sum, s2;
3915 
3916  sum = c[0] + c[1] + c[3] + c[4] + c[5] + c[6] + c[7] + c[8] + c[9];
3917  adapt_prob(&pp[0], c[DC_PRED], sum, 20, 128);
3918  sum -= c[TM_VP8_PRED];
3919  adapt_prob(&pp[1], c[TM_VP8_PRED], sum, 20, 128);
3920  sum -= c[VERT_PRED];
3921  adapt_prob(&pp[2], c[VERT_PRED], sum, 20, 128);
3922  s2 = c[HOR_PRED] + c[DIAG_DOWN_RIGHT_PRED] + c[VERT_RIGHT_PRED];
3923  sum -= s2;
3924  adapt_prob(&pp[3], s2, sum, 20, 128);
3925  s2 -= c[HOR_PRED];
3926  adapt_prob(&pp[4], c[HOR_PRED], s2, 20, 128);
3927  adapt_prob(&pp[5], c[DIAG_DOWN_RIGHT_PRED], c[VERT_RIGHT_PRED], 20, 128);
3928  sum -= c[DIAG_DOWN_LEFT_PRED];
3929  adapt_prob(&pp[6], c[DIAG_DOWN_LEFT_PRED], sum, 20, 128);
3930  sum -= c[VERT_LEFT_PRED];
3931  adapt_prob(&pp[7], c[VERT_LEFT_PRED], sum, 20, 128);
3932  adapt_prob(&pp[8], c[HOR_DOWN_PRED], c[HOR_UP_PRED], 20, 128);
3933  }
3934 
3935  // uv intra modes
3936  for (i = 0; i < 10; i++) {
3937  uint8_t *pp = p->uv_mode[i];
3938  unsigned *c = s->counts.uv_mode[i], sum, s2;
3939 
3940  sum = c[0] + c[1] + c[3] + c[4] + c[5] + c[6] + c[7] + c[8] + c[9];
3941  adapt_prob(&pp[0], c[DC_PRED], sum, 20, 128);
3942  sum -= c[TM_VP8_PRED];
3943  adapt_prob(&pp[1], c[TM_VP8_PRED], sum, 20, 128);
3944  sum -= c[VERT_PRED];
3945  adapt_prob(&pp[2], c[VERT_PRED], sum, 20, 128);
3946  s2 = c[HOR_PRED] + c[DIAG_DOWN_RIGHT_PRED] + c[VERT_RIGHT_PRED];
3947  sum -= s2;
3948  adapt_prob(&pp[3], s2, sum, 20, 128);
3949  s2 -= c[HOR_PRED];
3950  adapt_prob(&pp[4], c[HOR_PRED], s2, 20, 128);
3951  adapt_prob(&pp[5], c[DIAG_DOWN_RIGHT_PRED], c[VERT_RIGHT_PRED], 20, 128);
3952  sum -= c[DIAG_DOWN_LEFT_PRED];
3953  adapt_prob(&pp[6], c[DIAG_DOWN_LEFT_PRED], sum, 20, 128);
3954  sum -= c[VERT_LEFT_PRED];
3955  adapt_prob(&pp[7], c[VERT_LEFT_PRED], sum, 20, 128);
3956  adapt_prob(&pp[8], c[HOR_DOWN_PRED], c[HOR_UP_PRED], 20, 128);
3957  }
3958 }
3959 
3960 static void free_buffers(VP9Context *s)
3961 {
3962  av_freep(&s->intra_pred_data[0]);
3963  av_freep(&s->b_base);
3964  av_freep(&s->block_base);
3965 }
3966 
3967 static av_cold int vp9_decode_free(AVCodecContext *ctx)
3968 {
3969  VP9Context *s = ctx->priv_data;
3970  int i;
3971 
3972  for (i = 0; i < 3; i++) {
3973  if (s->frames[i].tf.f->data[0])
3974  vp9_unref_frame(ctx, &s->frames[i]);
3975  av_frame_free(&s->frames[i].tf.f);
3976  }
3977  for (i = 0; i < 8; i++) {
3978  if (s->refs[i].f->data[0])
3979  ff_thread_release_buffer(ctx, &s->refs[i]);
3980  av_frame_free(&s->refs[i].f);
3981  if (s->next_refs[i].f->data[0])
3982  ff_thread_release_buffer(ctx, &s->next_refs[i]);
3983  av_frame_free(&s->next_refs[i].f);
3984  }
3985  free_buffers(s);
3986  av_freep(&s->c_b);
3987  s->c_b_size = 0;
3988 
3989  return 0;
3990 }
3991 
3992 
3993 static int vp9_decode_frame(AVCodecContext *ctx, void *frame,
3994  int *got_frame, AVPacket *pkt)
3995 {
3996  const uint8_t *data = pkt->data;
3997  int size = pkt->size;
3998  VP9Context *s = ctx->priv_data;
3999  int res, tile_row, tile_col, i, ref, row, col;
4000  int retain_segmap_ref = s->frames[REF_FRAME_SEGMAP].segmentation_map &&
4001  (!s->segmentation.enabled || !s->segmentation.update_map);
4002  ptrdiff_t yoff, uvoff, ls_y, ls_uv;
4003  AVFrame *f;
4004  int bytesperpixel;
4005 
4006  if ((res = decode_frame_header(ctx, data, size, &ref)) < 0) {
4007  return res;
4008  } else if (res == 0) {
4009  if (!s->refs[ref].f->data[0]) {
4010  av_log(ctx, AV_LOG_ERROR, "Requested reference %d not available\n", ref);
4011  return AVERROR_INVALIDDATA;
4012  }
4013  if ((res = av_frame_ref(frame, s->refs[ref].f)) < 0)
4014  return res;
4015  ((AVFrame *)frame)->pkt_pts = pkt->pts;
4016  ((AVFrame *)frame)->pkt_dts = pkt->dts;
4017  for (i = 0; i < 8; i++) {
4018  if (s->next_refs[i].f->data[0])
4019  ff_thread_release_buffer(ctx, &s->next_refs[i]);
4020  if (s->refs[i].f->data[0] &&
4021  (res = ff_thread_ref_frame(&s->next_refs[i], &s->refs[i])) < 0)
4022  return res;
4023  }
4024  *got_frame = 1;
4025  return pkt->size;
4026  }
4027  data += res;
4028  size -= res;
4029 
4030  if (!retain_segmap_ref || s->keyframe || s->intraonly) {
4031  if (s->frames[REF_FRAME_SEGMAP].tf.f->data[0])
4032  vp9_unref_frame(ctx, &s->frames[REF_FRAME_SEGMAP]);
4033  if (!s->keyframe && !s->intraonly && !s->errorres && s->frames[CUR_FRAME].tf.f->data[0] &&
4034  (res = vp9_ref_frame(ctx, &s->frames[REF_FRAME_SEGMAP], &s->frames[CUR_FRAME])) < 0)
4035  return res;
4036  }
4037  if (s->frames[REF_FRAME_MVPAIR].tf.f->data[0])
4038  vp9_unref_frame(ctx, &s->frames[REF_FRAME_MVPAIR]);
4039  if (!s->intraonly && !s->keyframe && !s->errorres && s->frames[CUR_FRAME].tf.f->data[0] &&
4040  (res = vp9_ref_frame(ctx, &s->frames[REF_FRAME_MVPAIR], &s->frames[CUR_FRAME])) < 0)
4041  return res;
4042  if (s->frames[CUR_FRAME].tf.f->data[0])
4043  vp9_unref_frame(ctx, &s->frames[CUR_FRAME]);
4044  if ((res = vp9_alloc_frame(ctx, &s->frames[CUR_FRAME])) < 0)
4045  return res;
4046  f = s->frames[CUR_FRAME].tf.f;
4047  f->key_frame = s->keyframe;
4048  f->pict_type = (s->keyframe || s->intraonly) ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
4049  ls_y = f->linesize[0];
4050  ls_uv =f->linesize[1];
4051 
4052  // ref frame setup
4053  for (i = 0; i < 8; i++) {
4054  if (s->next_refs[i].f->data[0])
4055  ff_thread_release_buffer(ctx, &s->next_refs[i]);
4056  if (s->refreshrefmask & (1 << i)) {
4057  res = ff_thread_ref_frame(&s->next_refs[i], &s->frames[CUR_FRAME].tf);
4058  } else if (s->refs[i].f->data[0]) {
4059  res = ff_thread_ref_frame(&s->next_refs[i], &s->refs[i]);
4060  }
4061  if (res < 0)
4062  return res;
4063  }
4064 
4065  // main tile decode loop
4066  bytesperpixel = s->bytesperpixel;
4067  memset(s->above_partition_ctx, 0, s->cols);
4068  memset(s->above_skip_ctx, 0, s->cols);
4069  if (s->keyframe || s->intraonly) {
4070  memset(s->above_mode_ctx, DC_PRED, s->cols * 2);
4071  } else {
4072  memset(s->above_mode_ctx, NEARESTMV, s->cols);
4073  }
4074  memset(s->above_y_nnz_ctx, 0, s->sb_cols * 16);
4075  memset(s->above_uv_nnz_ctx[0], 0, s->sb_cols * 16 >> s->ss_h);
4076  memset(s->above_uv_nnz_ctx[1], 0, s->sb_cols * 16 >> s->ss_h);
4077  memset(s->above_segpred_ctx, 0, s->cols);
4078  s->pass = s->frames[CUR_FRAME].uses_2pass =
4079  ctx->active_thread_type == FF_THREAD_FRAME && s->refreshctx && !s->parallelmode;
4080  if ((res = update_block_buffers(ctx)) < 0) {
4081  av_log(ctx, AV_LOG_ERROR,
4082  "Failed to allocate block buffers\n");
4083  return res;
4084  }
4085  if (s->refreshctx && s->parallelmode) {
4086  int j, k, l, m;
4087 
4088  for (i = 0; i < 4; i++) {
4089  for (j = 0; j < 2; j++)
4090  for (k = 0; k < 2; k++)
4091  for (l = 0; l < 6; l++)
4092  for (m = 0; m < 6; m++)
4093  memcpy(s->prob_ctx[s->framectxid].coef[i][j][k][l][m],
4094  s->prob.coef[i][j][k][l][m], 3);
4095  if (s->txfmmode == i)
4096  break;
4097  }
4098  s->prob_ctx[s->framectxid].p = s->prob.p;
4099  ff_thread_finish_setup(ctx);
4100  } else if (!s->refreshctx) {
4101  ff_thread_finish_setup(ctx);
4102  }
4103 
4104  do {
4105  yoff = uvoff = 0;
4106  s->b = s->b_base;
4107  s->block = s->block_base;
4108  s->uvblock[0] = s->uvblock_base[0];
4109  s->uvblock[1] = s->uvblock_base[1];
4110  s->eob = s->eob_base;
4111  s->uveob[0] = s->uveob_base[0];
4112  s->uveob[1] = s->uveob_base[1];
4113 
4114  for (tile_row = 0; tile_row < s->tiling.tile_rows; tile_row++) {
4115  set_tile_offset(&s->tiling.tile_row_start, &s->tiling.tile_row_end,
4116  tile_row, s->tiling.log2_tile_rows, s->sb_rows);
4117  if (s->pass != 2) {
4118  for (tile_col = 0; tile_col < s->tiling.tile_cols; tile_col++) {
4119  int64_t tile_size;
4120 
4121  if (tile_col == s->tiling.tile_cols - 1 &&
4122  tile_row == s->tiling.tile_rows - 1) {
4123  tile_size = size;
4124  } else {
4125  tile_size = AV_RB32(data);
4126  data += 4;
4127  size -= 4;
4128  }
4129  if (tile_size > size) {
4130  ff_thread_report_progress(&s->frames[CUR_FRAME].tf, INT_MAX, 0);
4131  return AVERROR_INVALIDDATA;
4132  }
4133  ff_vp56_init_range_decoder(&s->c_b[tile_col], data, tile_size);
4134  if (vp56_rac_get_prob_branchy(&s->c_b[tile_col], 128)) { // marker bit
4135  ff_thread_report_progress(&s->frames[CUR_FRAME].tf, INT_MAX, 0);
4136  return AVERROR_INVALIDDATA;
4137  }
4138  data += tile_size;
4139  size -= tile_size;
4140  }
4141  }
4142 
4143  for (row = s->tiling.tile_row_start; row < s->tiling.tile_row_end;
4144  row += 8, yoff += ls_y * 64, uvoff += ls_uv * 64 >> s->ss_v) {
4145  struct VP9Filter *lflvl_ptr = s->lflvl;
4146  ptrdiff_t yoff2 = yoff, uvoff2 = uvoff;
4147 
4148  for (tile_col = 0; tile_col < s->tiling.tile_cols; tile_col++) {
4149  set_tile_offset(&s->tiling.tile_col_start, &s->tiling.tile_col_end,
4150  tile_col, s->tiling.log2_tile_cols, s->sb_cols);
4151 
4152  if (s->pass != 2) {
4153  memset(s->left_partition_ctx, 0, 8);
4154  memset(s->left_skip_ctx, 0, 8);
4155  if (s->keyframe || s->intraonly) {
4156  memset(s->left_mode_ctx, DC_PRED, 16);
4157  } else {
4158  memset(s->left_mode_ctx, NEARESTMV, 8);
4159  }
4160  memset(s->left_y_nnz_ctx, 0, 16);
4161  memset(s->left_uv_nnz_ctx, 0, 32);
4162  memset(s->left_segpred_ctx, 0, 8);
4163 
4164  memcpy(&s->c, &s->c_b[tile_col], sizeof(s->c));
4165  }
4166 
4167  for (col = s->tiling.tile_col_start;
4168  col < s->tiling.tile_col_end;
4169  col += 8, yoff2 += 64 * bytesperpixel,
4170  uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
4171  // FIXME integrate with lf code (i.e. zero after each
4172  // use, similar to invtxfm coefficients, or similar)
4173  if (s->pass != 1) {
4174  memset(lflvl_ptr->mask, 0, sizeof(lflvl_ptr->mask));
4175  }
4176 
4177  if (s->pass == 2) {
4178  decode_sb_mem(ctx, row, col, lflvl_ptr,
4179  yoff2, uvoff2, BL_64X64);
4180  } else {
4181  decode_sb(ctx, row, col, lflvl_ptr,
4182  yoff2, uvoff2, BL_64X64);
4183  }
4184  }
4185  if (s->pass != 2) {
4186  memcpy(&s->c_b[tile_col], &s->c, sizeof(s->c));
4187  }
4188  }
4189 
4190  if (s->pass == 1) {
4191  continue;
4192  }
4193 
4194  // backup pre-loopfilter reconstruction data for intra
4195  // prediction of next row of sb64s
4196  if (row + 8 < s->rows) {
4197  memcpy(s->intra_pred_data[0],
4198  f->data[0] + yoff + 63 * ls_y,
4199  8 * s->cols * bytesperpixel);
4200  memcpy(s->intra_pred_data[1],
4201  f->data[1] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
4202  8 * s->cols * bytesperpixel >> s->ss_h);
4203  memcpy(s->intra_pred_data[2],
4204  f->data[2] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
4205  8 * s->cols * bytesperpixel >> s->ss_h);
4206  }
4207 
4208  // loopfilter one row
4209  if (s->filter.level) {
4210  yoff2 = yoff;
4211  uvoff2 = uvoff;
4212  lflvl_ptr = s->lflvl;
4213  for (col = 0; col < s->cols;
4214  col += 8, yoff2 += 64 * bytesperpixel,
4215  uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
4216  loopfilter_sb(ctx, lflvl_ptr, row, col, yoff2, uvoff2);
4217  }
4218  }
4219 
4220  // FIXME maybe we can make this more finegrained by running the
4221  // loopfilter per-block instead of after each sbrow
4222  // In fact that would also make intra pred left preparation easier?
4223  ff_thread_report_progress(&s->frames[CUR_FRAME].tf, row >> 3, 0);
4224  }
4225  }
4226 
4227  if (s->pass < 2 && s->refreshctx && !s->parallelmode) {
4228  adapt_probs(s);
4229  ff_thread_finish_setup(ctx);
4230  }
4231  } while (s->pass++ == 1);
4232  ff_thread_report_progress(&s->frames[CUR_FRAME].tf, INT_MAX, 0);
4233 
4234  // ref frame setup
4235  for (i = 0; i < 8; i++) {
4236  if (s->refs[i].f->data[0])
4237  ff_thread_release_buffer(ctx, &s->refs[i]);
4238  ff_thread_ref_frame(&s->refs[i], &s->next_refs[i]);
4239  }
4240 
4241  if (!s->invisible) {
4242  if ((res = av_frame_ref(frame, s->frames[CUR_FRAME].tf.f)) < 0)
4243  return res;
4244  *got_frame = 1;
4245  }
4246 
4247  return pkt->size;
4248 }
4249 
4250 static void vp9_decode_flush(AVCodecContext *ctx)
4251 {
4252  VP9Context *s = ctx->priv_data;
4253  int i;
4254 
4255  for (i = 0; i < 3; i++)
4256  vp9_unref_frame(ctx, &s->frames[i]);
4257  for (i = 0; i < 8; i++)
4258  ff_thread_release_buffer(ctx, &s->refs[i]);
4259 }
4260 
4261 static int init_frames(AVCodecContext *ctx)
4262 {
4263  VP9Context *s = ctx->priv_data;
4264  int i;
4265 
4266  for (i = 0; i < 3; i++) {
4267  s->frames[i].tf.f = av_frame_alloc();
4268  if (!s->frames[i].tf.f) {
4269  vp9_decode_free(ctx);
4270  av_log(ctx, AV_LOG_ERROR, "Failed to allocate frame buffer %d\n", i);
4271  return AVERROR(ENOMEM);
4272  }
4273  }
4274  for (i = 0; i < 8; i++) {
4275  s->refs[i].f = av_frame_alloc();
4276  s->next_refs[i].f = av_frame_alloc();
4277  if (!s->refs[i].f || !s->next_refs[i].f) {
4278  vp9_decode_free(ctx);
4279  av_log(ctx, AV_LOG_ERROR, "Failed to allocate frame buffer %d\n", i);
4280  return AVERROR(ENOMEM);
4281  }
4282  }
4283 
4284  return 0;
4285 }
4286 
4287 static av_cold int vp9_decode_init(AVCodecContext *ctx)
4288 {
4289  VP9Context *s = ctx->priv_data;
4290 
4291  ctx->internal->allocate_progress = 1;
4292  s->last_bpp = 0;
4293  s->filter.sharpness = -1;
4294 
4295  return init_frames(ctx);
4296 }
4297 
4298 static av_cold int vp9_decode_init_thread_copy(AVCodecContext *avctx)
4299 {
4300  return init_frames(avctx);
4301 }
4302 
4303 static int vp9_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
4304 {
4305  int i, res;
4306  VP9Context *s = dst->priv_data, *ssrc = src->priv_data;
4307 
4308  // detect size changes in other threads
4309  if (s->intra_pred_data[0] &&
4310  (!ssrc->intra_pred_data[0] || s->cols != ssrc->cols || s->rows != ssrc->rows)) {
4311  free_buffers(s);
4312  }
4313 
4314  for (i = 0; i < 3; i++) {
4315  if (s->frames[i].tf.f->data[0])
4316  vp9_unref_frame(dst, &s->frames[i]);
4317  if (ssrc->frames[i].tf.f->data[0]) {
4318  if ((res = vp9_ref_frame(dst, &s->frames[i], &ssrc->frames[i])) < 0)
4319  return res;
4320  }
4321  }
4322  for (i = 0; i < 8; i++) {
4323  if (s->refs[i].f->data[0])
4324  ff_thread_release_buffer(dst, &s->refs[i]);
4325  if (ssrc->next_refs[i].f->data[0]) {
4326  if ((res = ff_thread_ref_frame(&s->refs[i], &ssrc->next_refs[i])) < 0)
4327  return res;
4328  }
4329  }
4330 
4331  s->invisible = ssrc->invisible;
4332  s->keyframe = ssrc->keyframe;
4333  s->intraonly = ssrc->intraonly;
4334  s->ss_v = ssrc->ss_v;
4335  s->ss_h = ssrc->ss_h;
4336  s->segmentation.enabled = ssrc->segmentation.enabled;
4337  s->segmentation.update_map = ssrc->segmentation.update_map;
4338  s->bytesperpixel = ssrc->bytesperpixel;
4339  s->bpp = ssrc->bpp;
4340  s->bpp_index = ssrc->bpp_index;
4341  memcpy(&s->prob_ctx, &ssrc->prob_ctx, sizeof(s->prob_ctx));
4342  memcpy(&s->lf_delta, &ssrc->lf_delta, sizeof(s->lf_delta));
4343  if (ssrc->segmentation.enabled) {
4344  memcpy(&s->segmentation.feat, &ssrc->segmentation.feat,
4345  sizeof(s->segmentation.feat));
4346  }
4347 
4348  return 0;
4349 }
4350 
4351 static const AVProfile profiles[] = {
4352  { FF_PROFILE_VP9_0, "Profile 0" },
4353  { FF_PROFILE_VP9_1, "Profile 1" },
4354  { FF_PROFILE_VP9_2, "Profile 2" },
4355  { FF_PROFILE_VP9_3, "Profile 3" },
4356  { FF_PROFILE_UNKNOWN },
4357 };
4358 
4359 AVCodec ff_vp9_decoder = {
4360  .name = "vp9",
4361  .long_name = NULL_IF_CONFIG_SMALL("Google VP9"),
4362  .type = AVMEDIA_TYPE_VIDEO,
4363  .id = AV_CODEC_ID_VP9,
4364  .priv_data_size = sizeof(VP9Context),
4365  .init = vp9_decode_init,
4366  .close = vp9_decode_free,
4367  .decode = vp9_decode_frame,
4368  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
4369  .flush = vp9_decode_flush,
4370  .init_thread_copy = ONLY_IF_THREADS_ENABLED(vp9_decode_init_thread_copy),
4371  .update_thread_context = ONLY_IF_THREADS_ENABLED(vp9_decode_update_thread_context),
4372  .profiles = NULL_IF_CONFIG_SMALL(profiles),
4373 };
AVCOL_SPC_BT709
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
Definition: pixfmt.h:519
VP9Frame::tf
ThreadFrame tf
Definition: vp9.c:74
BlockPartition
BlockPartition
Definition: vp9data.h:29
CompPredMode
CompPredMode
Definition: vp9.c:38
NULL
#define NULL
Definition: coverity.c:32
prob_context::skip
uint8_t skip[3]
Definition: vp9data.h:1455
VP9Context::resetctx
uint8_t resetctx
Definition: vp9.c:118
AV_CODEC_ID_VP9
Definition: avcodec.h:276
VP9Context::frames
VP9Frame frames[3]
Definition: vp9.c:134
val
const char const char void * val
Definition: avisynth_c.h:634
BS_32x64
Definition: vp9.c:54
VP9Context::hp
unsigned hp[2]
Definition: vp9.c:207
HOR_PRED
Definition: vp9.h:47
v
float v
Definition: avf_showspectrum.c:96
s
const char * s
Definition: avisynth_c.h:631
VP9Context::lossless
uint8_t lossless
Definition: vp9.c:149
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
VP9Frame::segmentation_map
uint8_t * segmentation_map
Definition: vp9.c:76
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:382
av_buffer_unref
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:124
filter_plane_cols
static av_always_inline void filter_plane_cols(VP9Context *s, int col, int ss_h, int ss_v, uint8_t *lvl, uint8_t(*mask)[4], uint8_t *dst, ptrdiff_t ls)
Definition: vp9.c:3534
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:171
set_tile_offset
static void set_tile_offset(int *start, int *end, int idx, int log2_n, int n)
Definition: vp9.c:3712
h
h
Definition: vp9dsp_template.c:2093
VP9Context::comp_ref
unsigned comp_ref[5][2]
Definition: vp9.c:193
data
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:490
BS_64x32
Definition: vp9.c:53
VP9Context::mblim_lut
uint8_t mblim_lut[64]
Definition: vp9.c:140
VP9Context::left_segpred_ctx
uint8_t left_segpred_ctx[8]
Definition: vp9.c:224
vp56.h
VP5 and VP6 compatible video decoder (common features)
get_sbits_inv
static av_always_inline int get_sbits_inv(GetBitContext *gb, int n)
Definition: vp9.c:415
vp9_segmentation_tree
static const int8_t vp9_segmentation_tree[7][2]
Definition: vp9data.h:66
VP9Context::feat
struct VP9Context::@107::@113 feat[MAX_SEGMENT]
vp9_model_pareto8
static const uint8_t vp9_model_pareto8[256][8]
Definition: vp9data.h:1184
VP9Context::above_skip_ctx
uint8_t * above_skip_ctx
Definition: vp9.c:234
VP9Context::eob_base
uint8_t * eob_base
Definition: vp9.c:251
prob_context::comp
uint8_t comp[5]
Definition: vp9data.h:1449
fmt
const char * fmt
Definition: avisynth_c.h:632
filter_plane_rows
static av_always_inline void filter_plane_rows(VP9Context *s, int row, int ss_h, int ss_v, uint8_t *lvl, uint8_t(*mask)[4], uint8_t *dst, ptrdiff_t ls)
Definition: vp9.c:3609
VP9Context::mvstep
uint8_t mvstep[3][2]
Definition: vp9.c:256
AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:68
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:260
prob_context::fp
uint8_t fp[3]
Definition: vp9data.h:1463
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
ThreadFrame::f
AVFrame * f
Definition: thread.h:36
vp8_rac_get_tree
static av_always_inline int vp8_rac_get_tree(VP56RangeCoder *c, const int8_t(*tree)[2], const uint8_t *probs)
Definition: vp56.h:376
BS_32x16
Definition: vp9.c:56
VP9Context::row
int row
Definition: vp9.c:106
INVALID_MV
#define INVALID_MV
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
prob_context::tx32p
uint8_t tx32p[2][3]
Definition: vp9data.h:1452
SPLAT_CTX
#define SPLAT_CTX(var, val, n)
vp9_alloc_frame
static int vp9_alloc_frame(AVCodecContext *ctx, VP9Frame *f)
Definition: vp9.c:269
vp9_default_kf_ymode_probs
static const uint8_t vp9_default_kf_ymode_probs[10][10][9]
Definition: vp9data.h:88
decode_coeffs_b_8bpp
static int decode_coeffs_b_8bpp(VP9Context *s, int16_t *coef, int n_coeffs, unsigned(*cnt)[6][3], unsigned(*eob)[6][2], uint8_t(*p)[6][11], int nnz, const int16_t *scan, const int16_t(*nb)[2], const int16_t *band_counts, const int16_t *qmul)
Definition: vp9.c:2291
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:523
VP9Context::vdsp
VideoDSPContext vdsp
Definition: vp9.c:99
VP9Context::uvdc_qdelta
int8_t uvdc_qdelta
Definition: vp9.c:148
vp9_mv_fp_tree
static const int8_t vp9_mv_fp_tree[3][2]
Definition: vp9data.h:2285
check_intra_mode
static av_always_inline int check_intra_mode(VP9Context *s, int mode, uint8_t **a, uint8_t *dst_edge, ptrdiff_t stride_edge, uint8_t *dst_inner, ptrdiff_t stride_inner, uint8_t *l, int col, int x, int w, int row, int y, enum TxfmMode tx, int p, int ss_h, int ss_v, int bytesperpixel)
Definition: vp9.c:2508
prob_context::tx16p
uint8_t tx16p[2][2]
Definition: vp9data.h:1453
VP9Context::last_keyframe
uint8_t last_keyframe
Definition: vp9.c:111
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2237
AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:188
VP9Context::ss_v
uint8_t ss_v
Definition: vp9.c:116
SET_CTXS
#define SET_CTXS(dir, off, n)
AVPacket::size
int size
Definition: avcodec.h:1424
b
const char * b
Definition: vf_curves.c:109
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:396
vp9_intramode_tree
static const int8_t vp9_intramode_tree[9][2]
Definition: vp9data.h:76
FF_CODEC_PROPERTY_LOSSLESS
#define FF_CODEC_PROPERTY_LOSSLESS
Definition: avcodec.h:3436
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:53
BS_64x64
Definition: vp9.c:52
AVCOL_SPC_SMPTE170M
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above ...
Definition: pixfmt.h:524
vp9_default_kf_uvmode_probs
static const uint8_t vp9_default_kf_uvmode_probs[10][9]
Definition: vp9data.h:202
VP9Frame::mv
struct VP9mvrefPair * mv
Definition: vp9.c:77
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1722
VP9Context::skip
unsigned skip[3][2]
Definition: vp9.c:197
REF_FRAME_SEGMAP
#define REF_FRAME_SEGMAP
Definition: vp9.c:133
prob_context
Definition: vp9data.h:1443
VP9Context::left_uv_nnz_ctx
uint8_t left_uv_nnz_ctx[2][16]
Definition: vp9.c:220
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:384
VP9Context::tile_cols
unsigned tile_cols
Definition: vp9.c:171
VP9Context::lf_enabled
uint8_t lf_enabled
Definition: vp9.c:159
update_size
static int update_size(AVCodecContext *ctx, int w, int h, enum AVPixelFormat fmt)
Definition: vp9.c:313
t8
#define t8
Definition: regdef.h:53
adapt_probs
static void adapt_probs(VP9Context *s)
Definition: vp9.c:3738
VP9DSPContext::intra_pred
void(* intra_pred[N_TXFM_SIZES][N_INTRA_PRED_MODES])(uint8_t *dst, ptrdiff_t stride, const uint8_t *left, const uint8_t *top)
Definition: vp9dsp.h:51
VP9Block
Definition: vp9.c:87
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
decode_frame_header
static int decode_frame_header(AVCodecContext *ctx, const uint8_t *data, int size, int *ref)
Definition: vp9.c:547
VP9Context::parallelmode
uint8_t parallelmode
Definition: vp9.c:125
ff_thread_await_progress
void ff_thread_await_progress(ThreadFrame *f, int n, int field)
Wait for earlier decoding threads to finish reference pictures.
Definition: pthread_frame.c:514
mask_edges
static av_always_inline void mask_edges(uint8_t(*mask)[8][4], int ss_h, int ss_v, int row_and_7, int col_and_7, int w, int h, int col_end, int row_end, enum TxfmMode tx, int skip_inter)
Definition: vp9.c:3085
VP9Context::cols
unsigned cols
Definition: vp9.c:174
VP9Context::tile_col_end
unsigned tile_col_end
Definition: vp9.c:172
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:3115
prob_context::class0_hp
uint8_t class0_hp
Definition: vp9data.h:1464
VP9Block::ref
uint8_t ref[2]
Definition: vp9.c:88
AVCodec
AVCodec.
Definition: avcodec.h:3472
prob_context::intra
uint8_t intra[4]
Definition: vp9data.h:1448
vp9_decode_frame
static int vp9_decode_frame(AVCodecContext *ctx, void *frame, int *got_frame, AVPacket *pkt)
Definition: vp9.c:3993
AVCOL_SPC_RGB
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
Definition: pixfmt.h:518
AV_WN32A
#define AV_WN32A(p, v)
Definition: intreadwrite.h:538
AV_COPY32
#define AV_COPY32(d, s)
Definition: intreadwrite.h:586
VP9Context::fp
unsigned fp[4]
Definition: vp9.c:205
VP9Context::update_map
uint8_t update_map
Definition: vp9.c:155
TX_8X8
Definition: vp9.h:29
VP9Context::max_mv
struct VP9Context::@112 max_mv
VP9Context::intra_pred_data
uint8_t * intra_pred_data[3]
Definition: vp9.c:244
band
Definition: af_biquads.c:76
VP9Context::errorres
uint8_t errorres
Definition: vp9.c:115
VP9Context::y
int y
Definition: vp9.c:252
VP9Context::varcompref
uint8_t varcompref[2]
Definition: vp9.c:129
AV_RN32A
#define AV_RN32A(p)
Definition: intreadwrite.h:526
BS_4x8
Definition: vp9.c:63
VP9Context::uv_mode
unsigned uv_mode[10][10]
Definition: vp9.c:187
VP9DSPContext::mc
vp9_mc_func mc[5][4][2][2][2]
Definition: vp9dsp.h:114
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
intra_recon_16bpp
static void intra_recon_16bpp(AVCodecContext *ctx, ptrdiff_t y_off, ptrdiff_t uv_off)
Definition: vp9.c:2764
VP56mv::y
int16_t y
Definition: vp56.h:67
vp9_unref_frame
static void vp9_unref_frame(AVCodecContext *ctx, VP9Frame *f)
Definition: vp9.c:288
VideoDSPContext::emulated_edge_mc
void(* emulated_edge_mc)(uint8_t *dst, const uint8_t *src, ptrdiff_t dst_linesize, ptrdiff_t src_linesize, int block_w, int block_h, int src_x, int src_y, int w, int h)
Copy a rectangular area of samples to a temporary buffer and replicate the border samples...
Definition: videodsp.h:63
VP9Context::coef
uint8_t coef[4][2][2][6][6][3]
Definition: vp9.c:177
VP9_SYNCCODE
#define VP9_SYNCCODE
Definition: vp9.c:36
inter_recon
static av_always_inline void inter_recon(AVCodecContext *ctx, int bytesperpixel)
Definition: vp9.c:3009
bits
uint8_t bits
Definition: crc.c:295
mem
int mem
Definition: avisynth_c.h:684
uint8_t
uint8_t
Definition: audio_convert.c:194
av_cold
#define av_cold
Definition: attributes.h:74
vp9_decode_update_thread_context
static int vp9_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: vp9.c:4303
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:135
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:63
BS_16x16
Definition: vp9.c:58
VP9Context::qmul
int16_t qmul[2][2]
Definition: vp9.c:165
VP9Context::y_mode
unsigned y_mode[4][10]
Definition: vp9.c:186
mode
mode
Definition: f_perms.c:27
H
#define H
Definition: swscale-test.c:344
TxfmType
TxfmType
Definition: vp9.h:37
AVColorSpace
AVColorSpace
YUV colorspace type.
Definition: pixfmt.h:517
prob_context::classes
uint8_t classes[10]
Definition: vp9data.h:1459
free_buffers
static void free_buffers(VP9Context *s)
Definition: vp9.c:3960
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
thread.h
Multithreading support functions.
VERT_PRED
Definition: vp9.h:46
VP9Context::bpp
uint8_t bpp
Definition: vp9.c:112
vp9_ac_qlookup
static const int16_t vp9_ac_qlookup[3][256]
Definition: vp9data.h:342
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:365
FF_PROFILE_UNKNOWN
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:3116
vp9_mc_template.c
VP9Context::uveob_base
uint8_t * uveob_base[2]
Definition: vp9.c:251
vp9_default_coef_probs
static const uint8_t vp9_default_coef_probs[4][2][2][6][6][3]
Definition: vp9data.h:1575
VP9Context::col
int col
Definition: vp9.c:106
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:87
VP9Context::prob_ctx
struct VP9Context::@109 prob_ctx[4]
VP9Context::log2_tile_rows
unsigned log2_tile_rows
Definition: vp9.c:170
frame
static AVFrame * frame
Definition: demuxing_decoding.c:53
BlockLevel
BlockLevel
Definition: vp9.c:44
vp9_decode_free
static av_cold int vp9_decode_free(AVCodecContext *ctx)
Definition: vp9.c:3967
AVPacket::data
uint8_t * data
Definition: avcodec.h:1423
VP9Frame::extradata
AVBufferRef * extradata
Definition: vp9.c:75
ff_thread_ref_frame
int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
Definition: utils.c:3762
get_bits.h
bitstream reader API header.
VP9Context::above_uv_nnz_ctx
uint8_t * above_uv_nnz_ctx[2]
Definition: vp9.c:233
VP9Context::dsp
VP9DSPContext dsp
Definition: vp9.c:98
VP9Context::lim_lut
uint8_t lim_lut[64]
Definition: vp9.c:139
clamp_mv
static av_always_inline void clamp_mv(VP56mv *dst, const VP56mv *src, VP9Context *s)
Definition: vp9.c:1081
size
ptrdiff_t size
Definition: opengl_enc.c:101
VP9Context::sign
unsigned sign[2]
Definition: vp9.c:200
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:385
DCT_DCT
Definition: vp9.h:38
decode_sb
static void decode_sb(AVCodecContext *ctx, int row, int col, struct VP9Filter *lflvl, ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
Definition: vp9.c:3406
ff_thread_finish_setup
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...
Definition: pthread_frame.c:532
VP9Context::mvscale
uint16_t mvscale[3][2]
Definition: vp9.c:255
VP9Block::mode
uint8_t mode[4]
Definition: vp9.c:88
VP9Filter
Definition: vp9.c:81
VP9Context::left_ref_ctx
uint8_t left_ref_ctx[8]
Definition: vp9.c:227
VP9Context::mv_comp
struct VP9Context::@111::@114 mv_comp[2]
VP9Context::x
int x
Definition: vp9.c:252
VP9Context::above_txfm_ctx
uint8_t * above_txfm_ctx
Definition: vp9.c:235
assign_val
#define assign_val(c, i, v)
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
VP9Context::ref
int8_t ref[4]
Definition: vp9.c:145
intra_recon_8bpp
static void intra_recon_8bpp(AVCodecContext *ctx, ptrdiff_t y_off, ptrdiff_t uv_off)
Definition: vp9.c:2759
m
unsigned m
Definition: audioconvert.c:187
TX_16X16
Definition: vp9.h:30
VP9Context::block
int16_t * block
Definition: vp9.c:250
VP9Context::bytesperpixel
uint8_t bytesperpixel
Definition: vp9.c:112
VP9Context::fixcompref
uint8_t fixcompref
Definition: vp9.c:123
VP9Filter::mask
uint8_t mask[2][2][8][4]
Definition: vp9.c:84
VP9Context::uvblock
int16_t * uvblock[2]
Definition: vp9.c:250
BL_32X32
Definition: vp9.c:46
TX_4X4
Definition: vp9.h:28
VP9Context::keyframe
uint8_t keyframe
Definition: vp9.c:111
AVFrame::width
int width
width and height of the video frame
Definition: frame.h:220
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
VP9Context::allowcompinter
uint8_t allowcompinter
Definition: vp9.c:122
VP9Context::sharpness
int8_t sharpness
Definition: vp9.c:138
av_fast_realloc
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given block if it is not large enough, otherwise do nothing.
Definition: mem.c:480
s2
#define s2
Definition: regdef.h:39
ff_thread_release_buffer
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
Definition: pthread_frame.c:886
update_block_buffers
static int update_block_buffers(AVCodecContext *ctx)
Definition: vp9.c:372
VP9Context::mv_mode
unsigned mv_mode[7][4]
Definition: vp9.c:189
mask
static const uint16_t mask[17]
Definition: lzw.c:38
VP9Context::comppredmode
enum CompPredMode comppredmode
Definition: vp9.c:214
vp9_mv_class_tree
static const int8_t vp9_mv_class_tree[10][2]
Definition: vp9data.h:2272
VP9Context::left_partition_ctx
uint8_t left_partition_ctx[8]
Definition: vp9.c:221
BS_8x4
Definition: vp9.c:62
AVERROR
#define AVERROR(e)
Definition: error.h:43
prob_context::comp_ref
uint8_t comp_ref[5]
Definition: vp9data.h:1451
VP9Context::gb
GetBitContext gb
Definition: vp9.c:100
VP9Context::uv_stride
ptrdiff_t uv_stride
Definition: vp9.c:108
prob_context::single_ref
uint8_t single_ref[5][2]
Definition: vp9data.h:1450
prob_context::mv_mode
uint8_t mv_mode[7][3]
Definition: vp9data.h:1447
prob_context::filter
uint8_t filter[4][2]
Definition: vp9data.h:1446
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:148
VP9Context::mv_joint
unsigned mv_joint[4]
Definition: vp9.c:198
vp9_filter_lut
static enum FilterMode vp9_filter_lut[3]
Definition: vp9data.h:233
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:175
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:3052
VP9Context::lf_delta
struct VP9Context::@106 lf_delta
r
const char * r
Definition: vf_curves.c:107
VP9Context::tiling
struct VP9Context::@108 tiling
VP9Context::tile_row_start
unsigned tile_row_start
Definition: vp9.c:172
decode_coeffs_8bpp
static int decode_coeffs_8bpp(AVCodecContext *ctx)
Definition: vp9.c:2498
prob_context::mv_comp
struct prob_context::@115 mv_comp[2]
inter_recon_16bpp
static void inter_recon_16bpp(AVCodecContext *ctx)
Definition: vp9.c:3080
VP9Context::bpp_index
uint8_t bpp_index
Definition: vp9.c:112
VP9Block::intra
uint8_t intra
Definition: vp9.c:88
MERGE_CTX
#define MERGE_CTX(step, rd)
decode_coeffs_b32_8bpp
static int decode_coeffs_b32_8bpp(VP9Context *s, int16_t *coef, int n_coeffs, unsigned(*cnt)[6][3], unsigned(*eob)[6][2], uint8_t(*p)[6][11], int nnz, const int16_t *scan, const int16_t(*nb)[2], const int16_t *band_counts, const int16_t *qmul)
Definition: vp9.c:2301
TxfmMode
TxfmMode
Definition: vp9.h:27
mc_chroma_unscaled
static av_always_inline void mc_chroma_unscaled(VP9Context *s, vp9_mc_func(*mc)[2], uint8_t *dst_u, uint8_t *dst_v, ptrdiff_t dst_stride, const uint8_t *ref_u, ptrdiff_t src_stride_u, const uint8_t *ref_v, ptrdiff_t src_stride_v, ThreadFrame *ref_frame, ptrdiff_t y, ptrdiff_t x, const VP56mv *mv, int bw, int bh, int w, int h, int bytesperpixel)
Definition: vp9.c:2941
avassert.h
simple assert() macros that are a bit more flexible than ISO C assert().
find_ref_mvs
static void find_ref_mvs(VP9Context *s, VP56mv *pmv, int ref, int z, int idx, int sb)
Definition: vp9.c:1088
vp9_intra_txfm_type
static enum TxfmType vp9_intra_txfm_type[14]
Definition: vp9data.h:445
VP9Context::refidx
uint8_t refidx[3]
Definition: vp9.c:127
AVCodec::name
const char * name
Name of the codec implementation.
Definition: avcodec.h:3479
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:383
VP9Context::comp
unsigned comp[5][2]
Definition: vp9.c:191
VP9Context::tx8p
unsigned tx8p[2][2]
Definition: vp9.c:196
VP9Context::uvblock_base
int16_t * uvblock_base[2]
Definition: vp9.c:250
VP9Context::use_last_frame_mvs
uint8_t use_last_frame_mvs
Definition: vp9.c:114
FFMAX
#define FFMAX(a, b)
Definition: common.h:79
avcodec.h
Libavcodec external API header.
prob_context::class0_fp
uint8_t class0_fp[2][3]
Definition: vp9data.h:1462
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:920
VP9Context
Definition: vp9.c:97
VP9Context::above_filter_ctx
uint8_t * above_filter_ctx
Definition: vp9.c:240
RETURN_DIRECT_MV
#define RETURN_DIRECT_MV(mv)
prob_context::hp
uint8_t hp
Definition: vp9data.h:1465
AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:67
ONLY_IF_THREADS_ENABLED
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:214
VP9Context::tile_rows
unsigned tile_rows
Definition: vp9.c:171
BL_64X64
Definition: vp9.c:45
VP9Context::lflvl
struct VP9Filter * lflvl
Definition: vp9.c:245
vp9_decode_flush
static void vp9_decode_flush(AVCodecContext *ctx)
Definition: vp9.c:4250
CUR_FRAME
#define CUR_FRAME
Definition: vp9.c:131
loopfilter_sb
static void loopfilter_sb(AVCodecContext *ctx, struct VP9Filter *lflvl, int row, int col, ptrdiff_t yoff, ptrdiff_t uvoff)
Definition: vp9.c:3686
VP9Context::c_b_size
unsigned c_b_size
Definition: vp9.c:103
VP9Context::yac_qi
uint8_t yac_qi
Definition: vp9.c:147
mc_chroma_scaled
static av_always_inline void mc_chroma_scaled(VP9Context *s, vp9_scaled_mc_func smc, uint8_t *dst_u, uint8_t *dst_v, ptrdiff_t dst_stride, const uint8_t *ref_u, ptrdiff_t src_stride_u, const uint8_t *ref_v, ptrdiff_t src_stride_v, ThreadFrame *ref_frame, ptrdiff_t y, ptrdiff_t x, const VP56mv *in_mv, int px, int py, int pw, int ph, int bw, int bh, int w, int h, int bytesperpixel, const uint16_t *scale, const uint8_t *step)
Definition: vp9.c:2816
th
#define th
Definition: regdef.h:75
ff_videodsp_init
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:38
decode_mode
static void decode_mode(AVCodecContext *ctx)
Definition: vp9.c:1462
AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:266
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:242
VP9Frame::uses_2pass
int uses_2pass
Definition: vp9.c:78
E
#define E
Definition: avdct.c:32
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
VP9Context::framectxid
uint8_t framectxid
Definition: vp9.c:126
VP9Context::class0_fp
unsigned class0_fp[2][4]
Definition: vp9.c:204
scale_mv
#define scale_mv(n, dim)
FFMIN
#define FFMIN(a, b)
Definition: common.h:81
VP9Context::left_mv_ctx
VP56mv left_mv_ctx[16][2]
Definition: vp9.c:219
VP9Context::left_y_nnz_ctx
uint8_t left_y_nnz_ctx[16]
Definition: vp9.c:217
y
float y
Definition: avf_showspectrum.c:96
VP9mvrefPair::ref
int8_t ref[2]
Definition: vp9.c:70
VP9Filter::level
uint8_t level[8 *8]
Definition: vp9.c:82
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:1681
VP9Context::col7
int col7
Definition: vp9.c:106
decode_coeffs_16bpp
static int decode_coeffs_16bpp(AVCodecContext *ctx)
Definition: vp9.c:2503
VP9Context::left_mode_ctx
uint8_t left_mode_ctx[16]
Definition: vp9.c:218
decode_sb_mem
static void decode_sb_mem(AVCodecContext *ctx, int row, int col, struct VP9Filter *lflvl, ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
Definition: vp9.c:3485
VP9Context::eob
unsigned eob[4][2][2][6][6][2]
Definition: vp9.c:211
AVCOL_SPC_BT2020_NCL
ITU-R BT2020 non-constant luminance system.
Definition: pixfmt.h:527
VP9DSPContext::loop_filter_16
void(* loop_filter_16[2])(uint8_t *dst, ptrdiff_t stride, int mb_lim, int lim, int hev_thr)
Definition: vp9dsp.h:88
ff_thread_report_progress
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
Definition: pthread_frame.c:496
prob_context::partition
uint8_t partition[4][4][3]
Definition: vp9data.h:1467
profiles
static const AVProfile profiles[]
Definition: vp9.c:4351
VP9Context::tx32p
unsigned tx32p[2][4]
Definition: vp9.c:194
VP9Context::tx16p
unsigned tx16p[2][3]
Definition: vp9.c:195
mc_luma_unscaled
static av_always_inline void mc_luma_unscaled(VP9Context *s, vp9_mc_func(*mc)[2], uint8_t *dst, ptrdiff_t dst_stride, const uint8_t *ref, ptrdiff_t ref_stride, ThreadFrame *ref_frame, ptrdiff_t y, ptrdiff_t x, const VP56mv *mv, int bw, int bh, int w, int h, int bytesperpixel)
Definition: vp9.c:2909
ff_vp9dsp_init
av_cold void ff_vp9dsp_init(VP9DSPContext *dsp, int bpp)
Definition: vp9dsp.c:28
VP9Context::filtermode
enum FilterMode filtermode
Definition: vp9.c:121
inter_recon_8bpp
static void inter_recon_8bpp(AVCodecContext *ctx)
Definition: vp9.c:3075
bwh_tab
static const uint8_t bwh_tab[2][N_BS_SIZES][2]
Definition: vp9.c:259
VP9Context::ref_val
uint8_t ref_val
Definition: vp9.c:162
VP9Block::uvmode
uint8_t uvmode
Definition: vp9.c:88
VP9Context::above_partition_ctx
uint8_t * above_partition_ctx
Definition: vp9.c:229
n
int n
Definition: avisynth_c.h:547
VP9Context::tmp_y
uint8_t tmp_y[64 *64 *2]
Definition: vp9.c:253
VP9Context::left_comp_ctx
uint8_t left_comp_ctx[8]
Definition: vp9.c:226
AV_WN64A
#define AV_WN64A(p, v)
Definition: intreadwrite.h:542
AV_WN16A
#define AV_WN16A(p, v)
Definition: intreadwrite.h:534
vp9_decode_init_thread_copy
static av_cold int vp9_decode_init_thread_copy(AVCodecContext *avctx)
Definition: vp9.c:4298
L
#define L(x)
Definition: vp56_arith.h:36
vp9_inter_mode_tree
static const int8_t vp9_inter_mode_tree[3][2]
Definition: vp9data.h:222
vp56_rac_get_prob
#define vp56_rac_get_prob
Definition: vp56.h:250
init_frames
static int init_frames(AVCodecContext *ctx)
Definition: vp9.c:4261
VP9Context::above_segpred_ctx
uint8_t * above_segpred_ctx
Definition: vp9.c:236
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen_template.c:36
VP9Context::tile_col_start
unsigned tile_col_start
Definition: vp9.c:172
AVCOL_RANGE_JPEG
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:540
VP9Context::intra
unsigned intra[4][2]
Definition: vp9.c:190
mc
#define mc
Definition: vf_colormatrix.c:107
pred
static const float pred[4]
Definition: siprdata.h:259
VP9Context::rows
unsigned rows
Definition: vp9.c:174
VP9Context::sb_cols
unsigned sb_cols
Definition: vp9.c:174
mv
static const int8_t mv[256][2]
Definition: 4xm.c:77
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:232
prob_context::sign
uint8_t sign
Definition: vp9data.h:1458
VP9Context::enabled
uint8_t enabled
Definition: vp9.c:143
VP9DSPContext::loop_filter_mix2
void(* loop_filter_mix2[2][2][2])(uint8_t *dst, ptrdiff_t stride, int mb_lim, int lim, int hev_thr)
Definition: vp9dsp.h:102
vp56_rac_get_prob_branchy
static av_always_inline int vp56_rac_get_prob_branchy(VP56RangeCoder *c, int prob)
Definition: vp56.h:267
vp9_scaled_mc_func
void(* vp9_scaled_mc_func)(uint8_t *dst, ptrdiff_t dst_stride, const uint8_t *ref, ptrdiff_t ref_stride, int h, int mx, int my, int dx, int dy)
Definition: vp9dsp.h:35
VP9Context::row7
int row7
Definition: vp9.c:106
VP9Context::uvac_qdelta
int8_t uvac_qdelta
Definition: vp9.c:148
FilterMode
FilterMode
Definition: vp9.h:64
VP9DSPContext::loop_filter_8
void(* loop_filter_8[3][2])(uint8_t *dst, ptrdiff_t stride, int mb_lim, int lim, int hev_thr)
Definition: vp9dsp.h:80
STORE_COEF
#define STORE_COEF(c, i, v)
VP9Context::class0
unsigned class0[2]
Definition: vp9.c:202
VP9Context::above_mv_ctx
VP56mv(* above_mv_ctx)[2]
Definition: vp9.c:241
src
AVS_Value src
Definition: avisynth_c.h:482
VP9Context::ref_enabled
uint8_t ref_enabled
Definition: vp9.c:160
VP9Context::prob
struct VP9Context::@110 prob
VP9Context::block_base
int16_t * block_base
Definition: vp9.c:250
vp9_default_probs
static const prob_context vp9_default_probs
Definition: vp9data.h:1470
vp9_mc_func
void(* vp9_mc_func)(uint8_t *dst, ptrdiff_t dst_stride, const uint8_t *ref, ptrdiff_t ref_stride, int h, int mx, int my)
Definition: vp9dsp.h:32
fill_mv
static void fill_mv(VP9Context *s, VP56mv *mv, int mode, int sb)
Definition: vp9.c:1343
VP9Context::level
uint8_t level
Definition: vp9.c:137
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:199
memset_bpp
#define memset_bpp(c, i1, v, i2, num)
BS_16x32
Definition: vp9.c:57
VP9Context::pass
int pass
Definition: vp9.c:105
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:441
ff_thread_get_buffer
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:878
VP9Context::left_skip_ctx
uint8_t left_skip_ctx[8]
Definition: vp9.c:222
AVCodecContext
main external API structure.
Definition: avcodec.h:1502
FASTDIV
#define FASTDIV(a, b)
Definition: mathops.h:210
NEWMV
Definition: vp9data.h:219
VP9Context::q_val
int16_t q_val
Definition: vp9.c:163
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:89
VP9Context::left_txfm_ctx
uint8_t left_txfm_ctx[8]
Definition: vp9.c:223
BL_8X8
Definition: vp9.c:48
vp9_decode_init
static av_cold int vp9_decode_init(AVCodecContext *ctx)
Definition: vp9.c:4287
VP9Context::c_b
VP56RangeCoder * c_b
Definition: vp9.c:102
VP9Context::invisible
uint8_t invisible
Definition: vp9.c:113
VP9Block::uvtx
enum TxfmMode tx uvtx
Definition: vp9.c:92
VP9Context::single_ref
unsigned single_ref[5][2][2]
Definition: vp9.c:192
prob_context::y_mode
uint8_t y_mode[4][9]
Definition: vp9data.h:1444
av_buffer_allocz
AVBufferRef * av_buffer_allocz(int size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:82
VP9Context::refs
ThreadFrame refs[8]
Definition: vp9.c:130
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:304
prob_context::tx8p
uint8_t tx8p[2]
Definition: vp9data.h:1454
BS_32x32
Definition: vp9.c:55
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:380
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:3044
VP9Context::partition
unsigned partition[4][4][4]
Definition: vp9.c:209
VP9Context::above_y_nnz_ctx
uint8_t * above_y_nnz_ctx
Definition: vp9.c:232
VP9Context::temporal
uint8_t temporal
Definition: vp9.c:153
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:297
decode_coeffs
static av_always_inline int decode_coeffs(AVCodecContext *ctx, int is8bitsperpixel)
Definition: vp9.c:2331
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2230
vp9_scans
static const int16_t *const vp9_scans[5][4]
Definition: vp9data.h:608
VP9Block::seg_id
uint8_t seg_id
Definition: vp9.c:88
SPLAT_ZERO_YUV
#define SPLAT_ZERO_YUV(dir, var, off, n, dir2)
DECODE_Y_COEF_LOOP
#define DECODE_Y_COEF_LOOP(step, mode_index, v)
N_BS_SIZES
Definition: vp9.c:65
VP9Context::ss_h
uint8_t ss_h
Definition: vp9.c:116
vp9_filter_tree
static const int8_t vp9_filter_tree[2][2]
Definition: vp9data.h:228
REF_FRAME_MVPAIR
#define REF_FRAME_MVPAIR
Definition: vp9.c:132
mc_luma_scaled
static av_always_inline void mc_luma_scaled(VP9Context *s, vp9_scaled_mc_func smc, uint8_t *dst, ptrdiff_t dst_stride, const uint8_t *ref, ptrdiff_t ref_stride, ThreadFrame *ref_frame, ptrdiff_t y, ptrdiff_t x, const VP56mv *in_mv, int px, int py, int pw, int ph, int bw, int bh, int w, int h, int bytesperpixel, const uint16_t *scale, const uint8_t *step)
Definition: vp9.c:2769
AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:386
VP9Context::left_filter_ctx
uint8_t left_filter_ctx[8]
Definition: vp9.c:228
VP9Context::last_bpp
uint8_t last_bpp
Definition: vp9.c:112
VP9Context::intraonly
uint8_t intraonly
Definition: vp9.c:117
VP9Context::signbias
uint8_t signbias[3]
Definition: vp9.c:128
VP9Context::above_intra_ctx
uint8_t * above_intra_ctx
Definition: vp9.c:237
VP9Block::bs
enum BlockSize bs
Definition: vp9.c:91
MAX_SEGMENT
#define MAX_SEGMENT
Definition: vp9.c:150
assign_bpp
#define assign_bpp(c, i1, v, i2)
AVCodecInternal::allocate_progress
int allocate_progress
Whether to allocate progress for frame threading.
Definition: internal.h:115
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:337
VP9Context::dst
uint8_t * dst[3]
Definition: vp9.c:107
VP9Context::segmentation
struct VP9Context::@107 segmentation
VP9Block::mv
VP56mv mv[4][2]
Definition: vp9.c:90
VP9Block::bp
enum BlockPartition bp
Definition: vp9.c:94
vp8_rac_get_uint
static int vp8_rac_get_uint(VP56RangeCoder *c, int bits)
Definition: vp56.h:320
VP9Context::b
VP9Block * b
Definition: vp9.c:104
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:397
vp9_ref_frame
static int vp9_ref_frame(AVCodecContext *ctx, VP9Frame *dst, VP9Frame *src)
Definition: vp9.c:295
VP9Context::txfmmode
enum TxfmMode txfmmode
Definition: vp9.c:213
VP9Context::uveob
uint8_t * uveob[2]
Definition: vp9.c:251
VP9Context::above_mode_ctx
uint8_t * above_mode_ctx
Definition: vp9.c:230
ff_vp56_init_range_decoder
void ff_vp56_init_range_decoder(VP56RangeCoder *c, const uint8_t *buf, int buf_size)
Definition: vp56rac.c:40
VP56mv
Definition: vp56.h:65
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:381
VP9Block::comp
uint8_t comp
Definition: vp9.c:88
VP9Context::filter
struct VP9Context::@105 filter
VP9Context::refreshctx
uint8_t refreshctx
Definition: vp9.c:124
VP9Context::next_refs
ThreadFrame next_refs[8]
Definition: vp9.c:130
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:387
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:182
VP9Context::class0_hp
unsigned class0_hp[2]
Definition: vp9.c:206
DC_PRED
Definition: vp9.h:48
AVCOL_RANGE_MPEG
the normal 219*2^(n-8) "MPEG" YUV ranges
Definition: pixfmt.h:539
VP9Context::counts
struct VP9Context::@111 counts
LOCAL_ALIGNED_32
#define LOCAL_ALIGNED_32(t, v,...)
Definition: internal.h:126
VP9Context::ydc_qdelta
int8_t ydc_qdelta
Definition: vp9.c:148
decode
static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
Definition: ccaption_dec.c:523
MVJoint
MVJoint
Definition: vp9data.h:2259
VP9Context::highprecisionmvs
uint8_t highprecisionmvs
Definition: vp9.c:120
FF_PROFILE_VP9_1
#define FF_PROFILE_VP9_1
Definition: avcodec.h:3190
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:81
inv_recenter_nonneg
static av_always_inline int inv_recenter_nonneg(int v, int m)
Definition: vp9.c:421
RETURN_MV
#define RETURN_MV(mv)
BlockSize
BlockSize
Definition: vp9.c:51
FF_PROFILE_VP9_3
#define FF_PROFILE_VP9_3
Definition: avcodec.h:3192
decode_coeffs_b32_16bpp
static int decode_coeffs_b32_16bpp(VP9Context *s, int16_t *coef, int n_coeffs, unsigned(*cnt)[6][3], unsigned(*eob)[6][2], uint8_t(*p)[6][11], int nnz, const int16_t *scan, const int16_t(*nb)[2], const int16_t *band_counts, const int16_t *qmul)
Definition: vp9.c:2321
stride
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
decode_coeffs_b_generic
static av_always_inline int decode_coeffs_b_generic(VP56RangeCoder *c, int16_t *coef, int n_coeffs, int is_tx32x32, int is8bitsperpixel, int bpp, unsigned(*cnt)[6][3], unsigned(*eob)[6][2], uint8_t(*p)[6][11], int nnz, const int16_t *scan, const int16_t(*nb)[2], const int16_t *band_counts, const int16_t *qmul)
Definition: vp9.c:2168
VP9DSPContext::itxfm_add
void(* itxfm_add[N_TXFM_SIZES+1][N_TXFM_TYPES])(uint8_t *dst, ptrdiff_t stride, int16_t *block, int eob)
Definition: vp9dsp.h:70
VP9Context::seg
uint8_t seg[7]
Definition: vp9.c:182
AV_ZERO64
#define AV_ZERO64(d)
Definition: intreadwrite.h:618
AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:63
VP56mv::x
int16_t x
Definition: vp56.h:66
prob_context::class0
uint8_t class0
Definition: vp9data.h:1460
internal.h
common internal api header.
if
if(ret< 0)
Definition: vf_mcdeint.c:280
vp9_default_kf_partition_probs
static const uint8_t vp9_default_kf_partition_probs[4][4][3]
Definition: vp9data.h:42
prob_context::uv_mode
uint8_t uv_mode[10][9]
Definition: vp9data.h:1445
ref_frame
static int ref_frame(Vp3DecodeContext *s, ThreadFrame *dst, ThreadFrame *src)
Definition: vp3.c:1915
BS_16x8
Definition: vp9.c:59
VP9Context::segpred
uint8_t segpred[3]
Definition: vp9.c:183
assign
#define assign(var, type, n)
VP9Context::p
prob_context p
Definition: vp9.c:176
c
static double c[64]
Definition: vsrc_mptestsrc.c:87
VP9Context::tmp_uv
uint8_t tmp_uv[2][64 *64 *2]
Definition: vp9.c:254
VP9Context::ignore_refmap
uint8_t ignore_refmap
Definition: vp9.c:156
FF_PROFILE_VP9_0
#define FF_PROFILE_VP9_0
Definition: avcodec.h:3189
BS_8x16
Definition: vp9.c:60
ff_vp9_decoder
AVCodec ff_vp9_decoder
Definition: vp9.c:4359
VP9Context::sb_rows
unsigned sb_rows
Definition: vp9.c:174
av_buffer_ref
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:92
AVProfile
AVProfile.
Definition: avcodec.h:3460
VP9Context::lflvl
uint8_t lflvl[4][2]
Definition: vp9.c:166
AVCodecContext::properties
unsigned properties
Definition: avcodec.h:3435
vp8_rac_get
static av_always_inline int vp8_rac_get(VP56RangeCoder *c)
Definition: vp56.h:304
vp9_dc_qlookup
static const int16_t vp9_dc_qlookup[3][256]
Definition: vp9data.h:239
videodsp.h
Core video DSP helper functions.
setctx_2d
static av_always_inline void setctx_2d(uint8_t *ptr, int w, int h, ptrdiff_t stride, int v)
Definition: vp9.c:1416
BL_16X16
Definition: vp9.c:47
vp9_mv_joint_tree
static const int8_t vp9_mv_joint_tree[3][2]
Definition: vp9data.h:2266
VP9Block::bl
enum BlockLevel bl
Definition: vp9.c:93
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:1544
VP9Context::bits
unsigned bits[10][2]
Definition: vp9.c:203
t4
#define t4
Definition: regdef.h:32
read_mv_component
static av_always_inline int read_mv_component(VP9Context *s, int idx, int hp)
Definition: vp9.c:1290
VP9Context::min_mv
struct VP9Context::@112 min_mv
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
memset_val
#define memset_val(c, val, num)
FF_PROFILE_VP9_2
#define FF_PROFILE_VP9_2
Definition: avcodec.h:3191
VP9Context::tile_row_end
unsigned tile_row_end
Definition: vp9.c:172
BS_8x8
Definition: vp9.c:61
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:1552
VP9Block::filter
enum FilterMode filter
Definition: vp9.c:89
decode012
static int decode012(GetBitContext *gb)
Definition: get_bits.h:570
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:237
AV_ZERO32
#define AV_ZERO32(d)
Definition: intreadwrite.h:614
decode_b
static void decode_b(AVCodecContext *ctx, int row, int col, struct VP9Filter *lflvl, ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl, enum BlockPartition bp)
Definition: vp9.c:3207
VP9Context::edge_emu_buffer
uint8_t edge_emu_buffer[135 *144 *2]
Definition: vp9.c:246
TX_32X32
Definition: vp9.h:31
prob_context::bits
uint8_t bits[10]
Definition: vp9data.h:1461
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:449
VP9Context::absolute_vals
uint8_t absolute_vals
Definition: vp9.c:154
AV_RN16A
#define AV_RN16A(p)
Definition: intreadwrite.h:522
DECODE_UV_COEF_LOOP
#define DECODE_UV_COEF_LOOP(step, v)
BS_4x4
Definition: vp9.c:64
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1422
VP9Context::lf_val
int8_t lf_val
Definition: vp9.c:164
adapt_prob
static av_always_inline void adapt_prob(uint8_t *p, unsigned ct0, unsigned ct1, int max_count, int update_factor)
Definition: vp9.c:3720
vp9_scans_nb
static const int16_t(*const [5][4] vp9_scans_nb)[2]
Definition: vp9data.h:1165
AVFrame::height
int height
Definition: frame.h:220
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:101
VP9Context::b_base
VP9Block * b_base
Definition: vp9.c:104
start
void INT64 start
Definition: avisynth_c.h:553
VP9Frame
Definition: vp9.c:73
init_thread_copy
static int init_thread_copy(AVCodecContext *avctx)
Definition: alac.c:646
AVMEDIA_TYPE_VIDEO
Definition: avutil.h:193
av_always_inline
#define av_always_inline
Definition: attributes.h:37
read_colorspace_details
static enum AVPixelFormat read_colorspace_details(AVCodecContext *ctx)
Definition: vp9.c:485
VP9mvrefPair::mv
VP56mv mv[2]
Definition: vp9.c:69
update_prob
static int update_prob(VP56RangeCoder *c, int p)
Definition: vp9.c:427
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
VP9Context::y_stride
ptrdiff_t y_stride
Definition: vp9.c:108
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2050
stride
#define stride
VP9Block::skip
uint8_t skip
Definition: vp9.c:88
VP9Context::mode
int8_t mode[2]
Definition: vp9.c:144
VP9Context::above_ref_ctx
uint8_t * above_ref_ctx
Definition: vp9.c:239
prob_context::mv_joint
uint8_t mv_joint[3]
Definition: vp9data.h:1456
VP9Context::q_enabled
uint8_t q_enabled
Definition: vp9.c:158
VP9Context::left_intra_ctx
uint8_t left_intra_ctx[8]
Definition: vp9.c:225
AV_RN64A
#define AV_RN64A(p)
Definition: intreadwrite.h:530
VP9Context::classes
unsigned classes[11]
Definition: vp9.c:201
VP9Context::refreshrefmask
uint8_t refreshrefmask
Definition: vp9.c:119
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:61
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1400
AV_GET_BUFFER_FLAG_REF
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:1216
VP9Context::above_comp_ctx
uint8_t * above_comp_ctx
Definition: vp9.c:238
av_mallocz
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:252
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:857
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1416
RETURN_SCALE_MV
#define RETURN_SCALE_MV(mv, scale)
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
VP9Context::block_alloc_using_2pass
int block_alloc_using_2pass
Definition: vp9.c:249
AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:267
VP9Context::skip_enabled
uint8_t skip_enabled
Definition: vp9.c:161
decode_coeffs_b_16bpp
static int decode_coeffs_b_16bpp(VP9Context *s, int16_t *coef, int n_coeffs, unsigned(*cnt)[6][3], unsigned(*eob)[6][2], uint8_t(*p)[6][11], int nnz, const int16_t *scan, const int16_t(*nb)[2], const int16_t *band_counts, const int16_t *qmul)
Definition: vp9.c:2311
VP9Context::log2_tile_cols
unsigned log2_tile_cols
Definition: vp9.c:170
a
a
Definition: h264pred_template.c:468
vp9_partition_tree
static const int8_t vp9_partition_tree[3][2]
Definition: vp9data.h:36
intra_recon
static av_always_inline void intra_recon(AVCodecContext *ctx, ptrdiff_t y_off, ptrdiff_t uv_off, int bytesperpixel)
Definition: vp9.c:2689
VP9Context::c
VP56RangeCoder c
Definition: vp9.c:101
Generated on Thu Sep 10 2015 11:39:02 for FFmpeg by   doxygen 1.8.6