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