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