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