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