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