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