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