Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

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