@@ -36,6 +36,7 @@ version <next>

 - make decoding alpha optional for prores, ffv1 and vp6 by setting

   the skip_alpha flag.

 - ladspa wrapper filter

+- native VP9 decoder

 version 2.0:

@@ -1909,6 +1909,7 @@ vp6_decoder_select="h264chroma hpeldsp huffman videodsp vp3dsp"

 vp6a_decoder_select="vp6_decoder"

 vp6f_decoder_select="vp6_decoder"

 vp8_decoder_select="h264pred videodsp"

+vp9_decoder_select="videodsp"

 webp_decoder_select="vp8_decoder"

 wmapro_decoder_select="mdct sinewin"

 wmav1_decoder_select="mdct sinewin"

@@ -94,7 +94,7 @@ Then pass @code{--enable-libtwolame} to configure to enable it.

 @section libvpx

-FFmpeg can make use of the libvpx library for VP8 encoding.

+FFmpeg can make use of the libvpx library for VP8/VP9 encoding.

 Go to @url{http://www.webmproject.org/} and follow the instructions for

 installing the library. Then pass @code{--enable-libvpx} to configure to

@@ -676,6 +676,8 @@ following image formats are supported:

     @tab fourcc: VP60,VP61,VP62

 @item VP8                    @tab  E  @tab  X

     @tab fourcc: VP80, encoding supported through external library libvpx

+@item VP9                    @tab  E  @tab  X

+    @tab encoding supported through external library libvpx

 @item Pinnacle TARGA CineWave YUV16 @tab     @tab  X

     @tab fourcc: Y216

 @item Prores                 @tab     @tab  X

@@ -471,6 +471,7 @@ OBJS-$(CONFIG_VP5_DECODER)             += vp5.o vp56.o vp56data.o vp56dsp.o \

 OBJS-$(CONFIG_VP6_DECODER)             += vp6.o vp56.o vp56data.o vp56dsp.o \

                                           vp6dsp.o vp56rac.o

 OBJS-$(CONFIG_VP8_DECODER)             += vp8.o vp8dsp.o vp56rac.o

+OBJS-$(CONFIG_VP9_DECODER)             += vp9.o vp9dsp.o vp56rac.o

 OBJS-$(CONFIG_VPLAYER_DECODER)         += textdec.o ass.o

 OBJS-$(CONFIG_VQA_DECODER)             += vqavideo.o

 OBJS-$(CONFIG_WAVPACK_DECODER)         += wavpack.o

@@ -285,6 +285,7 @@ void avcodec_register_all(void)

     REGISTER_DECODER(VP6A,              vp6a);

     REGISTER_DECODER(VP6F,              vp6f);

     REGISTER_DECODER(VP8,               vp8);

+    REGISTER_DECODER(VP9,               vp9);

     REGISTER_DECODER(VQA,               vqa);

     REGISTER_DECODER(WEBP,              webp);

     REGISTER_ENCDEC (WMV1,              wmv1);

new file mode 100644

@@ -0,0 +1,3576 @@

+/*

+ * VP9 compatible video decoder

+ *

+ * Copyright (C) 2013 Ronald S. Bultje <rsbultje gmail com>

+ * Copyright (C) 2013 Clément Bœsch <u pkh me>

+ *

+ * This file is part of FFmpeg.

+ *

+ * FFmpeg is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * FFmpeg is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with FFmpeg; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+#include "avcodec.h"

+#include "get_bits.h"

+#include "internal.h"

+#include "videodsp.h"

+#include "vp56.h"

+#include "vp9.h"

+#include "vp9data.h"

+#include "vp9dsp.h"

+#include "libavutil/avassert.h"

+

+#define VP9_SYNCCODE 0x498342

+

+enum CompPredMode {

+    PRED_SINGLEREF,

+    PRED_COMPREF,

+    PRED_SWITCHABLE,

+};

+

+enum BlockLevel {

+    BL_64X64,

+    BL_32X32,

+    BL_16X16,

+    BL_8X8,

+};

+

+enum BlockSize {

+    BS_64x64,

+    BS_64x32,

+    BS_32x64,

+    BS_32x32,

+    BS_32x16,

+    BS_16x32,

+    BS_16x16,

+    BS_16x8,

+    BS_8x16,

+    BS_8x8,

+    BS_8x4,

+    BS_4x8,

+    BS_4x4,

+    N_BS_SIZES,

+};

+

+struct VP9mvrefPair {

+    VP56mv mv[2];

+    int8_t ref[2];

+};

+

+struct VP9Filter {

+    uint8_t level[8 * 8];

+    uint8_t /* bit=col */ mask[2 /* 0=y, 1=uv */][2 /* 0=col, 1=row */]

+                              [8 /* rows */][4 /* 0=16, 1=8, 2=4, 3=inner4 */];

+};

+

+typedef struct VP9Block {

+    uint8_t seg_id, intra, comp, ref[2], mode[4], uvmode, skip;

+    enum FilterMode filter;

+    VP56mv mv[4 /* b_idx */][2 /* ref */];

+    enum BlockSize bs;

+    enum TxfmMode tx, uvtx;

+

+    int row, row7, col, col7;

+    uint8_t *dst[3];

+    ptrdiff_t y_stride, uv_stride;

+} VP9Block;

+

+typedef struct VP9Context {

+    VP9DSPContext dsp;

+    VideoDSPContext vdsp;

+    GetBitContext gb;

+    VP56RangeCoder c;

+    VP56RangeCoder *c_b;

+    unsigned c_b_size;

+    VP9Block b;

+

+    // bitstream header

+    uint8_t profile;

+    uint8_t keyframe, last_keyframe;

+    uint8_t invisible, last_invisible;

+    uint8_t use_last_frame_mvs;

+    uint8_t errorres;

+    uint8_t colorspace;

+    uint8_t fullrange;

+    uint8_t intraonly;

+    uint8_t resetctx;

+    uint8_t refreshrefmask;

+    uint8_t highprecisionmvs;

+    enum FilterMode filtermode;

+    uint8_t allowcompinter;

+    uint8_t fixcompref;

+    uint8_t refreshctx;

+    uint8_t parallelmode;

+    uint8_t framectxid;

+    uint8_t refidx[3];

+    uint8_t signbias[3];

+    uint8_t varcompref[2];

+    AVFrame *refs[8], *f, *fb[10];

+

+    struct {

+        uint8_t level;

+        int8_t sharpness;

+        uint8_t lim_lut[64];

+        uint8_t mblim_lut[64];

+    } filter;

+    struct {

+        uint8_t enabled;

+        int8_t mode[2];

+        int8_t ref[4];

+    } lf_delta;

+    uint8_t yac_qi;

+    int8_t ydc_qdelta, uvdc_qdelta, uvac_qdelta;

+    uint8_t lossless;

+    struct {

+        uint8_t enabled;

+        uint8_t temporal;

+        uint8_t absolute_vals;

+        uint8_t update_map;

+        struct {

+            uint8_t q_enabled;

+            uint8_t lf_enabled;

+            uint8_t ref_enabled;

+            uint8_t skip_enabled;

+            uint8_t ref_val;

+            int16_t q_val;

+            int8_t lf_val;

+            int16_t qmul[2][2];

+            uint8_t lflvl[4][2];

+        } feat[8];

+    } segmentation;

+    struct {

+        unsigned log2_tile_cols, log2_tile_rows;

+        unsigned tile_cols, tile_rows;

+        unsigned tile_row_start, tile_row_end, tile_col_start, tile_col_end;

+    } tiling;

+    unsigned sb_cols, sb_rows, rows, cols;

+    struct {

+        prob_context p;

+        uint8_t coef[4][2][2][6][6][3];

+    } prob_ctx[4];

+    struct {

+        prob_context p;

+        uint8_t coef[4][2][2][6][6][11];

+        uint8_t seg[7];

+        uint8_t segpred[3];

+    } prob;

+    struct {

+        unsigned y_mode[4][10];

+        unsigned uv_mode[10][10];

+        unsigned filter[4][3];

+        unsigned mv_mode[7][4];

+        unsigned intra[4][2];

+        unsigned comp[5][2];

+        unsigned single_ref[5][2][2];

+        unsigned comp_ref[5][2];

+        unsigned tx32p[2][4];

+        unsigned tx16p[2][3];

+        unsigned tx8p[2][2];

+        unsigned skip[3][2];

+        unsigned mv_joint[4];

+        struct {

+            unsigned sign[2];

+            unsigned classes[11];

+            unsigned class0[2];

+            unsigned bits[10][2];

+            unsigned class0_fp[2][4];

+            unsigned fp[4];

+            unsigned class0_hp[2];

+            unsigned hp[2];

+        } mv_comp[2];

+        unsigned partition[4][4][4];

+        unsigned coef[4][2][2][6][6][3];

+        unsigned eob[4][2][2][6][6][2];

+    } counts;

+    enum TxfmMode txfmmode;

+    enum CompPredMode comppredmode;

+

+    // contextual (left/above) cache

+    uint8_t left_partition_ctx[8], *above_partition_ctx;

+    uint8_t left_mode_ctx[16], *above_mode_ctx;

+    // FIXME maybe merge some of the below in a flags field?

+    uint8_t left_y_nnz_ctx[16], *above_y_nnz_ctx;

+    uint8_t left_uv_nnz_ctx[2][8], *above_uv_nnz_ctx[2];

+    uint8_t left_skip_ctx[8], *above_skip_ctx; // 1bit

+    uint8_t left_txfm_ctx[8], *above_txfm_ctx; // 2bit

+    uint8_t left_segpred_ctx[8], *above_segpred_ctx; // 1bit

+    uint8_t left_intra_ctx[8], *above_intra_ctx; // 1bit

+    uint8_t left_comp_ctx[8], *above_comp_ctx; // 1bit

+    uint8_t left_ref_ctx[8], *above_ref_ctx; // 2bit

+    uint8_t left_filter_ctx[8], *above_filter_ctx;

+    VP56mv left_mv_ctx[16][2], (*above_mv_ctx)[2];

+

+    // whole-frame cache

+    uint8_t *intra_pred_data[3];

+    uint8_t *segmentation_map;

+    struct VP9mvrefPair *mv[2];

+    struct VP9Filter *lflvl;

+    DECLARE_ALIGNED(32, uint8_t, edge_emu_buffer)[71*80];

+

+    // block reconstruction intermediates

+    DECLARE_ALIGNED(32, int16_t, block)[4096];

+    DECLARE_ALIGNED(32, int16_t, uvblock)[2][1024];

+    uint8_t eob[256];

+    uint8_t uveob[2][64];

+    VP56mv min_mv, max_mv;

+    DECLARE_ALIGNED(32, uint8_t, tmp_y)[64*64];

+    DECLARE_ALIGNED(32, uint8_t, tmp_uv)[2][32*32];

+} VP9Context;

+

+static const uint8_t bwh_tab[2][N_BS_SIZES][2] = {

+    {

+        { 16, 16 }, { 16, 8 }, { 8, 16 }, { 8, 8 }, { 8, 4 }, { 4, 8 },

+        { 4, 4 }, { 4, 2 }, { 2, 4 }, { 2, 2 }, { 2, 1 }, { 1, 2 }, { 1, 1 },

+    }, {

+        { 8, 8 }, { 8, 4 }, { 4, 8 }, { 4, 4 }, { 4, 2 }, { 2, 4 },

+        { 2, 2 }, { 2, 1 }, { 1, 2 }, { 1, 1 }, { 1, 1 }, { 1, 1 }, { 1, 1 },

+    }

+};

+

+static int update_size(AVCodecContext *ctx, int w, int h)

+{

+    VP9Context *s = ctx->priv_data;

+    uint8_t *p;

+

+    if (s->above_partition_ctx && w == ctx->width && h == ctx->height)

+        return 0;

+

+    ctx->width  = w;

+    ctx->height = h;

+    s->sb_cols  = (w + 63) >> 6;

+    s->sb_rows  = (h + 63) >> 6;

+    s->cols     = (w + 7) >> 3;

+    s->rows     = (h + 7) >> 3;

+

+#define assign(var, type, n) var = (type) p; p += s->sb_cols * n * sizeof(*var)

+    av_free(s->above_partition_ctx);

+    p = av_malloc(s->sb_cols * (240 + sizeof(*s->lflvl) + 16 * sizeof(*s->above_mv_ctx) +

+                                64 * s->sb_rows * (1 + sizeof(*s->mv[0]) * 2)));

+    if (!p)

+        return AVERROR(ENOMEM);

+    assign(s->above_partition_ctx, uint8_t *,              8);

+    assign(s->above_skip_ctx,      uint8_t *,              8);

+    assign(s->above_txfm_ctx,      uint8_t *,              8);

+    assign(s->above_mode_ctx,      uint8_t *,             16);

+    assign(s->above_y_nnz_ctx,     uint8_t *,             16);

+    assign(s->above_uv_nnz_ctx[0], uint8_t *,              8);

+    assign(s->above_uv_nnz_ctx[1], uint8_t *,              8);

+    assign(s->intra_pred_data[0],  uint8_t *,             64);

+    assign(s->intra_pred_data[1],  uint8_t *,             32);

+    assign(s->intra_pred_data[2],  uint8_t *,             32);

+    assign(s->above_segpred_ctx,   uint8_t *,              8);

+    assign(s->above_intra_ctx,     uint8_t *,              8);

+    assign(s->above_comp_ctx,      uint8_t *,              8);

+    assign(s->above_ref_ctx,       uint8_t *,              8);

+    assign(s->above_filter_ctx,    uint8_t *,              8);

+    assign(s->lflvl,               struct VP9Filter *,     1);

+    assign(s->above_mv_ctx,        VP56mv(*)[2],          16);

+    assign(s->segmentation_map,    uint8_t *,             64 * s->sb_rows);

+    assign(s->mv[0],               struct VP9mvrefPair *, 64 * s->sb_rows);

+    assign(s->mv[1],               struct VP9mvrefPair *, 64 * s->sb_rows);

+#undef assign

+

+    return 0;

+}

+

+// for some reason the sign bit is at the end, not the start, of a bit sequence

+static av_always_inline int get_sbits_inv(GetBitContext *gb, int n)

+{

+    int v = get_bits(gb, n);

+    return get_bits1(gb) ? -v : v;

+}

+

+static av_always_inline int inv_recenter_nonneg(int v, int m)

+{

+    return v > 2 * m ? v : v & 1 ? m - ((v + 1) >> 1) : m + (v >> 1);

+}

+

+// differential forward probability updates

+static int update_prob(VP56RangeCoder *c, int p)

+{

+    static const int inv_map_table[254] = {

+          7,  20,  33,  46,  59,  72,  85,  98, 111, 124, 137, 150, 163, 176,

+        189, 202, 215, 228, 241, 254,   1,   2,   3,   4,   5,   6,   8,   9,

+         10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  21,  22,  23,  24,

+         25,  26,  27,  28,  29,  30,  31,  32,  34,  35,  36,  37,  38,  39,

+         40,  41,  42,  43,  44,  45,  47,  48,  49,  50,  51,  52,  53,  54,

+         55,  56,  57,  58,  60,  61,  62,  63,  64,  65,  66,  67,  68,  69,

+         70,  71,  73,  74,  75,  76,  77,  78,  79,  80,  81,  82,  83,  84,

+         86,  87,  88,  89,  90,  91,  92,  93,  94,  95,  96,  97,  99, 100,

+        101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 112, 113, 114, 115,

+        116, 117, 118, 119, 120, 121, 122, 123, 125, 126, 127, 128, 129, 130,

+        131, 132, 133, 134, 135, 136, 138, 139, 140, 141, 142, 143, 144, 145,

+        146, 147, 148, 149, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160,

+        161, 162, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,

+        177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 190, 191,

+        192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 203, 204, 205, 206,

+        207, 208, 209, 210, 211, 212, 213, 214, 216, 217, 218, 219, 220, 221,

+        222, 223, 224, 225, 226, 227, 229, 230, 231, 232, 233, 234, 235, 236,

+        237, 238, 239, 240, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251,

+        252, 253,

+    };

+    int d;

+

+    /* This code is trying to do a differential probability update. For a

+     * current probability A in the range [1, 255], the difference to a new

+     * probability of any value can be expressed differentially as 1-A,255-A

+     * where some part of this (absolute range) exists both in positive as

+     * well as the negative part, whereas another part only exists in one

+     * half. We're trying to code this shared part differentially, i.e.

+     * times two where the value of the lowest bit specifies the sign, and

+     * the single part is then coded on top of this. This absolute difference

+     * then again has a value of [0,254], but a bigger value in this range

+     * indicates that we're further away from the original value A, so we

+     * can code this as a VLC code, since higher values are increasingly

+     * unlikely. The first 20 values in inv_map_table[] allow 'cheap, rough'

+     * updates vs. the 'fine, exact' updates further down the range, which

+     * adds one extra dimension to this differential update model. */

+

+    if (!vp8_rac_get(c)) {

+        d = vp8_rac_get_uint(c, 4) + 0;

+    } else if (!vp8_rac_get(c)) {

+        d = vp8_rac_get_uint(c, 4) + 16;

+    } else if (!vp8_rac_get(c)) {

+        d = vp8_rac_get_uint(c, 5) + 32;

+    } else {

+        d = vp8_rac_get_uint(c, 7);

+        if (d >= 65)

+            d = (d << 1) - 65 + vp8_rac_get(c);

+        d += 64;

+    }

+

+    return p <= 128 ? 1 + inv_recenter_nonneg(inv_map_table[d], p - 1) :

+                    255 - inv_recenter_nonneg(inv_map_table[d], 255 - p);

+}

+

+static int decode_frame_header(AVCodecContext *ctx,

+                               const uint8_t *data, int size, int *ref)

+{

+    VP9Context *s = ctx->priv_data;

+    int c, i, j, k, l, m, n, w, h, max, size2, res, sharp;

+    const uint8_t *data2;

+

+    /* general header */

+    if ((res = init_get_bits8(&s->gb, data, size)) < 0) {

+        av_log(ctx, AV_LOG_ERROR, "Failed to intialize bitstream reader\n");

+        return res;

+    }

+    if (get_bits(&s->gb, 2) != 0x2) { // frame marker

+        av_log(ctx, AV_LOG_ERROR, "Invalid frame marker\n");

+        return AVERROR_INVALIDDATA;

+    }

+    s->profile = get_bits1(&s->gb);

+    if (get_bits1(&s->gb)) { // reserved bit

+        av_log(ctx, AV_LOG_ERROR, "Reserved bit should be zero\n");

+        return AVERROR_INVALIDDATA;

+    }

+    if (get_bits1(&s->gb)) {

+        *ref = get_bits(&s->gb, 3);

+        return 0;

+    }

+    s->last_keyframe  = s->keyframe;

+    s->keyframe       = !get_bits1(&s->gb);

+    s->last_invisible = s->invisible;

+    s->invisible      = !get_bits1(&s->gb);

+    s->errorres       = get_bits1(&s->gb);

+    // FIXME disable this upon resolution change

+    s->use_last_frame_mvs = !s->errorres && !s->last_invisible;

+    if (s->keyframe) {

+        if (get_bits_long(&s->gb, 24) != VP9_SYNCCODE) { // synccode

+            av_log(ctx, AV_LOG_ERROR, "Invalid sync code\n");

+            return AVERROR_INVALIDDATA;

+        }

+        s->colorspace = get_bits(&s->gb, 3);

+        if (s->colorspace == 7) { // RGB = profile 1

+            av_log(ctx, AV_LOG_ERROR, "RGB not supported in profile 0\n");

+            return AVERROR_INVALIDDATA;

+        }

+        s->fullrange  = get_bits1(&s->gb);

+        // for profile 1, here follows the subsampling bits

+        s->refreshrefmask = 0xff;

+        w = get_bits(&s->gb, 16) + 1;

+        h = get_bits(&s->gb, 16) + 1;

+        if (get_bits1(&s->gb)) // display size

+            skip_bits(&s->gb, 32);

+    } else {

+        s->intraonly  = s->invisible ? get_bits1(&s->gb) : 0;

+        s->resetctx   = s->errorres ? 0 : get_bits(&s->gb, 2);

+        if (s->intraonly) {

+            if (get_bits_long(&s->gb, 24) != VP9_SYNCCODE) { // synccode

+                av_log(ctx, AV_LOG_ERROR, "Invalid sync code\n");

+                return AVERROR_INVALIDDATA;

+            }

+            s->refreshrefmask = get_bits(&s->gb, 8);

+            w = get_bits(&s->gb, 16) + 1;

+            h = get_bits(&s->gb, 16) + 1;

+            if (get_bits1(&s->gb)) // display size

+                skip_bits(&s->gb, 32);

+        } else {

+            s->refreshrefmask = get_bits(&s->gb, 8);

+            s->refidx[0]      = get_bits(&s->gb, 3);

+            s->signbias[0]    = get_bits1(&s->gb);

+            s->refidx[1]      = get_bits(&s->gb, 3);

+            s->signbias[1]    = get_bits1(&s->gb);

+            s->refidx[2]      = get_bits(&s->gb, 3);

+            s->signbias[2]    = get_bits1(&s->gb);

+            if (!s->refs[s->refidx[0]] || !s->refs[s->refidx[1]] ||

+                !s->refs[s->refidx[2]]) {

+                av_log(ctx, AV_LOG_ERROR, "Not all references are available\n");

+                return AVERROR_INVALIDDATA;

+            }

+            if (get_bits1(&s->gb)) {

+                w = s->refs[s->refidx[0]]->width;

+                h = s->refs[s->refidx[0]]->height;

+            } else if (get_bits1(&s->gb)) {

+                w = s->refs[s->refidx[1]]->width;

+                h = s->refs[s->refidx[1]]->height;

+            } else if (get_bits1(&s->gb)) {

+                w = s->refs[s->refidx[2]]->width;

+                h = s->refs[s->refidx[2]]->height;

+            } else {

+                w = get_bits(&s->gb, 16) + 1;

+                h = get_bits(&s->gb, 16) + 1;

+            }

+            if (get_bits1(&s->gb)) // display size

+                skip_bits(&s->gb, 32);

+            s->highprecisionmvs = get_bits1(&s->gb);

+            s->filtermode = get_bits1(&s->gb) ? FILTER_SWITCHABLE :

+                                                get_bits(&s->gb, 2);

+            s->allowcompinter = s->signbias[0] != s->signbias[1] ||

+                                s->signbias[0] != s->signbias[2];

+            if (s->allowcompinter) {

+                if (s->signbias[0] == s->signbias[1]) {

+                    s->fixcompref    = 2;

+                    s->varcompref[0] = 0;

+                    s->varcompref[1] = 1;

+                } else if (s->signbias[0] == s->signbias[2]) {

+                    s->fixcompref    = 1;

+                    s->varcompref[0] = 0;

+                    s->varcompref[1] = 2;

+                } else {

+                    s->fixcompref    = 0;

+                    s->varcompref[0] = 1;

+                    s->varcompref[1] = 2;

+                }

+            }

+        }

+    }

+    s->refreshctx   = s->errorres ? 0 : get_bits1(&s->gb);

+    s->parallelmode = s->errorres ? 1 : get_bits1(&s->gb);

+    s->framectxid   = c = get_bits(&s->gb, 2);

+

+    /* loopfilter header data */

+    s->filter.level = get_bits(&s->gb, 6);

+    sharp = get_bits(&s->gb, 3);

+    // if sharpness changed, reinit lim/mblim LUTs. if it didn't change, keep

+    // the old cache values since they are still valid

+    if (s->filter.sharpness != sharp)

+        memset(s->filter.lim_lut, 0, sizeof(s->filter.lim_lut));

+    s->filter.sharpness = sharp;

+    if ((s->lf_delta.enabled = get_bits1(&s->gb))) {

+        if (get_bits1(&s->gb)) {

+            for (i = 0; i < 4; i++)

+                if (get_bits1(&s->gb))

+                    s->lf_delta.ref[i] = get_sbits_inv(&s->gb, 6);

+            for (i = 0; i < 2; i++)

+                if (get_bits1(&s->gb))

+                    s->lf_delta.mode[i] = get_sbits_inv(&s->gb, 6);

+        }

+    } else {

+        memset(&s->lf_delta, 0, sizeof(s->lf_delta));

+    }

+

+    /* quantization header data */

+    s->yac_qi      = get_bits(&s->gb, 8);

+    s->ydc_qdelta  = get_bits1(&s->gb) ? get_sbits_inv(&s->gb, 4) : 0;

+    s->uvdc_qdelta = get_bits1(&s->gb) ? get_sbits_inv(&s->gb, 4) : 0;

+    s->uvac_qdelta = get_bits1(&s->gb) ? get_sbits_inv(&s->gb, 4) : 0;

+    s->lossless    = s->yac_qi == 0 && s->ydc_qdelta == 0 &&

+                     s->uvdc_qdelta == 0 && s->uvac_qdelta == 0;

+

+    /* segmentation header info */

+    if ((s->segmentation.enabled = get_bits1(&s->gb))) {

+        if ((s->segmentation.update_map = get_bits1(&s->gb))) {

+            for (i = 0; i < 7; i++)

+                s->prob.seg[i] = get_bits1(&s->gb) ?

+                                 get_bits(&s->gb, 8) : 255;

+            if ((s->segmentation.temporal = get_bits1(&s->gb)))

+                for (i = 0; i < 3; i++)

+                    s->prob.segpred[i] = get_bits1(&s->gb) ?

+                                         get_bits(&s->gb, 8) : 255;

+        }

+

+        if (get_bits1(&s->gb)) {

+            s->segmentation.absolute_vals = get_bits1(&s->gb);

+            for (i = 0; i < 8; i++) {

+                if ((s->segmentation.feat[i].q_enabled = get_bits1(&s->gb)))

+                    s->segmentation.feat[i].q_val = get_sbits_inv(&s->gb, 8);

+                if ((s->segmentation.feat[i].lf_enabled = get_bits1(&s->gb)))

+                    s->segmentation.feat[i].lf_val = get_sbits_inv(&s->gb, 6);

+                if ((s->segmentation.feat[i].ref_enabled = get_bits1(&s->gb)))

+                    s->segmentation.feat[i].ref_val = get_bits(&s->gb, 2);

+                s->segmentation.feat[i].skip_enabled = get_bits1(&s->gb);

+            }

+        }

+    } else {

+        s->segmentation.feat[0].q_enabled    = 0;

+        s->segmentation.feat[0].lf_enabled   = 0;

+        s->segmentation.feat[0].skip_enabled = 0;

+        s->segmentation.feat[0].ref_enabled  = 0;

+    }

+

+    // set qmul[] based on Y/UV, AC/DC and segmentation Q idx deltas

+    for (i = 0; i < (s->segmentation.enabled ? 8 : 1); i++) {

+        int qyac, qydc, quvac, quvdc, lflvl, sh;

+

+        if (s->segmentation.feat[i].q_enabled) {

+            if (s->segmentation.absolute_vals)

+                qyac = s->segmentation.feat[i].q_val;

+            else

+                qyac = s->yac_qi + s->segmentation.feat[i].q_val;

+        } else {

+            qyac  = s->yac_qi;

+        }

+        qydc  = av_clip_uintp2(qyac + s->ydc_qdelta, 8);

+        quvdc = av_clip_uintp2(qyac + s->uvdc_qdelta, 8);

+        quvac = av_clip_uintp2(qyac + s->uvac_qdelta, 8);

+        qyac  = av_clip_uintp2(qyac, 8);

+

+        s->segmentation.feat[i].qmul[0][0] = vp9_dc_qlookup[qydc];

+        s->segmentation.feat[i].qmul[0][1] = vp9_ac_qlookup[qyac];

+        s->segmentation.feat[i].qmul[1][0] = vp9_dc_qlookup[quvdc];

+        s->segmentation.feat[i].qmul[1][1] = vp9_ac_qlookup[quvac];

+

+        sh = s->filter.level >= 32;

+        if (s->segmentation.feat[i].lf_enabled) {

+            if (s->segmentation.absolute_vals)

+                lflvl = s->segmentation.feat[i].lf_val;

+            else

+                lflvl = s->filter.level + s->segmentation.feat[i].lf_val;

+        } else {

+            lflvl  = s->filter.level;

+        }

+        s->segmentation.feat[i].lflvl[0][0] =

+        s->segmentation.feat[i].lflvl[0][1] =

+            av_clip_uintp2(lflvl + (s->lf_delta.ref[0] << sh), 6);

+        for (j = 1; j < 4; j++) {

+            s->segmentation.feat[i].lflvl[j][0] =

+                av_clip_uintp2(lflvl + ((s->lf_delta.ref[j] +

+                                         s->lf_delta.mode[0]) << sh), 6);

+            s->segmentation.feat[i].lflvl[j][1] =

+                av_clip_uintp2(lflvl + ((s->lf_delta.ref[j] +

+                                         s->lf_delta.mode[1]) << sh), 6);

+        }

+    }

+

+    /* tiling info */

+    if ((res = update_size(ctx, w, h)) < 0) {

+        av_log(ctx, AV_LOG_ERROR, "Failed to initialize decoder for %dx%d\n", w, h);

+        return res;

+    }

+    for (s->tiling.log2_tile_cols = 0;

+         (s->sb_cols >> s->tiling.log2_tile_cols) > 64;

+         s->tiling.log2_tile_cols++) ;

+    for (max = 0; (s->sb_cols >> max) >= 4; max++) ;

+    max = FFMAX(0, max - 1);

+    while (max > s->tiling.log2_tile_cols) {

+        if (get_bits1(&s->gb))

+            s->tiling.log2_tile_cols++;

+        else

+            break;

+    }

+    s->tiling.log2_tile_rows = decode012(&s->gb);

+    s->tiling.tile_rows = 1 << s->tiling.log2_tile_rows;

+    if (s->tiling.tile_cols != (1 << s->tiling.log2_tile_cols)) {

+        s->tiling.tile_cols = 1 << s->tiling.log2_tile_cols;

+        s->c_b = av_fast_realloc(s->c_b, &s->c_b_size,

+                                 sizeof(VP56RangeCoder) * s->tiling.tile_cols);

+        if (!s->c_b) {

+            av_log(ctx, AV_LOG_ERROR, "Ran out of memory during range coder init\n");

+            return AVERROR(ENOMEM);

+        }

+    }

+

+    if (s->keyframe || s->errorres || s->intraonly) {

+        s->prob_ctx[0].p = s->prob_ctx[1].p = s->prob_ctx[2].p =

+                           s->prob_ctx[3].p = vp9_default_probs;

+        memcpy(s->prob_ctx[0].coef, vp9_default_coef_probs,

+               sizeof(vp9_default_coef_probs));

+        memcpy(s->prob_ctx[1].coef, vp9_default_coef_probs,

+               sizeof(vp9_default_coef_probs));

+        memcpy(s->prob_ctx[2].coef, vp9_default_coef_probs,

+               sizeof(vp9_default_coef_probs));

+        memcpy(s->prob_ctx[3].coef, vp9_default_coef_probs,

+               sizeof(vp9_default_coef_probs));

+    }

+

+    // next 16 bits is size of the rest of the header (arith-coded)

+    size2 = get_bits(&s->gb, 16);

+    data2 = align_get_bits(&s->gb);

+    if (size2 > size - (data2 - data)) {

+        av_log(ctx, AV_LOG_ERROR, "Invalid compressed header size\n");

+        return AVERROR_INVALIDDATA;

+    }

+    ff_vp56_init_range_decoder(&s->c, data2, size2);

+    if (vp56_rac_get_prob_branchy(&s->c, 128)) { // marker bit

+        av_log(ctx, AV_LOG_ERROR, "Marker bit was set\n");

+        return AVERROR_INVALIDDATA;

+    }

+

+    if (s->keyframe || s->intraonly) {

+        memset(s->counts.coef, 0, sizeof(s->counts.coef) + sizeof(s->counts.eob));

+    } else {

+        memset(&s->counts, 0, sizeof(s->counts));

+    }

+    // FIXME is it faster to not copy here, but do it down in the fw updates

+    // as explicit copies if the fw update is missing (and skip the copy upon

+    // fw update)?

+    s->prob.p = s->prob_ctx[c].p;

+

+    // txfm updates

+    if (s->lossless) {

+        s->txfmmode = TX_4X4;

+    } else {

+        s->txfmmode = vp8_rac_get_uint(&s->c, 2);

+        if (s->txfmmode == 3)

+            s->txfmmode += vp8_rac_get(&s->c);

+

+        if (s->txfmmode == TX_SWITCHABLE) {

+            for (i = 0; i < 2; i++)

+                if (vp56_rac_get_prob_branchy(&s->c, 252))

+                    s->prob.p.tx8p[i] = update_prob(&s->c, s->prob.p.tx8p[i]);

+            for (i = 0; i < 2; i++)

+                for (j = 0; j < 2; j++)

+                    if (vp56_rac_get_prob_branchy(&s->c, 252))

+                        s->prob.p.tx16p[i][j] =

+                            update_prob(&s->c, s->prob.p.tx16p[i][j]);

+            for (i = 0; i < 2; i++)

+                for (j = 0; j < 3; j++)

+                    if (vp56_rac_get_prob_branchy(&s->c, 252))

+                        s->prob.p.tx32p[i][j] =

+                            update_prob(&s->c, s->prob.p.tx32p[i][j]);

+        }

+    }

+

+    // coef updates

+    for (i = 0; i < 4; i++) {

+        uint8_t (*ref)[2][6][6][3] = s->prob_ctx[c].coef[i];

+        if (vp8_rac_get(&s->c)) {

+            for (j = 0; j < 2; j++)

+                for (k = 0; k < 2; k++)

+                    for (l = 0; l < 6; l++)

+                        for (m = 0; m < 6; m++) {

+                            uint8_t *p = s->prob.coef[i][j][k][l][m];

+                            uint8_t *r = ref[j][k][l][m];

+                            if (m >= 3 && l == 0) // dc only has 3 pt

+                                break;

+                            for (n = 0; n < 3; n++) {

+                                if (vp56_rac_get_prob_branchy(&s->c, 252)) {

+                                    p[n] = update_prob(&s->c, r[n]);

+                                } else {

+                                    p[n] = r[n];

+                                }

+                            }

+                            p[3] = 0;

+                        }

+        } else {

+            for (j = 0; j < 2; j++)

+                for (k = 0; k < 2; k++)

+                    for (l = 0; l < 6; l++)

+                        for (m = 0; m < 6; m++) {

+                            uint8_t *p = s->prob.coef[i][j][k][l][m];

+                            uint8_t *r = ref[j][k][l][m];

+                            if (m > 3 && l == 0) // dc only has 3 pt

+                                break;

+                            memcpy(p, r, 3);

+                            p[3] = 0;

+                        }

+        }

+        if (s->txfmmode == i)

+            break;

+    }

+

+    // mode updates

+    for (i = 0; i < 3; i++)

+        if (vp56_rac_get_prob_branchy(&s->c, 252))

+            s->prob.p.skip[i] = update_prob(&s->c, s->prob.p.skip[i]);

+    if (!s->keyframe && !s->intraonly) {

+        for (i = 0; i < 7; i++)

+            for (j = 0; j < 3; j++)

+                if (vp56_rac_get_prob_branchy(&s->c, 252))

+                    s->prob.p.mv_mode[i][j] =

+                        update_prob(&s->c, s->prob.p.mv_mode[i][j]);

+

+        if (s->filtermode == FILTER_SWITCHABLE)

+            for (i = 0; i < 4; i++)

+                for (j = 0; j < 2; j++)

+                    if (vp56_rac_get_prob_branchy(&s->c, 252))

+                        s->prob.p.filter[i][j] =

+                            update_prob(&s->c, s->prob.p.filter[i][j]);

+

+        for (i = 0; i < 4; i++)

+            if (vp56_rac_get_prob_branchy(&s->c, 252))

+                s->prob.p.intra[i] = update_prob(&s->c, s->prob.p.intra[i]);

+

+        if (s->allowcompinter) {

+            s->comppredmode = vp8_rac_get(&s->c);

+            if (s->comppredmode)

+                s->comppredmode += vp8_rac_get(&s->c);

+            if (s->comppredmode == PRED_SWITCHABLE)

+                for (i = 0; i < 5; i++)