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