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