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