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