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