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