git.sesse.net Git - ffmpeg/blob - libavcodec/vp9.c

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