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.
43415 Commits
32 Branches
824MB
Tree: 82b7525173
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '82b7525173'
${ noResults }
FFmpeg/libavcodec/vp9.c

1314 lines
52KB
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 Libav.

  8.  *

  9.  * Libav 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.  * Libav 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 Libav; if not, write to the Free Software

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

  22.  */

  23. 

  24. #include "libavutil/avassert.h"

  25. 

  26. #include "avcodec.h"

  27. #include "get_bits.h"

  28. #include "internal.h"

  29. #include "videodsp.h"

  30. #include "vp56.h"

  31. #include "vp9.h"

  32. #include "vp9data.h"

  33. 

  34. #define VP9_SYNCCODE 0x498342

  35. #define MAX_PROB 255

  36. 

  37. static void vp9_decode_flush(AVCodecContext *avctx)

  38. {

  39.     VP9Context *s = avctx->priv_data;

  40.     int i;

  41. 

  42.     for (i = 0; i < FF_ARRAY_ELEMS(s->refs); i++)

  43.         av_frame_unref(s->refs[i]);

  44. }

  45. 

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

  47. {

  48.     VP9Context *s = avctx->priv_data;

  49.     uint8_t *p;

  50. 

  51.     if (s->above_partition_ctx && w == avctx->width && h == avctx->height)

  52.         return 0;

  53. 

  54.     vp9_decode_flush(avctx);

  55. 

  56.     if (w <= 0 || h <= 0)

  57.         return AVERROR_INVALIDDATA;

  58. 

  59.     avctx->width  = w;

  60.     avctx->height = h;

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

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

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

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

  65. 

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

  67.     av_free(s->above_partition_ctx);

  68.     p = av_malloc(s->sb_cols *

  69.                   (240 + sizeof(*s->lflvl) + 16 * sizeof(*s->above_mv_ctx) +

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

  71.     if (!p)

  72.         return AVERROR(ENOMEM);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  91.     assign(s->mv[0],               VP9MVRefPair *, 64 * s->sb_rows);

  92.     assign(s->mv[1],               VP9MVRefPair *, 64 * s->sb_rows);

  93. #undef assign

  94. 

  95.     return 0;

  96. }

  97. 

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

  99. static av_always_inline int get_bits_with_sign(GetBitContext *gb, int n)

  100. {

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

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

  103. }

  104. 

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

  106. {

  107.     if (v > 2 * m)

  108.         return v;

  109.     if (v & 1)

  110.         return m - ((v + 1) >> 1);

  111.     return m + (v >> 1);

  112. }

  113. 

  114. // differential forward probability updates

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

  116. {

  117.     static const int inv_map_table[MAX_PROB - 1] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  136.         252, 253,

  137.     };

  138.     int d;

  139. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  154. 

  155.     if (!vp8_rac_get(c)) {

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

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

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

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

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

  161.     } else {

  162.         d = vp8_rac_get_uint(c, 7);

  163.         if (d >= 65) {

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

  165.             d = av_clip(d, 0, MAX_PROB - 65 - 1);

  166.         }

  167.         d += 64;

  168.     }

  169. 

  170.     return p <= 128

  171.            ?   1 + inv_recenter_nonneg(inv_map_table[d], p - 1)

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

  173. }

  174. 

  175. static int decode_frame_header(AVCodecContext *avctx,

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

  177. {

  178.     VP9Context *s = avctx->priv_data;

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

  180.     int last_invisible;

  181.     const uint8_t *data2;

  182. 

  183.     /* general header */

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

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

  186.         return ret;

  187.     }

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

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

  190.         return AVERROR_INVALIDDATA;

  191.     }

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

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

  194.         av_log(avctx, AV_LOG_ERROR, "Reserved bit should be zero\n");

  195.         return AVERROR_INVALIDDATA;

  196.     }

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

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

  199.         return 0;

  200.     }

  201. 

  202.     s->last_keyframe = s->keyframe;

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

  204. 

  205.     last_invisible = s->invisible;

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

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

  208.     // FIXME disable this upon resolution change

  209.     s->use_last_frame_mvs = !s->errorres && !last_invisible;

  210. 

  211.     if (s->keyframe) {

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

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

  214.             return AVERROR_INVALIDDATA;

  215.         }

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

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

  218.             av_log(avctx, AV_LOG_ERROR, "RGB not supported in profile 0\n");

  219.             return AVERROR_INVALIDDATA;

  220.         }

  221.         s->fullrange = get_bits1(&s->gb);

  222. 

  223.         // subsampling bits

  224.         if (s->profile == 1 || s->profile == 3) {

  225.             s->sub_x = get_bits1(&s->gb);

  226.             s->sub_y = get_bits1(&s->gb);

  227.             if (s->sub_x && s->sub_y) {

  228.                 av_log(avctx, AV_LOG_ERROR,

  229.                        "4:2:0 color not supported in profile 1 or 3\n");

  230.                 return AVERROR_INVALIDDATA;

  231.             }

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

  233.                 av_log(avctx, AV_LOG_ERROR, "Reserved bit should be zero\n");

  234.                 return AVERROR_INVALIDDATA;

  235.             }

  236.         } else {

  237.             s->sub_x = s->sub_y = 1;

  238.         }

  239.         if (!s->sub_x || !s->sub_y) {

  240.             avpriv_report_missing_feature(avctx, "Subsampling %d:%d",

  241.                                           s->sub_x, s->sub_y);

  242.             return AVERROR_PATCHWELCOME;

  243.         }

  244. 

  245.         s->refreshrefmask = 0xff;

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

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

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

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

  250.     } else {

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

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

  253.         if (s->intraonly) {

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

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

  256.                 return AVERROR_INVALIDDATA;

  257.             }

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

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

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

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

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

  263.         } else {

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

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

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

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

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

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

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

  271.             if (!s->refs[s->refidx[0]]->buf[0] ||

  272.                 !s->refs[s->refidx[1]]->buf[0] ||

  273.                 !s->refs[s->refidx[2]]->buf[0]) {

  274.                 av_log(avctx, AV_LOG_ERROR,

  275.                        "Not all references are available\n");

  276.                 return AVERROR_INVALIDDATA;

  277.             }

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

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

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

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

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

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

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

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

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

  287.             } else {

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

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

  290.             }

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

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

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

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

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

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

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

  298.             if (s->allowcompinter) {

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

  300.                     s->fixcompref    = 2;

  301.                     s->varcompref[0] = 0;

  302.                     s->varcompref[1] = 1;

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

  304.                     s->fixcompref    = 1;

  305.                     s->varcompref[0] = 0;

  306.                     s->varcompref[1] = 2;

  307.                 } else {

  308.                     s->fixcompref    = 0;

  309.                     s->varcompref[0] = 1;

  310.                     s->varcompref[1] = 2;

  311.                 }

  312.             }

  313.         }

  314.     }

  315. 

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

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

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

  319. 

  320.     /* loopfilter header data */

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

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

  323.     /* If sharpness changed, reinit lim/mblim LUTs. if it didn't change,

  324.      * keep the old cache values since they are still valid. */

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

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

  327.     s->filter.sharpness = sharp;

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

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

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

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

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

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

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

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

  336.         }

  337.     } else {

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

  339.     }

  340. 

  341.     /* quantization header data */

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

  343.     s->ydc_qdelta  = get_bits1(&s->gb) ? get_bits_with_sign(&s->gb, 4) : 0;

  344.     s->uvdc_qdelta = get_bits1(&s->gb) ? get_bits_with_sign(&s->gb, 4) : 0;

  345.     s->uvac_qdelta = get_bits1(&s->gb) ? get_bits_with_sign(&s->gb, 4) : 0;

  346.     s->lossless    = s->yac_qi == 0 && s->ydc_qdelta == 0 &&

  347.                      s->uvdc_qdelta == 0 && s->uvac_qdelta == 0;

  348. 

  349.     /* segmentation header info */

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

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

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

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

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

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

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

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

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

  359.         }

  360. 

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

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

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

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

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

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

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

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

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

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

  371.             }

  372.         }

  373.     } else {

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

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

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

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

  378.     }

  379. 

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

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

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

  383. 

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

  385.             if (s->segmentation.absolute_vals)

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

  387.             else

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

  389.         } else {

  390.             qyac = s->yac_qi;

  391.         }

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

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

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

  395.         qyac  = av_clip_uintp2(qyac, 8);

  396. 

  397.         s->segmentation.feat[i].qmul[0][0] = ff_vp9_dc_qlookup[qydc];

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

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

  400.         s->segmentation.feat[i].qmul[1][1] = ff_vp9_ac_qlookup[quvac];

  401. 

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

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

  404.             if (s->segmentation.absolute_vals)

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

  406.             else

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

  408.         } else {

  409.             lflvl = s->filter.level;

  410.         }

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

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

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

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

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

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

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

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

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

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

  421.         }

  422.     }

  423. 

  424.     /* tiling info */

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

  426.         av_log(avctx, AV_LOG_ERROR,

  427.                "Failed to initialize decoder for %dx%d\n", w, h);

  428.         return ret;

  429.     }

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

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

  432.          s->tiling.log2_tile_cols++) ;

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

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

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

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

  437.             s->tiling.log2_tile_cols++;

  438.         else

  439.             break;

  440.     }

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

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

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

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

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

  446.                                               sizeof(VP56RangeCoder) *

  447.                                               s->tiling.tile_cols);

  448.         if (!s->c_b) {

  449.             av_log(avctx, AV_LOG_ERROR,

  450.                    "Ran out of memory during range coder init\n");

  451.             return AVERROR(ENOMEM);

  452.         }

  453.     }

  454. 

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

  456.         s->prob_ctx[0].p =

  457.         s->prob_ctx[1].p =

  458.         s->prob_ctx[2].p =

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

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

  461.                sizeof(ff_vp9_default_coef_probs));

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

  463.                sizeof(ff_vp9_default_coef_probs));

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

  465.                sizeof(ff_vp9_default_coef_probs));

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

  467.                sizeof(ff_vp9_default_coef_probs));

  468.     }

  469. 

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

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

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

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

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

  475.         return AVERROR_INVALIDDATA;

  476.     }

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

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

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

  480.         return AVERROR_INVALIDDATA;

  481.     }

  482. 

  483.     if (s->keyframe || s->intraonly)

  484.         memset(s->counts.coef, 0,

  485.                sizeof(s->counts.coef) + sizeof(s->counts.eob));

  486.     else

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

  488. 

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

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

  491.      * fw update)? */

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

  493. 

  494.     // txfm updates

  495.     if (s->lossless) {

  496.         s->txfmmode = TX_4X4;

  497.     } else {

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

  499.         if (s->txfmmode == 3)

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

  501. 

  502.         if (s->txfmmode == TX_SWITCHABLE) {

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

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

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

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

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

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

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

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

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

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

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

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

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

  516.         }

  517.     }

  518. 

  519.     // coef updates

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

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

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

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

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

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

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

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

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

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

  530.                                 break;

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

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

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

  534.                                 else

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

  536.                             }

  537.                             p[3] = 0;

  538.                         }

  539.         } else {

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

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

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

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

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

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

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

  547.                                 break;

  548.                             memcpy(p, r, 3);

  549.                             p[3] = 0;

  550.                         }

  551.         }

  552.         if (s->txfmmode == i)

  553.             break;

  554.     }

  555. 

  556.     // mode updates

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

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

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

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

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

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

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

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

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

  566. 

  567.         if (s->filtermode == FILTER_SWITCHABLE)

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

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

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

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

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

  573. 

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

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

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

  577. 

  578.         if (s->allowcompinter) {

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

  580.             if (s->comppredmode)

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

  582.             if (s->comppredmode == PRED_SWITCHABLE)

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

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

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

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

  587.         } else {

  588.             s->comppredmode = PRED_SINGLEREF;

  589.         }

  590. 

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

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

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

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

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

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

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

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

  599.             }

  600.         }

  601. 

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

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

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

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

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

  607.         }

  608. 

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

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

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

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

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

  614. 

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

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

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

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

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

  620.                             update_prob(&s->c,

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

  622. 

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

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

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

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

  627. 

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

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

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

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

  632. 

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

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

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

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

  637. 

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

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

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

  641. 

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

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

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

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

  646.         }

  647. 

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

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

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

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

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

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

  654. 

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

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

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

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

  659.         }

  660. 

  661.         if (s->highprecisionmvs) {

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

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

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

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

  666. 

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

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

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

  670.             }

  671.         }

  672.     }

  673. 

  674.     return (data2 - data) + size2;

  675. }

  676. 

  677. static int decode_subblock(AVCodecContext *avctx, int row, int col,

  678.                            VP9Filter *lflvl,

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

  680. {

  681.     VP9Context *s = avctx->priv_data;

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

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

  684.     int ret;

  685.     const uint8_t *p = s->keyframe ? ff_vp9_default_kf_partition_probs[bl][c]

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

  687.     enum BlockPartition bp;

  688.     ptrdiff_t hbs = 4 >> bl;

  689. 

  690.     if (bl == BL_8X8) {

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

  692.         ret = ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, bl, bp);

  693.     } else if (col + hbs < s->cols) {

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

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

  696.             switch (bp) {

  697.             case PARTITION_NONE:

  698.                 ret = ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff,

  699.                                           bl, bp);

  700.                 break;

  701.             case PARTITION_H:

  702.                 ret = ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff,

  703.                                           bl, bp);

  704.                 if (!ret) {

  705.                     yoff  += hbs * 8 * s->cur_frame->linesize[0];

  706.                     uvoff += hbs * 4 * s->cur_frame->linesize[1];

  707.                     ret    = ff_vp9_decode_block(avctx, row + hbs, col, lflvl,

  708.                                                  yoff, uvoff, bl, bp);

  709.                 }

  710.                 break;

  711.             case PARTITION_V:

  712.                 ret = ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff,

  713.                                           bl, bp);

  714.                 if (!ret) {

  715.                     yoff  += hbs * 8;

  716.                     uvoff += hbs * 4;

  717.                     ret    = ff_vp9_decode_block(avctx, row, col + hbs, lflvl,

  718.                                                  yoff, uvoff, bl, bp);

  719.                 }

  720.                 break;

  721.             case PARTITION_SPLIT:

  722.                 ret = decode_subblock(avctx, row, col, lflvl,

  723.                                       yoff, uvoff, bl + 1);

  724.                 if (!ret) {

  725.                     ret = decode_subblock(avctx, row, col + hbs, lflvl,

  726.                                           yoff + 8 * hbs, uvoff + 4 * hbs,

  727.                                           bl + 1);

  728.                     if (!ret) {

  729.                         yoff  += hbs * 8 * s->cur_frame->linesize[0];

  730.                         uvoff += hbs * 4 * s->cur_frame->linesize[1];

  731.                         ret    = decode_subblock(avctx, row + hbs, col, lflvl,

  732.                                                  yoff, uvoff, bl + 1);

  733.                         if (!ret) {

  734.                             ret = decode_subblock(avctx, row + hbs, col + hbs,

  735.                                                   lflvl, yoff + 8 * hbs,

  736.                                                   uvoff + 4 * hbs, bl + 1);

  737.                         }

  738.                     }

  739.                 }

  740.                 break;

  741.             default:

  742.                 av_log(avctx, AV_LOG_ERROR, "Unexpected partition %d.", bp);

  743.                 return AVERROR_INVALIDDATA;

  744.             }

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

  746.             bp  = PARTITION_SPLIT;

  747.             ret = decode_subblock(avctx, row, col, lflvl, yoff, uvoff, bl + 1);

  748.             if (!ret)

  749.                 ret = decode_subblock(avctx, row, col + hbs, lflvl,

  750.                                       yoff + 8 * hbs, uvoff + 4 * hbs, bl + 1);

  751.         } else {

  752.             bp  = PARTITION_H;

  753.             ret = ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff,

  754.                                       bl, bp);

  755.         }

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

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

  758.             bp  = PARTITION_SPLIT;

  759.             ret = decode_subblock(avctx, row, col, lflvl, yoff, uvoff, bl + 1);

  760.             if (!ret) {

  761.                 yoff  += hbs * 8 * s->cur_frame->linesize[0];

  762.                 uvoff += hbs * 4 * s->cur_frame->linesize[1];

  763.                 ret    = decode_subblock(avctx, row + hbs, col, lflvl,

  764.                                          yoff, uvoff, bl + 1);

  765.             }

  766.         } else {

  767.             bp  = PARTITION_V;

  768.             ret = ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff,

  769.                                       bl, bp);

  770.         }

  771.     } else {

  772.         bp  = PARTITION_SPLIT;

  773.         ret = decode_subblock(avctx, row, col, lflvl, yoff, uvoff, bl + 1);

  774.     }

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

  776. 

  777.     return ret;

  778. }

  779. 

  780. static void loopfilter_subblock(AVCodecContext *avctx, VP9Filter *lflvl,

  781.                                 int row, int col,

  782.                                 ptrdiff_t yoff, ptrdiff_t uvoff)

  783. {

  784.     VP9Context *s = avctx->priv_data;

  785.     uint8_t *dst   = s->cur_frame->data[0] + yoff, *lvl = lflvl->level;

  786.     ptrdiff_t ls_y = s->cur_frame->linesize[0], ls_uv = s->cur_frame->linesize[1];

  787.     int y, x, p;

  788. 

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

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

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

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

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

  794. 

  795.     // filter edges between columns, Y plane (e.g. block1 | block2)

  796.     for (y = 0; y < 8; y += 2, dst += 16 * ls_y, lvl += 16) {

  797.         uint8_t *ptr = dst, *l = lvl, *hmask1 = lflvl->mask[0][0][y];

  798.         uint8_t *hmask2 = lflvl->mask[0][0][y + 1];

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

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

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

  802. 

  803.         for (x = 1; hm & ~(x - 1); x <<= 1, ptr += 8, l++) {

  804.             if (hm1 & x) {

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

  806.                 int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];

  807. 

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

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

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

  811.                             av_assert2(l[8] == L);

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

  813.                         } else {

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

  815.                         }

  816.                     } else if (hm2 & x) {

  817.                         L  = l[8];

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

  819.                         E |= s->filter.mblim_lut[L] << 8;

  820.                         I |= s->filter.lim_lut[L] << 8;

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

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

  823.                                                [0](ptr, ls_y, E, I, H);

  824.                     } else {

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

  826.                                             [0](ptr, ls_y, E, I, H);

  827.                     }

  828.                 }

  829.             } else if (hm2 & x) {

  830.                 int L = l[8], H = L >> 4;

  831.                 int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];

  832. 

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

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

  835.                                         [0](ptr + 8 * ls_y, ls_y, E, I, H);

  836.                 }

  837.             }

  838.             if (hm13 & x) {

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

  840.                 int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];

  841. 

  842.                 if (hm23 & x) {

  843.                     L  = l[8];

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

  845.                     E |= s->filter.mblim_lut[L] << 8;

  846.                     I |= s->filter.lim_lut[L] << 8;

  847.                     s->dsp.loop_filter_mix2[0][0][0](ptr + 4, ls_y, E, I, H);

  848.                 } else {

  849.                     s->dsp.loop_filter_8[0][0](ptr + 4, ls_y, E, I, H);

  850.                 }

  851.             } else if (hm23 & x) {

  852.                 int L = l[8], H = L >> 4;

  853.                 int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];

  854. 

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

  856.             }

  857.         }

  858.     }

  859. 

  860.     //                                          block1

  861.     // filter edges between rows, Y plane (e.g. ------)

  862.     //                                          block2

  863.     dst = s->cur_frame->data[0] + yoff;

  864.     lvl = lflvl->level;

  865.     for (y = 0; y < 8; y++, dst += 8 * ls_y, lvl += 8) {

  866.         uint8_t *ptr = dst, *l = lvl, *vmask = lflvl->mask[0][1][y];

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

  868. 

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

  870.             if (row || y) {

  871.                 if (vm & x) {

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

  873.                     int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];

  874. 

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

  876.                         if (vmask[0] & (x << 1)) {

  877.                             av_assert2(l[1] == L);

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

  879.                         } else {

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

  881.                         }

  882.                     } else if (vm & (x << 1)) {

  883.                         L  = l[1];

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

  885.                         E |= s->filter.mblim_lut[L] << 8;

  886.                         I |= s->filter.lim_lut[L] << 8;

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

  888.                                                [!!(vmask[1] & (x << 1))]

  889.                                                [1](ptr, ls_y, E, I, H);

  890.                     } else {

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

  892.                                             [1](ptr, ls_y, E, I, H);

  893.                     }

  894.                 } else if (vm & (x << 1)) {

  895.                     int L = l[1], H = L >> 4;

  896.                     int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];

  897. 

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

  899.                                         [1](ptr + 8, ls_y, E, I, H);

  900.                 }

  901.             }

  902.             if (vm3 & x) {

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

  904.                 int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];

  905. 

  906.                 if (vm3 & (x << 1)) {

  907.                     L  = l[1];

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

  909.                     E |= s->filter.mblim_lut[L] << 8;

  910.                     I |= s->filter.lim_lut[L] << 8;

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

  912.                 } else {

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

  914.                 }

  915.             } else if (vm3 & (x << 1)) {

  916.                 int L = l[1], H = L >> 4;

  917.                 int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];

  918. 

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

  920.             }

  921.         }

  922.     }

  923. 

  924.     // same principle but for U/V planes

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

  926.         lvl = lflvl->level;

  927.         dst = s->cur_frame->data[1 + p] + uvoff;

  928.         for (y = 0; y < 8; y += 4, dst += 16 * ls_uv, lvl += 32) {

  929.             uint8_t *ptr = dst, *l = lvl, *hmask1 = lflvl->mask[1][0][y];

  930.             uint8_t *hmask2 = lflvl->mask[1][0][y + 2];

  931.             unsigned hm1 = hmask1[0] | hmask1[1] | hmask1[2];

  932.             unsigned hm2 = hmask2[1] | hmask2[2], hm = hm1 | hm2;

  933. 

  934.             for (x = 1; hm & ~(x - 1); x <<= 1, ptr += 4) {

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

  936.                     if (hm1 & x) {

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

  938.                         int E = s->filter.mblim_lut[L];

  939.                         int I = s->filter.lim_lut[L];

  940. 

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

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

  943.                                 av_assert2(l[16] == L);

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

  945.                             } else {

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

  947.                             }

  948.                         } else if (hm2 & x) {

  949.                             L  = l[16];

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

  951.                             E |= s->filter.mblim_lut[L] << 8;

  952.                             I |= s->filter.lim_lut[L] << 8;

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

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

  955.                                                    [0](ptr, ls_uv, E, I, H);

  956.                         } else {

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

  958.                                                 [0](ptr, ls_uv, E, I, H);

  959.                         }

  960.                     } else if (hm2 & x) {

  961.                         int L = l[16], H = L >> 4;

  962.                         int E = s->filter.mblim_lut[L];

  963.                         int I = s->filter.lim_lut[L];

  964. 

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

  966.                                             [0](ptr + 8 * ls_uv, ls_uv, E, I, H);

  967.                     }

  968.                 }

  969.                 if (x & 0xAA)

  970.                     l += 2;

  971.             }

  972.         }

  973.         lvl = lflvl->level;

  974.         dst = s->cur_frame->data[1 + p] + uvoff;

  975.         for (y = 0; y < 8; y++, dst += 4 * ls_uv) {

  976.             uint8_t *ptr = dst, *l = lvl, *vmask = lflvl->mask[1][1][y];

  977.             unsigned vm = vmask[0] | vmask[1] | vmask[2];

  978. 

  979.             for (x = 1; vm & ~(x - 1); x <<= 4, ptr += 16, l += 4) {

  980.                 if (row || y) {

  981.                     if (vm & x) {

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

  983.                         int E = s->filter.mblim_lut[L];

  984.                         int I = s->filter.lim_lut[L];

  985. 

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

  987.                             if (vmask[0] & (x << 2)) {

  988.                                 av_assert2(l[2] == L);

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

  990.                             } else {

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

  992.                             }

  993.                         } else if (vm & (x << 2)) {

  994.                             L  = l[2];

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

  996.                             E |= s->filter.mblim_lut[L] << 8;

  997.                             I |= s->filter.lim_lut[L] << 8;

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

  999.                                                    [!!(vmask[1] & (x << 2))]

  1000.                                                    [1](ptr, ls_uv, E, I, H);

  1001.                         } else {

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

  1003.                                                 [1](ptr, ls_uv, E, I, H);

  1004.                         }

  1005.                     } else if (vm & (x << 2)) {

  1006.                         int L = l[2], H = L >> 4;

  1007.                         int E = s->filter.mblim_lut[L];

  1008.                         int I = s->filter.lim_lut[L];

  1009. 

  1010.                         s->dsp.loop_filter_8[!!(vmask[1] & (x << 2))]

  1011.                                             [1](ptr + 8, ls_uv, E, I, H);

  1012.                     }

  1013.                 }

  1014.             }

  1015.             if (y & 1)

  1016.                 lvl += 16;

  1017.         }

  1018.     }

  1019. }

  1020. 

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

  1022. {

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

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

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

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

  1027. }

  1028. 

  1029. static int vp9_decode_frame(AVCodecContext *avctx, AVFrame *frame,

  1030.                             int *got_frame, const uint8_t *data, int size)

  1031. {

  1032.     VP9Context *s = avctx->priv_data;

  1033.     int ret, tile_row, tile_col, i, ref = -1, row, col;

  1034.     ptrdiff_t yoff = 0, uvoff = 0;

  1035. 

  1036.     ret = decode_frame_header(avctx, data, size, &ref);

  1037.     if (ret < 0) {

  1038.         return ret;

  1039.     } else if (!ret) {

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

  1041.             av_log(avctx, AV_LOG_ERROR,

  1042.                    "Requested reference %d not available\n", ref);

  1043.             return AVERROR_INVALIDDATA;

  1044.         }

  1045. 

  1046.         ret = av_frame_ref(frame, s->refs[ref]);

  1047.         if (ret < 0)

  1048.             return ret;

  1049.         *got_frame = 1;

  1050.         return 0;

  1051.     }

  1052.     data += ret;

  1053.     size -= ret;

  1054. 

  1055.     s->cur_frame = frame;

  1056. 

  1057.     av_frame_unref(s->cur_frame);

  1058.     if ((ret = ff_get_buffer(avctx, s->cur_frame,

  1059.                              s->refreshrefmask ? AV_GET_BUFFER_FLAG_REF : 0)) < 0)

  1060.         return ret;

  1061.     s->cur_frame->key_frame = s->keyframe;

  1062.     s->cur_frame->pict_type = s->keyframe ? AV_PICTURE_TYPE_I

  1063.                                           : AV_PICTURE_TYPE_P;

  1064. 

  1065.     if (s->fullrange)

  1066.         avctx->color_range = AVCOL_RANGE_JPEG;

  1067.     else

  1068.         avctx->color_range = AVCOL_RANGE_MPEG;

  1069. 

  1070.     switch (s->colorspace) {

  1071.     case 1: avctx->colorspace = AVCOL_SPC_BT470BG; break;

  1072.     case 2: avctx->colorspace = AVCOL_SPC_BT709; break;

  1073.     case 3: avctx->colorspace = AVCOL_SPC_SMPTE170M; break;

  1074.     case 4: avctx->colorspace = AVCOL_SPC_SMPTE240M; break;

  1075.     }

  1076. 

  1077.     // main tile decode loop

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

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

  1080.     if (s->keyframe || s->intraonly)

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

  1082.     else

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

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

  1085.     memset(s->above_uv_nnz_ctx[0], 0, s->sb_cols * 8);

  1086.     memset(s->above_uv_nnz_ctx[1], 0, s->sb_cols * 8);

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

  1088.     for (tile_row = 0; tile_row < s->tiling.tile_rows; tile_row++) {

  1089.         set_tile_offset(&s->tiling.tile_row_start, &s->tiling.tile_row_end,

  1090.                         tile_row, s->tiling.log2_tile_rows, s->sb_rows);

  1091.         for (tile_col = 0; tile_col < s->tiling.tile_cols; tile_col++) {

  1092.             int64_t tile_size;

  1093. 

  1094.             if (tile_col == s->tiling.tile_cols - 1 &&

  1095.                 tile_row == s->tiling.tile_rows - 1) {

  1096.                 tile_size = size;

  1097.             } else {

  1098.                 tile_size = AV_RB32(data);

  1099.                 data     += 4;

  1100.                 size     -= 4;

  1101.             }

  1102.             if (tile_size > size)

  1103.                 return AVERROR_INVALIDDATA;

  1104.             ff_vp56_init_range_decoder(&s->c_b[tile_col], data, tile_size);

  1105.             if (vp56_rac_get_prob_branchy(&s->c_b[tile_col], 128)) // marker bit

  1106.                 return AVERROR_INVALIDDATA;

  1107.             data += tile_size;

  1108.             size -= tile_size;

  1109.         }

  1110. 

  1111.         for (row = s->tiling.tile_row_start;

  1112.              row < s->tiling.tile_row_end;

  1113.              row += 8, yoff += s->cur_frame->linesize[0] * 64,

  1114.              uvoff += s->cur_frame->linesize[1] * 32) {

  1115.             VP9Filter *lflvl = s->lflvl;

  1116.             ptrdiff_t yoff2 = yoff, uvoff2 = uvoff;

  1117. 

  1118.             for (tile_col = 0; tile_col < s->tiling.tile_cols; tile_col++) {

  1119.                 set_tile_offset(&s->tiling.tile_col_start,

  1120.                                 &s->tiling.tile_col_end,

  1121.                                 tile_col, s->tiling.log2_tile_cols, s->sb_cols);

  1122. 

  1123.                 memset(s->left_partition_ctx, 0, 8);

  1124.                 memset(s->left_skip_ctx, 0, 8);

  1125.                 if (s->keyframe || s->intraonly)

  1126.                     memset(s->left_mode_ctx, DC_PRED, 16);

  1127.                 else

  1128.                     memset(s->left_mode_ctx, NEARESTMV, 8);

  1129.                 memset(s->left_y_nnz_ctx, 0, 16);

  1130.                 memset(s->left_uv_nnz_ctx, 0, 16);

  1131.                 memset(s->left_segpred_ctx, 0, 8);

  1132. 

  1133.                 memcpy(&s->c, &s->c_b[tile_col], sizeof(s->c));

  1134.                 for (col = s->tiling.tile_col_start;

  1135.                      col < s->tiling.tile_col_end;

  1136.                      col += 8, yoff2 += 64, uvoff2 += 32, lflvl++) {

  1137.                     // FIXME integrate with lf code (i.e. zero after each

  1138.                     // use, similar to invtxfm coefficients, or similar)

  1139.                     memset(lflvl->mask, 0, sizeof(lflvl->mask));

  1140. 

  1141.                     if ((ret = decode_subblock(avctx, row, col, lflvl,

  1142.                                                yoff2, uvoff2, BL_64X64)) < 0)

  1143.                         return ret;

  1144.                 }

  1145.                 memcpy(&s->c_b[tile_col], &s->c, sizeof(s->c));

  1146.             }

  1147. 

  1148.             // backup pre-loopfilter reconstruction data for intra

  1149.             // prediction of next row of sb64s

  1150.             if (row + 8 < s->rows) {

  1151.                 memcpy(s->intra_pred_data[0],

  1152.                        s->cur_frame->data[0] + yoff +

  1153.                        63 * s->cur_frame->linesize[0],

  1154.                        8 * s->cols);

  1155.                 memcpy(s->intra_pred_data[1],

  1156.                        s->cur_frame->data[1] + uvoff +

  1157.                        31 * s->cur_frame->linesize[1],

  1158.                        4 * s->cols);

  1159.                 memcpy(s->intra_pred_data[2],

  1160.                        s->cur_frame->data[2] + uvoff +

  1161.                        31 * s->cur_frame->linesize[2],

  1162.                        4 * s->cols);

  1163.             }

  1164. 

  1165.             // loopfilter one row

  1166.             if (s->filter.level) {

  1167.                 yoff2  = yoff;

  1168.                 uvoff2 = uvoff;

  1169.                 lflvl  = s->lflvl;

  1170.                 for (col = 0; col < s->cols;

  1171.                      col += 8, yoff2 += 64, uvoff2 += 32, lflvl++)

  1172.                     loopfilter_subblock(avctx, lflvl, row, col, yoff2, uvoff2);

  1173.             }

  1174.         }

  1175.     }

  1176. 

  1177.     // bw adaptivity (or in case of parallel decoding mode, fw adaptivity

  1178.     // probability maintenance between frames)

  1179.     if (s->refreshctx) {

  1180.         if (s->parallelmode) {

  1181.             int j, k, l, m;

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

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

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

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

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

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

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

  1189.                 if (s->txfmmode == i)

  1190.                     break;

  1191.             }

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

  1193.         } else {

  1194.             ff_vp9_adapt_probs(s);

  1195.         }

  1196.     }

  1197.     FFSWAP(VP9MVRefPair *, s->mv[0], s->mv[1]);

  1198. 

  1199.     // ref frame setup

  1200.     for (i = 0; i < 8; i++)

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

  1202.             av_frame_unref(s->refs[i]);

  1203.             ret = av_frame_ref(s->refs[i], s->cur_frame);

  1204.             if (ret < 0)

  1205.                 return ret;

  1206.         }

  1207. 

  1208.     if (s->invisible)

  1209.         av_frame_unref(s->cur_frame);

  1210.     else

  1211.         *got_frame = 1;

  1212. 

  1213.     return 0;

  1214. }

  1215. 

  1216. static int vp9_decode_packet(AVCodecContext *avctx, void *frame,

  1217.                              int *got_frame, AVPacket *avpkt)

  1218. {

  1219.     const uint8_t *data = avpkt->data;

  1220.     int size            = avpkt->size;

  1221.     int marker, ret;

  1222. 

  1223.     /* Read superframe index - this is a collection of individual frames

  1224.      * that together lead to one visible frame */

  1225.     marker = data[size - 1];

  1226.     if ((marker & 0xe0) == 0xc0) {

  1227.         int nbytes   = 1 + ((marker >> 3) & 0x3);

  1228.         int n_frames = 1 + (marker & 0x7);

  1229.         int idx_sz   = 2 + n_frames * nbytes;

  1230. 

  1231.         if (size >= idx_sz && data[size - idx_sz] == marker) {

  1232.             const uint8_t *idx = data + size + 1 - idx_sz;

  1233. 

  1234.             while (n_frames--) {

  1235.                 unsigned sz = AV_RL32(idx);

  1236. 

  1237.                 if (nbytes < 4)

  1238.                     sz &= (1 << (8 * nbytes)) - 1;

  1239.                 idx += nbytes;

  1240. 

  1241.                 if (sz > size) {

  1242.                     av_log(avctx, AV_LOG_ERROR,

  1243.                            "Superframe packet size too big: %u > %d\n",

  1244.                            sz, size);

  1245.                     return AVERROR_INVALIDDATA;

  1246.                 }

  1247. 

  1248.                 ret = vp9_decode_frame(avctx, frame, got_frame, data, sz);

  1249.                 if (ret < 0)

  1250.                     return ret;

  1251.                 data += sz;

  1252.                 size -= sz;

  1253.             }

  1254.             return avpkt->size;

  1255.         }

  1256.     }

  1257. 

  1258.     /* If we get here, there was no valid superframe index, i.e. this is just

  1259.      * one whole single frame. Decode it as such from the complete input buf. */

  1260.     if ((ret = vp9_decode_frame(avctx, frame, got_frame, data, size)) < 0)

  1261.         return ret;

  1262.     return size;

  1263. }

  1264. 

  1265. static av_cold int vp9_decode_free(AVCodecContext *avctx)

  1266. {

  1267.     VP9Context *s = avctx->priv_data;

  1268.     int i;

  1269. 

  1270.     for (i = 0; i < FF_ARRAY_ELEMS(s->refs); i++)

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

  1272. 

  1273.     av_freep(&s->c_b);

  1274.     av_freep(&s->above_partition_ctx);

  1275. 

  1276.     return 0;

  1277. }

  1278. 

  1279. static av_cold int vp9_decode_init(AVCodecContext *avctx)

  1280. {

  1281.     VP9Context *s = avctx->priv_data;

  1282.     int i;

  1283. 

  1284.     avctx->pix_fmt = AV_PIX_FMT_YUV420P;

  1285. 

  1286.     ff_vp9dsp_init(&s->dsp);

  1287.     ff_videodsp_init(&s->vdsp, 8);

  1288. 

  1289.     for (i = 0; i < FF_ARRAY_ELEMS(s->refs); i++) {

  1290.         s->refs[i] = av_frame_alloc();

  1291.         if (!s->refs[i]) {

  1292.             vp9_decode_free(avctx);

  1293.             return AVERROR(ENOMEM);

  1294.         }

  1295.     }

  1296. 

  1297.     s->filter.sharpness = -1;

  1298. 

  1299.     return 0;

  1300. }

  1301. 

  1302. AVCodec ff_vp9_decoder = {

  1303.     .name           = "vp9",

  1304.     .long_name      = NULL_IF_CONFIG_SMALL("Google VP9"),

  1305.     .type           = AVMEDIA_TYPE_VIDEO,

  1306.     .id             = AV_CODEC_ID_VP9,

  1307.     .priv_data_size = sizeof(VP9Context),

  1308.     .init           = vp9_decode_init,

  1309.     .decode         = vp9_decode_packet,

  1310.     .flush          = vp9_decode_flush,

  1311.     .close          = vp9_decode_free,

  1312.     .capabilities   = AV_CODEC_CAP_DR1,

  1313. };