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