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