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