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