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