avcodec/vp9: use av_freep() for above_partition_ctx
[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 intialize 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, 80,
2227                                  ref - !!my * 3 * ref_stride - !!mx * 3,
2228                                  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, 80,
2257                                  ref_u - !!my * 3 * src_stride_u - !!mx * 3, src_stride_u,
2258                                  bw + !!mx * 7, bh + !!my * 7,
2259                                  x - !!mx * 3, y - !!my * 3, w, h);
2260         ref_u = s->edge_emu_buffer + !!my * 3 * 80 + !!mx * 3;
2261         mc[!!mx][!!my](dst_u, dst_stride, ref_u, 80, bh, mx, my);
2262
2263         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, 80,
2264                                  ref_v - !!my * 3 * src_stride_v - !!mx * 3, src_stride_v,
2265                                  bw + !!mx * 7, bh + !!my * 7,
2266                                  x - !!mx * 3, y - !!my * 3, w, h);
2267         ref_v = s->edge_emu_buffer + !!my * 3 * 80 + !!mx * 3;
2268         mc[!!mx][!!my](dst_v, dst_stride, ref_v, 80, bh, mx, my);
2269     } else {
2270         mc[!!mx][!!my](dst_u, dst_stride, ref_u, src_stride_u, bh, mx, my);
2271         mc[!!mx][!!my](dst_v, dst_stride, ref_v, src_stride_v, bh, mx, my);
2272     }
2273 }
2274
2275 static void inter_recon(AVCodecContext *ctx)
2276 {
2277     static const uint8_t bwlog_tab[2][N_BS_SIZES] = {
2278         { 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 },
2279         { 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 4 },
2280     };
2281     VP9Context *s = ctx->priv_data;
2282     VP9Block *const b = &s->b;
2283     int row = b->row, col = b->col;
2284     AVFrame *ref1 = s->refs[s->refidx[b->ref[0]]];
2285     AVFrame *ref2 = b->comp ? s->refs[s->refidx[b->ref[1]]] : NULL;
2286     int w = ctx->width, h = ctx->height;
2287     ptrdiff_t ls_y = b->y_stride, ls_uv = b->uv_stride;
2288
2289     // y inter pred
2290     if (b->bs > BS_8x8) {
2291         if (b->bs == BS_8x4) {
2292             mc_luma_dir(s, s->dsp.mc[3][b->filter][0], b->dst[0], ls_y,
2293                         ref1->data[0], ref1->linesize[0],
2294                         row << 3, col << 3, &b->mv[0][0], 8, 4, w, h);
2295             mc_luma_dir(s, s->dsp.mc[3][b->filter][0],
2296                         b->dst[0] + 4 * ls_y, ls_y,
2297                         ref1->data[0], ref1->linesize[0],
2298                         (row << 3) + 4, col << 3, &b->mv[2][0], 8, 4, w, h);
2299
2300             if (b->comp) {
2301                 mc_luma_dir(s, s->dsp.mc[3][b->filter][1], b->dst[0], ls_y,
2302                             ref2->data[0], ref2->linesize[0],
2303                             row << 3, col << 3, &b->mv[0][1], 8, 4, w, h);
2304                 mc_luma_dir(s, s->dsp.mc[3][b->filter][1],
2305                             b->dst[0] + 4 * ls_y, ls_y,
2306                             ref2->data[0], ref2->linesize[0],
2307                             (row << 3) + 4, col << 3, &b->mv[2][1], 8, 4, w, h);
2308             }
2309         } else if (b->bs == BS_4x8) {
2310             mc_luma_dir(s, s->dsp.mc[4][b->filter][0], b->dst[0], ls_y,
2311                         ref1->data[0], ref1->linesize[0],
2312                         row << 3, col << 3, &b->mv[0][0], 4, 8, w, h);
2313             mc_luma_dir(s, s->dsp.mc[4][b->filter][0], b->dst[0] + 4, ls_y,
2314                         ref1->data[0], ref1->linesize[0],
2315                         row << 3, (col << 3) + 4, &b->mv[1][0], 4, 8, w, h);
2316
2317             if (b->comp) {
2318                 mc_luma_dir(s, s->dsp.mc[4][b->filter][1], b->dst[0], ls_y,
2319                             ref2->data[0], ref2->linesize[0],
2320                             row << 3, col << 3, &b->mv[0][1], 4, 8, w, h);
2321                 mc_luma_dir(s, s->dsp.mc[4][b->filter][1], b->dst[0] + 4, ls_y,
2322                             ref2->data[0], ref2->linesize[0],
2323                             row << 3, (col << 3) + 4, &b->mv[1][1], 4, 8, w, h);
2324             }
2325         } else {
2326             av_assert2(b->bs == BS_4x4);
2327
2328             // FIXME if two horizontally adjacent blocks have the same MV,
2329             // do a w8 instead of a w4 call
2330             mc_luma_dir(s, s->dsp.mc[4][b->filter][0], b->dst[0], ls_y,
2331                         ref1->data[0], ref1->linesize[0],
2332                         row << 3, col << 3, &b->mv[0][0], 4, 4, w, h);
2333             mc_luma_dir(s, s->dsp.mc[4][b->filter][0], b->dst[0] + 4, ls_y,
2334                         ref1->data[0], ref1->linesize[0],
2335                         row << 3, (col << 3) + 4, &b->mv[1][0], 4, 4, w, h);
2336             mc_luma_dir(s, s->dsp.mc[4][b->filter][0],
2337                         b->dst[0] + 4 * ls_y, ls_y,
2338                         ref1->data[0], ref1->linesize[0],
2339                         (row << 3) + 4, col << 3, &b->mv[2][0], 4, 4, w, h);
2340             mc_luma_dir(s, s->dsp.mc[4][b->filter][0],
2341                         b->dst[0] + 4 * ls_y + 4, ls_y,
2342                         ref1->data[0], ref1->linesize[0],
2343                         (row << 3) + 4, (col << 3) + 4, &b->mv[3][0], 4, 4, w, h);
2344
2345             if (b->comp) {
2346                 mc_luma_dir(s, s->dsp.mc[4][b->filter][1], b->dst[0], ls_y,
2347                             ref2->data[0], ref2->linesize[0],
2348                             row << 3, col << 3, &b->mv[0][1], 4, 4, w, h);
2349                 mc_luma_dir(s, s->dsp.mc[4][b->filter][1], b->dst[0] + 4, ls_y,
2350                             ref2->data[0], ref2->linesize[0],
2351                             row << 3, (col << 3) + 4, &b->mv[1][1], 4, 4, w, h);
2352                 mc_luma_dir(s, s->dsp.mc[4][b->filter][1],
2353                             b->dst[0] + 4 * ls_y, ls_y,
2354                             ref2->data[0], ref2->linesize[0],
2355                             (row << 3) + 4, col << 3, &b->mv[2][1], 4, 4, w, h);
2356                 mc_luma_dir(s, s->dsp.mc[4][b->filter][1],
2357                             b->dst[0] + 4 * ls_y + 4, ls_y,
2358                             ref2->data[0], ref2->linesize[0],
2359                             (row << 3) + 4, (col << 3) + 4, &b->mv[3][1], 4, 4, w, h);
2360             }
2361         }
2362     } else {
2363         int bwl = bwlog_tab[0][b->bs];
2364         int bw = bwh_tab[0][b->bs][0] * 4, bh = bwh_tab[0][b->bs][1] * 4;
2365
2366         mc_luma_dir(s, s->dsp.mc[bwl][b->filter][0], b->dst[0], ls_y,
2367                     ref1->data[0], ref1->linesize[0],
2368                     row << 3, col << 3, &b->mv[0][0],bw, bh, w, h);
2369
2370         if (b->comp)
2371             mc_luma_dir(s, s->dsp.mc[bwl][b->filter][1], b->dst[0], ls_y,
2372                         ref2->data[0], ref2->linesize[0],
2373                         row << 3, col << 3, &b->mv[0][1], bw, bh, w, h);
2374     }
2375
2376     // uv inter pred
2377     {
2378         int bwl = bwlog_tab[1][b->bs];
2379         int bw = bwh_tab[1][b->bs][0] * 4, bh = bwh_tab[1][b->bs][1] * 4;
2380         VP56mv mvuv;
2381
2382         w = (w + 1) >> 1;
2383         h = (h + 1) >> 1;
2384         if (b->bs > BS_8x8) {
2385             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);
2386             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);
2387         } else {
2388             mvuv = b->mv[0][0];
2389         }
2390
2391         mc_chroma_dir(s, s->dsp.mc[bwl][b->filter][0],
2392                       b->dst[1], b->dst[2], ls_uv,
2393                       ref1->data[1], ref1->linesize[1],
2394                       ref1->data[2], ref1->linesize[2],
2395                       row << 2, col << 2, &mvuv, bw, bh, w, h);
2396
2397         if (b->comp) {
2398             if (b->bs > BS_8x8) {
2399                 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);
2400                 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);
2401             } else {
2402                 mvuv = b->mv[0][1];
2403             }
2404             mc_chroma_dir(s, s->dsp.mc[bwl][b->filter][1],
2405                           b->dst[1], b->dst[2], ls_uv,
2406                           ref2->data[1], ref2->linesize[1],
2407                           ref2->data[2], ref2->linesize[2],
2408                           row << 2, col << 2, &mvuv, bw, bh, w, h);
2409         }
2410     }
2411
2412     if (!b->skip) {
2413         /* mostly copied intra_reconn() */
2414
2415         int w4 = bwh_tab[1][b->bs][0] << 1, step1d = 1 << b->tx, n;
2416         int h4 = bwh_tab[1][b->bs][1] << 1, x, y, step = 1 << (b->tx * 2);
2417         int end_x = FFMIN(2 * (s->cols - col), w4);
2418         int end_y = FFMIN(2 * (s->rows - row), h4);
2419         int tx = 4 * s->lossless + b->tx, uvtx = b->uvtx + 4 * s->lossless;
2420         int uvstep1d = 1 << b->uvtx, p;
2421         uint8_t *dst = b->dst[0];
2422
2423         // y itxfm add
2424         for (n = 0, y = 0; y < end_y; y += step1d) {
2425             uint8_t *ptr = dst;
2426             for (x = 0; x < end_x; x += step1d, ptr += 4 * step1d, n += step) {
2427                 int eob = b->tx > TX_8X8 ? AV_RN16A(&s->eob[n]) : s->eob[n];
2428
2429                 if (eob)
2430                     s->dsp.itxfm_add[tx][DCT_DCT](ptr, b->y_stride,
2431                                                   s->block + 16 * n, eob);
2432             }
2433             dst += 4 * b->y_stride * step1d;
2434         }
2435
2436         // uv itxfm add
2437         h4 >>= 1;
2438         w4 >>= 1;
2439         end_x >>= 1;
2440         end_y >>= 1;
2441         step = 1 << (b->uvtx * 2);
2442         for (p = 0; p < 2; p++) {
2443             dst = b->dst[p + 1];
2444             for (n = 0, y = 0; y < end_y; y += uvstep1d) {
2445                 uint8_t *ptr = dst;
2446                 for (x = 0; x < end_x; x += uvstep1d, ptr += 4 * uvstep1d, n += step) {
2447                     int eob = b->uvtx > TX_8X8 ? AV_RN16A(&s->uveob[p][n]) : s->uveob[p][n];
2448
2449                     if (eob)
2450                         s->dsp.itxfm_add[uvtx][DCT_DCT](ptr, b->uv_stride,
2451                                                         s->uvblock[p] + 16 * n, eob);
2452                 }
2453                 dst += 4 * uvstep1d * b->uv_stride;
2454             }
2455         }
2456     }
2457 }
2458
2459 static av_always_inline void mask_edges(struct VP9Filter *lflvl, int is_uv,
2460                                         int row_and_7, int col_and_7,
2461                                         int w, int h, int col_end, int row_end,
2462                                         enum TxfmMode tx, int skip_inter)
2463 {
2464     // FIXME I'm pretty sure all loops can be replaced by a single LUT if
2465     // we make VP9Filter.mask uint64_t (i.e. row/col all single variable)
2466     // and make the LUT 5-indexed (bl, bp, is_uv, tx and row/col), and then
2467     // use row_and_7/col_and_7 as shifts (1*col_and_7+8*row_and_7)
2468
2469     // the intended behaviour of the vp9 loopfilter is to work on 8-pixel
2470     // edges. This means that for UV, we work on two subsampled blocks at
2471     // a time, and we only use the topleft block's mode information to set
2472     // things like block strength. Thus, for any block size smaller than
2473     // 16x16, ignore the odd portion of the block.
2474     if (tx == TX_4X4 && is_uv) {
2475         if (h == 1) {
2476             if (row_and_7 & 1)
2477                 return;
2478             if (!row_end)
2479                 h += 1;
2480         }
2481         if (w == 1) {
2482             if (col_and_7 & 1)
2483                 return;
2484             if (!col_end)
2485                 w += 1;
2486         }
2487     }
2488
2489     if (tx == TX_4X4 && !skip_inter) {
2490         int t = 1 << col_and_7, m_col = (t << w) - t, y;
2491         int m_col_odd = (t << (w - 1)) - t;
2492
2493         // on 32-px edges, use the 8-px wide loopfilter; else, use 4-px wide
2494         if (is_uv) {
2495             int m_row_8 = m_col & 0x01, m_row_4 = m_col - m_row_8;
2496
2497             for (y = row_and_7; y < h + row_and_7; y++) {
2498                 int col_mask_id = 2 - !(y & 7);
2499
2500                 lflvl->mask[is_uv][0][y][1] |= m_row_8;
2501                 lflvl->mask[is_uv][0][y][2] |= m_row_4;
2502                 // for odd lines, if the odd col is not being filtered,
2503                 // skip odd row also:
2504                 // .---. <-- a
2505                 // |   |
2506                 // |___| <-- b
2507                 // ^   ^
2508                 // c   d
2509                 //
2510                 // if a/c are even row/col and b/d are odd, and d is skipped,
2511                 // e.g. right edge of size-66x66.webm, then skip b also (bug)
2512                 if ((col_end & 1) && (y & 1)) {
2513                     lflvl->mask[is_uv][1][y][col_mask_id] |= m_col_odd;
2514                 } else {
2515                     lflvl->mask[is_uv][1][y][col_mask_id] |= m_col;
2516                 }
2517             }
2518         } else {
2519             int m_row_8 = m_col & 0x11, m_row_4 = m_col - m_row_8;
2520
2521             for (y = row_and_7; y < h + row_and_7; y++) {
2522                 int col_mask_id = 2 - !(y & 3);
2523
2524                 lflvl->mask[is_uv][0][y][1] |= m_row_8; // row edge
2525                 lflvl->mask[is_uv][0][y][2] |= m_row_4;
2526                 lflvl->mask[is_uv][1][y][col_mask_id] |= m_col; // col edge
2527                 lflvl->mask[is_uv][0][y][3] |= m_col;
2528                 lflvl->mask[is_uv][1][y][3] |= m_col;
2529             }
2530         }
2531     } else {
2532         int y, t = 1 << col_and_7, m_col = (t << w) - t;
2533
2534         if (!skip_inter) {
2535             int mask_id = (tx == TX_8X8);
2536             int l2 = tx + is_uv - 1, step1d = 1 << l2;
2537             static const unsigned masks[4] = { 0xff, 0x55, 0x11, 0x01 };
2538             int m_row = m_col & masks[l2];
2539
2540             // at odd UV col/row edges tx16/tx32 loopfilter edges, force
2541             // 8wd loopfilter to prevent going off the visible edge.
2542             if (is_uv && tx > TX_8X8 && (w ^ (w - 1)) == 1) {
2543                 int m_row_16 = ((t << (w - 1)) - t) & masks[l2];
2544                 int m_row_8 = m_row - m_row_16;
2545
2546                 for (y = row_and_7; y < h + row_and_7; y++) {
2547                     lflvl->mask[is_uv][0][y][0] |= m_row_16;
2548                     lflvl->mask[is_uv][0][y][1] |= m_row_8;
2549                 }
2550             } else {
2551                 for (y = row_and_7; y < h + row_and_7; y++)
2552                     lflvl->mask[is_uv][0][y][mask_id] |= m_row;
2553             }
2554
2555             if (is_uv && tx > TX_8X8 && (h ^ (h - 1)) == 1) {
2556                 for (y = row_and_7; y < h + row_and_7 - 1; y += step1d)
2557                     lflvl->mask[is_uv][1][y][0] |= m_col;
2558                 if (y - row_and_7 == h - 1)
2559                     lflvl->mask[is_uv][1][y][1] |= m_col;
2560             } else {
2561                 for (y = row_and_7; y < h + row_and_7; y += step1d)
2562                     lflvl->mask[is_uv][1][y][mask_id] |= m_col;
2563             }
2564         } else if (tx != TX_4X4) {
2565             int mask_id;
2566
2567             mask_id = (tx == TX_8X8) || (is_uv && h == 1);
2568             lflvl->mask[is_uv][1][row_and_7][mask_id] |= m_col;
2569             mask_id = (tx == TX_8X8) || (is_uv && w == 1);
2570             for (y = row_and_7; y < h + row_and_7; y++)
2571                 lflvl->mask[is_uv][0][y][mask_id] |= t;
2572         } else if (is_uv) {
2573             int t8 = t & 0x01, t4 = t - t8;
2574
2575             for (y = row_and_7; y < h + row_and_7; y++) {
2576                 lflvl->mask[is_uv][0][y][2] |= t4;
2577                 lflvl->mask[is_uv][0][y][1] |= t8;
2578             }
2579             lflvl->mask[is_uv][1][row_and_7][2 - !(row_and_7 & 7)] |= m_col;
2580         } else {
2581             int t8 = t & 0x11, t4 = t - t8;
2582
2583             for (y = row_and_7; y < h + row_and_7; y++) {
2584                 lflvl->mask[is_uv][0][y][2] |= t4;
2585                 lflvl->mask[is_uv][0][y][1] |= t8;
2586             }
2587             lflvl->mask[is_uv][1][row_and_7][2 - !(row_and_7 & 3)] |= m_col;
2588         }
2589     }
2590 }
2591
2592 static int decode_b(AVCodecContext *ctx, int row, int col,
2593                     struct VP9Filter *lflvl, ptrdiff_t yoff, ptrdiff_t uvoff,
2594                     enum BlockLevel bl, enum BlockPartition bp)
2595 {
2596     VP9Context *s = ctx->priv_data;
2597     VP9Block *const b = &s->b;
2598     enum BlockSize bs = bl * 3 + bp;
2599     int res, y, w4 = bwh_tab[1][bs][0], h4 = bwh_tab[1][bs][1], lvl;
2600     int emu[2];
2601
2602     b->row = row;
2603     b->row7 = row & 7;
2604     b->col = col;
2605     b->col7 = col & 7;
2606     s->min_mv.x = -(128 + col * 64);
2607     s->min_mv.y = -(128 + row * 64);
2608     s->max_mv.x = 128 + (s->cols - col - w4) * 64;
2609     s->max_mv.y = 128 + (s->rows - row - h4) * 64;
2610     b->bs = bs;
2611     decode_mode(ctx);
2612     b->uvtx = b->tx - (w4 * 2 == (1 << b->tx) || h4 * 2 == (1 << b->tx));
2613
2614     if (!b->skip) {
2615         if ((res = decode_coeffs(ctx)) < 0)
2616             return res;
2617     } else {
2618         int pl;
2619
2620         memset(&s->above_y_nnz_ctx[col * 2], 0, w4 * 2);
2621         memset(&s->left_y_nnz_ctx[(row & 7) << 1], 0, h4 * 2);
2622         for (pl = 0; pl < 2; pl++) {
2623             memset(&s->above_uv_nnz_ctx[pl][col], 0, w4);
2624             memset(&s->left_uv_nnz_ctx[pl][row & 7], 0, h4);
2625         }
2626     }
2627
2628     // emulated overhangs if the stride of the target buffer can't hold. This
2629     // allows to support emu-edge and so on even if we have large block
2630     // overhangs
2631     emu[0] = (col + w4) * 8 > s->f->linesize[0] ||
2632              (row + h4) > s->rows + 2 * !(ctx->flags & CODEC_FLAG_EMU_EDGE);
2633     emu[1] = (col + w4) * 4 > s->f->linesize[1] ||
2634              (row + h4) > s->rows + 2 * !(ctx->flags & CODEC_FLAG_EMU_EDGE);
2635     if (emu[0]) {
2636         b->dst[0] = s->tmp_y;
2637         b->y_stride = 64;
2638     } else {
2639         b->dst[0] = s->f->data[0] + yoff;
2640         b->y_stride = s->f->linesize[0];
2641     }
2642     if (emu[1]) {
2643         b->dst[1] = s->tmp_uv[0];
2644         b->dst[2] = s->tmp_uv[1];
2645         b->uv_stride = 32;
2646     } else {
2647         b->dst[1] = s->f->data[1] + uvoff;
2648         b->dst[2] = s->f->data[2] + uvoff;
2649         b->uv_stride = s->f->linesize[1];
2650     }
2651     if (b->intra) {
2652         intra_recon(ctx, yoff, uvoff);
2653     } else {
2654         inter_recon(ctx);
2655     }
2656     if (emu[0]) {
2657         int w = FFMIN(s->cols - col, w4) * 8, h = FFMIN(s->rows - row, h4) * 8, n, o = 0;
2658
2659         for (n = 0; o < w; n++) {
2660             int bw = 64 >> n;
2661
2662             av_assert2(n <= 4);
2663             if (w & bw) {
2664                 s->dsp.mc[n][0][0][0][0](s->f->data[0] + yoff + o, s->f->linesize[0],
2665                                          s->tmp_y + o, 64, h, 0, 0);
2666                 o += bw;
2667             }
2668         }
2669     }
2670     if (emu[1]) {
2671         int w = FFMIN(s->cols - col, w4) * 4, h = FFMIN(s->rows - row, h4) * 4, n, o = 0;
2672
2673         for (n = 1; o < w; n++) {
2674             int bw = 64 >> n;
2675
2676             av_assert2(n <= 4);
2677             if (w & bw) {
2678                 s->dsp.mc[n][0][0][0][0](s->f->data[1] + uvoff + o, s->f->linesize[1],
2679                                          s->tmp_uv[0] + o, 32, h, 0, 0);
2680                 s->dsp.mc[n][0][0][0][0](s->f->data[2] + uvoff + o, s->f->linesize[2],
2681                                          s->tmp_uv[1] + o, 32, h, 0, 0);
2682                 o += bw;
2683             }
2684         }
2685     }
2686
2687     // pick filter level and find edges to apply filter to
2688     if (s->filter.level &&
2689         (lvl = s->segmentation.feat[b->seg_id].lflvl[b->intra ? 0 : b->ref[0] + 1]
2690                                                     [b->mode[3] != ZEROMV]) > 0) {
2691         int x_end = FFMIN(s->cols - col, w4), y_end = FFMIN(s->rows - row, h4);
2692         int skip_inter = !b->intra && b->skip;
2693
2694         for (y = 0; y < h4; y++)
2695             memset(&lflvl->level[((row & 7) + y) * 8 + (col & 7)], lvl, w4);
2696         mask_edges(lflvl, 0, row & 7, col & 7, x_end, y_end, 0, 0, b->tx, skip_inter);
2697         mask_edges(lflvl, 1, row & 7, col & 7, x_end, y_end,
2698                    s->cols & 1 && col + w4 >= s->cols ? s->cols & 7 : 0,
2699                    s->rows & 1 && row + h4 >= s->rows ? s->rows & 7 : 0,
2700                    b->uvtx, skip_inter);
2701
2702         if (!s->filter.lim_lut[lvl]) {
2703             int sharp = s->filter.sharpness;
2704             int limit = lvl;
2705
2706             if (sharp > 0) {
2707                 limit >>= (sharp + 3) >> 2;
2708                 limit = FFMIN(limit, 9 - sharp);
2709             }
2710             limit = FFMAX(limit, 1);
2711
2712             s->filter.lim_lut[lvl] = limit;
2713             s->filter.mblim_lut[lvl] = 2 * (lvl + 2) + limit;
2714         }
2715     }
2716
2717     return 0;
2718 }
2719
2720 static int decode_sb(AVCodecContext *ctx, int row, int col, struct VP9Filter *lflvl,
2721                      ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
2722 {
2723     VP9Context *s = ctx->priv_data;
2724     int c = ((s->above_partition_ctx[col] >> (3 - bl)) & 1) |
2725             (((s->left_partition_ctx[row & 0x7] >> (3 - bl)) & 1) << 1), res;
2726     const uint8_t *p = s->keyframe ? vp9_default_kf_partition_probs[bl][c] :
2727                                      s->prob.p.partition[bl][c];
2728     enum BlockPartition bp;
2729     ptrdiff_t hbs = 4 >> bl;
2730
2731     if (bl == BL_8X8) {
2732         bp = vp8_rac_get_tree(&s->c, vp9_partition_tree, p);
2733         res = decode_b(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
2734     } else if (col + hbs < s->cols) {
2735         if (row + hbs < s->rows) {
2736             bp = vp8_rac_get_tree(&s->c, vp9_partition_tree, p);
2737             switch (bp) {
2738             case PARTITION_NONE:
2739                 res = decode_b(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
2740                 break;
2741             case PARTITION_H:
2742                 if (!(res = decode_b(ctx, row, col, lflvl, yoff, uvoff, bl, bp))) {
2743                     yoff  += hbs * 8 * s->f->linesize[0];
2744                     uvoff += hbs * 4 * s->f->linesize[1];
2745                     res = decode_b(ctx, row + hbs, col, lflvl, yoff, uvoff, bl, bp);
2746                 }
2747                 break;
2748             case PARTITION_V:
2749                 if (!(res = decode_b(ctx, row, col, lflvl, yoff, uvoff, bl, bp))) {
2750                     yoff  += hbs * 8;
2751                     uvoff += hbs * 4;
2752                     res = decode_b(ctx, row, col + hbs, lflvl, yoff, uvoff, bl, bp);
2753                 }
2754                 break;
2755             case PARTITION_SPLIT:
2756                 if (!(res = decode_sb(ctx, row, col, lflvl, yoff, uvoff, bl + 1))) {
2757                     if (!(res = decode_sb(ctx, row, col + hbs, lflvl,
2758                                           yoff + 8 * hbs, uvoff + 4 * hbs, bl + 1))) {
2759                         yoff  += hbs * 8 * s->f->linesize[0];
2760                         uvoff += hbs * 4 * s->f->linesize[1];
2761                         if (!(res = decode_sb(ctx, row + hbs, col, lflvl,
2762                                               yoff, uvoff, bl + 1)))
2763                             res = decode_sb(ctx, row + hbs, col + hbs, lflvl,
2764                                             yoff + 8 * hbs, uvoff + 4 * hbs, bl + 1);
2765                     }
2766                 }
2767                 break;
2768             }
2769         } else if (vp56_rac_get_prob_branchy(&s->c, p[1])) {
2770             bp = PARTITION_SPLIT;
2771             if (!(res = decode_sb(ctx, row, col, lflvl, yoff, uvoff, bl + 1)))
2772                 res = decode_sb(ctx, row, col + hbs, lflvl,
2773                                 yoff + 8 * hbs, uvoff + 4 * hbs, bl + 1);
2774         } else {
2775             bp = PARTITION_H;
2776             res = decode_b(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
2777         }
2778     } else if (row + hbs < s->rows) {
2779         if (vp56_rac_get_prob_branchy(&s->c, p[2])) {
2780             bp = PARTITION_SPLIT;
2781             if (!(res = decode_sb(ctx, row, col, lflvl, yoff, uvoff, bl + 1))) {
2782                 yoff  += hbs * 8 * s->f->linesize[0];
2783                 uvoff += hbs * 4 * s->f->linesize[1];
2784                 res = decode_sb(ctx, row + hbs, col, lflvl,
2785                                 yoff, uvoff, bl + 1);
2786             }
2787         } else {
2788             bp = PARTITION_V;
2789             res = decode_b(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
2790         }
2791     } else {
2792         bp = PARTITION_SPLIT;
2793         res = decode_sb(ctx, row, col, lflvl, yoff, uvoff, bl + 1);
2794     }
2795     s->counts.partition[bl][c][bp]++;
2796
2797     return res;
2798 }
2799
2800 static void loopfilter_sb(AVCodecContext *ctx, struct VP9Filter *lflvl,
2801                           int row, int col, ptrdiff_t yoff, ptrdiff_t uvoff)
2802 {
2803     VP9Context *s = ctx->priv_data;
2804     uint8_t *dst = s->f->data[0] + yoff, *lvl = lflvl->level;
2805     ptrdiff_t ls_y = s->f->linesize[0], ls_uv = s->f->linesize[1];
2806     int y, x, p;
2807
2808     // FIXME in how far can we interleave the v/h loopfilter calls? E.g.
2809     // if you think of them as acting on a 8x8 block max, we can interleave
2810     // each v/h within the single x loop, but that only works if we work on
2811     // 8 pixel blocks, and we won't always do that (we want at least 16px
2812     // to use SSE2 optimizations, perhaps 32 for AVX2)
2813
2814     // filter edges between columns, Y plane (e.g. block1 | block2)
2815     for (y = 0; y < 8; y += 2, dst += 16 * ls_y, lvl += 16) {
2816         uint8_t *ptr = dst, *l = lvl, *hmask1 = lflvl->mask[0][0][y];
2817         uint8_t *hmask2 = lflvl->mask[0][0][y + 1];
2818         unsigned hm1 = hmask1[0] | hmask1[1] | hmask1[2], hm13 = hmask1[3];
2819         unsigned hm2 = hmask2[1] | hmask2[2], hm23 = hmask2[3];
2820         unsigned hm = hm1 | hm2 | hm13 | hm23;
2821
2822         for (x = 1; hm & ~(x - 1); x <<= 1, ptr += 8, l++) {
2823             if (hm1 & x) {
2824                 int L = *l, H = L >> 4;
2825                 int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
2826
2827                 if (col || x > 1) {
2828                     if (hmask1[0] & x) {
2829                         if (hmask2[0] & x) {
2830                             av_assert2(l[8] == L);
2831                             s->dsp.loop_filter_16[0](ptr, ls_y, E, I, H);
2832                         } else {
2833                             s->dsp.loop_filter_8[2][0](ptr, ls_y, E, I, H);
2834                         }
2835                     } else if (hm2 & x) {
2836                         L = l[8];
2837                         H |= (L >> 4) << 8;
2838                         E |= s->filter.mblim_lut[L] << 8;
2839                         I |= s->filter.lim_lut[L] << 8;
2840                         s->dsp.loop_filter_mix2[!!(hmask1[1] & x)]
2841                                                [!!(hmask2[1] & x)]
2842                                                [0](ptr, ls_y, E, I, H);
2843                     } else {
2844                         s->dsp.loop_filter_8[!!(hmask1[1] & x)]
2845                                             [0](ptr, ls_y, E, I, H);
2846                     }
2847                 }
2848             } else if (hm2 & x) {
2849                 int L = l[8], H = L >> 4;
2850                 int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
2851
2852                 if (col || x > 1) {
2853                     s->dsp.loop_filter_8[!!(hmask2[1] & x)]
2854                                         [0](ptr + 8 * ls_y, ls_y, E, I, H);
2855                 }
2856             }
2857             if (hm13 & x) {
2858                 int L = *l, H = L >> 4;
2859                 int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
2860
2861                 if (hm23 & x) {
2862                     L = l[8];
2863                     H |= (L >> 4) << 8;
2864                     E |= s->filter.mblim_lut[L] << 8;
2865                     I |= s->filter.lim_lut[L] << 8;
2866                     s->dsp.loop_filter_mix2[0][0][0](ptr + 4, ls_y, E, I, H);
2867                 } else {
2868                     s->dsp.loop_filter_8[0][0](ptr + 4, ls_y, E, I, H);
2869                 }
2870             } else if (hm23 & x) {
2871                 int L = l[8], H = L >> 4;
2872                 int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
2873
2874                 s->dsp.loop_filter_8[0][0](ptr + 8 * ls_y + 4, ls_y, E, I, H);
2875             }
2876         }
2877     }
2878
2879     //                                          block1
2880     // filter edges between rows, Y plane (e.g. ------)
2881     //                                          block2
2882     dst = s->f->data[0] + yoff;
2883     lvl = lflvl->level;
2884     for (y = 0; y < 8; y++, dst += 8 * ls_y, lvl += 8) {
2885         uint8_t *ptr = dst, *l = lvl, *vmask = lflvl->mask[0][1][y];
2886         unsigned vm = vmask[0] | vmask[1] | vmask[2], vm3 = vmask[3];
2887
2888         for (x = 1; vm & ~(x - 1); x <<= 2, ptr += 16, l += 2) {
2889             if (row || y) {
2890                 if (vm & x) {
2891                     int L = *l, H = L >> 4;
2892                     int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
2893
2894                     if (vmask[0] & x) {
2895                         if (vmask[0] & (x << 1)) {
2896                             av_assert2(l[1] == L);
2897                             s->dsp.loop_filter_16[1](ptr, ls_y, E, I, H);
2898                         } else {
2899                             s->dsp.loop_filter_8[2][1](ptr, ls_y, E, I, H);
2900                         }
2901                     } else if (vm & (x << 1)) {
2902                         L = l[1];
2903                         H |= (L >> 4) << 8;
2904                         E |= s->filter.mblim_lut[L] << 8;
2905                         I |= s->filter.lim_lut[L] << 8;
2906                         s->dsp.loop_filter_mix2[!!(vmask[1] &  x)]
2907                                                [!!(vmask[1] & (x << 1))]
2908                                                [1](ptr, ls_y, E, I, H);
2909                     } else {
2910                         s->dsp.loop_filter_8[!!(vmask[1] & x)]
2911                                             [1](ptr, ls_y, E, I, H);
2912                     }
2913                 } else if (vm & (x << 1)) {
2914                     int L = l[1], H = L >> 4;
2915                     int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
2916
2917                     s->dsp.loop_filter_8[!!(vmask[1] & (x << 1))]
2918                                         [1](ptr + 8, ls_y, E, I, H);
2919                 }
2920             }
2921             if (vm3 & x) {
2922                 int L = *l, H = L >> 4;
2923                 int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
2924
2925                 if (vm3 & (x << 1)) {
2926                     L = l[1];
2927                     H |= (L >> 4) << 8;
2928                     E |= s->filter.mblim_lut[L] << 8;
2929                     I |= s->filter.lim_lut[L] << 8;
2930                     s->dsp.loop_filter_mix2[0][0][1](ptr + ls_y * 4, ls_y, E, I, H);
2931                 } else {
2932                     s->dsp.loop_filter_8[0][1](ptr + ls_y * 4, ls_y, E, I, H);
2933                 }
2934             } else if (vm3 & (x << 1)) {
2935                 int L = l[1], H = L >> 4;
2936                 int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
2937
2938                 s->dsp.loop_filter_8[0][1](ptr + ls_y * 4 + 8, ls_y, E, I, H);
2939             }
2940         }
2941     }
2942
2943     // same principle but for U/V planes
2944     for (p = 0; p < 2; p++) {
2945         lvl = lflvl->level;
2946         dst = s->f->data[1 + p] + uvoff;
2947         for (y = 0; y < 8; y += 4, dst += 16 * ls_uv, lvl += 32) {
2948             uint8_t *ptr = dst, *l = lvl, *hmask1 = lflvl->mask[1][0][y];
2949             uint8_t *hmask2 = lflvl->mask[1][0][y + 2];
2950             unsigned hm1 = hmask1[0] | hmask1[1] | hmask1[2];
2951             unsigned hm2 = hmask2[1] | hmask2[2], hm = hm1 | hm2;
2952
2953             for (x = 1; hm & ~(x - 1); x <<= 1, ptr += 4) {
2954                 if (col || x > 1) {
2955                     if (hm1 & x) {
2956                         int L = *l, H = L >> 4;
2957                         int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
2958
2959                         if (hmask1[0] & x) {
2960                             if (hmask2[0] & x) {
2961                                 av_assert2(l[16] == L);
2962                                 s->dsp.loop_filter_16[0](ptr, ls_uv, E, I, H);
2963                             } else {
2964                                 s->dsp.loop_filter_8[2][0](ptr, ls_uv, E, I, H);
2965                             }
2966                         } else if (hm2 & x) {
2967                             L = l[16];
2968                             H |= (L >> 4) << 8;
2969                             E |= s->filter.mblim_lut[L] << 8;
2970                             I |= s->filter.lim_lut[L] << 8;
2971                             s->dsp.loop_filter_mix2[!!(hmask1[1] & x)]
2972                                                    [!!(hmask2[1] & x)]
2973                                                    [0](ptr, ls_uv, E, I, H);
2974                         } else {
2975                             s->dsp.loop_filter_8[!!(hmask1[1] & x)]
2976                                                 [0](ptr, ls_uv, E, I, H);
2977                         }
2978                     } else if (hm2 & x) {
2979                         int L = l[16], H = L >> 4;
2980                         int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
2981
2982                         s->dsp.loop_filter_8[!!(hmask2[1] & x)]
2983                                             [0](ptr + 8 * ls_uv, ls_uv, E, I, H);
2984                     }
2985                 }
2986                 if (x & 0xAA)
2987                     l += 2;
2988             }
2989         }
2990         lvl = lflvl->level;
2991         dst = s->f->data[1 + p] + uvoff;
2992         for (y = 0; y < 8; y++, dst += 4 * ls_uv) {
2993             uint8_t *ptr = dst, *l = lvl, *vmask = lflvl->mask[1][1][y];
2994             unsigned vm = vmask[0] | vmask[1] | vmask[2];
2995
2996             for (x = 1; vm & ~(x - 1); x <<= 4, ptr += 16, l += 4) {
2997                 if (row || y) {
2998                     if (vm & x) {
2999                         int L = *l, H = L >> 4;
3000                         int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
3001
3002                         if (vmask[0] & x) {
3003                             if (vmask[0] & (x << 2)) {
3004                                 av_assert2(l[2] == L);
3005                                 s->dsp.loop_filter_16[1](ptr, ls_uv, E, I, H);
3006                             } else {
3007                                 s->dsp.loop_filter_8[2][1](ptr, ls_uv, E, I, H);
3008                             }
3009                         } else if (vm & (x << 2)) {
3010                             L = l[2];
3011                             H |= (L >> 4) << 8;
3012                             E |= s->filter.mblim_lut[L] << 8;
3013                             I |= s->filter.lim_lut[L] << 8;
3014                             s->dsp.loop_filter_mix2[!!(vmask[1] &  x)]
3015                                                    [!!(vmask[1] & (x << 2))]
3016                                                    [1](ptr, ls_uv, E, I, H);
3017                         } else {
3018                             s->dsp.loop_filter_8[!!(vmask[1] & x)]
3019                                                 [1](ptr, ls_uv, E, I, H);
3020                         }
3021                     } else if (vm & (x << 2)) {
3022                         int L = l[2], H = L >> 4;
3023                         int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
3024
3025                         s->dsp.loop_filter_8[!!(vmask[1] & (x << 2))]
3026                                             [1](ptr + 8, ls_uv, E, I, H);
3027                     }
3028                 }
3029             }
3030             if (y & 1)
3031                 lvl += 16;
3032         }
3033     }
3034 }
3035
3036 static void set_tile_offset(int *start, int *end, int idx, int log2_n, int n)
3037 {
3038     int sb_start = ( idx      * n) >> log2_n;
3039     int sb_end   = ((idx + 1) * n) >> log2_n;
3040     *start = FFMIN(sb_start, n) << 3;
3041     *end   = FFMIN(sb_end,   n) << 3;
3042 }
3043
3044 static av_always_inline void adapt_prob(uint8_t *p, unsigned ct0, unsigned ct1,
3045                                         int max_count, int update_factor)
3046 {
3047     unsigned ct = ct0 + ct1, p2, p1;
3048
3049     if (!ct)
3050         return;
3051
3052     p1 = *p;
3053     p2 = ((ct0 << 8) + (ct >> 1)) / ct;
3054     p2 = av_clip(p2, 1, 255);
3055     ct = FFMIN(ct, max_count);
3056     update_factor = FASTDIV(update_factor * ct, max_count);
3057
3058     // (p1 * (256 - update_factor) + p2 * update_factor + 128) >> 8
3059     *p = p1 + (((p2 - p1) * update_factor + 128) >> 8);
3060 }
3061
3062 static void adapt_probs(VP9Context *s)
3063 {
3064     int i, j, k, l, m;
3065     prob_context *p = &s->prob_ctx[s->framectxid].p;
3066     int uf = (s->keyframe || s->intraonly || !s->last_keyframe) ? 112 : 128;
3067
3068     // coefficients
3069     for (i = 0; i < 4; i++)
3070         for (j = 0; j < 2; j++)
3071             for (k = 0; k < 2; k++)
3072                 for (l = 0; l < 6; l++)
3073                     for (m = 0; m < 6; m++) {
3074                         uint8_t *pp = s->prob_ctx[s->framectxid].coef[i][j][k][l][m];
3075                         unsigned *e = s->counts.eob[i][j][k][l][m];
3076                         unsigned *c = s->counts.coef[i][j][k][l][m];
3077
3078                         if (l == 0 && m >= 3) // dc only has 3 pt
3079                             break;
3080
3081                         adapt_prob(&pp[0], e[0], e[1], 24, uf);
3082                         adapt_prob(&pp[1], c[0], c[1] + c[2], 24, uf);
3083                         adapt_prob(&pp[2], c[1], c[2], 24, uf);
3084                     }
3085
3086     if (s->keyframe || s->intraonly) {
3087         memcpy(p->skip,  s->prob.p.skip,  sizeof(p->skip));
3088         memcpy(p->tx32p, s->prob.p.tx32p, sizeof(p->tx32p));
3089         memcpy(p->tx16p, s->prob.p.tx16p, sizeof(p->tx16p));
3090         memcpy(p->tx8p,  s->prob.p.tx8p,  sizeof(p->tx8p));
3091         return;
3092     }
3093
3094     // skip flag
3095     for (i = 0; i < 3; i++)
3096         adapt_prob(&p->skip[i], s->counts.skip[i][0], s->counts.skip[i][1], 20, 128);
3097
3098     // intra/inter flag
3099     for (i = 0; i < 4; i++)
3100         adapt_prob(&p->intra[i], s->counts.intra[i][0], s->counts.intra[i][1], 20, 128);
3101
3102     // comppred flag
3103     if (s->comppredmode == PRED_SWITCHABLE) {
3104       for (i = 0; i < 5; i++)
3105           adapt_prob(&p->comp[i], s->counts.comp[i][0], s->counts.comp[i][1], 20, 128);
3106     }
3107
3108     // reference frames
3109     if (s->comppredmode != PRED_SINGLEREF) {
3110       for (i = 0; i < 5; i++)
3111           adapt_prob(&p->comp_ref[i], s->counts.comp_ref[i][0],
3112                      s->counts.comp_ref[i][1], 20, 128);
3113     }
3114
3115     if (s->comppredmode != PRED_COMPREF) {
3116       for (i = 0; i < 5; i++) {
3117           uint8_t *pp = p->single_ref[i];
3118           unsigned (*c)[2] = s->counts.single_ref[i];
3119
3120           adapt_prob(&pp[0], c[0][0], c[0][1], 20, 128);
3121           adapt_prob(&pp[1], c[1][0], c[1][1], 20, 128);
3122       }
3123     }
3124
3125     // block partitioning
3126     for (i = 0; i < 4; i++)
3127         for (j = 0; j < 4; j++) {
3128             uint8_t *pp = p->partition[i][j];
3129             unsigned *c = s->counts.partition[i][j];
3130
3131             adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
3132             adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
3133             adapt_prob(&pp[2], c[2], c[3], 20, 128);
3134         }
3135
3136     // tx size
3137     if (s->txfmmode == TX_SWITCHABLE) {
3138       for (i = 0; i < 2; i++) {
3139           unsigned *c16 = s->counts.tx16p[i], *c32 = s->counts.tx32p[i];
3140
3141           adapt_prob(&p->tx8p[i], s->counts.tx8p[i][0], s->counts.tx8p[i][1], 20, 128);
3142           adapt_prob(&p->tx16p[i][0], c16[0], c16[1] + c16[2], 20, 128);
3143           adapt_prob(&p->tx16p[i][1], c16[1], c16[2], 20, 128);
3144           adapt_prob(&p->tx32p[i][0], c32[0], c32[1] + c32[2] + c32[3], 20, 128);
3145           adapt_prob(&p->tx32p[i][1], c32[1], c32[2] + c32[3], 20, 128);
3146           adapt_prob(&p->tx32p[i][2], c32[2], c32[3], 20, 128);
3147       }
3148     }
3149
3150     // interpolation filter
3151     if (s->filtermode == FILTER_SWITCHABLE) {
3152         for (i = 0; i < 4; i++) {
3153             uint8_t *pp = p->filter[i];
3154             unsigned *c = s->counts.filter[i];
3155
3156             adapt_prob(&pp[0], c[0], c[1] + c[2], 20, 128);
3157             adapt_prob(&pp[1], c[1], c[2], 20, 128);
3158         }
3159     }
3160
3161     // inter modes
3162     for (i = 0; i < 7; i++) {
3163         uint8_t *pp = p->mv_mode[i];
3164         unsigned *c = s->counts.mv_mode[i];
3165
3166         adapt_prob(&pp[0], c[2], c[1] + c[0] + c[3], 20, 128);
3167         adapt_prob(&pp[1], c[0], c[1] + c[3], 20, 128);
3168         adapt_prob(&pp[2], c[1], c[3], 20, 128);
3169     }
3170
3171     // mv joints
3172     {
3173         uint8_t *pp = p->mv_joint;
3174         unsigned *c = s->counts.mv_joint;
3175
3176         adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
3177         adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
3178         adapt_prob(&pp[2], c[2], c[3], 20, 128);
3179     }
3180
3181     // mv components
3182     for (i = 0; i < 2; i++) {
3183         uint8_t *pp;
3184         unsigned *c, (*c2)[2], sum;
3185
3186         adapt_prob(&p->mv_comp[i].sign, s->counts.mv_comp[i].sign[0],
3187                    s->counts.mv_comp[i].sign[1], 20, 128);
3188
3189         pp = p->mv_comp[i].classes;
3190         c = s->counts.mv_comp[i].classes;
3191         sum = c[1] + c[2] + c[3] + c[4] + c[5] + c[6] + c[7] + c[8] + c[9] + c[10];
3192         adapt_prob(&pp[0], c[0], sum, 20, 128);
3193         sum -= c[1];
3194         adapt_prob(&pp[1], c[1], sum, 20, 128);
3195         sum -= c[2] + c[3];
3196         adapt_prob(&pp[2], c[2] + c[3], sum, 20, 128);
3197         adapt_prob(&pp[3], c[2], c[3], 20, 128);
3198         sum -= c[4] + c[5];
3199         adapt_prob(&pp[4], c[4] + c[5], sum, 20, 128);
3200         adapt_prob(&pp[5], c[4], c[5], 20, 128);
3201         sum -= c[6];
3202         adapt_prob(&pp[6], c[6], sum, 20, 128);
3203         adapt_prob(&pp[7], c[7] + c[8], c[9] + c[10], 20, 128);
3204         adapt_prob(&pp[8], c[7], c[8], 20, 128);
3205         adapt_prob(&pp[9], c[9], c[10], 20, 128);
3206
3207         adapt_prob(&p->mv_comp[i].class0, s->counts.mv_comp[i].class0[0],
3208                    s->counts.mv_comp[i].class0[1], 20, 128);
3209         pp = p->mv_comp[i].bits;
3210         c2 = s->counts.mv_comp[i].bits;
3211         for (j = 0; j < 10; j++)
3212             adapt_prob(&pp[j], c2[j][0], c2[j][1], 20, 128);
3213
3214         for (j = 0; j < 2; j++) {
3215             pp = p->mv_comp[i].class0_fp[j];
3216             c = s->counts.mv_comp[i].class0_fp[j];
3217             adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
3218             adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
3219             adapt_prob(&pp[2], c[2], c[3], 20, 128);
3220         }
3221         pp = p->mv_comp[i].fp;
3222         c = s->counts.mv_comp[i].fp;
3223         adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
3224         adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
3225         adapt_prob(&pp[2], c[2], c[3], 20, 128);
3226
3227         if (s->highprecisionmvs) {
3228             adapt_prob(&p->mv_comp[i].class0_hp, s->counts.mv_comp[i].class0_hp[0],
3229                        s->counts.mv_comp[i].class0_hp[1], 20, 128);
3230             adapt_prob(&p->mv_comp[i].hp, s->counts.mv_comp[i].hp[0],
3231                        s->counts.mv_comp[i].hp[1], 20, 128);
3232         }
3233     }
3234
3235     // y intra modes
3236     for (i = 0; i < 4; i++) {
3237         uint8_t *pp = p->y_mode[i];
3238         unsigned *c = s->counts.y_mode[i], sum, s2;
3239
3240         sum = c[0] + c[1] + c[3] + c[4] + c[5] + c[6] + c[7] + c[8] + c[9];
3241         adapt_prob(&pp[0], c[DC_PRED], sum, 20, 128);
3242         sum -= c[TM_VP8_PRED];
3243         adapt_prob(&pp[1], c[TM_VP8_PRED], sum, 20, 128);
3244         sum -= c[VERT_PRED];
3245         adapt_prob(&pp[2], c[VERT_PRED], sum, 20, 128);
3246         s2 = c[HOR_PRED] + c[DIAG_DOWN_RIGHT_PRED] + c[VERT_RIGHT_PRED];
3247         sum -= s2;
3248         adapt_prob(&pp[3], s2, sum, 20, 128);
3249         s2 -= c[HOR_PRED];
3250         adapt_prob(&pp[4], c[HOR_PRED], s2, 20, 128);
3251         adapt_prob(&pp[5], c[DIAG_DOWN_RIGHT_PRED], c[VERT_RIGHT_PRED], 20, 128);
3252         sum -= c[DIAG_DOWN_LEFT_PRED];
3253         adapt_prob(&pp[6], c[DIAG_DOWN_LEFT_PRED], sum, 20, 128);
3254         sum -= c[VERT_LEFT_PRED];
3255         adapt_prob(&pp[7], c[VERT_LEFT_PRED], sum, 20, 128);
3256         adapt_prob(&pp[8], c[HOR_DOWN_PRED], c[HOR_UP_PRED], 20, 128);
3257     }
3258
3259     // uv intra modes
3260     for (i = 0; i < 10; i++) {
3261         uint8_t *pp = p->uv_mode[i];
3262         unsigned *c = s->counts.uv_mode[i], sum, s2;
3263
3264         sum = c[0] + c[1] + c[3] + c[4] + c[5] + c[6] + c[7] + c[8] + c[9];
3265         adapt_prob(&pp[0], c[DC_PRED], sum, 20, 128);
3266         sum -= c[TM_VP8_PRED];
3267         adapt_prob(&pp[1], c[TM_VP8_PRED], sum, 20, 128);
3268         sum -= c[VERT_PRED];
3269         adapt_prob(&pp[2], c[VERT_PRED], sum, 20, 128);
3270         s2 = c[HOR_PRED] + c[DIAG_DOWN_RIGHT_PRED] + c[VERT_RIGHT_PRED];
3271         sum -= s2;
3272         adapt_prob(&pp[3], s2, sum, 20, 128);
3273         s2 -= c[HOR_PRED];
3274         adapt_prob(&pp[4], c[HOR_PRED], s2, 20, 128);
3275         adapt_prob(&pp[5], c[DIAG_DOWN_RIGHT_PRED], c[VERT_RIGHT_PRED], 20, 128);
3276         sum -= c[DIAG_DOWN_LEFT_PRED];
3277         adapt_prob(&pp[6], c[DIAG_DOWN_LEFT_PRED], sum, 20, 128);
3278         sum -= c[VERT_LEFT_PRED];
3279         adapt_prob(&pp[7], c[VERT_LEFT_PRED], sum, 20, 128);
3280         adapt_prob(&pp[8], c[HOR_DOWN_PRED], c[HOR_UP_PRED], 20, 128);
3281     }
3282 }
3283
3284 static int vp9_decode_frame(AVCodecContext *ctx, void *out_pic,
3285                             int *got_frame, const uint8_t *data, int size)
3286 {
3287     VP9Context *s = ctx->priv_data;
3288     int res, tile_row, tile_col, i, ref, row, col;
3289     ptrdiff_t yoff = 0, uvoff = 0;
3290     //AVFrame *prev_frame = s->f; // for segmentation map
3291
3292     if ((res = decode_frame_header(ctx, data, size, &ref)) < 0) {
3293         return res;
3294     } else if (res == 0) {
3295         if (!s->refs[ref]) {
3296             av_log(ctx, AV_LOG_ERROR, "Requested reference %d not available\n", ref);
3297             return AVERROR_INVALIDDATA;
3298         }
3299         if ((res = av_frame_ref(out_pic, s->refs[ref])) < 0)
3300             return res;
3301         *got_frame = 1;
3302         return 0;
3303     }
3304     data += res;
3305     size -= res;
3306
3307     // discard old references
3308     for (i = 0; i < 10; i++) {
3309         AVFrame *f = s->fb[i];
3310         if (f->data[0] && f != s->f &&
3311             f != s->refs[0] && f != s->refs[1] &&
3312             f != s->refs[2] && f != s->refs[3] &&
3313             f != s->refs[4] && f != s->refs[5] &&
3314             f != s->refs[6] && f != s->refs[7])
3315             av_frame_unref(f);
3316     }
3317
3318     // find unused reference
3319     for (i = 0; i < 10; i++)
3320         if (!s->fb[i]->data[0])
3321             break;
3322     av_assert0(i < 10);
3323     s->f = s->fb[i];
3324     if ((res = ff_get_buffer(ctx, s->f,
3325                              s->refreshrefmask ? AV_GET_BUFFER_FLAG_REF : 0)) < 0)
3326         return res;
3327     s->f->key_frame = s->keyframe;
3328     s->f->pict_type = s->keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
3329
3330     // main tile decode loop
3331     memset(s->above_partition_ctx, 0, s->cols);
3332     memset(s->above_skip_ctx, 0, s->cols);
3333     if (s->keyframe || s->intraonly) {
3334         memset(s->above_mode_ctx, DC_PRED, s->cols * 2);
3335     } else {
3336         memset(s->above_mode_ctx, NEARESTMV, s->cols);
3337     }
3338     memset(s->above_y_nnz_ctx, 0, s->sb_cols * 16);
3339     memset(s->above_uv_nnz_ctx[0], 0, s->sb_cols * 8);
3340     memset(s->above_uv_nnz_ctx[1], 0, s->sb_cols * 8);
3341     memset(s->above_segpred_ctx, 0, s->cols);
3342     for (tile_row = 0; tile_row < s->tiling.tile_rows; tile_row++) {
3343         set_tile_offset(&s->tiling.tile_row_start, &s->tiling.tile_row_end,
3344                         tile_row, s->tiling.log2_tile_rows, s->sb_rows);
3345         for (tile_col = 0; tile_col < s->tiling.tile_cols; tile_col++) {
3346             unsigned tile_size;
3347
3348             if (tile_col == s->tiling.tile_cols - 1 &&
3349                 tile_row == s->tiling.tile_rows - 1) {
3350                 tile_size = size;
3351             } else {
3352                 tile_size = AV_RB32(data);
3353                 data += 4;
3354                 size -= 4;
3355             }
3356             if (tile_size > size)
3357                 return AVERROR_INVALIDDATA;
3358             ff_vp56_init_range_decoder(&s->c_b[tile_col], data, tile_size);
3359             if (vp56_rac_get_prob_branchy(&s->c_b[tile_col], 128)) // marker bit
3360                 return AVERROR_INVALIDDATA;
3361             data += tile_size;
3362             size -= tile_size;
3363         }
3364
3365         for (row = s->tiling.tile_row_start;
3366              row < s->tiling.tile_row_end;
3367              row += 8, yoff += s->f->linesize[0] * 64,
3368              uvoff += s->f->linesize[1] * 32) {
3369             struct VP9Filter *lflvl_ptr = s->lflvl;
3370             ptrdiff_t yoff2 = yoff, uvoff2 = uvoff;
3371
3372             for (tile_col = 0; tile_col < s->tiling.tile_cols; tile_col++) {
3373                 set_tile_offset(&s->tiling.tile_col_start, &s->tiling.tile_col_end,
3374                                 tile_col, s->tiling.log2_tile_cols, s->sb_cols);
3375
3376                 memset(s->left_partition_ctx, 0, 8);
3377                 memset(s->left_skip_ctx, 0, 8);
3378                 if (s->keyframe || s->intraonly) {
3379                     memset(s->left_mode_ctx, DC_PRED, 16);
3380                 } else {
3381                     memset(s->left_mode_ctx, NEARESTMV, 8);
3382                 }
3383                 memset(s->left_y_nnz_ctx, 0, 16);
3384                 memset(s->left_uv_nnz_ctx, 0, 16);
3385                 memset(s->left_segpred_ctx, 0, 8);
3386
3387                 memcpy(&s->c, &s->c_b[tile_col], sizeof(s->c));
3388                 for (col = s->tiling.tile_col_start;
3389                      col < s->tiling.tile_col_end;
3390                      col += 8, yoff2 += 64, uvoff2 += 32, lflvl_ptr++) {
3391                     // FIXME integrate with lf code (i.e. zero after each
3392                     // use, similar to invtxfm coefficients, or similar)
3393                     memset(lflvl_ptr->mask, 0, sizeof(lflvl_ptr->mask));
3394
3395                     if ((res = decode_sb(ctx, row, col, lflvl_ptr,
3396                                          yoff2, uvoff2, BL_64X64)) < 0)
3397                         return res;
3398                 }
3399                 memcpy(&s->c_b[tile_col], &s->c, sizeof(s->c));
3400             }
3401
3402             // backup pre-loopfilter reconstruction data for intra
3403             // prediction of next row of sb64s
3404             if (row + 8 < s->rows) {
3405                 memcpy(s->intra_pred_data[0],
3406                        s->f->data[0] + yoff + 63 * s->f->linesize[0],
3407                        8 * s->cols);
3408                 memcpy(s->intra_pred_data[1],
3409                        s->f->data[1] + uvoff + 31 * s->f->linesize[1],
3410                        4 * s->cols);
3411                 memcpy(s->intra_pred_data[2],
3412                        s->f->data[2] + uvoff + 31 * s->f->linesize[2],
3413                        4 * s->cols);
3414             }
3415
3416             // loopfilter one row
3417             if (s->filter.level) {
3418                 yoff2 = yoff;
3419                 uvoff2 = uvoff;
3420                 lflvl_ptr = s->lflvl;
3421                 for (col = 0; col < s->cols;
3422                      col += 8, yoff2 += 64, uvoff2 += 32, lflvl_ptr++) {
3423                     loopfilter_sb(ctx, lflvl_ptr, row, col, yoff2, uvoff2);
3424                 }
3425             }
3426         }
3427     }
3428
3429     // bw adaptivity (or in case of parallel decoding mode, fw adaptivity
3430     // probability maintenance between frames)
3431     if (s->refreshctx) {
3432         if (s->parallelmode) {
3433             int i, j, k, l, m;
3434
3435             for (i = 0; i < 4; i++)
3436                 for (j = 0; j < 2; j++)
3437                     for (k = 0; k < 2; k++)
3438                         for (l = 0; l < 6; l++)
3439                             for (m = 0; m < 6; m++)
3440                                 memcpy(s->prob_ctx[s->framectxid].coef[i][j][k][l][m],
3441                                        s->prob.coef[i][j][k][l][m], 3);
3442             s->prob_ctx[s->framectxid].p = s->prob.p;
3443         } else {
3444             adapt_probs(s);
3445         }
3446     }
3447     FFSWAP(struct VP9mvrefPair *, s->mv[0], s->mv[1]);
3448
3449     // ref frame setup
3450     for (i = 0; i < 8; i++)
3451         if (s->refreshrefmask & (1 << i))
3452             s->refs[i] = s->f;
3453
3454     if (!s->invisible) {
3455         if ((res = av_frame_ref(out_pic, s->f)) < 0)
3456             return res;
3457         *got_frame = 1;
3458     }
3459
3460     return 0;
3461 }
3462
3463 static int vp9_decode_packet(AVCodecContext *avctx, void *out_pic,
3464                              int *got_frame, AVPacket *avpkt)
3465 {
3466     const uint8_t *data = avpkt->data;
3467     int size = avpkt->size, marker, res;
3468
3469     // read superframe index - this is a collection of individual frames that
3470     // together lead to one visible frame
3471     av_assert1(size > 0); // without CODEC_CAP_DELAY, this is implied
3472     marker = data[size - 1];
3473     if ((marker & 0xe0) == 0xc0) {
3474         int nbytes = 1 + ((marker >> 3) & 0x3);
3475         int n_frames = 1 + (marker & 0x7), idx_sz = 2 + n_frames * nbytes;
3476
3477         if (size >= idx_sz && data[size - idx_sz] == marker) {
3478             const uint8_t *idx = data + size + 1 - idx_sz;
3479             switch (nbytes) {
3480 #define case_n(a, rd) \
3481                 case a: \
3482                     while (n_frames--) { \
3483                         int sz = rd; \
3484                         idx += a; \
3485                         if (sz > size) { \
3486                             av_log(avctx, AV_LOG_ERROR, \
3487                                    "Superframe packet size too big: %d > %d\n", \
3488                                    sz, size); \
3489                             return AVERROR_INVALIDDATA; \
3490                         } \
3491                         res = vp9_decode_frame(avctx, out_pic, got_frame, \
3492                                                data, sz); \
3493                         if (res < 0) \
3494                             return res; \
3495                         data += sz; \
3496                         size -= sz; \
3497                     } \
3498                     break;
3499                 case_n(1, *idx);
3500                 case_n(2, AV_RL16(idx));
3501                 case_n(3, AV_RL24(idx));
3502                 case_n(4, AV_RL32(idx));
3503             }
3504             return avpkt->size;
3505         }
3506     }
3507     // if we get here, there was no valid superframe index, i.e. this is just
3508     // one whole single frame - decode it as such from the complete input buf
3509     if ((res = vp9_decode_frame(avctx, out_pic, got_frame, data, size)) < 0)
3510         return res;
3511     return avpkt->size;
3512 }
3513
3514 static void vp9_decode_flush(AVCodecContext *ctx)
3515 {
3516     VP9Context *s = ctx->priv_data;
3517     int i;
3518
3519     for (i = 0; i < 10; i++)
3520         if (s->fb[i]->data[0])
3521             av_frame_unref(s->fb[i]);
3522     for (i = 0; i < 8; i++)
3523         s->refs[i] = NULL;
3524     s->f = NULL;
3525 }
3526
3527 static av_cold int vp9_decode_init(AVCodecContext *ctx)
3528 {
3529     VP9Context *s = ctx->priv_data;
3530     int i;
3531
3532     ctx->pix_fmt = AV_PIX_FMT_YUV420P;
3533     ff_vp9dsp_init(&s->dsp);
3534     ff_videodsp_init(&s->vdsp, 8);
3535     for (i = 0; i < 10; i++) {
3536         s->fb[i] = av_frame_alloc();
3537         if (!s->fb[i]) {
3538             av_log(ctx, AV_LOG_ERROR, "Failed to allocate frame buffer %d\n", i);
3539             return AVERROR(ENOMEM);
3540         }
3541     }
3542     s->filter.sharpness = -1;
3543
3544     return 0;
3545 }
3546
3547 static av_cold int vp9_decode_free(AVCodecContext *ctx)
3548 {
3549     VP9Context *s = ctx->priv_data;
3550     int i;
3551
3552     for (i = 0; i < 10; i++) {
3553         if (s->fb[i]->data[0])
3554             av_frame_unref(s->fb[i]);
3555         av_frame_free(&s->fb[i]);
3556     }
3557     av_freep(&s->above_partition_ctx);
3558     s->above_skip_ctx = s->above_txfm_ctx = s->above_mode_ctx = NULL;
3559     s->above_y_nnz_ctx = s->above_uv_nnz_ctx[0] = s->above_uv_nnz_ctx[1] = NULL;
3560     s->intra_pred_data[0] = s->intra_pred_data[1] = s->intra_pred_data[2] = NULL;
3561     s->above_segpred_ctx = s->above_intra_ctx = s->above_comp_ctx = NULL;
3562     s->above_ref_ctx = s->above_filter_ctx = NULL;
3563     s->above_mv_ctx = NULL;
3564     s->segmentation_map = NULL;
3565     s->mv[0] = s->mv[1] = NULL;
3566     s->lflvl = NULL;
3567     av_freep(&s->c_b);
3568     s->c_b_size = 0;
3569
3570     return 0;
3571 }
3572
3573 AVCodec ff_vp9_decoder = {
3574   .name                  = "vp9",
3575   .long_name             = NULL_IF_CONFIG_SMALL("Google VP9"),
3576   .type                  = AVMEDIA_TYPE_VIDEO,
3577   .id                    = AV_CODEC_ID_VP9,
3578   .priv_data_size        = sizeof(VP9Context),
3579   .init                  = vp9_decode_init,
3580   .close                 = vp9_decode_free,
3581   .decode                = vp9_decode_packet,
3582   .capabilities          = CODEC_CAP_DR1,
3583   .flush                 = vp9_decode_flush,
3584 };