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