lavc: VP9 decoder

Originally written by Ronald S. Bultje <rsbultje@gmail.com> and
Clément Bœsch <u@pkh.me>

Further contributions by:
Anton Khirnov <anton@khirnov.net>
Diego Biurrun <diego@biurrun.de>
Luca Barbato <lu_zero@gentoo.org>
Martin Storsjö <martin@martin.st>

Signed-off-by: Luca Barbato <lu_zero@gentoo.org>
Signed-off-by: Anton Khirnov <anton@khirnov.net>

Changelog

@@ -47,6 +47,7 @@ version 10:
 - Live HDS muxer
 - setsar/setdar filters now support variables in ratio expressions
 - dar variable in the scale filter now returns the actual DAR (i.e. a * sar)
+- VP9 decoder
 
 
 version 9:

configure

@@ -1702,6 +1702,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"

doc/general.texi

@@ -594,6 +594,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 planar RGB             @tab     @tab  X
     @tab fourcc: 8BPS
 @item Q-team QPEG            @tab     @tab  X

libavcodec/Makefile

@@ -392,6 +392,8 @@ 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 vp9data.o vp9dsp.o \
+                                          vp9block.o vp9prob.o vp9mvs.o vp56rac.o
 OBJS-$(CONFIG_VQA_DECODER)             += vqavideo.o
 OBJS-$(CONFIG_WAVPACK_DECODER)         += wavpack.o
 OBJS-$(CONFIG_WEBP_DECODER)            += webp.o

libavcodec/allcodecs.c

@@ -257,6 +257,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);

libavcodec/version.h

@@ -27,7 +27,7 @@
  */
 
 #define LIBAVCODEC_VERSION_MAJOR 55
-#define LIBAVCODEC_VERSION_MINOR 27
+#define LIBAVCODEC_VERSION_MINOR 28
 #define LIBAVCODEC_VERSION_MICRO  0
 
 #define LIBAVCODEC_VERSION_INT  AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \

libavcodec/vp9.h

@@ -0,0 +1,419 @@
+/*
+ * 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 Libav.
+ *
+ * Libav 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.
+ *
+ * Libav 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 Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_VP9_H
+#define AVCODEC_VP9_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "libavutil/internal.h"
+
+#include "avcodec.h"
+#include "vp56.h"
+
+enum TxfmMode {
+    TX_4X4,
+    TX_8X8,
+    TX_16X16,
+    TX_32X32,
+    N_TXFM_SIZES,
+    TX_SWITCHABLE = N_TXFM_SIZES,
+    N_TXFM_MODES
+};
+
+enum TxfmType {
+    DCT_DCT,
+    DCT_ADST,
+    ADST_DCT,
+    ADST_ADST,
+    N_TXFM_TYPES
+};
+
+enum IntraPredMode {
+    VERT_PRED,
+    HOR_PRED,
+    DC_PRED,
+    DIAG_DOWN_LEFT_PRED,
+    DIAG_DOWN_RIGHT_PRED,
+    VERT_RIGHT_PRED,
+    HOR_DOWN_PRED,
+    VERT_LEFT_PRED,
+    HOR_UP_PRED,
+    TM_VP8_PRED,
+    LEFT_DC_PRED,
+    TOP_DC_PRED,
+    DC_128_PRED,
+    DC_127_PRED,
+    DC_129_PRED,
+    N_INTRA_PRED_MODES
+};
+
+enum FilterMode {
+    FILTER_8TAP_SMOOTH,
+    FILTER_8TAP_REGULAR,
+    FILTER_8TAP_SHARP,
+    FILTER_BILINEAR,
+    FILTER_SWITCHABLE,
+};
+
+enum BlockPartition {
+    PARTITION_NONE,    // [ ] <-.
+    PARTITION_H,       // [-]   |
+    PARTITION_V,       // [|]   |
+    PARTITION_SPLIT,   // [+] --'
+};
+
+enum InterPredMode {
+    NEARESTMV = 10,
+    NEARMV    = 11,
+    ZEROMV    = 12,
+    NEWMV     = 13,
+};
+
+enum MVJoint {
+    MV_JOINT_ZERO,
+    MV_JOINT_H,
+    MV_JOINT_V,
+    MV_JOINT_HV,
+};
+
+typedef struct ProbContext {
+    uint8_t y_mode[4][9];
+    uint8_t uv_mode[10][9];
+    uint8_t filter[4][2];
+    uint8_t mv_mode[7][3];
+    uint8_t intra[4];
+    uint8_t comp[5];
+    uint8_t single_ref[5][2];
+    uint8_t comp_ref[5];
+    uint8_t tx32p[2][3];
+    uint8_t tx16p[2][2];
+    uint8_t tx8p[2];
+    uint8_t skip[3];
+    uint8_t mv_joint[3];
+    struct {
+        uint8_t sign;
+        uint8_t classes[10];
+        uint8_t class0;
+        uint8_t bits[10];
+        uint8_t class0_fp[2][3];
+        uint8_t fp[3];
+        uint8_t class0_hp;
+        uint8_t hp;
+    } mv_comp[2];
+    uint8_t partition[4][4][3];
+} ProbContext;
+
+typedef void (*vp9_mc_func)(uint8_t *dst, const uint8_t *ref,
+                            ptrdiff_t dst_stride,
+                            ptrdiff_t ref_stride,
+                            int h, int mx, int my);
+
+typedef struct VP9DSPContext {
+    /*
+     * dimension 1: 0=4x4, 1=8x8, 2=16x16, 3=32x32
+     * dimension 2: intra prediction modes
+     *
+     * dst/left/top is aligned by transform-size (i.e. 4, 8, 16 or 32 pixels)
+     * stride is aligned by 16 pixels
+     * top[-1] is top/left; top[4,7] is top-right for 4x4
+     */
+    // FIXME(rbultje) maybe replace left/top pointers with HAVE_TOP/
+    // HAVE_LEFT/HAVE_TOPRIGHT flags instead, and then handle it in-place?
+    // also needs to fit in with what h264/vp8/etc do
+    void (*intra_pred[N_TXFM_SIZES][N_INTRA_PRED_MODES])(uint8_t *dst,
+                                                         ptrdiff_t stride,
+                                                         const uint8_t *left,
+                                                         const uint8_t *top);
+
+    /*
+     * dimension 1: 0=4x4, 1=8x8, 2=16x16, 3=32x32, 4=lossless (3-4=dct only)
+     * dimension 2: 0=dct/dct, 1=dct/adst, 2=adst/dct, 3=adst/adst
+     *
+     * dst is aligned by transform-size (i.e. 4, 8, 16 or 32 pixels)
+     * stride is aligned by 16 pixels
+     * block is 16-byte aligned
+     * eob indicates the position (+1) of the last non-zero coefficient,
+     * in scan-order. This can be used to write faster versions, e.g. a
+     * dc-only 4x4/8x8/16x16/32x32, or a 4x4-only (eob<10) 8x8/16x16/32x32,
+     * etc.
+     */
+    // FIXME also write idct_add_block() versions for whole (inter) pred
+    // blocks, so we can do 2 4x4s at once
+    void (*itxfm_add[N_TXFM_SIZES + 1][N_TXFM_TYPES])(uint8_t *dst,
+                                                      ptrdiff_t stride,
+                                                      int16_t *block, int eob);
+
+    /*
+     * dimension 1: width of filter (0=4, 1=8, 2=16)
+     * dimension 2: 0=col-edge filter (h), 1=row-edge filter (v)
+     *
+     * dst/stride are aligned by 8
+     */
+    void (*loop_filter_8[3][2])(uint8_t *dst, ptrdiff_t stride,
+                                int mb_lim, int lim, int hev_thr);
+
+    /*
+     * dimension 1: 0=col-edge filter (h), 1=row-edge filter (v)
+     *
+     * The width of filter is assumed to be 16; dst/stride are aligned by 16
+     */
+    void (*loop_filter_16[2])(uint8_t *dst, ptrdiff_t stride,
+                              int mb_lim, int lim, int hev_thr);
+
+    /*
+     * dimension 1/2: width of filter (0=4, 1=8) for each filter half
+     * dimension 3: 0=col-edge filter (h), 1=row-edge filter (v)
+     *
+     * dst/stride are aligned by operation size
+     * this basically calls loop_filter[d1][d3][0](), followed by
+     * loop_filter[d2][d3][0]() on the next 8 pixels
+     * mb_lim/lim/hev_thr contain two values in the lowest two bytes of the
+     * integer.
+     */
+    // FIXME perhaps a mix4 that operates on 32px (for AVX2)
+    void (*loop_filter_mix2[2][2][2])(uint8_t *dst, ptrdiff_t stride,
+                                      int mb_lim, int lim, int hev_thr);
+
+    /*
+     * dimension 1: hsize (0: 64, 1: 32, 2: 16, 3: 8, 4: 4)
+     * dimension 2: filter type (0: smooth, 1: regular, 2: sharp, 3: bilin)
+     * dimension 3: averaging type (0: put, 1: avg)
+     * dimension 4: x subpel interpolation (0: none, 1: 8tap/bilin)
+     * dimension 5: y subpel interpolation (1: none, 1: 8tap/bilin)
+     *
+     * dst/stride are aligned by hsize
+     */
+    vp9_mc_func mc[5][4][2][2][2];
+} VP9DSPContext;
+
+enum CompPredMode {
+    PRED_SINGLEREF,
+    PRED_COMPREF,
+    PRED_SWITCHABLE,
+};
+
+typedef struct VP9MVRefPair {
+    VP56mv mv[2];
+    int8_t ref[2];
+} VP9MVRefPair;
+
+typedef 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 */];
+} VP9Filter;
+
+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,
+};
+
+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;
+    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];
+    AVFrame *cur_frame;
+
+    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 {
+        ProbContext p;
+        uint8_t coef[4][2][2][6][6][3];
+    } prob_ctx[4];
+    struct {
+        ProbContext 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;
+    VP9MVRefPair *mv[2];
+    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;
+
+void ff_vp9dsp_init(VP9DSPContext *dsp);
+
+void ff_vp9dsp_init_x86(VP9DSPContext *dsp);
+
+void ff_vp9_fill_mv(VP9Context *s, VP56mv *mv, int mode, int sb);
+
+void ff_vp9_adapt_probs(VP9Context *s);
+
+int ff_vp9_decode_block(AVCodecContext *avctx, int row, int col,
+                        VP9Filter *lflvl, ptrdiff_t yoff, ptrdiff_t uvoff,
+                        enum BlockLevel bl, enum BlockPartition bp);
+
+#endif /* AVCODEC_VP9_H */

libavcodec/vp9data.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2013 Ronald S. Bultje <rsbultje gmail com>
+ * Copyright (C) 2013 Clément Bœsch <u pkh me>
+ *
+ * This file is part of Libav.
+ *
+ * Libav 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.
+ *
+ * Libav 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 Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_VP9DATA_H
+#define AVCODEC_VP9DATA_H
+
+#include <stdint.h>
+
+#include "vp9.h"
+
+extern const int8_t ff_vp9_partition_tree[3][2];
+extern const uint8_t ff_vp9_default_kf_partition_probs[4][4][3];
+extern const int8_t ff_vp9_segmentation_tree[7][2];
+extern const int8_t ff_vp9_intramode_tree[9][2];
+extern const uint8_t ff_vp9_default_kf_ymode_probs[10][10][9];
+extern const uint8_t ff_vp9_default_kf_uvmode_probs[10][9];
+extern const int8_t ff_vp9_inter_mode_tree[3][2];
+extern const int8_t ff_vp9_filter_tree[2][2];
+extern const enum FilterMode ff_vp9_filter_lut[3];
+extern const int16_t ff_vp9_dc_qlookup[256];
+extern const int16_t ff_vp9_ac_qlookup[256];
+extern const enum TxfmType ff_vp9_intra_txfm_type[14];
+extern const int16_t ff_vp9_default_scan_4x4[16];
+extern const int16_t ff_vp9_col_scan_4x4[16];
+extern const int16_t ff_vp9_row_scan_4x4[16];
+extern const int16_t ff_vp9_default_scan_8x8[64];
+extern const int16_t ff_vp9_col_scan_8x8[64];
+extern const int16_t ff_vp9_row_scan_8x8[64];
+extern const int16_t ff_vp9_default_scan_16x16[256];
+extern const int16_t ff_vp9_col_scan_16x16[256];
+extern const int16_t ff_vp9_row_scan_16x16[256];
+extern const int16_t ff_vp9_default_scan_32x32[1024];
+extern const int16_t *ff_vp9_scans[5][4];
+extern const int16_t ff_vp9_default_scan_4x4_nb[16][2];
+extern const int16_t ff_vp9_col_scan_4x4_nb[16][2];
+extern const int16_t ff_vp9_row_scan_4x4_nb[16][2];
+extern const int16_t ff_vp9_default_scan_8x8_nb[64][2];
+extern const int16_t ff_vp9_col_scan_8x8_nb[64][2];
+extern const int16_t ff_vp9_row_scan_8x8_nb[64][2];
+extern const int16_t ff_vp9_default_scan_16x16_nb[256][2];
+extern const int16_t ff_vp9_col_scan_16x16_nb[256][2];
+extern const int16_t ff_vp9_row_scan_16x16_nb[256][2];
+extern const int16_t ff_vp9_default_scan_32x32_nb[1024][2];
+extern const int16_t (*ff_vp9_scans_nb[5][4])[2];
+extern const uint8_t ff_vp9_model_pareto8[256][8];
+extern const ProbContext ff_vp9_default_probs;
+extern const uint8_t ff_vp9_default_coef_probs[4][2][2][6][6][3];
+extern const int8_t ff_vp9_mv_joint_tree[3][2];
+extern const int8_t ff_vp9_mv_class_tree[10][2];
+extern const int8_t ff_vp9_mv_fp_tree[3][2];
+
+#endif /* AVCODEC_VP9DATA_H */

libavcodec/vp9mvs.c

@@ -0,0 +1,344 @@
+/*
+ * 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 Libav.
+ *
+ * Libav 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.
+ *
+ * Libav 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 Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "internal.h"
+#include "vp56.h"
+#include "vp9.h"
+#include "vp9data.h"
+
+static av_always_inline void clamp_mv(VP56mv *dst, const VP56mv *src,
+                                      VP9Context *s)
+{
+    dst->x = av_clip(src->x, s->min_mv.x, s->max_mv.x);
+    dst->y = av_clip(src->y, s->min_mv.y, s->max_mv.y);
+}
+
+static void find_ref_mvs(VP9Context *s,
+                         VP56mv *pmv, int ref, int z, int idx, int sb)
+{
+    static const int8_t mv_ref_blk_off[N_BS_SIZES][8][2] = {
+        [BS_64x64] = { {  3, -1 }, { -1,  3 }, {  4, -1 }, { -1,  4 },
+                       { -1, -1 }, {  0, -1 }, { -1,  0 }, {  6, -1 } },
+        [BS_64x32] = { {  0, -1 }, { -1,  0 }, {  4, -1 }, { -1,  2 },
+                       { -1, -1 }, {  0, -3 }, { -3,  0 }, {  2, -1 } },
+        [BS_32x64] = { { -1,  0 }, {  0, -1 }, { -1,  4 }, {  2, -1 },
+                       { -1, -1 }, { -3,  0 }, {  0, -3 }, { -1,  2 } },
+        [BS_32x32] = { {  1, -1 }, { -1,  1 }, {  2, -1 }, { -1,  2 },
+                       { -1, -1 }, {  0, -3 }, { -3,  0 }, { -3, -3 } },
+        [BS_32x16] = { {  0, -1 }, { -1,  0 }, {  2, -1 }, { -1, -1 },
+                       { -1,  1 }, {  0, -3 }, { -3,  0 }, { -3, -3 } },
+        [BS_16x32] = { { -1,  0 }, {  0, -1 }, { -1,  2 }, { -1, -1 },
+                       {  1, -1 }, { -3,  0 }, {  0, -3 }, { -3, -3 } },
+        [BS_16x16] = { {  0, -1 }, { -1,  0 }, {  1, -1 }, { -1,  1 },
+                       { -1, -1 }, {  0, -3 }, { -3,  0 }, { -3, -3 } },
+        [BS_16x8]  = { {  0, -1 }, { -1,  0 }, {  1, -1 }, { -1, -1 },
+                       {  0, -2 }, { -2,  0 }, { -2, -1 }, { -1, -2 } },
+        [BS_8x16]  = { { -1,  0 }, {  0, -1 }, { -1,  1 }, { -1, -1 },
+                       { -2,  0 }, {  0, -2 }, { -1, -2 }, { -2, -1 } },
+        [BS_8x8]   = { {  0, -1 }, { -1,  0 }, { -1, -1 }, {  0, -2 },
+                       { -2,  0 }, { -1, -2 }, { -2, -1 }, { -2, -2 } },
+        [BS_8x4]   = { {  0, -1 }, { -1,  0 }, { -1, -1 }, {  0, -2 },
+                       { -2,  0 }, { -1, -2 }, { -2, -1 }, { -2, -2 } },
+        [BS_4x8]   = { {  0, -1 }, { -1,  0 }, { -1, -1 }, {  0, -2 },
+                       { -2,  0 }, { -1, -2 }, { -2, -1 }, { -2, -2 } },
+        [BS_4x4]   = { {  0, -1 }, { -1,  0 }, { -1, -1 }, {  0, -2 },
+                       { -2,  0 }, { -1, -2 }, { -2, -1 }, { -2, -2 } },
+    };
+    VP9Block *const b = &s->b;
+    int row = b->row, col = b->col, row7 = b->row7;
+    const int8_t (*p)[2] = mv_ref_blk_off[b->bs];
+#define INVALID_MV 0x80008000U
+    uint32_t mem = INVALID_MV;
+    int i;
+
+#define RETURN_DIRECT_MV(mv)                    \
+    do {                                        \
+        uint32_t m = AV_RN32A(&mv);             \
+        if (!idx) {                             \
+            AV_WN32A(pmv, m);                   \
+            return;                             \
+        } else if (mem == INVALID_MV) {         \
+            mem = m;                            \
+        } else if (m != mem) {                  \
+            AV_WN32A(pmv, m);                   \
+            return;                             \
+        }                                       \
+    } while (0)
+
+    if (sb >= 0) {
+        if (sb == 2 || sb == 1) {
+            RETURN_DIRECT_MV(b->mv[0][z]);
+        } else if (sb == 3) {
+            RETURN_DIRECT_MV(b->mv[2][z]);
+            RETURN_DIRECT_MV(b->mv[1][z]);
+            RETURN_DIRECT_MV(b->mv[0][z]);
+        }
+
+#define RETURN_MV(mv)                           \
+    do {                                        \
+        if (sb > 0) {                           \
+            VP56mv tmp;                         \
+            uint32_t m;                         \
+            clamp_mv(&tmp, &mv, s);             \
+            m = AV_RN32A(&tmp);                 \
+            if (!idx) {                         \
+                AV_WN32A(pmv, m);               \
+                return;                         \
+            } else if (mem == INVALID_MV) {     \
+                mem = m;                        \
+            } else if (m != mem) {              \
+                AV_WN32A(pmv, m);               \
+                return;                         \
+            }                                   \
+        } else {                                \
+            uint32_t m = AV_RN32A(&mv);         \
+            if (!idx) {                         \
+                clamp_mv(pmv, &mv, s);          \
+                return;                         \
+            } else if (mem == INVALID_MV) {     \
+                mem = m;                        \
+            } else if (m != mem) {              \
+                clamp_mv(pmv, &mv, s);          \
+                return;                         \
+            }                                   \
+        }                                       \
+    } while (0)
+
+        if (row > 0) {
+            VP9MVRefPair *mv = &s->mv[0][(row - 1) * s->sb_cols * 8 + col];
+
+            if (mv->ref[0] == ref)
+                RETURN_MV(s->above_mv_ctx[2 * col + (sb & 1)][0]);
+            else if (mv->ref[1] == ref)
+                RETURN_MV(s->above_mv_ctx[2 * col + (sb & 1)][1]);
+        }
+        if (col > s->tiling.tile_col_start) {
+            VP9MVRefPair *mv = &s->mv[0][row * s->sb_cols * 8 + col - 1];
+
+            if (mv->ref[0] == ref)
+                RETURN_MV(s->left_mv_ctx[2 * row7 + (sb >> 1)][0]);
+            else if (mv->ref[1] == ref)
+                RETURN_MV(s->left_mv_ctx[2 * row7 + (sb >> 1)][1]);
+        }
+        i = 2;
+    } else {
+        i = 0;
+    }
+
+    // previously coded MVs in the neighborhood, using same reference frame
+    for (; i < 8; i++) {
+        int c = p[i][0] + col, r = p[i][1] + row;
+
+        if (c >= s->tiling.tile_col_start && c < s->cols &&
+            r >= 0 && r < s->rows) {
+            VP9MVRefPair *mv = &s->mv[0][r * s->sb_cols * 8 + c];
+
+            if (mv->ref[0] == ref)
+                RETURN_MV(mv->mv[0]);
+            else if (mv->ref[1] == ref)
+                RETURN_MV(mv->mv[1]);
+        }
+    }
+
+    // MV at this position in previous frame, using same reference frame
+    if (s->use_last_frame_mvs) {
+        VP9MVRefPair *mv = &s->mv[1][row * s->sb_cols * 8 + col];
+
+        if (mv->ref[0] == ref)
+            RETURN_MV(mv->mv[0]);
+        else if (mv->ref[1] == ref)
+            RETURN_MV(mv->mv[1]);
+    }
+
+#define RETURN_SCALE_MV(mv, scale)              \
+    do {                                        \
+        if (scale) {                            \
+            VP56mv mv_temp = { -mv.x, -mv.y };  \
+            RETURN_MV(mv_temp);                 \
+        } else {                                \
+            RETURN_MV(mv);                      \
+        }                                       \
+    } while (0)
+
+    // previously coded MVs in the neighborhood, using different reference frame
+    for (i = 0; i < 8; i++) {
+        int c = p[i][0] + col, r = p[i][1] + row;
+
+        if (c >= s->tiling.tile_col_start && c < s->cols &&
+            r >= 0 && r < s->rows) {
+            VP9MVRefPair *mv = &s->mv[0][r * s->sb_cols * 8 + c];
+
+            if (mv->ref[0] != ref && mv->ref[0] >= 0)
+                RETURN_SCALE_MV(mv->mv[0],
+                                s->signbias[mv->ref[0]] != s->signbias[ref]);
+            if (mv->ref[1] != ref && mv->ref[1] >= 0)
+                RETURN_SCALE_MV(mv->mv[1],
+                                s->signbias[mv->ref[1]] != s->signbias[ref]);
+        }
+    }
+
+    // MV at this position in previous frame, using different reference frame
+    if (s->use_last_frame_mvs) {
+        VP9MVRefPair *mv = &s->mv[1][row * s->sb_cols * 8 + col];
+
+        if (mv->ref[0] != ref && mv->ref[0] >= 0)
+            RETURN_SCALE_MV(mv->mv[0],
+                            s->signbias[mv->ref[0]] != s->signbias[ref]);
+        if (mv->ref[1] != ref && mv->ref[1] >= 0)
+            RETURN_SCALE_MV(mv->mv[1],
+                            s->signbias[mv->ref[1]] != s->signbias[ref]);
+    }
+
+    AV_ZERO32(pmv);
+#undef INVALID_MV
+#undef RETURN_MV
+#undef RETURN_SCALE_MV
+}
+
+static av_always_inline int read_mv_component(VP9Context *s, int idx, int hp)
+{
+    int bit, sign = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].sign);
+    int n, c = vp8_rac_get_tree(&s->c, ff_vp9_mv_class_tree,
+                                s->prob.p.mv_comp[idx].classes);
+
+    s->counts.mv_comp[idx].sign[sign]++;
+    s->counts.mv_comp[idx].classes[c]++;
+    if (c) {
+        int m;
+
+        for (n = 0, m = 0; m < c; m++) {
+            bit = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].bits[m]);
+            n  |= bit << m;
+            s->counts.mv_comp[idx].bits[m][bit]++;
+        }
+        n <<= 3;
+        bit = vp8_rac_get_tree(&s->c, ff_vp9_mv_fp_tree,
+                               s->prob.p.mv_comp[idx].fp);
+        n  |= bit << 1;
+        s->counts.mv_comp[idx].fp[bit]++;
+        if (hp) {
+            bit = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].hp);
+            s->counts.mv_comp[idx].hp[bit]++;
+            n |= bit;
+        } else {
+            n |= 1;
+            // bug in libvpx - we count for bw entropy purposes even if the
+            // bit wasn't coded
+            s->counts.mv_comp[idx].hp[1]++;
+        }
+        n += 8 << c;
+    } else {
+        n = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].class0);
+        s->counts.mv_comp[idx].class0[n]++;
+        bit = vp8_rac_get_tree(&s->c, ff_vp9_mv_fp_tree,
+                               s->prob.p.mv_comp[idx].class0_fp[n]);
+        s->counts.mv_comp[idx].class0_fp[n][bit]++;
+        n = (n << 3) | (bit << 1);
+        if (hp) {
+            bit = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].class0_hp);
+            s->counts.mv_comp[idx].class0_hp[bit]++;
+            n |= bit;
+        } else {
+            n |= 1;
+            // bug in libvpx - we count for bw entropy purposes even if the
+            // bit wasn't coded
+            s->counts.mv_comp[idx].class0_hp[1]++;
+        }
+    }
+
+    return sign ? -(n + 1) : (n + 1);
+}
+
+void ff_vp9_fill_mv(VP9Context *s, VP56mv *mv, int mode, int sb)
+{
+    VP9Block *const b = &s->b;
+
+    if (mode == ZEROMV) {
+        memset(mv, 0, sizeof(*mv) * 2);
+    } else {
+        int hp;
+
+        // FIXME cache this value and reuse for other subblocks
+        find_ref_mvs(s, &mv[0], b->ref[0], 0, mode == NEARMV,
+                     mode == NEWMV ? -1 : sb);
+        // FIXME maybe move this code into find_ref_mvs()
+        if ((mode == NEWMV || sb == -1) &&
+            !(hp = s->highprecisionmvs &&
+              abs(mv[0].x) < 64 && abs(mv[0].y) < 64)) {
+            if (mv[0].y & 1) {
+                if (mv[0].y < 0)
+                    mv[0].y++;
+                else
+                    mv[0].y--;
+            }
+            if (mv[0].x & 1) {
+                if (mv[0].x < 0)
+                    mv[0].x++;
+                else
+                    mv[0].x--;
+            }
+        }
+        if (mode == NEWMV) {
+            enum MVJoint j = vp8_rac_get_tree(&s->c, ff_vp9_mv_joint_tree,
+                                              s->prob.p.mv_joint);
+
+            s->counts.mv_joint[j]++;
+            if (j >= MV_JOINT_V)
+                mv[0].y += read_mv_component(s, 0, hp);
+            if (j & 1)
+                mv[0].x += read_mv_component(s, 1, hp);
+        }
+
+        if (b->comp) {
+            // FIXME cache this value and reuse for other subblocks
+            find_ref_mvs(s, &mv[1], b->ref[1], 1, mode == NEARMV,
+                         mode == NEWMV ? -1 : sb);
+            if ((mode == NEWMV || sb == -1) &&
+                !(hp = s->highprecisionmvs &&
+                  abs(mv[1].x) < 64 && abs(mv[1].y) < 64)) {
+                if (mv[1].y & 1) {
+                    if (mv[1].y < 0)
+                        mv[1].y++;
+                    else
+                        mv[1].y--;
+                }
+                if (mv[1].x & 1) {
+                    if (mv[1].x < 0)
+                        mv[1].x++;
+                    else
+                        mv[1].x--;
+                }
+            }
+            if (mode == NEWMV) {
+                enum MVJoint j = vp8_rac_get_tree(&s->c, ff_vp9_mv_joint_tree,
+                                                  s->prob.p.mv_joint);
+
+                s->counts.mv_joint[j]++;
+                if (j >= MV_JOINT_V)
+                    mv[1].y += read_mv_component(s, 0, hp);
+                if (j & 1)
+                    mv[1].x += read_mv_component(s, 1, hp);
+            }
+        }
+    }
+}

libavcodec/vp9prob.c

@@ -0,0 +1,274 @@
+/*
+ * 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 Libav.
+ *
+ * Libav 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.
+ *
+ * Libav 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 Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "vp56.h"
+#include "vp9.h"
+#include "vp9data.h"
+
+static av_always_inline void adapt_prob(uint8_t *p, unsigned ct0, unsigned ct1,
+                                        int max_count, int update_factor)
+{
+    unsigned ct = ct0 + ct1, p2, p1;
+
+    if (!ct)
+        return;
+
+    p1 = *p;
+    p2 = ((ct0 << 8) + (ct >> 1)) / ct;
+    p2 = av_clip(p2, 1, 255);
+    ct = FFMIN(ct, max_count);
+    update_factor = FASTDIV(update_factor * ct, max_count);
+
+    // (p1 * (256 - update_factor) + p2 * update_factor + 128) >> 8
+    *p = p1 + (((p2 - p1) * update_factor + 128) >> 8);
+}
+
+void ff_vp9_adapt_probs(VP9Context *s)
+{
+    int i, j, k, l, m;
+    ProbContext *p = &s->prob_ctx[s->framectxid].p;
+    int uf = (s->keyframe || s->intraonly || !s->last_keyframe) ? 112 : 128;
+
+    // coefficients
+    for (i = 0; i < 4; i++)
+        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 *pp = s->prob_ctx[s->framectxid].coef[i][j][k][l][m];
+                        unsigned *e = s->counts.eob[i][j][k][l][m];
+                        unsigned *c = s->counts.coef[i][j][k][l][m];
+
+                        if (l == 0 && m >= 3) // dc only has 3 pt
+                            break;
+
+                        adapt_prob(&pp[0], e[0], e[1], 24, uf);
+                        adapt_prob(&pp[1], c[0], c[1] + c[2], 24, uf);
+                        adapt_prob(&pp[2], c[1], c[2], 24, uf);
+                    }
+
+    if (s->keyframe || s->intraonly) {
+        memcpy(p->skip,  s->prob.p.skip,  sizeof(p->skip));
+        memcpy(p->tx32p, s->prob.p.tx32p, sizeof(p->tx32p));
+        memcpy(p->tx16p, s->prob.p.tx16p, sizeof(p->tx16p));
+        memcpy(p->tx8p,  s->prob.p.tx8p,  sizeof(p->tx8p));
+        return;
+    }
+
+    // skip flag
+    for (i = 0; i < 3; i++)
+        adapt_prob(&p->skip[i], s->counts.skip[i][0],
+                   s->counts.skip[i][1], 20, 128);
+
+    // intra/inter flag
+    for (i = 0; i < 4; i++)
+        adapt_prob(&p->intra[i], s->counts.intra[i][0],
+                   s->counts.intra[i][1], 20, 128);
+
+    // comppred flag
+    if (s->comppredmode == PRED_SWITCHABLE) {
+        for (i = 0; i < 5; i++)
+            adapt_prob(&p->comp[i], s->counts.comp[i][0],
+                       s->counts.comp[i][1], 20, 128);
+    }
+
+    // reference frames
+    if (s->comppredmode != PRED_SINGLEREF) {
+        for (i = 0; i < 5; i++)
+            adapt_prob(&p->comp_ref[i], s->counts.comp_ref[i][0],
+                       s->counts.comp_ref[i][1], 20, 128);
+    }
+
+    if (s->comppredmode != PRED_COMPREF) {
+        for (i = 0; i < 5; i++) {
+            uint8_t *pp = p->single_ref[i];
+            unsigned (*c)[2] = s->counts.single_ref[i];
+
+            adapt_prob(&pp[0], c[0][0], c[0][1], 20, 128);
+            adapt_prob(&pp[1], c[1][0], c[1][1], 20, 128);
+        }
+    }
+
+    // block partitioning
+    for (i = 0; i < 4; i++)
+        for (j = 0; j < 4; j++) {
+            uint8_t *pp = p->partition[i][j];
+            unsigned *c = s->counts.partition[i][j];
+
+            adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
+            adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
+            adapt_prob(&pp[2], c[2], c[3], 20, 128);
+        }
+
+    // tx size
+    if (s->txfmmode == TX_SWITCHABLE) {
+        for (i = 0; i < 2; i++) {
+            unsigned *c16 = s->counts.tx16p[i], *c32 = s->counts.tx32p[i];
+
+            adapt_prob(&p->tx8p[i], s->counts.tx8p[i][0],
+                       s->counts.tx8p[i][1], 20, 128);
+            adapt_prob(&p->tx16p[i][0], c16[0], c16[1] + c16[2], 20, 128);
+            adapt_prob(&p->tx16p[i][1], c16[1], c16[2], 20, 128);
+            adapt_prob(&p->tx32p[i][0], c32[0], c32[1] + c32[2] + c32[3], 20, 128);
+            adapt_prob(&p->tx32p[i][1], c32[1], c32[2] + c32[3], 20, 128);
+            adapt_prob(&p->tx32p[i][2], c32[2], c32[3], 20, 128);
+        }
+    }
+
+    // interpolation filter
+    if (s->filtermode == FILTER_SWITCHABLE) {
+        for (i = 0; i < 4; i++) {
+            uint8_t *pp = p->filter[i];
+            unsigned *c = s->counts.filter[i];
+
+            adapt_prob(&pp[0], c[0], c[1] + c[2], 20, 128);
+            adapt_prob(&pp[1], c[1], c[2], 20, 128);
+        }
+    }
+
+    // inter modes
+    for (i = 0; i < 7; i++) {
+        uint8_t *pp = p->mv_mode[i];
+        unsigned *c = s->counts.mv_mode[i];
+
+        adapt_prob(&pp[0], c[2], c[1] + c[0] + c[3], 20, 128);
+        adapt_prob(&pp[1], c[0], c[1] + c[3], 20, 128);
+        adapt_prob(&pp[2], c[1], c[3], 20, 128);
+    }
+
+    // mv joints
+    {
+        uint8_t *pp = p->mv_joint;
+        unsigned *c = s->counts.mv_joint;
+
+        adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
+        adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
+        adapt_prob(&pp[2], c[2], c[3], 20, 128);
+    }
+
+    // mv components
+    for (i = 0; i < 2; i++) {
+        uint8_t *pp;
+        unsigned *c, (*c2)[2], sum;
+
+        adapt_prob(&p->mv_comp[i].sign, s->counts.mv_comp[i].sign[0],
+                   s->counts.mv_comp[i].sign[1], 20, 128);
+
+        pp  = p->mv_comp[i].classes;
+        c   = s->counts.mv_comp[i].classes;
+        sum = c[1] + c[2] + c[3] + c[4] + c[5] +
+              c[6] + c[7] + c[8] + c[9] + c[10];
+        adapt_prob(&pp[0], c[0], sum, 20, 128);
+        sum -= c[1];
+        adapt_prob(&pp[1], c[1], sum, 20, 128);
+        sum -= c[2] + c[3];
+        adapt_prob(&pp[2], c[2] + c[3], sum, 20, 128);
+        adapt_prob(&pp[3], c[2], c[3], 20, 128);
+        sum -= c[4] + c[5];
+        adapt_prob(&pp[4], c[4] + c[5], sum, 20, 128);
+        adapt_prob(&pp[5], c[4], c[5], 20, 128);
+        sum -= c[6];
+        adapt_prob(&pp[6], c[6], sum, 20, 128);
+        adapt_prob(&pp[7], c[7] + c[8], c[9] + c[10], 20, 128);
+        adapt_prob(&pp[8], c[7], c[8], 20, 128);
+        adapt_prob(&pp[9], c[9], c[10], 20, 128);
+
+        adapt_prob(&p->mv_comp[i].class0, s->counts.mv_comp[i].class0[0],
+                   s->counts.mv_comp[i].class0[1], 20, 128);
+        pp = p->mv_comp[i].bits;
+        c2 = s->counts.mv_comp[i].bits;
+        for (j = 0; j < 10; j++)
+            adapt_prob(&pp[j], c2[j][0], c2[j][1], 20, 128);
+
+        for (j = 0; j < 2; j++) {
+            pp = p->mv_comp[i].class0_fp[j];
+            c  = s->counts.mv_comp[i].class0_fp[j];
+            adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
+            adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
+            adapt_prob(&pp[2], c[2], c[3], 20, 128);
+        }
+        pp = p->mv_comp[i].fp;
+        c  = s->counts.mv_comp[i].fp;
+        adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
+        adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
+        adapt_prob(&pp[2], c[2], c[3], 20, 128);
+
+        if (s->highprecisionmvs) {
+            adapt_prob(&p->mv_comp[i].class0_hp,
+                       s->counts.mv_comp[i].class0_hp[0],
+                       s->counts.mv_comp[i].class0_hp[1], 20, 128);
+            adapt_prob(&p->mv_comp[i].hp, s->counts.mv_comp[i].hp[0],
+                       s->counts.mv_comp[i].hp[1], 20, 128);
+        }
+    }
+
+    // y intra modes
+    for (i = 0; i < 4; i++) {
+        uint8_t *pp = p->y_mode[i];
+        unsigned *c = s->counts.y_mode[i], sum, s2;
+
+        sum = c[0] + c[1] + c[3] + c[4] + c[5] + c[6] + c[7] + c[8] + c[9];
+        adapt_prob(&pp[0], c[DC_PRED], sum, 20, 128);
+        sum -= c[TM_VP8_PRED];
+        adapt_prob(&pp[1], c[TM_VP8_PRED], sum, 20, 128);
+        sum -= c[VERT_PRED];
+        adapt_prob(&pp[2], c[VERT_PRED], sum, 20, 128);
+        s2   = c[HOR_PRED] + c[DIAG_DOWN_RIGHT_PRED] + c[VERT_RIGHT_PRED];
+        sum -= s2;
+        adapt_prob(&pp[3], s2, sum, 20, 128);
+        s2 -= c[HOR_PRED];
+        adapt_prob(&pp[4], c[HOR_PRED], s2, 20, 128);
+        adapt_prob(&pp[5], c[DIAG_DOWN_RIGHT_PRED], c[VERT_RIGHT_PRED],
+                   20, 128);
+        sum -= c[DIAG_DOWN_LEFT_PRED];
+        adapt_prob(&pp[6], c[DIAG_DOWN_LEFT_PRED], sum, 20, 128);
+        sum -= c[VERT_LEFT_PRED];
+        adapt_prob(&pp[7], c[VERT_LEFT_PRED], sum, 20, 128);
+        adapt_prob(&pp[8], c[HOR_DOWN_PRED], c[HOR_UP_PRED], 20, 128);
+    }
+
+    // uv intra modes
+    for (i = 0; i < 10; i++) {
+        uint8_t *pp = p->uv_mode[i];
+        unsigned *c = s->counts.uv_mode[i], sum, s2;
+
+        sum = c[0] + c[1] + c[3] + c[4] + c[5] + c[6] + c[7] + c[8] + c[9];
+        adapt_prob(&pp[0], c[DC_PRED], sum, 20, 128);
+        sum -= c[TM_VP8_PRED];
+        adapt_prob(&pp[1], c[TM_VP8_PRED], sum, 20, 128);
+        sum -= c[VERT_PRED];
+        adapt_prob(&pp[2], c[VERT_PRED], sum, 20, 128);
+        s2   = c[HOR_PRED] + c[DIAG_DOWN_RIGHT_PRED] + c[VERT_RIGHT_PRED];
+        sum -= s2;
+        adapt_prob(&pp[3], s2, sum, 20, 128);
+        s2 -= c[HOR_PRED];
+        adapt_prob(&pp[4], c[HOR_PRED], s2, 20, 128);
+        adapt_prob(&pp[5], c[DIAG_DOWN_RIGHT_PRED], c[VERT_RIGHT_PRED],
+                   20, 128);
+        sum -= c[DIAG_DOWN_LEFT_PRED];
+        adapt_prob(&pp[6], c[DIAG_DOWN_LEFT_PRED], sum, 20, 128);
+        sum -= c[VERT_LEFT_PRED];
+        adapt_prob(&pp[7], c[VERT_LEFT_PRED], sum, 20, 128);
+        adapt_prob(&pp[8], c[HOR_DOWN_PRED], c[HOR_UP_PRED], 20, 128);
+    }
+}

libavcodec/x86/Makefile

@@ -35,6 +35,7 @@ OBJS-$(CONFIG_VORBIS_DECODER)          += x86/vorbisdsp_init.o
 OBJS-$(CONFIG_VP3DSP)                  += x86/vp3dsp_init.o
 OBJS-$(CONFIG_VP6_DECODER)             += x86/vp6dsp_init.o
 OBJS-$(CONFIG_VP8_DECODER)             += x86/vp8dsp_init.o
+OBJS-$(CONFIG_VP9_DECODER)             += x86/vp9dsp_init.o
 OBJS-$(CONFIG_XMM_CLOBBER_TEST)        += x86/w64xmmtest.o
 
 MMX-OBJS-$(CONFIG_DSPUTIL)             += x86/dsputil_mmx.o             \
@@ -90,3 +91,4 @@ YASM-OBJS-$(CONFIG_VP3DSP)             += x86/vp3dsp.o
 YASM-OBJS-$(CONFIG_VP6_DECODER)        += x86/vp6dsp.o
 YASM-OBJS-$(CONFIG_VP8_DECODER)        += x86/vp8dsp.o                  \
                                           x86/vp8dsp_loopfilter.o
+YASM-OBJS-$(CONFIG_VP9_DECODER)        += x86/vp9dsp.o

libavcodec/x86/vp9dsp.asm

@@ -0,0 +1,277 @@
+;******************************************************************************
+;* VP9 SIMD optimizations
+;*
+;* Copyright (c) 2013 Ronald S. Bultje <rsbultje gmail com>
+;*
+;* This file is part of Libav.
+;*
+;* Libav 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.
+;*
+;* Libav 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 Libav; if not, write to the Free Software
+;* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+;******************************************************************************
+
+%include "libavutil/x86/x86util.asm"
+
+SECTION_RODATA
+
+; FIXME share with vp8dsp.asm
+pw_256:   times 8 dw 256
+
+%macro F8_TAPS 8
+times 8 db %1, %2
+times 8 db %3, %4
+times 8 db %5, %6
+times 8 db %7, %8
+%endmacro
+; int8_t ff_filters_ssse3[3][15][4][16]
+const filters_ssse3 ; smooth
+                    F8_TAPS -3, -1,  32,  64,  38,   1, -3,  0
+                    F8_TAPS -2, -2,  29,  63,  41,   2, -3,  0
+                    F8_TAPS -2, -2,  26,  63,  43,   4, -4,  0
+                    F8_TAPS -2, -3,  24,  62,  46,   5, -4,  0
+                    F8_TAPS -2, -3,  21,  60,  49,   7, -4,  0
+                    F8_TAPS -1, -4,  18,  59,  51,   9, -4,  0
+                    F8_TAPS -1, -4,  16,  57,  53,  12, -4, -1
+                    F8_TAPS -1, -4,  14,  55,  55,  14, -4, -1
+                    F8_TAPS -1, -4,  12,  53,  57,  16, -4, -1
+                    F8_TAPS  0, -4,   9,  51,  59,  18, -4, -1
+                    F8_TAPS  0, -4,   7,  49,  60,  21, -3, -2
+                    F8_TAPS  0, -4,   5,  46,  62,  24, -3, -2
+                    F8_TAPS  0, -4,   4,  43,  63,  26, -2, -2
+                    F8_TAPS  0, -3,   2,  41,  63,  29, -2, -2
+                    F8_TAPS  0, -3,   1,  38,  64,  32, -1, -3
+                    ; regular
+                    F8_TAPS  0,  1,  -5, 126,   8,  -3,  1,  0
+                    F8_TAPS -1,  3, -10, 122,  18,  -6,  2,  0
+                    F8_TAPS -1,  4, -13, 118,  27,  -9,  3, -1
+                    F8_TAPS -1,  4, -16, 112,  37, -11,  4, -1
+                    F8_TAPS -1,  5, -18, 105,  48, -14,  4, -1
+                    F8_TAPS -1,  5, -19,  97,  58, -16,  5, -1
+                    F8_TAPS -1,  6, -19,  88,  68, -18,  5, -1
+                    F8_TAPS -1,  6, -19,  78,  78, -19,  6, -1
+                    F8_TAPS -1,  5, -18,  68,  88, -19,  6, -1
+                    F8_TAPS -1,  5, -16,  58,  97, -19,  5, -1
+                    F8_TAPS -1,  4, -14,  48, 105, -18,  5, -1
+                    F8_TAPS -1,  4, -11,  37, 112, -16,  4, -1
+                    F8_TAPS -1,  3,  -9,  27, 118, -13,  4, -1
+                    F8_TAPS  0,  2,  -6,  18, 122, -10,  3, -1
+                    F8_TAPS  0,  1,  -3,   8, 126,  -5,  1,  0
+                    ; sharp
+                    F8_TAPS -1,  3,  -7, 127,   8,  -3,  1,  0
+                    F8_TAPS -2,  5, -13, 125,  17,  -6,  3, -1
+                    F8_TAPS -3,  7, -17, 121,  27, -10,  5, -2
+                    F8_TAPS -4,  9, -20, 115,  37, -13,  6, -2
+                    F8_TAPS -4, 10, -23, 108,  48, -16,  8, -3
+                    F8_TAPS -4, 10, -24, 100,  59, -19,  9, -3
+                    F8_TAPS -4, 11, -24,  90,  70, -21, 10, -4
+                    F8_TAPS -4, 11, -23,  80,  80, -23, 11, -4
+                    F8_TAPS -4, 10, -21,  70,  90, -24, 11, -4
+                    F8_TAPS -3,  9, -19,  59, 100, -24, 10, -4
+                    F8_TAPS -3,  8, -16,  48, 108, -23, 10, -4
+                    F8_TAPS -2,  6, -13,  37, 115, -20,  9, -4
+                    F8_TAPS -2,  5, -10,  27, 121, -17,  7, -3
+                    F8_TAPS -1,  3,  -6,  17, 125, -13,  5, -2
+                    F8_TAPS  0,  1,  -3,   8, 127,  -7,  3, -1
+
+SECTION .text
+
+%macro filter_h_fn 1
+%assign %%px mmsize/2
+cglobal %1_8tap_1d_h_ %+ %%px, 6, 6, 11, dst, src, dstride, sstride, h, filtery
+    mova        m6, [pw_256]
+    mova        m7, [filteryq+ 0]
+%if ARCH_X86_64 && mmsize > 8
+    mova        m8, [filteryq+16]
+    mova        m9, [filteryq+32]
+    mova       m10, [filteryq+48]
+%endif
+.loop:
+    movh        m0, [srcq-3]
+    movh        m1, [srcq-2]
+    movh        m2, [srcq-1]
+    movh        m3, [srcq+0]
+    movh        m4, [srcq+1]
+    movh        m5, [srcq+2]
+    punpcklbw   m0, m1
+    punpcklbw   m2, m3
+    movh        m1, [srcq+3]
+    movh        m3, [srcq+4]
+    add       srcq, sstrideq
+    punpcklbw   m4, m5
+    punpcklbw   m1, m3
+    pmaddubsw   m0, m7
+%if ARCH_X86_64 && mmsize > 8
+    pmaddubsw   m2, m8
+    pmaddubsw   m4, m9
+    pmaddubsw   m1, m10
+%else
+    pmaddubsw   m2, [filteryq+16]
+    pmaddubsw   m4, [filteryq+32]
+    pmaddubsw   m1, [filteryq+48]
+%endif
+    paddw       m0, m2
+    paddw       m4, m1
+    paddsw      m0, m4
+    pmulhrsw    m0, m6
+%ifidn %1, avg
+    movh        m1, [dstq]
+%endif
+    packuswb    m0, m0
+%ifidn %1, avg
+    pavgb       m0, m1
+%endif
+    movh    [dstq], m0
+    add       dstq, dstrideq
+    dec         hd
+    jg .loop
+    RET
+%endmacro
+
+INIT_MMX ssse3
+filter_h_fn put
+filter_h_fn avg
+
+INIT_XMM ssse3
+filter_h_fn put
+filter_h_fn avg
+
+%macro filter_v_fn 1
+%assign %%px mmsize/2
+%if ARCH_X86_64
+cglobal %1_8tap_1d_v_ %+ %%px, 6, 8, 11, dst, src, dstride, sstride, h, filtery, src4, sstride3
+%else
+cglobal %1_8tap_1d_v_ %+ %%px, 4, 7, 11, dst, src, dstride, sstride, filtery, src4, sstride3
+    mov   filteryq, r5mp
+%define hd r4mp
+%endif
+    sub       srcq, sstrideq
+    lea  sstride3q, [sstrideq*3]
+    sub       srcq, sstrideq
+    mova        m6, [pw_256]
+    sub       srcq, sstrideq
+    mova        m7, [filteryq+ 0]
+    lea      src4q, [srcq+sstrideq*4]
+%if ARCH_X86_64 && mmsize > 8
+    mova        m8, [filteryq+16]
+    mova        m9, [filteryq+32]
+    mova       m10, [filteryq+48]
+%endif
+.loop:
+    ; FIXME maybe reuse loads from previous rows, or just more generally
+    ; unroll this to prevent multiple loads of the same data?
+    movh        m0, [srcq]
+    movh        m1, [srcq+sstrideq]
+    movh        m2, [srcq+sstrideq*2]
+    movh        m3, [srcq+sstride3q]
+    movh        m4, [src4q]
+    movh        m5, [src4q+sstrideq]
+    punpcklbw   m0, m1
+    punpcklbw   m2, m3
+    movh        m1, [src4q+sstrideq*2]
+    movh        m3, [src4q+sstride3q]
+    add       srcq, sstrideq
+    add      src4q, sstrideq
+    punpcklbw   m4, m5
+    punpcklbw   m1, m3
+    pmaddubsw   m0, m7
+%if ARCH_X86_64 && mmsize > 8
+    pmaddubsw   m2, m8
+    pmaddubsw   m4, m9
+    pmaddubsw   m1, m10
+%else
+    pmaddubsw   m2, [filteryq+16]
+    pmaddubsw   m4, [filteryq+32]
+    pmaddubsw   m1, [filteryq+48]
+%endif
+    paddw       m0, m2
+    paddw       m4, m1
+    paddsw      m0, m4
+    pmulhrsw    m0, m6
+%ifidn %1, avg
+    movh        m1, [dstq]
+%endif
+    packuswb    m0, m0
+%ifidn %1, avg
+    pavgb       m0, m1
+%endif
+    movh    [dstq], m0
+    add       dstq, dstrideq
+    dec         hd
+    jg .loop
+    RET
+%endmacro
+
+INIT_MMX ssse3
+filter_v_fn put
+filter_v_fn avg
+
+INIT_XMM ssse3
+filter_v_fn put
+filter_v_fn avg
+
+%macro fpel_fn 6
+%if %2 == 4
+%define %%srcfn movh
+%define %%dstfn movh
+%else
+%define %%srcfn movu
+%define %%dstfn mova
+%endif
+
+%if %2 <= 16
+cglobal %1%2, 5, 7, 4, dst, src, dstride, sstride, h, dstride3, sstride3
+    lea  sstride3q, [sstrideq*3]
+    lea  dstride3q, [dstrideq*3]
+%else
+cglobal %1%2, 5, 5, 4, dst, src, dstride, sstride, h
+%endif
+.loop:
+    %%srcfn     m0, [srcq]
+    %%srcfn     m1, [srcq+s%3]
+    %%srcfn     m2, [srcq+s%4]
+    %%srcfn     m3, [srcq+s%5]
+    lea       srcq, [srcq+sstrideq*%6]
+%ifidn %1, avg
+    pavgb       m0, [dstq]
+    pavgb       m1, [dstq+d%3]
+    pavgb       m2, [dstq+d%4]
+    pavgb       m3, [dstq+d%5]
+%endif
+    %%dstfn [dstq], m0
+    %%dstfn [dstq+d%3], m1
+    %%dstfn [dstq+d%4], m2
+    %%dstfn [dstq+d%5], m3
+    lea       dstq, [dstq+dstrideq*%6]
+    sub         hd, %6
+    jnz .loop
+    RET
+%endmacro
+
+%define d16 16
+%define s16 16
+INIT_MMX mmx
+fpel_fn put, 4,  strideq, strideq*2, stride3q, 4
+fpel_fn put, 8,  strideq, strideq*2, stride3q, 4
+INIT_MMX sse
+fpel_fn avg, 4,  strideq, strideq*2, stride3q, 4
+fpel_fn avg, 8,  strideq, strideq*2, stride3q, 4
+INIT_XMM sse
+fpel_fn put, 16, strideq, strideq*2, stride3q, 4
+fpel_fn put, 32, mmsize,  strideq,   strideq+mmsize, 2
+fpel_fn put, 64, mmsize,  mmsize*2,  mmsize*3, 1
+INIT_XMM sse2
+fpel_fn avg, 16, strideq, strideq*2, stride3q, 4
+fpel_fn avg, 32, mmsize,  strideq,   strideq+mmsize, 2
+fpel_fn avg, 64, mmsize,  mmsize*2,  mmsize*3, 1
+%undef s16
+%undef d16

libavcodec/x86/vp9dsp_init.c

@@ -0,0 +1,245 @@
+/*
+ * VP9 SIMD optimizations
+ *
+ * Copyright (c) 2013 Ronald S. Bultje <rsbultje@gmail.com>
+ *
+ * This file is part of Libav.
+ *
+ * Libav 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.
+ *
+ * Libav 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 Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "libavutil/cpu.h"
+#include "libavutil/internal.h"
+#include "libavutil/mem.h"
+#include "libavutil/x86/asm.h"
+#include "libavutil/x86/cpu.h"
+#include "libavcodec/vp9.h"
+
+#if HAVE_YASM
+
+#define fpel_func(avg, sz, opt)                                         \
+void ff_ ## avg ## sz ## _ ## opt(uint8_t *dst, const uint8_t *src,     \
+                                  ptrdiff_t dst_stride,                 \
+                                  ptrdiff_t src_stride,                 \
+                                  int h, int mx, int my)
+
+fpel_func(put,  4, mmx);
+fpel_func(put,  8, mmx);
+fpel_func(put, 16, sse);
+fpel_func(put, 32, sse);
+fpel_func(put, 64, sse);
+fpel_func(avg,  4, sse);
+fpel_func(avg,  8, sse);
+fpel_func(avg, 16, sse2);
+fpel_func(avg, 32, sse2);
+fpel_func(avg, 64, sse2);
+#undef fpel_func
+
+#define mc_func(avg, sz, dir, opt)                                          \
+void                                                                        \
+ff_ ## avg ## _8tap_1d_ ## dir ## _ ## sz ## _ ## opt(uint8_t *dst,         \
+                                                      const uint8_t *src,   \
+                                                      ptrdiff_t dst_stride, \
+                                                      ptrdiff_t src_stride, \
+                                                      int h,                \
+                                                      const int8_t (*filter)[16])
+
+#define mc_funcs(sz)            \
+    mc_func(put, sz, h, ssse3); \
+    mc_func(avg, sz, h, ssse3); \
+    mc_func(put, sz, v, ssse3); \
+    mc_func(avg, sz, v, ssse3)
+
+mc_funcs(4);
+mc_funcs(8);
+
+#undef mc_funcs
+#undef mc_func
+
+#define mc_rep_func(avg, sz, hsz, dir, opt)                                 \
+static av_always_inline void                                                \
+ff_ ## avg ## _8tap_1d_ ## dir ## _ ## sz ## _ ## opt(uint8_t *dst,         \
+                                                      const uint8_t *src,   \
+                                                      ptrdiff_t dst_stride, \
+                                                      ptrdiff_t src_stride, \
+                                                      int h,                \
+                                                      const int8_t (*filter)[16]) \
+{                                                                           \
+    ff_ ## avg ## _8tap_1d_ ## dir ## _ ## hsz ## _ ## opt(dst, src,        \
+                                                           dst_stride,      \
+                                                           src_stride,      \
+                                                           h,               \
+                                                           filter);         \
+    ff_ ## avg ## _8tap_1d_ ## dir ## _ ## hsz ## _ ## opt(dst + hsz,       \
+                                                           src + hsz,       \
+                                                           dst_stride,      \
+                                                           src_stride,      \
+                                                           h, filter);      \
+}
+
+#define mc_rep_funcs(sz, hsz)            \
+    mc_rep_func(put, sz, hsz, h, ssse3); \
+    mc_rep_func(avg, sz, hsz, h, ssse3); \
+    mc_rep_func(put, sz, hsz, v, ssse3); \
+    mc_rep_func(avg, sz, hsz, v, ssse3)
+
+mc_rep_funcs(16, 8);
+mc_rep_funcs(32, 16);
+mc_rep_funcs(64, 32);
+
+#undef mc_rep_funcs
+#undef mc_rep_func
+
+extern const int8_t ff_filters_ssse3[3][15][4][16];
+
+#define filter_8tap_2d_fn(op, sz, f, fname)                             \
+static void                                                             \
+op ## _8tap_ ## fname ## _ ## sz ## hv_ssse3(uint8_t *dst,              \
+                                             const uint8_t *src,        \
+                                             ptrdiff_t dst_stride,      \
+                                             ptrdiff_t src_stride,      \
+                                             int h, int mx, int my)     \
+{                                                                       \
+    LOCAL_ALIGNED_16(uint8_t, temp, [71 * 64]);                         \
+    ff_put_8tap_1d_h_ ## sz ## _ssse3(temp, src - 3 * src_stride,       \
+                                      64, src_stride,                   \
+                                      h + 7,                            \
+                                      ff_filters_ssse3[f][mx - 1]);     \
+    ff_ ## op ## _8tap_1d_v_ ## sz ## _ssse3(dst, temp + 3 * 64,        \
+                                             dst_stride, 64,            \
+                                             h,                         \
+                                             ff_filters_ssse3[f][my - 1]); \
+}
+
+#define filters_8tap_2d_fn(op, sz)                          \
+    filter_8tap_2d_fn(op, sz, FILTER_8TAP_REGULAR, regular) \
+    filter_8tap_2d_fn(op, sz, FILTER_8TAP_SHARP, sharp)     \
+    filter_8tap_2d_fn(op, sz, FILTER_8TAP_SMOOTH, smooth)
+
+#define filters_8tap_2d_fn2(op) \
+    filters_8tap_2d_fn(op, 64)  \
+    filters_8tap_2d_fn(op, 32)  \
+    filters_8tap_2d_fn(op, 16)  \
+    filters_8tap_2d_fn(op, 8)   \
+    filters_8tap_2d_fn(op, 4)
+
+filters_8tap_2d_fn2(put)
+filters_8tap_2d_fn2(avg)
+
+#undef filters_8tap_2d_fn2
+#undef filters_8tap_2d_fn
+#undef filter_8tap_2d_fn
+
+#define filter_8tap_1d_fn(op, sz, f, fname, dir, dvar)                  \
+static void                                                             \
+op ## _8tap_ ## fname ## _ ## sz ## dir ## _ssse3(uint8_t *dst,         \
+                                                  const uint8_t *src,   \
+                                                  ptrdiff_t dst_stride, \
+                                                  ptrdiff_t src_stride, \
+                                                  int h, int mx,        \
+                                                  int my)               \
+{                                                                       \
+    ff_ ## op ## _8tap_1d_ ## dir ## _ ## sz ## _ssse3(dst, src,        \
+                                                       dst_stride,      \
+                                                       src_stride, h,   \
+                                                       ff_filters_ssse3[f][dvar - 1]); \
+}
+
+#define filters_8tap_1d_fn(op, sz, dir, dvar)                          \
+    filter_8tap_1d_fn(op, sz, FILTER_8TAP_REGULAR, regular, dir, dvar) \
+    filter_8tap_1d_fn(op, sz, FILTER_8TAP_SHARP, sharp, dir, dvar)     \
+    filter_8tap_1d_fn(op, sz, FILTER_8TAP_SMOOTH, smooth, dir, dvar)
+
+#define filters_8tap_1d_fn2(op, sz)             \
+    filters_8tap_1d_fn(op, sz, h, mx)           \
+    filters_8tap_1d_fn(op, sz, v, my)
+
+#define filters_8tap_1d_fn3(op) \
+    filters_8tap_1d_fn2(op, 64) \
+    filters_8tap_1d_fn2(op, 32) \
+    filters_8tap_1d_fn2(op, 16) \
+    filters_8tap_1d_fn2(op,  8) \
+    filters_8tap_1d_fn2(op,  4)
+
+filters_8tap_1d_fn3(put)
+filters_8tap_1d_fn3(avg)
+
+#undef filters_8tap_1d_fn
+#undef filters_8tap_1d_fn2
+#undef filters_8tap_1d_fn3
+#undef filter_8tap_1d_fn
+
+#endif /* HAVE_YASM */
+
+av_cold void ff_vp9dsp_init_x86(VP9DSPContext *dsp)
+{
+#if HAVE_YASM
+    int cpu_flags = av_get_cpu_flags();
+
+#define init_fpel(idx1, idx2, sz, type, opt)                            \
+    dsp->mc[idx1][FILTER_8TAP_SMOOTH ][idx2][0][0] =                    \
+    dsp->mc[idx1][FILTER_8TAP_REGULAR][idx2][0][0] =                    \
+    dsp->mc[idx1][FILTER_8TAP_SHARP  ][idx2][0][0] =                    \
+    dsp->mc[idx1][FILTER_BILINEAR    ][idx2][0][0] = ff_ ## type ## sz ## _ ## opt
+
+
+#define init_subpel1(idx1, idx2, idxh, idxv, sz, dir, type, opt) \
+    dsp->mc[idx1][FILTER_8TAP_SMOOTH][idx2][idxh][idxv]  = type ## _8tap_smooth_  ## sz ## dir ## _ ## opt; \
+    dsp->mc[idx1][FILTER_8TAP_REGULAR][idx2][idxh][idxv] = type ## _8tap_regular_ ## sz ## dir ## _ ## opt; \
+    dsp->mc[idx1][FILTER_8TAP_SHARP][idx2][idxh][idxv]   = type ## _8tap_sharp_   ## sz ## dir ## _ ## opt
+
+#define init_subpel2(idx, idxh, idxv, dir, type, opt)     \
+    init_subpel1(0, idx, idxh, idxv, 64, dir, type, opt); \
+    init_subpel1(1, idx, idxh, idxv, 32, dir, type, opt); \
+    init_subpel1(2, idx, idxh, idxv, 16, dir, type, opt); \
+    init_subpel1(3, idx, idxh, idxv,  8, dir, type, opt); \
+    init_subpel1(4, idx, idxh, idxv,  4, dir, type, opt)
+
+#define init_subpel3(idx, type, opt)        \
+    init_subpel2(idx, 1, 1, hv, type, opt); \
+    init_subpel2(idx, 0, 1,  v, type, opt); \
+    init_subpel2(idx, 1, 0,  h, type, opt)
+
+    if (EXTERNAL_MMX(cpu_flags)) {
+        init_fpel(4, 0,  4, put, mmx);
+        init_fpel(3, 0,  8, put, mmx);
+    }
+
+    if (EXTERNAL_SSE(cpu_flags)) {
+        init_fpel(2, 0, 16, put, sse);
+        init_fpel(1, 0, 32, put, sse);
+        init_fpel(0, 0, 64, put, sse);
+        init_fpel(4, 1,  4, avg, sse);
+        init_fpel(3, 1,  8, avg, sse);
+    }
+
+    if (EXTERNAL_SSE2(cpu_flags)) {
+        init_fpel(2, 1, 16, avg, sse2);
+        init_fpel(1, 1, 32, avg, sse2);
+        init_fpel(0, 1, 64, avg, sse2);
+    }
+
+    if (EXTERNAL_SSSE3(cpu_flags)) {
+        init_subpel3(0, put, ssse3);
+        init_subpel3(1, avg, ssse3);
+    }
+
+#undef init_fpel
+#undef init_subpel1
+#undef init_subpel2
+#undef init_subpel3
+
+#endif /* HAVE_YASM */
+}

tests/fate/vpx.mak

@@ -52,3 +52,34 @@ $(call FATE_VP8_FULL,-emu-edge,-flags +emu_edge)
 
 FATE_SAMPLES_AVCONV-$(CONFIG_VP8_DECODER) += $(FATE_VP8-yes)
 fate-vp8: $(FATE_VP8-yes)
+
+define FATE_VP9_SUITE
+FATE_VP9-$(CONFIG_MATROSKA_DEMUXER) += fate-vp9$(2)-$(1)
+fate-vp9$(2)-$(1): CMD = framemd5 $(3) -i $(TARGET_SAMPLES)/vp9-test-vectors/vp90-2-$(1).webm
+fate-vp9$(2)-$(1): REF = $(SRC_PATH)/tests/ref/fate/vp9-$(1)
+endef
+
+VP9_Q = 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 \
+        16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 \
+        32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 \
+        48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
+VP9_SHARP = 1 2 3 4 5 6 7
+VP9_SIZE_A = 08 10 16 18 32 34 64 66
+VP9_SIZE_B = 196 198 200 202 208 210 224 226
+
+define FATE_VP9_FULL
+$(foreach Q,$(VP9_Q),$(eval $(call FATE_VP9_SUITE,00-quantizer-$(Q),$(1),$(2))))
+$(foreach SHARP,$(VP9_SHARP),$(eval $(call FATE_VP9_SUITE,01-sharpness-$(SHARP),$(1),$(2))))
+$(foreach W,$(VP9_SIZE_A),$(eval $(foreach H,$(VP9_SIZE_A),$(eval $(call FATE_VP9_SUITE,02-size-$(W)x$(H),$(1),$(2))))))
+$(foreach W,$(VP9_SIZE_B),$(eval $(foreach H,$(VP9_SIZE_B),$(eval $(call FATE_VP9_SUITE,03-size-$(W)x$(H),$(1),$(2))))))
+$(eval $(call FATE_VP9_SUITE,03-deltaq,$(1),$(2)))
+$(eval $(call FATE_VP9_SUITE,2pass-akiyo,$(1),$(2)))
+$(eval $(call FATE_VP9_SUITE,segmentation-akiyo,$(1),$(2)))
+$(eval $(call FATE_VP9_SUITE,tiling-pedestrian,$(1),$(2)))
+endef
+
+$(eval $(call FATE_VP9_FULL))
+$(eval $(call FATE_VP9_FULL,-emu-edge,-flags +emu_edge))
+
+FATE_SAMPLES_AVCONV-$(CONFIG_VP9_DECODER) += $(FATE_VP9-yes)
+fate-vp9: $(FATE_VP9-yes)

tests/ref/fate/vp9-00-quantizer-00

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, c3fbb7abbdb5bd4ed4a7e34768c17df1
+0,         33,         33,        0,   152064, 08203c2595bdb2d58ead6f921345d699

tests/ref/fate/vp9-00-quantizer-01

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, f041b870cf9236d5f22e2b08a77d5958
+0,         33,         33,        0,   152064, cbdb7526986ae15592891488c9afc84c

tests/ref/fate/vp9-00-quantizer-02

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 98048cfdb4af5059f4085c5acc94ef8f
+0,         33,         33,        0,   152064, 8160183e1eed1d0af4427be216b8b9f7

tests/ref/fate/vp9-00-quantizer-03

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 15c548208f5eda243a151a42f4d64855
+0,         33,         33,        0,   152064, e96d463dc8e9b27b1c2ec40f77eee6ef

tests/ref/fate/vp9-00-quantizer-04

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 928c64a0747ac57ab50c1520d694fea7
+0,         33,         33,        0,   152064, a6f6daa293231e95ef30ed168f582c84

tests/ref/fate/vp9-00-quantizer-05

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 082460718b7d7046c8fb23184b7f71ca
+0,         33,         33,        0,   152064, 4a41aad51c40a92df72333e13f47d3fe

tests/ref/fate/vp9-00-quantizer-06

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, cfca1bed96ff62a69b2d841fda01c6b9
+0,         33,         33,        0,   152064, 9b4d61f1b998745c108f8eb67925e03d

tests/ref/fate/vp9-00-quantizer-07

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 6f5122064bead9d9882bec2698a6ed9c
+0,         33,         33,        0,   152064, 50dae67d2f57a76eece210dee8b6df9e

tests/ref/fate/vp9-00-quantizer-08

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, eb3d6985fcda5d93dd62d53354e8a093
+0,         33,         33,        0,   152064, 5b1f5b7780b4cafe1f75e56a0b526643

tests/ref/fate/vp9-00-quantizer-09

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, d7ccaf28c59875fe91983def5490d2b1
+0,         33,         33,        0,   152064, bd98fe9492054826748de840b4495309

tests/ref/fate/vp9-00-quantizer-10

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 20dda6231f9801c9c237c6d09d9939b6
+0,         33,         33,        0,   152064, 23c91e93807fb9a4ed5bd5bdd449d99f

tests/ref/fate/vp9-00-quantizer-11

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 960833315ebcdee97f46c4d98d0f3fef
+0,         33,         33,        0,   152064, eec40507d17b64b7895a61cb87b2096a

tests/ref/fate/vp9-00-quantizer-12

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 6533224d3b6ba1ec0dd973bbe56c6349
+0,         33,         33,        0,   152064, 12ceadc6d28327a24a75f8c40b6084d1

tests/ref/fate/vp9-00-quantizer-13

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 7268de6756014f79a56dcf010c52a97f
+0,         33,         33,        0,   152064, 9e39e9b0e2295b8460dfa05f44762771

tests/ref/fate/vp9-00-quantizer-14

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 57e9e333c641fa952f7485b788df225a
+0,         33,         33,        0,   152064, 551f0cea83dcdf4540c3983736757874

tests/ref/fate/vp9-00-quantizer-15

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 17a0a2842856b9e89aede237648d5dda
+0,         33,         33,        0,   152064, c9fcade888a38621bebe3d4b41664245

tests/ref/fate/vp9-00-quantizer-16

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 6cc2089e9a3d352fe10b59ccd935c677
+0,         33,         33,        0,   152064, d165bf7b9cb901e121a65038758d8613

tests/ref/fate/vp9-00-quantizer-17

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, bc80511c83162c09661f155cd29f6dd8
+0,         33,         33,        0,   152064, a62f1cbdb3f86d2fb4c880cfd917def5

tests/ref/fate/vp9-00-quantizer-18

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, b2d350f6faa41cb50c2e8a9907d0f4a5
+0,         33,         33,        0,   152064, 39b4380d16bc8e093dd4dba475175fb3

tests/ref/fate/vp9-00-quantizer-19

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 441e09be3c15fcb240afd74bb7a10a72
+0,         33,         33,        0,   152064, 32ae5dac876ca5d5ae6ab7c74f4dc25d

tests/ref/fate/vp9-00-quantizer-20

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 7786eb9944dba0553e129133523a98c1
+0,         33,         33,        0,   152064, 206d888f8453427f10a40aa8bf5f6df0

tests/ref/fate/vp9-00-quantizer-21

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, aab95e195be71feca050a839d7b3154d
+0,         33,         33,        0,   152064, 02a05d699bbbdc477e34bb0dad9f0391

tests/ref/fate/vp9-00-quantizer-22

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 41f853c3ee2d4611b645cc643d82e287
+0,         33,         33,        0,   152064, 1c240c653110ff8609ca0f0287a6496d

tests/ref/fate/vp9-00-quantizer-23

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, bc5b07369df50c8f97ce1a377fe513cf
+0,         33,         33,        0,   152064, ce62ddb4f3e305d0f8587ae8bb44cc79

tests/ref/fate/vp9-00-quantizer-24

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 982d54041221c977b6f0e37a9236cc76
+0,         33,         33,        0,   152064, 57631e7f13f645c834e2944ebfd6d40e

tests/ref/fate/vp9-00-quantizer-25

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, b0fb55f3f2f56b3d27038e83c10123ce
+0,         33,         33,        0,   152064, 9fcac3becdcc2d30d778a55eca4c2018

tests/ref/fate/vp9-00-quantizer-26

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 4f645e0f354da77b9e2f2a6753c361da
+0,         33,         33,        0,   152064, b7542998ec298273ca662bc9b658d10e

tests/ref/fate/vp9-00-quantizer-27

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 6edc96a3747cad43828397045764206e
+0,         33,         33,        0,   152064, 5fbc65d20fdca1abd69079851ce676d3

tests/ref/fate/vp9-00-quantizer-28

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 5db3e910e70da38bb91d01d73acc33dd
+0,         33,         33,        0,   152064, b920ee7f7e61b7fdf9f44b1f738d0292

tests/ref/fate/vp9-00-quantizer-29

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 3cb3e310be5305077efa6216f6f10654
+0,         33,         33,        0,   152064, 692d3e098af5978fe1a898ebc1a66a7a

tests/ref/fate/vp9-00-quantizer-30

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, e3b3cea66ea38c5dfba1aa73bb4c611d
+0,         33,         33,        0,   152064, 42bb3e54b19c3f4c4f7ee3a6ba012e19

tests/ref/fate/vp9-00-quantizer-31

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 2523e9ecfd3781eafcd7da192dc105e9
+0,         33,         33,        0,   152064, 6d5feea012b9a1f51fc643633e728764

tests/ref/fate/vp9-00-quantizer-32

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 0a0305eba36500ebf6cc6cc0f01f5a3b
+0,         33,         33,        0,   152064, 2c76bcd6763467f9057a726fbcf50ab1

tests/ref/fate/vp9-00-quantizer-33

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, c68433e0e94047c220be9b629334f744
+0,         33,         33,        0,   152064, fcfa4dff7a39bc9c5e315849ecbb46ea

tests/ref/fate/vp9-00-quantizer-34

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, ad9dc2f912c137b014a33e2792c88a25
+0,         33,         33,        0,   152064, 11221ee4ea5c776f43af68756682cd5a

tests/ref/fate/vp9-00-quantizer-35

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 75031f898cccf303a64ab46b1f815389
+0,         33,         33,        0,   152064, a4fc864e7fbc470dfcab6207e0eea152

tests/ref/fate/vp9-00-quantizer-36

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, c7824af009fde6cafdd8d39fae6bb6cf
+0,         33,         33,        0,   152064, 516a82d5fc4dfa3daf713ed2ec36041b

tests/ref/fate/vp9-00-quantizer-37

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, a2e5c820fd9733e18f9349fb658ca281
+0,         33,         33,        0,   152064, fb23e0bc64728a492a33d985032f21b8

tests/ref/fate/vp9-00-quantizer-38

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 8347bfb891317e89ef66781d6c28e24f
+0,         33,         33,        0,   152064, a5722f824d32deac042513a1a7dcdcd0

tests/ref/fate/vp9-00-quantizer-39

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 018968f97fac3bdff146cf22c1da5ef0
+0,         33,         33,        0,   152064, ca8b09b01e5132183395e238f1c7901e

tests/ref/fate/vp9-00-quantizer-40

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 792660f6589ad5340be4bd0554435866
+0,         33,         33,        0,   152064, 68c84c8a15d679e0a73678b93215c62c

tests/ref/fate/vp9-00-quantizer-41

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, a456bdfc6c1c07b4cb3a3848843743b9
+0,         33,         33,        0,   152064, fe41a12b8cb6bc5667ba2179e076f3b0

tests/ref/fate/vp9-00-quantizer-42

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, f016dd8431694d989700fb1ba71a5b2d
+0,         33,         33,        0,   152064, e89c3c5b935157b40f2fb0ab92415828

tests/ref/fate/vp9-00-quantizer-43

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 7b8ab82625f3006bac89d4fb5197e71c
+0,         33,         33,        0,   152064, 18bd3716045563dfba2c72b640b3274b

tests/ref/fate/vp9-00-quantizer-44

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 66fde04d8320c750e56406feefd29979
+0,         33,         33,        0,   152064, f9d01d8fc1722ec345e624e14b404215

tests/ref/fate/vp9-00-quantizer-45

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, cc97597b015896d73f3e60e7ae44c4da
+0,         33,         33,        0,   152064, fea98bc508f92135641ab99762444b14

tests/ref/fate/vp9-00-quantizer-46

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 79ed95c741178bb3c0954f1f6f8e21a3
+0,         33,         33,        0,   152064, f02a06a5e2b5b7619c9a52c5bea0564d

tests/ref/fate/vp9-00-quantizer-47

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 9b98e948b8c2a822f21bd8419e6f4410
+0,         33,         33,        0,   152064, 491382d68c16c2a3c6f1746598bc4a97

tests/ref/fate/vp9-00-quantizer-48

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, f0f095b0edae7262f44d7ed7ef84ded4
+0,         33,         33,        0,   152064, 0e833889ccac81d60251007d1baf6500

tests/ref/fate/vp9-00-quantizer-49

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 6c1b7b7827617fb9b8417aca2cfdbcaa
+0,         33,         33,        0,   152064, 4c1fc8a89297fdcf79f0faabd42b8684

tests/ref/fate/vp9-00-quantizer-50

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, ca6142db68463487bc28c888ab38476c
+0,         33,         33,        0,   152064, 02a71153ec70f569524c3d814cb62f86

tests/ref/fate/vp9-00-quantizer-51

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, eece2627df1ddf0872256eb92352e179
+0,         33,         33,        0,   152064, 0ee9f221246ad747250e4b5e8ba586e2

tests/ref/fate/vp9-00-quantizer-52

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 7290039d974c4e50db9d69f9864bcdbe
+0,         33,         33,        0,   152064, 264765de9d02503038a4da54133b9f85

tests/ref/fate/vp9-00-quantizer-53

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 917af24da66f143a56a01eb2c2254285
+0,         33,         33,        0,   152064, 45a05d3bc644420519619e4115662a70

tests/ref/fate/vp9-00-quantizer-54

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 6fea2820bb10a9dec9add4d2452b01f5
+0,         33,         33,        0,   152064, 74675169a4bfc2ff5463c4db5d85a79f

tests/ref/fate/vp9-00-quantizer-55

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 11e5d196f6537fb7d85988d90195e556
+0,         33,         33,        0,   152064, 8536106795f7c93c5a43a11493527469

tests/ref/fate/vp9-00-quantizer-56

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 40839b7a3a40ec10f96b8a75224f646d
+0,         33,         33,        0,   152064, 11408dd73e8c45ddaab99f5c9650102b

tests/ref/fate/vp9-00-quantizer-57

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, d0e9fa03dd48da4592ebaadb4e3794e0
+0,         33,         33,        0,   152064, 5172e29b1e04cd543833d6a68aab297c

tests/ref/fate/vp9-00-quantizer-58

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, bef4a27d460e7697e038fe6f1c8bd597
+0,         33,         33,        0,   152064, 124674686cafc5f2ff5bc7ea412b8f3b

tests/ref/fate/vp9-00-quantizer-59

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, ae9d99e9d16ef20073300559566844ae
+0,         33,         33,        0,   152064, da9405e5a6bfe4ed18d927ba2004008e

tests/ref/fate/vp9-00-quantizer-60

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 9e66bb8e1b5e206ea4afe4bf2d335ac5
+0,         33,         33,        0,   152064, 092b74c905c12c1e87e90f5a79857736

tests/ref/fate/vp9-00-quantizer-61

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, d062dc6be246c8042744018765ef50a8
+0,         33,         33,        0,   152064, 45fd9cbacb6a91060a7e49a58a85869d

tests/ref/fate/vp9-00-quantizer-62

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 62f7e42fe653e81c5a65a25389e045b5
+0,         33,         33,        0,   152064, cb0cdd0b25689e0a43328550011d960d

tests/ref/fate/vp9-00-quantizer-63

@@ -0,0 +1,3 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, 8467643dceff827e04acd82eeff1d1b0
+0,         33,         33,        0,   152064, c786f49d66f4dfd685dea9605821a19f

tests/ref/fate/vp9-01-sharpness-1

@@ -0,0 +1,11 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, a2e5c820fd9733e18f9349fb658ca281
+0,         33,         33,        0,   152064, aa20a75be3a316193496706c9f760d08
+0,         66,         66,        0,   152064, 95567be97a64d3c9efe45f2524116a2e
+0,        100,        100,        0,   152064, 219e86cd6b3cca312856eead21776b1c
+0,        133,        133,        0,   152064, 4a67fd359ca362398e97c15eb018a2bb
+0,        166,        166,        0,   152064, 9916d4e359274d690827f0eb22547423
+0,        200,        200,        0,   152064, a07785b52561150c48f1a8eff89d5d75
+0,        233,        233,        0,   152064, a3382a92982953dfa20018e5ac975b51
+0,        266,        266,        0,   152064, 911836989ca7b148438aa3ec7fc7e303
+0,        300,        300,        0,   152064, 5627b981e3fc9e4401d35d3a5ab25917

tests/ref/fate/vp9-01-sharpness-2

@@ -0,0 +1,11 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, a2e5c820fd9733e18f9349fb658ca281
+0,         33,         33,        0,   152064, cd94572239817ae7c9b07de739c3272b
+0,         66,         66,        0,   152064, 383cf752d457e122b5ff49d08960208e
+0,        100,        100,        0,   152064, 1c0a6ec9cd3ce29b8b004e7526f1b07e
+0,        133,        133,        0,   152064, 91c42a8a108d67947cabfc2a5a80df66
+0,        166,        166,        0,   152064, 08c57fc1f3fec0305883315a66c714d1
+0,        200,        200,        0,   152064, 70cb8d8dc83eac82f2d3c4b0376bb1aa
+0,        233,        233,        0,   152064, ffd62a9ef829ec81f0f74f740488a41f
+0,        266,        266,        0,   152064, bab0aa23b5854e2a70926046e4618710
+0,        300,        300,        0,   152064, fec456f38f2a43661e786a8d5f67ed15

tests/ref/fate/vp9-01-sharpness-3

@@ -0,0 +1,11 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, a2e5c820fd9733e18f9349fb658ca281
+0,         33,         33,        0,   152064, 0d487a146393a0b8b84b4be1b371b507
+0,         66,         66,        0,   152064, 68372e191eba620a431cfff226026ac3
+0,        100,        100,        0,   152064, de7fd274460e36b983fe93acc208d72f
+0,        133,        133,        0,   152064, afbd36c61bab65b98ff9acf08e215721
+0,        166,        166,        0,   152064, e1e9fc2ab4e7a187a8d8d84aae48d6b9
+0,        200,        200,        0,   152064, 11d95de6a9cc5e00511e99534779faac
+0,        233,        233,        0,   152064, cd2f5539fdfc2d8eefe6b6da28c13398
+0,        266,        266,        0,   152064, a8b3aeed41da7aeb8d5b962ee4a4af93
+0,        300,        300,        0,   152064, 4283670bd1c1c506ef18d3dafca22035

tests/ref/fate/vp9-01-sharpness-4

@@ -0,0 +1,11 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, a2e5c820fd9733e18f9349fb658ca281
+0,         33,         33,        0,   152064, 8bad76c55b5149169d64ce6512521de6
+0,         66,         66,        0,   152064, c1d986e1f9bf46382e598ba289b9bd7c
+0,        100,        100,        0,   152064, 86c097ac6069c786023d3561dae68bac
+0,        133,        133,        0,   152064, 8c238a2831b8c7c49736b6de6ff76ed8
+0,        166,        166,        0,   152064, cb5a038ed0a74a317ee72dae93a7ee3e
+0,        200,        200,        0,   152064, f8fe330a257e3e4e4c39c1c12820a654
+0,        233,        233,        0,   152064, a73e2fcdcbb9334c0c123f8276a2c881
+0,        266,        266,        0,   152064, 24fccece8ee639e4d0e00e4060e1db0c
+0,        300,        300,        0,   152064, 46d6e9aad69a39c718c5fd1e41e86e6e

tests/ref/fate/vp9-01-sharpness-5

@@ -0,0 +1,11 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, a2e5c820fd9733e18f9349fb658ca281
+0,         33,         33,        0,   152064, f1ce0a5d57a46c9ff1331804b7b03fdb
+0,         66,         66,        0,   152064, 0364a085b06bee6b980189cf5378eda9
+0,        100,        100,        0,   152064, 4b5358698d734b0ae210909a913d4c1e
+0,        133,        133,        0,   152064, dc22565aaceee77b15fd8ab3c84bd5e0
+0,        166,        166,        0,   152064, 5f6340b656536292b46ba9a647aeb6e4
+0,        200,        200,        0,   152064, b7d4bce9a04b2a6caa45801be15e331e
+0,        233,        233,        0,   152064, 534c851cfe59ffc047815ece98d8cede
+0,        266,        266,        0,   152064, 786b0e1564d5c71aabfc2dd528cff4e7
+0,        300,        300,        0,   152064, cac0366209cf471bb7cc3e64966cbbd4

tests/ref/fate/vp9-01-sharpness-6

@@ -0,0 +1,11 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, a2e5c820fd9733e18f9349fb658ca281
+0,         33,         33,        0,   152064, 45d9ca07ed04210b1ebc743169bc8ec4
+0,         66,         66,        0,   152064, 5b646cc309a711f1d8814f925002d8c4
+0,        100,        100,        0,   152064, 34db8db727fa1ded0a55cc7cf85be249
+0,        133,        133,        0,   152064, 54173d08afe6369b16a9c0c9cc6ce04d
+0,        166,        166,        0,   152064, 76275b0a478cdb3c1fb527ebbce023c3
+0,        200,        200,        0,   152064, e7643cdf0c42f2af700d8730bfc1a453
+0,        233,        233,        0,   152064, 6e53097e56f680cb658d63100e7736f7
+0,        266,        266,        0,   152064, 1a407c3c8ea1d5245ae68c5ce7de70e1
+0,        300,        300,        0,   152064, 6cbca24912cadf09b20be74f14e359c9

tests/ref/fate/vp9-01-sharpness-7

@@ -0,0 +1,11 @@
+#tb 0: 1/1000
+0,          0,          0,        0,   152064, a2e5c820fd9733e18f9349fb658ca281
+0,         33,         33,        0,   152064, f719d0be18d16a448b4e7da3e2d9bf28
+0,         66,         66,        0,   152064, 83ee8ebc0ca796782a2376a76f2ffc26
+0,        100,        100,        0,   152064, 7cf5afdbc229e1af50a5377cfc23d831
+0,        133,        133,        0,   152064, 44244e896e0362f6376ba5afa563ba8b
+0,        166,        166,        0,   152064, df5f518d44eb6cb91b2df5a30d27ef82
+0,        200,        200,        0,   152064, 43cc3f151b8337aca7ee659c8abeb783
+0,        233,        233,        0,   152064, 4e89573470d9b97464e10806fc81aa8b
+0,        266,        266,        0,   152064, 62e0ba70f07ece8d85372f0a42e83a9a
+0,        300,        300,        0,   152064, 45ac2928acb11326f6c4a21401f3609c

tests/ref/fate/vp9-02-size-08x08

@@ -0,0 +1,11 @@
+#tb 0: 1/1000
+0,          0,          0,        0,       96, 52def242c36123e5a8f5f53d6a971399
+0,         33,         33,        0,       96, 79c93360fbd47179400414bbfee0901c
+0,         66,         66,        0,       96, c3b1947c79537baa7838905276276a91
+0,        100,        100,        0,       96, 20f35e501bdee0bc63e87b9240265c25
+0,        133,        133,        0,       96, 5e8f1c464bafd54833c51860906b5368
+0,        166,        166,        0,       96, f57b592600dfc99e634a083278af769a
+0,        200,        200,        0,       96, 7b02191f85590cbad3f148c7b92d6436
+0,        233,        233,        0,       96, b0a1c9870447a1744f64cd4087ef55ee
+0,        266,        266,        0,       96, c82712b1ba7a95efb67cbdde0ad708b6
+0,        300,        300,        0,       96, 89f4539f8d7a7b45a91fd2f46335988e

tests/ref/fate/vp9-02-size-08x10

@@ -0,0 +1,11 @@
+#tb 0: 1/1000
+0,          0,          0,        0,      120, ea3e0f807304b0eb2d3e329b0124f75c
+0,         33,         33,        0,      120, 8d13cf682d63e7eb13094f55d67fc458
+0,         66,         66,        0,      120, e729cc6c3684c94a8f6118c618efc3ea
+0,        100,        100,        0,      120, ac43a0ace8e4112e877c2491ecc14fb5
+0,        133,        133,        0,      120, 53695f90b88d8e8cb838f0faec3238d3
+0,        166,        166,        0,      120, 40afd1c4dfd4a2e3b31631c46d252bcc
+0,        200,        200,        0,      120, 2b656f76f2e84d2f82d9bda2b5be94d3
+0,        233,        233,        0,      120, b22f004d678d047bc401be5e040cf883
+0,        266,        266,        0,      120, 57c840319abfb9c31013fbde54de3fb0
+0,        300,        300,        0,      120, 0f3dfc156216d7cfb6fd1d8c77dadab9

tests/ref/fate/vp9-02-size-08x16

@@ -0,0 +1,11 @@
+#tb 0: 1/1000
+0,          0,          0,        0,      192, 0553e56a9d89aea496421885aab491f5
+0,         33,         33,        0,      192, b2a14cf676f7ebf3c50450050f76ad16
+0,         66,         66,        0,      192, a308d981e09b50571fb0c8ebdcefe505
+0,        100,        100,        0,      192, d592ec625a0ac0373e82610c3eed9864
+0,        133,        133,        0,      192, acd19642455e643023b4fb882c3891ba
+0,        166,        166,        0,      192, 5af5390fd8c29b795e0ddf83f3f34284
+0,        200,        200,        0,      192, 473505aa2a76231725cf2107d6c9dbef
+0,        233,        233,        0,      192, 84860db6887e320f2d64f80cf0032e57
+0,        266,        266,        0,      192, 408e9cf60e99ae99d204ff08f3196d1a
+0,        300,        300,        0,      192, d8af96b79258f9382e911ed38340bdf5

tests/ref/fate/vp9-02-size-08x18

@@ -0,0 +1,11 @@
+#tb 0: 1/1000
+0,          0,          0,        0,      216, 4c41f93b1b280b37bc77d7047435eaa4
+0,         33,         33,        0,      216, c9c80fdba2ebc2b8c3490ae35e34f84f
+0,         66,         66,        0,      216, 089d86acb3263fa5ef4f591a7f44556d
+0,        100,        100,        0,      216, 938fca6d93b83484144f5054e4838a41
+0,        133,        133,        0,      216, e0592e2ac9f5e09525ce0d3904cadf47
+0,        166,        166,        0,      216, ea43ff5d1330986e60c08567262ea764
+0,        200,        200,        0,      216, 08b40fe109ee90188f1cba9bbb1b376e
+0,        233,        233,        0,      216, b067068a2a7e36d5c5b5b405a1e73a18
+0,        266,        266,        0,      216, 9cf2d350296288803434b7451bd2be85
+0,        300,        300,        0,      216, 3c785e21dc228d6396738fbfcb470289

tests/ref/fate/vp9-02-size-08x32

@@ -0,0 +1,11 @@
+#tb 0: 1/1000
+0,          0,          0,        0,      384, f92a7777fd69aa2f2914d9a41c4828ba
+0,         33,         33,        0,      384, 62e1cc73487d2249a88a60e35a22d9c7
+0,         66,         66,        0,      384, aa2619b605cb65eda15fdd99d5775550
+0,        100,        100,        0,      384, e6f0a491c543b835d0cefe5ca62c3dbe
+0,        133,        133,        0,      384, 361be1a06913c398f09494ca1b2d288f
+0,        166,        166,        0,      384, 0497bf849a973357c0ccb8d43f5bd8b4
+0,        200,        200,        0,      384, 5ac6ac523147c409dd00820622161dd7
+0,        233,        233,        0,      384, 7d07245574a46c524360f09be29a5f19
+0,        266,        266,        0,      384, fcfa7fbcaf42f81e4e34a4ee5a029ca1
+0,        300,        300,        0,      384, 336e3fe4f15d3d6c82d82b1855dcfeb4

tests/ref/fate/vp9-02-size-08x34

@@ -0,0 +1,11 @@
+#tb 0: 1/1000
+0,          0,          0,        0,      408, f3f2cd8f157466ff23dace85d77367ce
+0,         33,         33,        0,      408, 639d9b70a14062e95559c12d2b597f91
+0,         66,         66,        0,      408, b2ee07a6656af583f19593229fa11848
+0,        100,        100,        0,      408, 74e3b5ab4c798a0afe745694e871bbd5
+0,        133,        133,        0,      408, 35f1c30d0f8678f319a392a6c53b5989
+0,        166,        166,        0,      408, 07e2b4c0b92a394bfb11124fe80476f0
+0,        200,        200,        0,      408, 7864bd20dfc5280e5f027d67ea22bf30
+0,        233,        233,        0,      408, 10a2925a7b91dfa9b82de76069388fd4
+0,        266,        266,        0,      408, 79cc7f7a149e8d6e04e065f75e63733c
+0,        300,        300,        0,      408, 6453d10d97532d9bb03f7c06cba9fca0

tests/ref/fate/vp9-02-size-08x64

@@ -0,0 +1,11 @@
+#tb 0: 1/1000
+0,          0,          0,        0,      768, 764bd02b781a38c621a109c12f3d9393
+0,         33,         33,        0,      768, 79496bd2b9212026af816b3b7a0587d5
+0,         66,         66,        0,      768, 2a3afd47ba3d075033fd94d5c3746c45
+0,        100,        100,        0,      768, fca00cad8d37a6646337baebadd0ca31
+0,        133,        133,        0,      768, aca376fb3f8a5ef670ecc2430037262a
+0,        166,        166,        0,      768, 7e6c8d96d1e24855c3e380f1bf2ce02c
+0,        200,        200,        0,      768, 09e051241972969d439f27f324d78490
+0,        233,        233,        0,      768, 2566b2a425caaba41305bf04ff10ea01
+0,        266,        266,        0,      768, db3995bedee42ada1b4ee63c339daf1b
+0,        300,        300,        0,      768, b00b8f1bf4fd907f0487738f5b5442c6

tests/ref/fate/vp9-02-size-08x66

@@ -0,0 +1,11 @@
+#tb 0: 1/1000
+0,          0,          0,        0,      792, df20e8df89449fe50bb610e95a449a95
+0,         33,         33,        0,      792, 18f1a66d463274d1b0489f3a50e86857
+0,         66,         66,        0,      792, b0cc102875a94c9a92e53826617adbe9
+0,        100,        100,        0,      792, dfece7c17b4b149283ef51bdc1bd440e
+0,        133,        133,        0,      792, 6e346884f67be259fcabe493109cb63c
+0,        166,        166,        0,      792, 6d282127311eb2d958377490d7cb77f0
+0,        200,        200,        0,      792, 637ac8b14ca5ddbaf7b8910406c3cd08
+0,        233,        233,        0,      792, e7980f3fcb36969da0d218c4389fa9e8
+0,        266,        266,        0,      792, 730a1c95b9fb165f6e1a2f33a0d25de0
+0,        300,        300,        0,      792, 7bd8424d0783b1c8ad617e17408371bb

tests/ref/fate/vp9-02-size-10x08

@@ -0,0 +1,11 @@
+#tb 0: 1/1000
+0,          0,          0,        0,      120, e1e66a88615da98523ef887f1463fc42
+0,         33,         33,        0,      120, 549842fa98c8faf572882d38b0aae390
+0,         66,         66,        0,      120, 17ee85785517705fdc78c6122a4b2548
+0,        100,        100,        0,      120, 1143391d419dac30a6c11f366157c974
+0,        133,        133,        0,      120, b62d2a962c4c36809ef75a610106715c
+0,        166,        166,        0,      120, e6f143ca33fbc0e776bb149950cdedff
+0,        200,        200,        0,      120, 01716a1077ec66df00474fd4510d2789
+0,        233,        233,        0,      120, 8cb5b6a865fa2cbb15f0d7736fda88a6
+0,        266,        266,        0,      120, 0fb9fd883e895a540fe1704dddbbab04
+0,        300,        300,        0,      120, 150a3b99aa24ef102c92f87c8adb4386

tests/ref/fate/vp9-02-size-10x10

@@ -0,0 +1,11 @@
+#tb 0: 1/1000
+0,          0,          0,        0,      150, 083d638f2e147295d817bb14fff5e4f4
+0,         33,         33,        0,      150, 6dbdc445b6fd6bb99f2025cc2a40977e
+0,         66,         66,        0,      150, 41714089383b181d64fbfa7de5904608
+0,        100,        100,        0,      150, 11fdb8465e1599f7a9227706646d2cba
+0,        133,        133,        0,      150, 907876b3342a10040db0851a936af4e3
+0,        166,        166,        0,      150, e7b18d47d06b25de205d873d3d941640
+0,        200,        200,        0,      150, 523ce7413c8da7f6a657a9b661f36c44
+0,        233,        233,        0,      150, 23caff863af875c66c903662a3e1e6a1
+0,        266,        266,        0,      150, ed4cc5557203e5b7a119112ee9ceb00b
+0,        300,        300,        0,      150, 4bb78a996be3188888d1c60e11a08e1b

tests/ref/fate/vp9-02-size-10x16

@@ -0,0 +1,11 @@
+#tb 0: 1/1000
+0,          0,          0,        0,      240, fab07d6209d2413e0a434e1aaaa12154
+0,         33,         33,        0,      240, f9ffffdb96f98527ba2e553d1265edbb
+0,         66,         66,        0,      240, 56a992264cf7da2b23dd97435e9d0365
+0,        100,        100,        0,      240, b1db980423d8004bd45a789b02b92a65
+0,        133,        133,        0,      240, b29496aedc7026566367b634f55ebb28
+0,        166,        166,        0,      240, 2bc9def672da4a2fc17cbd669e2b8081
+0,        200,        200,        0,      240, 8c54721514cdf577a52a8668b9135f13
+0,        233,        233,        0,      240, 2efab81d5e039d82b3bc7b0303b022c4
+0,        266,        266,        0,      240, bd0f42b91b5d126fd0baec765b1096ad
+0,        300,        300,        0,      240, c6bfea2735a629167bc6a7a7c76eb7f3