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