falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
84693 Commits
32 Branches
303MB
Tree: 37814a21cb
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '37814a21cb'
${ noResults }
FFmpeg/libavcodec/vp9.c

1673 lines
68KB
Raw Blame History 

  1. /*

  2.  * VP9 compatible video decoder

  3.  *

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

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

  6.  *

  7.  * This file is part of FFmpeg.

  8.  *

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

  10.  * modify it under the terms of the GNU Lesser General Public

  11.  * License as published by the Free Software Foundation; either

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

  13.  *

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

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

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

  17.  * Lesser General Public License for more details.

  18.  *

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

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

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

  22.  */

  23. 

  24. #include "avcodec.h"

  25. #include "get_bits.h"

  26. #include "internal.h"

  27. #include "profiles.h"

  28. #include "thread.h"

  29. #include "videodsp.h"

  30. #include "vp56.h"

  31. #include "vp9.h"

  32. #include "vp9data.h"

  33. #include "vp9.h"

  34. #include "libavutil/avassert.h"

  35. #include "libavutil/pixdesc.h"

  36. 

  37. #define VP9_SYNCCODE 0x498342

  38. 

  39. static void vp9_frame_unref(AVCodecContext *avctx, VP9Frame *f)

  40. {

  41.     ff_thread_release_buffer(avctx, &f->tf);

  42.     av_buffer_unref(&f->extradata);

  43.     av_buffer_unref(&f->hwaccel_priv_buf);

  44.     f->segmentation_map = NULL;

  45.     f->hwaccel_picture_private = NULL;

  46. }

  47. 

  48. static int vp9_frame_alloc(AVCodecContext *avctx, VP9Frame *f)

  49. {

  50.     VP9Context *s = avctx->priv_data;

  51.     int ret, sz;

  52. 

  53.     ret = ff_thread_get_buffer(avctx, &f->tf, AV_GET_BUFFER_FLAG_REF);

  54.     if (ret < 0)

  55.         return ret;

  56. 

  57.     sz = 64 * s->sb_cols * s->sb_rows;

  58.     f->extradata = av_buffer_allocz(sz * (1 + sizeof(VP9mvrefPair)));

  59.     if (!f->extradata) {

  60.         goto fail;

  61.     }

  62. 

  63.     f->segmentation_map = f->extradata->data;

  64.     f->mv = (VP9mvrefPair *) (f->extradata->data + sz);

  65. 

  66.     if (avctx->hwaccel) {

  67.         const AVHWAccel *hwaccel = avctx->hwaccel;

  68.         av_assert0(!f->hwaccel_picture_private);

  69.         if (hwaccel->frame_priv_data_size) {

  70.             f->hwaccel_priv_buf = av_buffer_allocz(hwaccel->frame_priv_data_size);

  71.             if (!f->hwaccel_priv_buf)

  72.                 goto fail;

  73.             f->hwaccel_picture_private = f->hwaccel_priv_buf->data;

  74.         }

  75.     }

  76. 

  77.     return 0;

  78. 

  79. fail:

  80.     vp9_frame_unref(avctx, f);

  81.     return AVERROR(ENOMEM);

  82. }

  83. 

  84. static int vp9_frame_ref(AVCodecContext *avctx, VP9Frame *dst, VP9Frame *src)

  85. {

  86.     int ret;

  87. 

  88.     ret = ff_thread_ref_frame(&dst->tf, &src->tf);

  89.     if (ret < 0)

  90.         return ret;

  91. 

  92.     dst->extradata = av_buffer_ref(src->extradata);

  93.     if (!dst->extradata)

  94.         goto fail;

  95. 

  96.     dst->segmentation_map = src->segmentation_map;

  97.     dst->mv = src->mv;

  98.     dst->uses_2pass = src->uses_2pass;

  99. 

  100.     if (src->hwaccel_picture_private) {

  101.         dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);

  102.         if (!dst->hwaccel_priv_buf)

  103.             goto fail;

  104.         dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;

  105.     }

  106. 

  107.     return 0;

  108. 

  109. fail:

  110.     vp9_frame_unref(avctx, dst);

  111.     return AVERROR(ENOMEM);

  112. }

  113. 

  114. static int update_size(AVCodecContext *avctx, int w, int h)

  115. {

  116. #define HWACCEL_MAX (CONFIG_VP9_DXVA2_HWACCEL + CONFIG_VP9_D3D11VA_HWACCEL + CONFIG_VP9_VAAPI_HWACCEL)

  117.     enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmtp = pix_fmts;

  118.     VP9Context *s = avctx->priv_data;

  119.     uint8_t *p;

  120.     int bytesperpixel = s->bytesperpixel, ret, cols, rows;

  121. 

  122.     av_assert0(w > 0 && h > 0);

  123. 

  124.     if (!(s->pix_fmt == s->gf_fmt && w == s->w && h == s->h)) {

  125.         if ((ret = ff_set_dimensions(avctx, w, h)) < 0)

  126.             return ret;

  127. 

  128.         switch (s->pix_fmt) {

  129.         case AV_PIX_FMT_YUV420P:

  130. #if CONFIG_VP9_DXVA2_HWACCEL

  131.             *fmtp++ = AV_PIX_FMT_DXVA2_VLD;

  132. #endif

  133. #if CONFIG_VP9_D3D11VA_HWACCEL

  134.             *fmtp++ = AV_PIX_FMT_D3D11VA_VLD;

  135. #endif

  136. #if CONFIG_VP9_VAAPI_HWACCEL

  137.             *fmtp++ = AV_PIX_FMT_VAAPI;

  138. #endif

  139.             break;

  140.         case AV_PIX_FMT_YUV420P10:

  141.         case AV_PIX_FMT_YUV420P12:

  142. #if CONFIG_VP9_VAAPI_HWACCEL

  143.             *fmtp++ = AV_PIX_FMT_VAAPI;

  144. #endif

  145.             break;

  146.         }

  147. 

  148.         *fmtp++ = s->pix_fmt;

  149.         *fmtp = AV_PIX_FMT_NONE;

  150. 

  151.         ret = ff_thread_get_format(avctx, pix_fmts);

  152.         if (ret < 0)

  153.             return ret;

  154. 

  155.         avctx->pix_fmt = ret;

  156.         s->gf_fmt  = s->pix_fmt;

  157.         s->w = w;

  158.         s->h = h;

  159.     }

  160. 

  161.     cols = (w + 7) >> 3;

  162.     rows = (h + 7) >> 3;

  163. 

  164.     if (s->intra_pred_data[0] && cols == s->cols && rows == s->rows && s->pix_fmt == s->last_fmt)

  165.         return 0;

  166. 

  167.     s->last_fmt  = s->pix_fmt;

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

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

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

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

  172. 

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

  174.     av_freep(&s->intra_pred_data[0]);

  175.     // FIXME we slightly over-allocate here for subsampled chroma, but a little

  176.     // bit of padding shouldn't affect performance...

  177.     p = av_malloc(s->sb_cols * (128 + 192 * bytesperpixel +

  178.                                 sizeof(*s->lflvl) + 16 * sizeof(*s->above_mv_ctx)));

  179.     if (!p)

  180.         return AVERROR(ENOMEM);

  181.     assign(s->intra_pred_data[0],  uint8_t *,             64 * bytesperpixel);

  182.     assign(s->intra_pred_data[1],  uint8_t *,             64 * bytesperpixel);

  183.     assign(s->intra_pred_data[2],  uint8_t *,             64 * bytesperpixel);

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

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

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

  187.     assign(s->above_uv_nnz_ctx[0], uint8_t *,             16);

  188.     assign(s->above_uv_nnz_ctx[1], uint8_t *,             16);

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

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

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

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

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

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

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

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

  197.     assign(s->lflvl,               VP9Filter *,            1);

  198. #undef assign

  199. 

  200.     // these will be re-allocated a little later

  201.     av_freep(&s->b_base);

  202.     av_freep(&s->block_base);

  203. 

  204.     if (s->s.h.bpp != s->last_bpp) {

  205.         ff_vp9dsp_init(&s->dsp, s->s.h.bpp, avctx->flags & AV_CODEC_FLAG_BITEXACT);

  206.         ff_videodsp_init(&s->vdsp, s->s.h.bpp);

  207.         s->last_bpp = s->s.h.bpp;

  208.     }

  209. 

  210.     return 0;

  211. }

  212. 

  213. static int update_block_buffers(AVCodecContext *avctx)

  214. {

  215.     VP9Context *s = avctx->priv_data;

  216.     int chroma_blocks, chroma_eobs, bytesperpixel = s->bytesperpixel;

  217. 

  218.     if (s->b_base && s->block_base && s->block_alloc_using_2pass == s->s.frames[CUR_FRAME].uses_2pass)

  219.         return 0;

  220. 

  221.     av_free(s->b_base);

  222.     av_free(s->block_base);

  223.     chroma_blocks = 64 * 64 >> (s->ss_h + s->ss_v);

  224.     chroma_eobs   = 16 * 16 >> (s->ss_h + s->ss_v);

  225.     if (s->s.frames[CUR_FRAME].uses_2pass) {

  226.         int sbs = s->sb_cols * s->sb_rows;

  227. 

  228.         s->b_base = av_malloc_array(s->cols * s->rows, sizeof(VP9Block));

  229.         s->block_base = av_mallocz(((64 * 64 + 2 * chroma_blocks) * bytesperpixel * sizeof(int16_t) +

  230.                                     16 * 16 + 2 * chroma_eobs) * sbs);

  231.         if (!s->b_base || !s->block_base)

  232.             return AVERROR(ENOMEM);

  233.         s->uvblock_base[0] = s->block_base + sbs * 64 * 64 * bytesperpixel;

  234.         s->uvblock_base[1] = s->uvblock_base[0] + sbs * chroma_blocks * bytesperpixel;

  235.         s->eob_base = (uint8_t *) (s->uvblock_base[1] + sbs * chroma_blocks * bytesperpixel);

  236.         s->uveob_base[0] = s->eob_base + 16 * 16 * sbs;

  237.         s->uveob_base[1] = s->uveob_base[0] + chroma_eobs * sbs;

  238.     } else {

  239.         s->b_base = av_malloc(sizeof(VP9Block));

  240.         s->block_base = av_mallocz((64 * 64 + 2 * chroma_blocks) * bytesperpixel * sizeof(int16_t) +

  241.                                    16 * 16 + 2 * chroma_eobs);

  242.         if (!s->b_base || !s->block_base)

  243.             return AVERROR(ENOMEM);

  244.         s->uvblock_base[0] = s->block_base + 64 * 64 * bytesperpixel;

  245.         s->uvblock_base[1] = s->uvblock_base[0] + chroma_blocks * bytesperpixel;

  246.         s->eob_base = (uint8_t *) (s->uvblock_base[1] + chroma_blocks * bytesperpixel);

  247.         s->uveob_base[0] = s->eob_base + 16 * 16;

  248.         s->uveob_base[1] = s->uveob_base[0] + chroma_eobs;

  249.     }

  250.     s->block_alloc_using_2pass = s->s.frames[CUR_FRAME].uses_2pass;

  251. 

  252.     return 0;

  253. }

  254. 

  255. // The sign bit is at the end, not the start, of a bit sequence

  256. static av_always_inline int get_sbits_inv(GetBitContext *gb, int n)

  257. {

  258.     int v = get_bits(gb, n);

  259.     return get_bits1(gb) ? -v : v;

  260. }

  261. 

  262. static av_always_inline int inv_recenter_nonneg(int v, int m)

  263. {

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

  265. }

  266. 

  267. // differential forward probability updates

  268. static int update_prob(VP56RangeCoder *c, int p)

  269. {

  270.     static const int inv_map_table[255] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  289.         252, 253, 253,

  290.     };

  291.     int d;

  292. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  307. 

  308.     if (!vp8_rac_get(c)) {

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

  310.     } else if (!vp8_rac_get(c)) {

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

  312.     } else if (!vp8_rac_get(c)) {

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

  314.     } else {

  315.         d = vp8_rac_get_uint(c, 7);

  316.         if (d >= 65)

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

  318.         d += 64;

  319.         av_assert2(d < FF_ARRAY_ELEMS(inv_map_table));

  320.     }

  321. 

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

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

  324. }

  325. 

  326. static int read_colorspace_details(AVCodecContext *avctx)

  327. {

  328.     static const enum AVColorSpace colorspaces[8] = {

  329.         AVCOL_SPC_UNSPECIFIED, AVCOL_SPC_BT470BG, AVCOL_SPC_BT709, AVCOL_SPC_SMPTE170M,

  330.         AVCOL_SPC_SMPTE240M, AVCOL_SPC_BT2020_NCL, AVCOL_SPC_RESERVED, AVCOL_SPC_RGB,

  331.     };

  332.     VP9Context *s = avctx->priv_data;

  333.     int bits = avctx->profile <= 1 ? 0 : 1 + get_bits1(&s->gb); // 0:8, 1:10, 2:12

  334. 

  335.     s->bpp_index = bits;

  336.     s->s.h.bpp = 8 + bits * 2;

  337.     s->bytesperpixel = (7 + s->s.h.bpp) >> 3;

  338.     avctx->colorspace = colorspaces[get_bits(&s->gb, 3)];

  339.     if (avctx->colorspace == AVCOL_SPC_RGB) { // RGB = profile 1

  340.         static const enum AVPixelFormat pix_fmt_rgb[3] = {

  341.             AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12

  342.         };

  343.         s->ss_h = s->ss_v = 0;

  344.         avctx->color_range = AVCOL_RANGE_JPEG;

  345.         s->pix_fmt = pix_fmt_rgb[bits];

  346.         if (avctx->profile & 1) {

  347.             if (get_bits1(&s->gb)) {

  348.                 av_log(avctx, AV_LOG_ERROR, "Reserved bit set in RGB\n");

  349.                 return AVERROR_INVALIDDATA;

  350.             }

  351.         } else {

  352.             av_log(avctx, AV_LOG_ERROR, "RGB not supported in profile %d\n",

  353.                    avctx->profile);

  354.             return AVERROR_INVALIDDATA;

  355.         }

  356.     } else {

  357.         static const enum AVPixelFormat pix_fmt_for_ss[3][2 /* v */][2 /* h */] = {

  358.             { { AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P },

  359.               { AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV420P } },

  360.             { { AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV422P10 },

  361.               { AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV420P10 } },

  362.             { { AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV422P12 },

  363.               { AV_PIX_FMT_YUV440P12, AV_PIX_FMT_YUV420P12 } }

  364.         };

  365.         avctx->color_range = get_bits1(&s->gb) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;

  366.         if (avctx->profile & 1) {

  367.             s->ss_h = get_bits1(&s->gb);

  368.             s->ss_v = get_bits1(&s->gb);

  369.             s->pix_fmt = pix_fmt_for_ss[bits][s->ss_v][s->ss_h];

  370.             if (s->pix_fmt == AV_PIX_FMT_YUV420P) {

  371.                 av_log(avctx, AV_LOG_ERROR, "YUV 4:2:0 not supported in profile %d\n",

  372.                        avctx->profile);

  373.                 return AVERROR_INVALIDDATA;

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

  375.                 av_log(avctx, AV_LOG_ERROR, "Profile %d color details reserved bit set\n",

  376.                        avctx->profile);

  377.                 return AVERROR_INVALIDDATA;

  378.             }

  379.         } else {

  380.             s->ss_h = s->ss_v = 1;

  381.             s->pix_fmt = pix_fmt_for_ss[bits][1][1];

  382.         }

  383.     }

  384. 

  385.     return 0;

  386. }

  387. 

  388. static int decode_frame_header(AVCodecContext *avctx,

  389.                                const uint8_t *data, int size, int *ref)

  390. {

  391.     VP9Context *s = avctx->priv_data;

  392.     int c, i, j, k, l, m, n, w, h, max, size2, ret, sharp;

  393.     int last_invisible;

  394.     const uint8_t *data2;

  395. 

  396.     /* general header */

  397.     if ((ret = init_get_bits8(&s->gb, data, size)) < 0) {

  398.         av_log(avctx, AV_LOG_ERROR, "Failed to initialize bitstream reader\n");

  399.         return ret;

  400.     }

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

  402.         av_log(avctx, AV_LOG_ERROR, "Invalid frame marker\n");

  403.         return AVERROR_INVALIDDATA;

  404.     }

  405.     avctx->profile  = get_bits1(&s->gb);

  406.     avctx->profile |= get_bits1(&s->gb) << 1;

  407.     if (avctx->profile == 3) avctx->profile += get_bits1(&s->gb);

  408.     if (avctx->profile > 3) {

  409.         av_log(avctx, AV_LOG_ERROR, "Profile %d is not yet supported\n", avctx->profile);

  410.         return AVERROR_INVALIDDATA;

  411.     }

  412.     s->s.h.profile = avctx->profile;

  413.     if (get_bits1(&s->gb)) {

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

  415.         return 0;

  416.     }

  417. 

  418.     s->last_keyframe  = s->s.h.keyframe;

  419.     s->s.h.keyframe   = !get_bits1(&s->gb);

  420. 

  421.     last_invisible   = s->s.h.invisible;

  422.     s->s.h.invisible = !get_bits1(&s->gb);

  423.     s->s.h.errorres  = get_bits1(&s->gb);

  424.     s->s.h.use_last_frame_mvs = !s->s.h.errorres && !last_invisible;

  425. 

  426.     if (s->s.h.keyframe) {

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

  428.             av_log(avctx, AV_LOG_ERROR, "Invalid sync code\n");

  429.             return AVERROR_INVALIDDATA;

  430.         }

  431.         if ((ret = read_colorspace_details(avctx)) < 0)

  432.             return ret;

  433.         // for profile 1, here follows the subsampling bits

  434.         s->s.h.refreshrefmask = 0xff;

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

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

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

  438.             skip_bits(&s->gb, 32);

  439.     } else {

  440.         s->s.h.intraonly = s->s.h.invisible ? get_bits1(&s->gb) : 0;

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

  442.         if (s->s.h.intraonly) {

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

  444.                 av_log(avctx, AV_LOG_ERROR, "Invalid sync code\n");

  445.                 return AVERROR_INVALIDDATA;

  446.             }

  447.             if (avctx->profile >= 1) {

  448.                 if ((ret = read_colorspace_details(avctx)) < 0)

  449.                     return ret;

  450.             } else {

  451.                 s->ss_h = s->ss_v = 1;

  452.                 s->s.h.bpp = 8;

  453.                 s->bpp_index = 0;

  454.                 s->bytesperpixel = 1;

  455.                 s->pix_fmt = AV_PIX_FMT_YUV420P;

  456.                 avctx->colorspace = AVCOL_SPC_BT470BG;

  457.                 avctx->color_range = AVCOL_RANGE_JPEG;

  458.             }

  459.             s->s.h.refreshrefmask = get_bits(&s->gb, 8);

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

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

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

  463.                 skip_bits(&s->gb, 32);

  464.         } else {

  465.             s->s.h.refreshrefmask = get_bits(&s->gb, 8);

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

  467.             s->s.h.signbias[0]    = get_bits1(&s->gb) && !s->s.h.errorres;

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

  469.             s->s.h.signbias[1]    = get_bits1(&s->gb) && !s->s.h.errorres;

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

  471.             s->s.h.signbias[2]    = get_bits1(&s->gb) && !s->s.h.errorres;

  472.             if (!s->s.refs[s->s.h.refidx[0]].f->buf[0] ||

  473.                 !s->s.refs[s->s.h.refidx[1]].f->buf[0] ||

  474.                 !s->s.refs[s->s.h.refidx[2]].f->buf[0]) {

  475.                 av_log(avctx, AV_LOG_ERROR, "Not all references are available\n");

  476.                 return AVERROR_INVALIDDATA;

  477.             }

  478.             if (get_bits1(&s->gb)) {

  479.                 w = s->s.refs[s->s.h.refidx[0]].f->width;

  480.                 h = s->s.refs[s->s.h.refidx[0]].f->height;

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

  482.                 w = s->s.refs[s->s.h.refidx[1]].f->width;

  483.                 h = s->s.refs[s->s.h.refidx[1]].f->height;

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

  485.                 w = s->s.refs[s->s.h.refidx[2]].f->width;

  486.                 h = s->s.refs[s->s.h.refidx[2]].f->height;

  487.             } else {

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

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

  490.             }

  491.             // Note that in this code, "CUR_FRAME" is actually before we

  492.             // have formally allocated a frame, and thus actually represents

  493.             // the _last_ frame

  494.             s->s.h.use_last_frame_mvs &= s->s.frames[CUR_FRAME].tf.f->width == w &&

  495.                                        s->s.frames[CUR_FRAME].tf.f->height == h;

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

  497.                 skip_bits(&s->gb, 32);

  498.             s->s.h.highprecisionmvs = get_bits1(&s->gb);

  499.             s->s.h.filtermode = get_bits1(&s->gb) ? FILTER_SWITCHABLE :

  500.                                                   get_bits(&s->gb, 2);

  501.             s->s.h.allowcompinter = s->s.h.signbias[0] != s->s.h.signbias[1] ||

  502.                                   s->s.h.signbias[0] != s->s.h.signbias[2];

  503.             if (s->s.h.allowcompinter) {

  504.                 if (s->s.h.signbias[0] == s->s.h.signbias[1]) {

  505.                     s->s.h.fixcompref    = 2;

  506.                     s->s.h.varcompref[0] = 0;

  507.                     s->s.h.varcompref[1] = 1;

  508.                 } else if (s->s.h.signbias[0] == s->s.h.signbias[2]) {

  509.                     s->s.h.fixcompref    = 1;

  510.                     s->s.h.varcompref[0] = 0;

  511.                     s->s.h.varcompref[1] = 2;

  512.                 } else {

  513.                     s->s.h.fixcompref    = 0;

  514.                     s->s.h.varcompref[0] = 1;

  515.                     s->s.h.varcompref[1] = 2;

  516.                 }

  517.             }

  518.         }

  519.     }

  520.     s->s.h.refreshctx   = s->s.h.errorres ? 0 : get_bits1(&s->gb);

  521.     s->s.h.parallelmode = s->s.h.errorres ? 1 : get_bits1(&s->gb);

  522.     s->s.h.framectxid   = c = get_bits(&s->gb, 2);

  523.     if (s->s.h.keyframe || s->s.h.intraonly)

  524.         s->s.h.framectxid = 0; // BUG: libvpx ignores this field in keyframes

  525. 

  526.     /* loopfilter header data */

  527.     if (s->s.h.keyframe || s->s.h.errorres || s->s.h.intraonly) {

  528.         // reset loopfilter defaults

  529.         s->s.h.lf_delta.ref[0] = 1;

  530.         s->s.h.lf_delta.ref[1] = 0;

  531.         s->s.h.lf_delta.ref[2] = -1;

  532.         s->s.h.lf_delta.ref[3] = -1;

  533.         s->s.h.lf_delta.mode[0] = 0;

  534.         s->s.h.lf_delta.mode[1] = 0;

  535.         memset(s->s.h.segmentation.feat, 0, sizeof(s->s.h.segmentation.feat));

  536.     }

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

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

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

  540.     // the old cache values since they are still valid

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

  542.         memset(s->filter_lut.lim_lut, 0, sizeof(s->filter_lut.lim_lut));

  543.     s->s.h.filter.sharpness = sharp;

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

  545.         if ((s->s.h.lf_delta.updated = get_bits1(&s->gb))) {

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

  547.                 if (get_bits1(&s->gb))

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

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

  550.                 if (get_bits1(&s->gb))

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

  552.         }

  553.     }

  554. 

  555.     /* quantization header data */

  556.     s->s.h.yac_qi      = get_bits(&s->gb, 8);

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

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

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

  560.     s->s.h.lossless    = s->s.h.yac_qi == 0 && s->s.h.ydc_qdelta == 0 &&

  561.                        s->s.h.uvdc_qdelta == 0 && s->s.h.uvac_qdelta == 0;

  562.     if (s->s.h.lossless)

  563.         avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;

  564. 

  565.     /* segmentation header info */

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

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

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

  569.                 s->s.h.segmentation.prob[i] = get_bits1(&s->gb) ?

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

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

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

  573.                     s->s.h.segmentation.pred_prob[i] = get_bits1(&s->gb) ?

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

  575.         }

  576. 

  577.         if (get_bits1(&s->gb)) {

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

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

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

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

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

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

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

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

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

  587.             }

  588.         }

  589.     }

  590. 

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

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

  593.         int qyac, qydc, quvac, quvdc, lflvl, sh;

  594. 

  595.         if (s->s.h.segmentation.enabled && s->s.h.segmentation.feat[i].q_enabled) {

  596.             if (s->s.h.segmentation.absolute_vals)

  597.                 qyac = av_clip_uintp2(s->s.h.segmentation.feat[i].q_val, 8);

  598.             else

  599.                 qyac = av_clip_uintp2(s->s.h.yac_qi + s->s.h.segmentation.feat[i].q_val, 8);

  600.         } else {

  601.             qyac  = s->s.h.yac_qi;

  602.         }

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

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

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

  606.         qyac  = av_clip_uintp2(qyac, 8);

  607. 

  608.         s->s.h.segmentation.feat[i].qmul[0][0] = ff_vp9_dc_qlookup[s->bpp_index][qydc];

  609.         s->s.h.segmentation.feat[i].qmul[0][1] = ff_vp9_ac_qlookup[s->bpp_index][qyac];

  610.         s->s.h.segmentation.feat[i].qmul[1][0] = ff_vp9_dc_qlookup[s->bpp_index][quvdc];

  611.         s->s.h.segmentation.feat[i].qmul[1][1] = ff_vp9_ac_qlookup[s->bpp_index][quvac];

  612. 

  613.         sh = s->s.h.filter.level >= 32;

  614.         if (s->s.h.segmentation.enabled && s->s.h.segmentation.feat[i].lf_enabled) {

  615.             if (s->s.h.segmentation.absolute_vals)

  616.                 lflvl = av_clip_uintp2(s->s.h.segmentation.feat[i].lf_val, 6);

  617.             else

  618.                 lflvl = av_clip_uintp2(s->s.h.filter.level + s->s.h.segmentation.feat[i].lf_val, 6);

  619.         } else {

  620.             lflvl  = s->s.h.filter.level;

  621.         }

  622.         if (s->s.h.lf_delta.enabled) {

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

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

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

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

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

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

  629.                                              s->s.h.lf_delta.mode[0]) * (1 << sh)), 6);

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

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

  632.                                              s->s.h.lf_delta.mode[1]) * (1 << sh)), 6);

  633.             }

  634.         } else {

  635.             memset(s->s.h.segmentation.feat[i].lflvl, lflvl,

  636.                    sizeof(s->s.h.segmentation.feat[i].lflvl));

  637.         }

  638.     }

  639. 

  640.     /* tiling info */

  641.     if ((ret = update_size(avctx, w, h)) < 0) {

  642.         av_log(avctx, AV_LOG_ERROR, "Failed to initialize decoder for %dx%d @ %d\n",

  643.                w, h, s->pix_fmt);

  644.         return ret;

  645.     }

  646.     for (s->s.h.tiling.log2_tile_cols = 0;

  647.          s->sb_cols > (64 << s->s.h.tiling.log2_tile_cols);

  648.          s->s.h.tiling.log2_tile_cols++) ;

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

  650.     max = FFMAX(0, max - 1);

  651.     while (max > s->s.h.tiling.log2_tile_cols) {

  652.         if (get_bits1(&s->gb))

  653.             s->s.h.tiling.log2_tile_cols++;

  654.         else

  655.             break;

  656.     }

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

  658.     s->s.h.tiling.tile_rows = 1 << s->s.h.tiling.log2_tile_rows;

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

  660.         s->s.h.tiling.tile_cols = 1 << s->s.h.tiling.log2_tile_cols;

  661.         s->c_b = av_fast_realloc(s->c_b, &s->c_b_size,

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

  663.         if (!s->c_b) {

  664.             av_log(avctx, AV_LOG_ERROR, "Ran out of memory during range coder init\n");

  665.             return AVERROR(ENOMEM);

  666.         }

  667.     }

  668. 

  669.     /* check reference frames */

  670.     if (!s->s.h.keyframe && !s->s.h.intraonly) {

  671.         for (i = 0; i < 3; i++) {

  672.             AVFrame *ref = s->s.refs[s->s.h.refidx[i]].f;

  673.             int refw = ref->width, refh = ref->height;

  674. 

  675.             if (ref->format != avctx->pix_fmt) {

  676.                 av_log(avctx, AV_LOG_ERROR,

  677.                        "Ref pixfmt (%s) did not match current frame (%s)",

  678.                        av_get_pix_fmt_name(ref->format),

  679.                        av_get_pix_fmt_name(avctx->pix_fmt));

  680.                 return AVERROR_INVALIDDATA;

  681.             } else if (refw == w && refh == h) {

  682.                 s->mvscale[i][0] = s->mvscale[i][1] = 0;

  683.             } else {

  684.                 if (w * 2 < refw || h * 2 < refh || w > 16 * refw || h > 16 * refh) {

  685.                     av_log(avctx, AV_LOG_ERROR,

  686.                            "Invalid ref frame dimensions %dx%d for frame size %dx%d\n",

  687.                            refw, refh, w, h);

  688.                     return AVERROR_INVALIDDATA;

  689.                 }

  690.                 s->mvscale[i][0] = (refw << 14) / w;

  691.                 s->mvscale[i][1] = (refh << 14) / h;

  692.                 s->mvstep[i][0] = 16 * s->mvscale[i][0] >> 14;

  693.                 s->mvstep[i][1] = 16 * s->mvscale[i][1] >> 14;

  694.             }

  695.         }

  696.     }

  697. 

  698.     if (s->s.h.keyframe || s->s.h.errorres || (s->s.h.intraonly && s->s.h.resetctx == 3)) {

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

  700.                            s->prob_ctx[3].p = ff_vp9_default_probs;

  701.         memcpy(s->prob_ctx[0].coef, ff_vp9_default_coef_probs,

  702.                sizeof(ff_vp9_default_coef_probs));

  703.         memcpy(s->prob_ctx[1].coef, ff_vp9_default_coef_probs,

  704.                sizeof(ff_vp9_default_coef_probs));

  705.         memcpy(s->prob_ctx[2].coef, ff_vp9_default_coef_probs,

  706.                sizeof(ff_vp9_default_coef_probs));

  707.         memcpy(s->prob_ctx[3].coef, ff_vp9_default_coef_probs,

  708.                sizeof(ff_vp9_default_coef_probs));

  709.     } else if (s->s.h.intraonly && s->s.h.resetctx == 2) {

  710.         s->prob_ctx[c].p = ff_vp9_default_probs;

  711.         memcpy(s->prob_ctx[c].coef, ff_vp9_default_coef_probs,

  712.                sizeof(ff_vp9_default_coef_probs));

  713.     }

  714. 

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

  716.     s->s.h.compressed_header_size = size2 = get_bits(&s->gb, 16);

  717.     s->s.h.uncompressed_header_size = (get_bits_count(&s->gb) + 7) / 8;

  718. 

  719.     data2 = align_get_bits(&s->gb);

  720.     if (size2 > size - (data2 - data)) {

  721.         av_log(avctx, AV_LOG_ERROR, "Invalid compressed header size\n");

  722.         return AVERROR_INVALIDDATA;

  723.     }

  724.     ret = ff_vp56_init_range_decoder(&s->c, data2, size2);

  725.     if (ret < 0)

  726.         return ret;

  727. 

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

  729.         av_log(avctx, AV_LOG_ERROR, "Marker bit was set\n");

  730.         return AVERROR_INVALIDDATA;

  731.     }

  732. 

  733.     if (s->s.h.keyframe || s->s.h.intraonly) {

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

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

  736.     } else {

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

  738.     }

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

  740.      * as explicit copies if the fw update is missing (and skip the copy upon

  741.      * fw update)? */

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

  743. 

  744.     // txfm updates

  745.     if (s->s.h.lossless) {

  746.         s->s.h.txfmmode = TX_4X4;

  747.     } else {

  748.         s->s.h.txfmmode = vp8_rac_get_uint(&s->c, 2);

  749.         if (s->s.h.txfmmode == 3)

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

  751. 

  752.         if (s->s.h.txfmmode == TX_SWITCHABLE) {

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

  754.                 if (vp56_rac_get_prob_branchy(&s->c, 252))

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

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

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

  758.                     if (vp56_rac_get_prob_branchy(&s->c, 252))

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

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

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

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

  763.                     if (vp56_rac_get_prob_branchy(&s->c, 252))

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

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

  766.         }

  767.     }

  768. 

  769.     // coef updates

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

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

  772.         if (vp8_rac_get(&s->c)) {

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

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

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

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

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

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

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

  780.                                 break;

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

  782.                                 if (vp56_rac_get_prob_branchy(&s->c, 252))

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

  784.                                 else

  785.                                     p[n] = r[n];

  786.                             }

  787.                             p[3] = 0;

  788.                         }

  789.         } else {

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

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

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

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

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

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

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

  797.                                 break;

  798.                             memcpy(p, r, 3);

  799.                             p[3] = 0;

  800.                         }

  801.         }

  802.         if (s->s.h.txfmmode == i)

  803.             break;

  804.     }

  805. 

  806.     // mode updates

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

  808.         if (vp56_rac_get_prob_branchy(&s->c, 252))

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

  810.     if (!s->s.h.keyframe && !s->s.h.intraonly) {

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

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

  813.                 if (vp56_rac_get_prob_branchy(&s->c, 252))

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

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

  816. 

  817.         if (s->s.h.filtermode == FILTER_SWITCHABLE)

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

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

  820.                     if (vp56_rac_get_prob_branchy(&s->c, 252))

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

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

  823. 

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

  825.             if (vp56_rac_get_prob_branchy(&s->c, 252))

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

  827. 

  828.         if (s->s.h.allowcompinter) {

  829.             s->s.h.comppredmode = vp8_rac_get(&s->c);

  830.             if (s->s.h.comppredmode)

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

  832.             if (s->s.h.comppredmode == PRED_SWITCHABLE)

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

  834.                     if (vp56_rac_get_prob_branchy(&s->c, 252))

  835.                         s->prob.p.comp[i] =

  836.                             update_prob(&s->c, s->prob.p.comp[i]);

  837.         } else {

  838.             s->s.h.comppredmode = PRED_SINGLEREF;

  839.         }

  840. 

  841.         if (s->s.h.comppredmode != PRED_COMPREF) {

  842.             for (i = 0; i < 5; i++) {

  843.                 if (vp56_rac_get_prob_branchy(&s->c, 252))

  844.                     s->prob.p.single_ref[i][0] =

  845.                         update_prob(&s->c, s->prob.p.single_ref[i][0]);

  846.                 if (vp56_rac_get_prob_branchy(&s->c, 252))

  847.                     s->prob.p.single_ref[i][1] =

  848.                         update_prob(&s->c, s->prob.p.single_ref[i][1]);

  849.             }

  850.         }

  851. 

  852.         if (s->s.h.comppredmode != PRED_SINGLEREF) {

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

  854.                 if (vp56_rac_get_prob_branchy(&s->c, 252))

  855.                     s->prob.p.comp_ref[i] =

  856.                         update_prob(&s->c, s->prob.p.comp_ref[i]);

  857.         }

  858. 

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

  860.             for (j = 0; j < 9; j++)

  861.                 if (vp56_rac_get_prob_branchy(&s->c, 252))

  862.                     s->prob.p.y_mode[i][j] =

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

  864. 

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

  866.             for (j = 0; j < 4; j++)

  867.                 for (k = 0; k < 3; k++)

  868.                     if (vp56_rac_get_prob_branchy(&s->c, 252))

  869.                         s->prob.p.partition[3 - i][j][k] =

  870.                             update_prob(&s->c,

  871.                                         s->prob.p.partition[3 - i][j][k]);

  872. 

  873.         // mv fields don't use the update_prob subexp model for some reason

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

  875.             if (vp56_rac_get_prob_branchy(&s->c, 252))

  876.                 s->prob.p.mv_joint[i] = (vp8_rac_get_uint(&s->c, 7) << 1) | 1;

  877. 

  878.         for (i = 0; i < 2; i++) {

  879.             if (vp56_rac_get_prob_branchy(&s->c, 252))

  880.                 s->prob.p.mv_comp[i].sign =

  881.                     (vp8_rac_get_uint(&s->c, 7) << 1) | 1;

  882. 

  883.             for (j = 0; j < 10; j++)

  884.                 if (vp56_rac_get_prob_branchy(&s->c, 252))

  885.                     s->prob.p.mv_comp[i].classes[j] =

  886.                         (vp8_rac_get_uint(&s->c, 7) << 1) | 1;

  887. 

  888.             if (vp56_rac_get_prob_branchy(&s->c, 252))

  889.                 s->prob.p.mv_comp[i].class0 =

  890.                     (vp8_rac_get_uint(&s->c, 7) << 1) | 1;

  891. 

  892.             for (j = 0; j < 10; j++)

  893.                 if (vp56_rac_get_prob_branchy(&s->c, 252))

  894.                     s->prob.p.mv_comp[i].bits[j] =

  895.                         (vp8_rac_get_uint(&s->c, 7) << 1) | 1;

  896.         }

  897. 

  898.         for (i = 0; i < 2; i++) {

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

  900.                 for (k = 0; k < 3; k++)

  901.                     if (vp56_rac_get_prob_branchy(&s->c, 252))

  902.                         s->prob.p.mv_comp[i].class0_fp[j][k] =

  903.                             (vp8_rac_get_uint(&s->c, 7) << 1) | 1;

  904. 

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

  906.                 if (vp56_rac_get_prob_branchy(&s->c, 252))

  907.                     s->prob.p.mv_comp[i].fp[j] =

  908.                         (vp8_rac_get_uint(&s->c, 7) << 1) | 1;

  909.         }

  910. 

  911.         if (s->s.h.highprecisionmvs) {

  912.             for (i = 0; i < 2; i++) {

  913.                 if (vp56_rac_get_prob_branchy(&s->c, 252))

  914.                     s->prob.p.mv_comp[i].class0_hp =

  915.                         (vp8_rac_get_uint(&s->c, 7) << 1) | 1;

  916. 

  917.                 if (vp56_rac_get_prob_branchy(&s->c, 252))

  918.                     s->prob.p.mv_comp[i].hp =

  919.                         (vp8_rac_get_uint(&s->c, 7) << 1) | 1;

  920.             }

  921.         }

  922.     }

  923. 

  924.     return (data2 - data) + size2;

  925. }

  926. 

  927. static void decode_sb(AVCodecContext *avctx, int row, int col, VP9Filter *lflvl,

  928.                       ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)

  929. {

  930.     VP9Context *s = avctx->priv_data;

  931.     int c = ((s->above_partition_ctx[col] >> (3 - bl)) & 1) |

  932.             (((s->left_partition_ctx[row & 0x7] >> (3 - bl)) & 1) << 1);

  933.     const uint8_t *p = s->s.h.keyframe || s->s.h.intraonly ? ff_vp9_default_kf_partition_probs[bl][c] :

  934.                                                      s->prob.p.partition[bl][c];

  935.     enum BlockPartition bp;

  936.     ptrdiff_t hbs = 4 >> bl;

  937.     AVFrame *f = s->s.frames[CUR_FRAME].tf.f;

  938.     ptrdiff_t y_stride = f->linesize[0], uv_stride = f->linesize[1];

  939.     int bytesperpixel = s->bytesperpixel;

  940. 

  941.     if (bl == BL_8X8) {

  942.         bp = vp8_rac_get_tree(&s->c, ff_vp9_partition_tree, p);

  943.         ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, bl, bp);

  944.     } else if (col + hbs < s->cols) { // FIXME why not <=?

  945.         if (row + hbs < s->rows) { // FIXME why not <=?

  946.             bp = vp8_rac_get_tree(&s->c, ff_vp9_partition_tree, p);

  947.             switch (bp) {

  948.             case PARTITION_NONE:

  949.                 ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, bl, bp);

  950.                 break;

  951.             case PARTITION_H:

  952.                 ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, bl, bp);

  953.                 yoff  += hbs * 8 * y_stride;

  954.                 uvoff += hbs * 8 * uv_stride >> s->ss_v;

  955.                 ff_vp9_decode_block(avctx, row + hbs, col, lflvl, yoff, uvoff, bl, bp);

  956.                 break;

  957.             case PARTITION_V:

  958.                 ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, bl, bp);

  959.                 yoff  += hbs * 8 * bytesperpixel;

  960.                 uvoff += hbs * 8 * bytesperpixel >> s->ss_h;

  961.                 ff_vp9_decode_block(avctx, row, col + hbs, lflvl, yoff, uvoff, bl, bp);

  962.                 break;

  963.             case PARTITION_SPLIT:

  964.                 decode_sb(avctx, row, col, lflvl, yoff, uvoff, bl + 1);

  965.                 decode_sb(avctx, row, col + hbs, lflvl,

  966.                           yoff + 8 * hbs * bytesperpixel,

  967.                           uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);

  968.                 yoff  += hbs * 8 * y_stride;

  969.                 uvoff += hbs * 8 * uv_stride >> s->ss_v;

  970.                 decode_sb(avctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);

  971.                 decode_sb(avctx, row + hbs, col + hbs, lflvl,

  972.                           yoff + 8 * hbs * bytesperpixel,

  973.                           uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);

  974.                 break;

  975.             default:

  976.                 av_assert0(0);

  977.             }

  978.         } else if (vp56_rac_get_prob_branchy(&s->c, p[1])) {

  979.             bp = PARTITION_SPLIT;

  980.             decode_sb(avctx, row, col, lflvl, yoff, uvoff, bl + 1);

  981.             decode_sb(avctx, row, col + hbs, lflvl,

  982.                       yoff + 8 * hbs * bytesperpixel,

  983.                       uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);

  984.         } else {

  985.             bp = PARTITION_H;

  986.             ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, bl, bp);

  987.         }

  988.     } else if (row + hbs < s->rows) { // FIXME why not <=?

  989.         if (vp56_rac_get_prob_branchy(&s->c, p[2])) {

  990.             bp = PARTITION_SPLIT;

  991.             decode_sb(avctx, row, col, lflvl, yoff, uvoff, bl + 1);

  992.             yoff  += hbs * 8 * y_stride;

  993.             uvoff += hbs * 8 * uv_stride >> s->ss_v;

  994.             decode_sb(avctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);

  995.         } else {

  996.             bp = PARTITION_V;

  997.             ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, bl, bp);

  998.         }

  999.     } else {

  1000.         bp = PARTITION_SPLIT;

  1001.         decode_sb(avctx, row, col, lflvl, yoff, uvoff, bl + 1);

  1002.     }

  1003.     s->counts.partition[bl][c][bp]++;

  1004. }

  1005. 

  1006. static void decode_sb_mem(AVCodecContext *avctx, int row, int col, VP9Filter *lflvl,

  1007.                           ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)

  1008. {

  1009.     VP9Context *s = avctx->priv_data;

  1010.     VP9Block *b = s->b;

  1011.     ptrdiff_t hbs = 4 >> bl;

  1012.     AVFrame *f = s->s.frames[CUR_FRAME].tf.f;

  1013.     ptrdiff_t y_stride = f->linesize[0], uv_stride = f->linesize[1];

  1014.     int bytesperpixel = s->bytesperpixel;

  1015. 

  1016.     if (bl == BL_8X8) {

  1017.         av_assert2(b->bl == BL_8X8);

  1018.         ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, b->bl, b->bp);

  1019.     } else if (s->b->bl == bl) {

  1020.         ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, b->bl, b->bp);

  1021.         if (b->bp == PARTITION_H && row + hbs < s->rows) {

  1022.             yoff  += hbs * 8 * y_stride;

  1023.             uvoff += hbs * 8 * uv_stride >> s->ss_v;

  1024.             ff_vp9_decode_block(avctx, row + hbs, col, lflvl, yoff, uvoff, b->bl, b->bp);

  1025.         } else if (b->bp == PARTITION_V && col + hbs < s->cols) {

  1026.             yoff  += hbs * 8 * bytesperpixel;

  1027.             uvoff += hbs * 8 * bytesperpixel >> s->ss_h;

  1028.             ff_vp9_decode_block(avctx, row, col + hbs, lflvl, yoff, uvoff, b->bl, b->bp);

  1029.         }

  1030.     } else {

  1031.         decode_sb_mem(avctx, row, col, lflvl, yoff, uvoff, bl + 1);

  1032.         if (col + hbs < s->cols) { // FIXME why not <=?

  1033.             if (row + hbs < s->rows) {

  1034.                 decode_sb_mem(avctx, row, col + hbs, lflvl, yoff + 8 * hbs * bytesperpixel,

  1035.                               uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);

  1036.                 yoff  += hbs * 8 * y_stride;

  1037.                 uvoff += hbs * 8 * uv_stride >> s->ss_v;

  1038.                 decode_sb_mem(avctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);

  1039.                 decode_sb_mem(avctx, row + hbs, col + hbs, lflvl,

  1040.                               yoff + 8 * hbs * bytesperpixel,

  1041.                               uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);

  1042.             } else {

  1043.                 yoff  += hbs * 8 * bytesperpixel;

  1044.                 uvoff += hbs * 8 * bytesperpixel >> s->ss_h;

  1045.                 decode_sb_mem(avctx, row, col + hbs, lflvl, yoff, uvoff, bl + 1);

  1046.             }

  1047.         } else if (row + hbs < s->rows) {

  1048.             yoff  += hbs * 8 * y_stride;

  1049.             uvoff += hbs * 8 * uv_stride >> s->ss_v;

  1050.             decode_sb_mem(avctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);

  1051.         }

  1052.     }

  1053. }

  1054. 

  1055. static av_always_inline void filter_plane_cols(VP9Context *s, int col, int ss_h, int ss_v,

  1056.                                                uint8_t *lvl, uint8_t (*mask)[4],

  1057.                                                uint8_t *dst, ptrdiff_t ls)

  1058. {

  1059.     int y, x, bytesperpixel = s->bytesperpixel;

  1060. 

  1061.     // filter edges between columns (e.g. block1 | block2)

  1062.     for (y = 0; y < 8; y += 2 << ss_v, dst += 16 * ls, lvl += 16 << ss_v) {

  1063.         uint8_t *ptr = dst, *l = lvl, *hmask1 = mask[y], *hmask2 = mask[y + 1 + ss_v];

  1064.         unsigned hm1 = hmask1[0] | hmask1[1] | hmask1[2], hm13 = hmask1[3];

  1065.         unsigned hm2 = hmask2[1] | hmask2[2], hm23 = hmask2[3];

  1066.         unsigned hm = hm1 | hm2 | hm13 | hm23;

  1067. 

  1068.         for (x = 1; hm & ~(x - 1); x <<= 1, ptr += 8 * bytesperpixel >> ss_h) {

  1069.             if (col || x > 1) {

  1070.                 if (hm1 & x) {

  1071.                     int L = *l, H = L >> 4;

  1072.                     int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];

  1073. 

  1074.                     if (hmask1[0] & x) {

  1075.                         if (hmask2[0] & x) {

  1076.                             av_assert2(l[8 << ss_v] == L);

  1077.                             s->dsp.loop_filter_16[0](ptr, ls, E, I, H);

  1078.                         } else {

  1079.                             s->dsp.loop_filter_8[2][0](ptr, ls, E, I, H);

  1080.                         }

  1081.                     } else if (hm2 & x) {

  1082.                         L = l[8 << ss_v];

  1083.                         H |= (L >> 4) << 8;

  1084.                         E |= s->filter_lut.mblim_lut[L] << 8;

  1085.                         I |= s->filter_lut.lim_lut[L] << 8;

  1086.                         s->dsp.loop_filter_mix2[!!(hmask1[1] & x)]

  1087.                                                [!!(hmask2[1] & x)]

  1088.                                                [0](ptr, ls, E, I, H);

  1089.                     } else {

  1090.                         s->dsp.loop_filter_8[!!(hmask1[1] & x)]

  1091.                                             [0](ptr, ls, E, I, H);

  1092.                     }

  1093.                 } else if (hm2 & x) {

  1094.                     int L = l[8 << ss_v], H = L >> 4;

  1095.                     int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];

  1096. 

  1097.                     s->dsp.loop_filter_8[!!(hmask2[1] & x)]

  1098.                                         [0](ptr + 8 * ls, ls, E, I, H);

  1099.                 }

  1100.             }

  1101.             if (ss_h) {

  1102.                 if (x & 0xAA)

  1103.                     l += 2;

  1104.             } else {

  1105.                 if (hm13 & x) {

  1106.                     int L = *l, H = L >> 4;

  1107.                     int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];

  1108. 

  1109.                     if (hm23 & x) {

  1110.                         L = l[8 << ss_v];

  1111.                         H |= (L >> 4) << 8;

  1112.                         E |= s->filter_lut.mblim_lut[L] << 8;

  1113.                         I |= s->filter_lut.lim_lut[L] << 8;

  1114.                         s->dsp.loop_filter_mix2[0][0][0](ptr + 4 * bytesperpixel, ls, E, I, H);

  1115.                     } else {

  1116.                         s->dsp.loop_filter_8[0][0](ptr + 4 * bytesperpixel, ls, E, I, H);

  1117.                     }

  1118.                 } else if (hm23 & x) {

  1119.                     int L = l[8 << ss_v], H = L >> 4;

  1120.                     int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];

  1121. 

  1122.                     s->dsp.loop_filter_8[0][0](ptr + 8 * ls + 4 * bytesperpixel, ls, E, I, H);

  1123.                 }

  1124.                 l++;

  1125.             }

  1126.         }

  1127.     }

  1128. }

  1129. 

  1130. static av_always_inline void filter_plane_rows(VP9Context *s, int row, int ss_h, int ss_v,

  1131.                                                uint8_t *lvl, uint8_t (*mask)[4],

  1132.                                                uint8_t *dst, ptrdiff_t ls)

  1133. {

  1134.     int y, x, bytesperpixel = s->bytesperpixel;

  1135. 

  1136.     //                                 block1

  1137.     // filter edges between rows (e.g. ------)

  1138.     //                                 block2

  1139.     for (y = 0; y < 8; y++, dst += 8 * ls >> ss_v) {

  1140.         uint8_t *ptr = dst, *l = lvl, *vmask = mask[y];

  1141.         unsigned vm = vmask[0] | vmask[1] | vmask[2], vm3 = vmask[3];

  1142. 

  1143.         for (x = 1; vm & ~(x - 1); x <<= (2 << ss_h), ptr += 16 * bytesperpixel, l += 2 << ss_h) {

  1144.             if (row || y) {

  1145.                 if (vm & x) {

  1146.                     int L = *l, H = L >> 4;

  1147.                     int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];

  1148. 

  1149.                     if (vmask[0] & x) {

  1150.                         if (vmask[0] & (x << (1 + ss_h))) {

  1151.                             av_assert2(l[1 + ss_h] == L);

  1152.                             s->dsp.loop_filter_16[1](ptr, ls, E, I, H);

  1153.                         } else {

  1154.                             s->dsp.loop_filter_8[2][1](ptr, ls, E, I, H);

  1155.                         }

  1156.                     } else if (vm & (x << (1 + ss_h))) {

  1157.                         L = l[1 + ss_h];

  1158.                         H |= (L >> 4) << 8;

  1159.                         E |= s->filter_lut.mblim_lut[L] << 8;

  1160.                         I |= s->filter_lut.lim_lut[L] << 8;

  1161.                         s->dsp.loop_filter_mix2[!!(vmask[1] &  x)]

  1162.                                                [!!(vmask[1] & (x << (1 + ss_h)))]

  1163.                                                [1](ptr, ls, E, I, H);

  1164.                     } else {

  1165.                         s->dsp.loop_filter_8[!!(vmask[1] & x)]

  1166.                                             [1](ptr, ls, E, I, H);

  1167.                     }

  1168.                 } else if (vm & (x << (1 + ss_h))) {

  1169.                     int L = l[1 + ss_h], H = L >> 4;

  1170.                     int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];

  1171. 

  1172.                     s->dsp.loop_filter_8[!!(vmask[1] & (x << (1 + ss_h)))]

  1173.                                         [1](ptr + 8 * bytesperpixel, ls, E, I, H);

  1174.                 }

  1175.             }

  1176.             if (!ss_v) {

  1177.                 if (vm3 & x) {

  1178.                     int L = *l, H = L >> 4;

  1179.                     int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];

  1180. 

  1181.                     if (vm3 & (x << (1 + ss_h))) {

  1182.                         L = l[1 + ss_h];

  1183.                         H |= (L >> 4) << 8;

  1184.                         E |= s->filter_lut.mblim_lut[L] << 8;

  1185.                         I |= s->filter_lut.lim_lut[L] << 8;

  1186.                         s->dsp.loop_filter_mix2[0][0][1](ptr + ls * 4, ls, E, I, H);

  1187.                     } else {

  1188.                         s->dsp.loop_filter_8[0][1](ptr + ls * 4, ls, E, I, H);

  1189.                     }

  1190.                 } else if (vm3 & (x << (1 + ss_h))) {

  1191.                     int L = l[1 + ss_h], H = L >> 4;

  1192.                     int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];

  1193. 

  1194.                     s->dsp.loop_filter_8[0][1](ptr + ls * 4 + 8 * bytesperpixel, ls, E, I, H);

  1195.                 }

  1196.             }

  1197.         }

  1198.         if (ss_v) {

  1199.             if (y & 1)

  1200.                 lvl += 16;

  1201.         } else {

  1202.             lvl += 8;

  1203.         }

  1204.     }

  1205. }

  1206. 

  1207. static void loopfilter_sb(AVCodecContext *avctx, VP9Filter *lflvl,

  1208.                           int row, int col, ptrdiff_t yoff, ptrdiff_t uvoff)

  1209. {

  1210.     VP9Context *s = avctx->priv_data;

  1211.     AVFrame *f = s->s.frames[CUR_FRAME].tf.f;

  1212.     uint8_t *dst = f->data[0] + yoff;

  1213.     ptrdiff_t ls_y = f->linesize[0], ls_uv = f->linesize[1];

  1214.     uint8_t (*uv_masks)[8][4] = lflvl->mask[s->ss_h | s->ss_v];

  1215.     int p;

  1216. 

  1217.     /* FIXME: In how far can we interleave the v/h loopfilter calls? E.g.

  1218.      * if you think of them as acting on a 8x8 block max, we can interleave

  1219.      * each v/h within the single x loop, but that only works if we work on

  1220.      * 8 pixel blocks, and we won't always do that (we want at least 16px

  1221.      * to use SSE2 optimizations, perhaps 32 for AVX2) */

  1222. 

  1223.     filter_plane_cols(s, col, 0, 0, lflvl->level, lflvl->mask[0][0], dst, ls_y);

  1224.     filter_plane_rows(s, row, 0, 0, lflvl->level, lflvl->mask[0][1], dst, ls_y);

  1225. 

  1226.     for (p = 0; p < 2; p++) {

  1227.         dst = f->data[1 + p] + uvoff;

  1228.         filter_plane_cols(s, col, s->ss_h, s->ss_v, lflvl->level, uv_masks[0], dst, ls_uv);

  1229.         filter_plane_rows(s, row, s->ss_h, s->ss_v, lflvl->level, uv_masks[1], dst, ls_uv);

  1230.     }

  1231. }

  1232. 

  1233. static void set_tile_offset(int *start, int *end, int idx, int log2_n, int n)

  1234. {

  1235.     int sb_start = ( idx      * n) >> log2_n;

  1236.     int sb_end   = ((idx + 1) * n) >> log2_n;

  1237.     *start = FFMIN(sb_start, n) << 3;

  1238.     *end   = FFMIN(sb_end,   n) << 3;

  1239. }

  1240. 

  1241. static void free_buffers(VP9Context *s)

  1242. {

  1243.     av_freep(&s->intra_pred_data[0]);

  1244.     av_freep(&s->b_base);

  1245.     av_freep(&s->block_base);

  1246. }

  1247. 

  1248. static av_cold int vp9_decode_free(AVCodecContext *avctx)

  1249. {

  1250.     VP9Context *s = avctx->priv_data;

  1251.     int i;

  1252. 

  1253.     for (i = 0; i < 3; i++) {

  1254.         if (s->s.frames[i].tf.f->buf[0])

  1255.             vp9_frame_unref(avctx, &s->s.frames[i]);

  1256.         av_frame_free(&s->s.frames[i].tf.f);

  1257.     }

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

  1259.         if (s->s.refs[i].f->buf[0])

  1260.             ff_thread_release_buffer(avctx, &s->s.refs[i]);

  1261.         av_frame_free(&s->s.refs[i].f);

  1262.         if (s->next_refs[i].f->buf[0])

  1263.             ff_thread_release_buffer(avctx, &s->next_refs[i]);

  1264.         av_frame_free(&s->next_refs[i].f);

  1265.     }

  1266.     free_buffers(s);

  1267.     av_freep(&s->c_b);

  1268.     s->c_b_size = 0;

  1269. 

  1270.     return 0;

  1271. }

  1272. 

  1273. 

  1274. static int vp9_decode_frame(AVCodecContext *avctx, void *frame,

  1275.                             int *got_frame, AVPacket *pkt)

  1276. {

  1277.     const uint8_t *data = pkt->data;

  1278.     int size = pkt->size;

  1279.     VP9Context *s = avctx->priv_data;

  1280.     int ret, tile_row, tile_col, i, ref, row, col;

  1281.     int retain_segmap_ref = s->s.frames[REF_FRAME_SEGMAP].segmentation_map &&

  1282.                             (!s->s.h.segmentation.enabled || !s->s.h.segmentation.update_map);

  1283.     ptrdiff_t yoff, uvoff, ls_y, ls_uv;

  1284.     AVFrame *f;

  1285.     int bytesperpixel;

  1286. 

  1287.     if ((ret = decode_frame_header(avctx, data, size, &ref)) < 0) {

  1288.         return ret;

  1289.     } else if (ret == 0) {

  1290.         if (!s->s.refs[ref].f->buf[0]) {

  1291.             av_log(avctx, AV_LOG_ERROR, "Requested reference %d not available\n", ref);

  1292.             return AVERROR_INVALIDDATA;

  1293.         }

  1294.         if ((ret = av_frame_ref(frame, s->s.refs[ref].f)) < 0)

  1295.             return ret;

  1296.         ((AVFrame *)frame)->pts = pkt->pts;

  1297. #if FF_API_PKT_PTS

  1298. FF_DISABLE_DEPRECATION_WARNINGS

  1299.         ((AVFrame *)frame)->pkt_pts = pkt->pts;

  1300. FF_ENABLE_DEPRECATION_WARNINGS

  1301. #endif

  1302.         ((AVFrame *)frame)->pkt_dts = pkt->dts;

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

  1304.             if (s->next_refs[i].f->buf[0])

  1305.                 ff_thread_release_buffer(avctx, &s->next_refs[i]);

  1306.             if (s->s.refs[i].f->buf[0] &&

  1307.                 (ret = ff_thread_ref_frame(&s->next_refs[i], &s->s.refs[i])) < 0)

  1308.                 return ret;

  1309.         }

  1310.         *got_frame = 1;

  1311.         return pkt->size;

  1312.     }

  1313.     data += ret;

  1314.     size -= ret;

  1315. 

  1316.     if (!retain_segmap_ref || s->s.h.keyframe || s->s.h.intraonly) {

  1317.         if (s->s.frames[REF_FRAME_SEGMAP].tf.f->buf[0])

  1318.             vp9_frame_unref(avctx, &s->s.frames[REF_FRAME_SEGMAP]);

  1319.         if (!s->s.h.keyframe && !s->s.h.intraonly && !s->s.h.errorres && s->s.frames[CUR_FRAME].tf.f->buf[0] &&

  1320.             (ret = vp9_frame_ref(avctx, &s->s.frames[REF_FRAME_SEGMAP], &s->s.frames[CUR_FRAME])) < 0)

  1321.             return ret;

  1322.     }

  1323.     if (s->s.frames[REF_FRAME_MVPAIR].tf.f->buf[0])

  1324.         vp9_frame_unref(avctx, &s->s.frames[REF_FRAME_MVPAIR]);

  1325.     if (!s->s.h.intraonly && !s->s.h.keyframe && !s->s.h.errorres && s->s.frames[CUR_FRAME].tf.f->buf[0] &&

  1326.         (ret = vp9_frame_ref(avctx, &s->s.frames[REF_FRAME_MVPAIR], &s->s.frames[CUR_FRAME])) < 0)

  1327.         return ret;

  1328.     if (s->s.frames[CUR_FRAME].tf.f->buf[0])

  1329.         vp9_frame_unref(avctx, &s->s.frames[CUR_FRAME]);

  1330.     if ((ret = vp9_frame_alloc(avctx, &s->s.frames[CUR_FRAME])) < 0)

  1331.         return ret;

  1332.     f = s->s.frames[CUR_FRAME].tf.f;

  1333.     f->key_frame = s->s.h.keyframe;

  1334.     f->pict_type = (s->s.h.keyframe || s->s.h.intraonly) ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;

  1335.     ls_y = f->linesize[0];

  1336.     ls_uv =f->linesize[1];

  1337. 

  1338.     if (s->s.frames[REF_FRAME_SEGMAP].tf.f->buf[0] &&

  1339.         (s->s.frames[REF_FRAME_MVPAIR].tf.f->width  != s->s.frames[CUR_FRAME].tf.f->width ||

  1340.          s->s.frames[REF_FRAME_MVPAIR].tf.f->height != s->s.frames[CUR_FRAME].tf.f->height)) {

  1341.         vp9_frame_unref(avctx, &s->s.frames[REF_FRAME_SEGMAP]);

  1342.     }

  1343. 

  1344.     // ref frame setup

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

  1346.         if (s->next_refs[i].f->buf[0])

  1347.             ff_thread_release_buffer(avctx, &s->next_refs[i]);

  1348.         if (s->s.h.refreshrefmask & (1 << i)) {

  1349.             ret = ff_thread_ref_frame(&s->next_refs[i], &s->s.frames[CUR_FRAME].tf);

  1350.         } else if (s->s.refs[i].f->buf[0]) {

  1351.             ret = ff_thread_ref_frame(&s->next_refs[i], &s->s.refs[i]);

  1352.         }

  1353.         if (ret < 0)

  1354.             return ret;

  1355.     }

  1356. 

  1357.     if (avctx->hwaccel) {

  1358.         ret = avctx->hwaccel->start_frame(avctx, NULL, 0);

  1359.         if (ret < 0)

  1360.             return ret;

  1361.         ret = avctx->hwaccel->decode_slice(avctx, pkt->data, pkt->size);

  1362.         if (ret < 0)

  1363.             return ret;

  1364.         ret = avctx->hwaccel->end_frame(avctx);

  1365.         if (ret < 0)

  1366.             return ret;

  1367.         goto finish;

  1368.     }

  1369. 

  1370.     // main tile decode loop

  1371.     bytesperpixel = s->bytesperpixel;

  1372.     memset(s->above_partition_ctx, 0, s->cols);

  1373.     memset(s->above_skip_ctx, 0, s->cols);

  1374.     if (s->s.h.keyframe || s->s.h.intraonly) {

  1375.         memset(s->above_mode_ctx, DC_PRED, s->cols * 2);

  1376.     } else {

  1377.         memset(s->above_mode_ctx, NEARESTMV, s->cols);

  1378.     }

  1379.     memset(s->above_y_nnz_ctx, 0, s->sb_cols * 16);

  1380.     memset(s->above_uv_nnz_ctx[0], 0, s->sb_cols * 16 >> s->ss_h);

  1381.     memset(s->above_uv_nnz_ctx[1], 0, s->sb_cols * 16 >> s->ss_h);

  1382.     memset(s->above_segpred_ctx, 0, s->cols);

  1383.     s->pass = s->s.frames[CUR_FRAME].uses_2pass =

  1384.         avctx->active_thread_type == FF_THREAD_FRAME && s->s.h.refreshctx && !s->s.h.parallelmode;

  1385.     if ((ret = update_block_buffers(avctx)) < 0) {

  1386.         av_log(avctx, AV_LOG_ERROR,

  1387.                "Failed to allocate block buffers\n");

  1388.         return ret;

  1389.     }

  1390.     if (s->s.h.refreshctx && s->s.h.parallelmode) {

  1391.         int j, k, l, m;

  1392. 

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

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

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

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

  1397.                         for (m = 0; m < 6; m++)

  1398.                             memcpy(s->prob_ctx[s->s.h.framectxid].coef[i][j][k][l][m],

  1399.                                    s->prob.coef[i][j][k][l][m], 3);

  1400.             if (s->s.h.txfmmode == i)

  1401.                 break;

  1402.         }

  1403.         s->prob_ctx[s->s.h.framectxid].p = s->prob.p;

  1404.         ff_thread_finish_setup(avctx);

  1405.     } else if (!s->s.h.refreshctx) {

  1406.         ff_thread_finish_setup(avctx);

  1407.     }

  1408. 

  1409.     do {

  1410.         yoff = uvoff = 0;

  1411.         s->b = s->b_base;

  1412.         s->block = s->block_base;

  1413.         s->uvblock[0] = s->uvblock_base[0];

  1414.         s->uvblock[1] = s->uvblock_base[1];

  1415.         s->eob = s->eob_base;

  1416.         s->uveob[0] = s->uveob_base[0];

  1417.         s->uveob[1] = s->uveob_base[1];

  1418. 

  1419.         for (tile_row = 0; tile_row < s->s.h.tiling.tile_rows; tile_row++) {

  1420.             set_tile_offset(&s->tile_row_start, &s->tile_row_end,

  1421.                             tile_row, s->s.h.tiling.log2_tile_rows, s->sb_rows);

  1422.             if (s->pass != 2) {

  1423.                 for (tile_col = 0; tile_col < s->s.h.tiling.tile_cols; tile_col++) {

  1424.                     int64_t tile_size;

  1425. 

  1426.                     if (tile_col == s->s.h.tiling.tile_cols - 1 &&

  1427.                         tile_row == s->s.h.tiling.tile_rows - 1) {

  1428.                         tile_size = size;

  1429.                     } else {

  1430.                         tile_size = AV_RB32(data);

  1431.                         data += 4;

  1432.                         size -= 4;

  1433.                     }

  1434.                     if (tile_size > size) {

  1435.                         ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, INT_MAX, 0);

  1436.                         return AVERROR_INVALIDDATA;

  1437.                     }

  1438.                     ret = ff_vp56_init_range_decoder(&s->c_b[tile_col], data, tile_size);

  1439.                     if (ret < 0)

  1440.                         return ret;

  1441.                     if (vp56_rac_get_prob_branchy(&s->c_b[tile_col], 128)) { // marker bit

  1442.                         ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, INT_MAX, 0);

  1443.                         return AVERROR_INVALIDDATA;

  1444.                     }

  1445.                     data += tile_size;

  1446.                     size -= tile_size;

  1447.                 }

  1448.             }

  1449. 

  1450.             for (row = s->tile_row_start; row < s->tile_row_end;

  1451.                  row += 8, yoff += ls_y * 64, uvoff += ls_uv * 64 >> s->ss_v) {

  1452.                 VP9Filter *lflvl_ptr = s->lflvl;

  1453.                 ptrdiff_t yoff2 = yoff, uvoff2 = uvoff;

  1454. 

  1455.                 for (tile_col = 0; tile_col < s->s.h.tiling.tile_cols; tile_col++) {

  1456.                     set_tile_offset(&s->tile_col_start, &s->tile_col_end,

  1457.                                     tile_col, s->s.h.tiling.log2_tile_cols, s->sb_cols);

  1458. 

  1459.                     if (s->pass != 2) {

  1460.                         memset(s->left_partition_ctx, 0, 8);

  1461.                         memset(s->left_skip_ctx, 0, 8);

  1462.                         if (s->s.h.keyframe || s->s.h.intraonly) {

  1463.                             memset(s->left_mode_ctx, DC_PRED, 16);

  1464.                         } else {

  1465.                             memset(s->left_mode_ctx, NEARESTMV, 8);

  1466.                         }

  1467.                         memset(s->left_y_nnz_ctx, 0, 16);

  1468.                         memset(s->left_uv_nnz_ctx, 0, 32);

  1469.                         memset(s->left_segpred_ctx, 0, 8);

  1470. 

  1471.                         memcpy(&s->c, &s->c_b[tile_col], sizeof(s->c));

  1472.                     }

  1473. 

  1474.                     for (col = s->tile_col_start;

  1475.                          col < s->tile_col_end;

  1476.                          col += 8, yoff2 += 64 * bytesperpixel,

  1477.                          uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {

  1478.                         // FIXME integrate with lf code (i.e. zero after each

  1479.                         // use, similar to invtxfm coefficients, or similar)

  1480.                         if (s->pass != 1) {

  1481.                             memset(lflvl_ptr->mask, 0, sizeof(lflvl_ptr->mask));

  1482.                         }

  1483. 

  1484.                         if (s->pass == 2) {

  1485.                             decode_sb_mem(avctx, row, col, lflvl_ptr,

  1486.                                           yoff2, uvoff2, BL_64X64);

  1487.                         } else {

  1488.                             decode_sb(avctx, row, col, lflvl_ptr,

  1489.                                       yoff2, uvoff2, BL_64X64);

  1490.                         }

  1491.                     }

  1492.                     if (s->pass != 2)

  1493.                         memcpy(&s->c_b[tile_col], &s->c, sizeof(s->c));

  1494.                 }

  1495. 

  1496.                 if (s->pass == 1)

  1497.                     continue;

  1498. 

  1499.                 // backup pre-loopfilter reconstruction data for intra

  1500.                 // prediction of next row of sb64s

  1501.                 if (row + 8 < s->rows) {

  1502.                     memcpy(s->intra_pred_data[0],

  1503.                            f->data[0] + yoff + 63 * ls_y,

  1504.                            8 * s->cols * bytesperpixel);

  1505.                     memcpy(s->intra_pred_data[1],

  1506.                            f->data[1] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,

  1507.                            8 * s->cols * bytesperpixel >> s->ss_h);

  1508.                     memcpy(s->intra_pred_data[2],

  1509.                            f->data[2] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,

  1510.                            8 * s->cols * bytesperpixel >> s->ss_h);

  1511.                 }

  1512. 

  1513.                 // loopfilter one row

  1514.                 if (s->s.h.filter.level) {

  1515.                     yoff2 = yoff;

  1516.                     uvoff2 = uvoff;

  1517.                     lflvl_ptr = s->lflvl;

  1518.                     for (col = 0; col < s->cols;

  1519.                          col += 8, yoff2 += 64 * bytesperpixel,

  1520.                          uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {

  1521.                         loopfilter_sb(avctx, lflvl_ptr, row, col, yoff2, uvoff2);

  1522.                     }

  1523.                 }

  1524. 

  1525.                 // FIXME maybe we can make this more finegrained by running the

  1526.                 // loopfilter per-block instead of after each sbrow

  1527.                 // In fact that would also make intra pred left preparation easier?

  1528.                 ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, row >> 3, 0);

  1529.             }

  1530.         }

  1531. 

  1532.         if (s->pass < 2 && s->s.h.refreshctx && !s->s.h.parallelmode) {

  1533.             ff_vp9_adapt_probs(s);

  1534.             ff_thread_finish_setup(avctx);

  1535.         }

  1536.     } while (s->pass++ == 1);

  1537.     ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, INT_MAX, 0);

  1538. 

  1539. finish:

  1540.     // ref frame setup

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

  1542.         if (s->s.refs[i].f->buf[0])

  1543.             ff_thread_release_buffer(avctx, &s->s.refs[i]);

  1544.         if (s->next_refs[i].f->buf[0] &&

  1545.             (ret = ff_thread_ref_frame(&s->s.refs[i], &s->next_refs[i])) < 0)

  1546.             return ret;

  1547.     }

  1548. 

  1549.     if (!s->s.h.invisible) {

  1550.         if ((ret = av_frame_ref(frame, s->s.frames[CUR_FRAME].tf.f)) < 0)

  1551.             return ret;

  1552.         *got_frame = 1;

  1553.     }

  1554. 

  1555.     return pkt->size;

  1556. }

  1557. 

  1558. static void vp9_decode_flush(AVCodecContext *avctx)

  1559. {

  1560.     VP9Context *s = avctx->priv_data;

  1561.     int i;

  1562. 

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

  1564.         vp9_frame_unref(avctx, &s->s.frames[i]);

  1565.     for (i = 0; i < 8; i++)

  1566.         ff_thread_release_buffer(avctx, &s->s.refs[i]);

  1567. }

  1568. 

  1569. static int init_frames(AVCodecContext *avctx)

  1570. {

  1571.     VP9Context *s = avctx->priv_data;

  1572.     int i;

  1573. 

  1574.     for (i = 0; i < 3; i++) {

  1575.         s->s.frames[i].tf.f = av_frame_alloc();

  1576.         if (!s->s.frames[i].tf.f) {

  1577.             vp9_decode_free(avctx);

  1578.             av_log(avctx, AV_LOG_ERROR, "Failed to allocate frame buffer %d\n", i);

  1579.             return AVERROR(ENOMEM);

  1580.         }

  1581.     }

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

  1583.         s->s.refs[i].f = av_frame_alloc();

  1584.         s->next_refs[i].f = av_frame_alloc();

  1585.         if (!s->s.refs[i].f || !s->next_refs[i].f) {

  1586.             vp9_decode_free(avctx);

  1587.             av_log(avctx, AV_LOG_ERROR, "Failed to allocate frame buffer %d\n", i);

  1588.             return AVERROR(ENOMEM);

  1589.         }

  1590.     }

  1591. 

  1592.     return 0;

  1593. }

  1594. 

  1595. static av_cold int vp9_decode_init(AVCodecContext *avctx)

  1596. {

  1597.     VP9Context *s = avctx->priv_data;

  1598. 

  1599.     avctx->internal->allocate_progress = 1;

  1600.     s->last_bpp = 0;

  1601.     s->s.h.filter.sharpness = -1;

  1602. 

  1603.     return init_frames(avctx);

  1604. }

  1605. 

  1606. #if HAVE_THREADS

  1607. static av_cold int vp9_decode_init_thread_copy(AVCodecContext *avctx)

  1608. {

  1609.     return init_frames(avctx);

  1610. }

  1611. 

  1612. static int vp9_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)

  1613. {

  1614.     int i, ret;

  1615.     VP9Context *s = dst->priv_data, *ssrc = src->priv_data;

  1616. 

  1617.     for (i = 0; i < 3; i++) {

  1618.         if (s->s.frames[i].tf.f->buf[0])

  1619.             vp9_frame_unref(dst, &s->s.frames[i]);

  1620.         if (ssrc->s.frames[i].tf.f->buf[0]) {

  1621.             if ((ret = vp9_frame_ref(dst, &s->s.frames[i], &ssrc->s.frames[i])) < 0)

  1622.                 return ret;

  1623.         }

  1624.     }

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

  1626.         if (s->s.refs[i].f->buf[0])

  1627.             ff_thread_release_buffer(dst, &s->s.refs[i]);

  1628.         if (ssrc->next_refs[i].f->buf[0]) {

  1629.             if ((ret = ff_thread_ref_frame(&s->s.refs[i], &ssrc->next_refs[i])) < 0)

  1630.                 return ret;

  1631.         }

  1632.     }

  1633. 

  1634.     s->s.h.invisible = ssrc->s.h.invisible;

  1635.     s->s.h.keyframe = ssrc->s.h.keyframe;

  1636.     s->s.h.intraonly = ssrc->s.h.intraonly;

  1637.     s->ss_v = ssrc->ss_v;

  1638.     s->ss_h = ssrc->ss_h;

  1639.     s->s.h.segmentation.enabled = ssrc->s.h.segmentation.enabled;

  1640.     s->s.h.segmentation.update_map = ssrc->s.h.segmentation.update_map;

  1641.     s->s.h.segmentation.absolute_vals = ssrc->s.h.segmentation.absolute_vals;

  1642.     s->bytesperpixel = ssrc->bytesperpixel;

  1643.     s->gf_fmt = ssrc->gf_fmt;

  1644.     s->w = ssrc->w;

  1645.     s->h = ssrc->h;

  1646.     s->s.h.bpp = ssrc->s.h.bpp;

  1647.     s->bpp_index = ssrc->bpp_index;

  1648.     s->pix_fmt = ssrc->pix_fmt;

  1649.     memcpy(&s->prob_ctx, &ssrc->prob_ctx, sizeof(s->prob_ctx));

  1650.     memcpy(&s->s.h.lf_delta, &ssrc->s.h.lf_delta, sizeof(s->s.h.lf_delta));

  1651.     memcpy(&s->s.h.segmentation.feat, &ssrc->s.h.segmentation.feat,

  1652.            sizeof(s->s.h.segmentation.feat));

  1653. 

  1654.     return 0;

  1655. }

  1656. #endif

  1657. 

  1658. AVCodec ff_vp9_decoder = {

  1659.     .name                  = "vp9",

  1660.     .long_name             = NULL_IF_CONFIG_SMALL("Google VP9"),

  1661.     .type                  = AVMEDIA_TYPE_VIDEO,

  1662.     .id                    = AV_CODEC_ID_VP9,

  1663.     .priv_data_size        = sizeof(VP9Context),

  1664.     .init                  = vp9_decode_init,

  1665.     .close                 = vp9_decode_free,

  1666.     .decode                = vp9_decode_frame,

  1667.     .capabilities          = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,

  1668.     .flush                 = vp9_decode_flush,

  1669.     .init_thread_copy      = ONLY_IF_THREADS_ENABLED(vp9_decode_init_thread_copy),

  1670.     .update_thread_context = ONLY_IF_THREADS_ENABLED(vp9_decode_update_thread_context),

  1671.     .profiles              = NULL_IF_CONFIG_SMALL(ff_vp9_profiles),

  1672. };