lavc/vp9: rename ctx to avctx
[ffmpeg.git] / libavcodec / vp9.c
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_unref_frame(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_alloc_frame(AVCodecContext *avctx, VP9Frame *f)
49 {
50     VP9Context *s = avctx->priv_data;
51     int ret, sz;
52
53     if ((ret = ff_thread_get_buffer(avctx, &f->tf, AV_GET_BUFFER_FLAG_REF)) < 0)
54         return ret;
55     sz = 64 * s->sb_cols * s->sb_rows;
56     if (!(f->extradata = av_buffer_allocz(sz * (1 + sizeof(struct VP9mvrefPair))))) {
57         goto fail;
58     }
59
60     f->segmentation_map = f->extradata->data;
61     f->mv = (struct VP9mvrefPair *) (f->extradata->data + sz);
62
63     if (avctx->hwaccel) {
64         const AVHWAccel *hwaccel = avctx->hwaccel;
65         av_assert0(!f->hwaccel_picture_private);
66         if (hwaccel->frame_priv_data_size) {
67             f->hwaccel_priv_buf = av_buffer_allocz(hwaccel->frame_priv_data_size);
68             if (!f->hwaccel_priv_buf)
69                 goto fail;
70             f->hwaccel_picture_private = f->hwaccel_priv_buf->data;
71         }
72     }
73
74     return 0;
75
76 fail:
77     vp9_unref_frame(avctx, f);
78     return AVERROR(ENOMEM);
79 }
80
81 static int vp9_ref_frame(AVCodecContext *avctx, VP9Frame *dst, VP9Frame *src)
82 {
83     int res;
84
85     if ((res = ff_thread_ref_frame(&dst->tf, &src->tf)) < 0) {
86         return res;
87     } else if (!(dst->extradata = av_buffer_ref(src->extradata))) {
88         goto fail;
89     }
90
91     dst->segmentation_map = src->segmentation_map;
92     dst->mv = src->mv;
93     dst->uses_2pass = src->uses_2pass;
94
95     if (src->hwaccel_picture_private) {
96         dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
97         if (!dst->hwaccel_priv_buf)
98             goto fail;
99         dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
100     }
101
102     return 0;
103
104 fail:
105     vp9_unref_frame(avctx, dst);
106     return AVERROR(ENOMEM);
107 }
108
109 static int update_size(AVCodecContext *avctx, int w, int h)
110 {
111 #define HWACCEL_MAX (CONFIG_VP9_DXVA2_HWACCEL + CONFIG_VP9_D3D11VA_HWACCEL + CONFIG_VP9_VAAPI_HWACCEL)
112     enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmtp = pix_fmts;
113     VP9Context *s = avctx->priv_data;
114     uint8_t *p;
115     int bytesperpixel = s->bytesperpixel, res, cols, rows;
116
117     av_assert0(w > 0 && h > 0);
118
119     if (!(s->pix_fmt == s->gf_fmt && w == s->w && h == s->h)) {
120         if ((res = ff_set_dimensions(avctx, w, h)) < 0)
121             return res;
122
123         switch (s->pix_fmt) {
124         case AV_PIX_FMT_YUV420P:
125 #if CONFIG_VP9_DXVA2_HWACCEL
126             *fmtp++ = AV_PIX_FMT_DXVA2_VLD;
127 #endif
128 #if CONFIG_VP9_D3D11VA_HWACCEL
129             *fmtp++ = AV_PIX_FMT_D3D11VA_VLD;
130 #endif
131 #if CONFIG_VP9_VAAPI_HWACCEL
132             *fmtp++ = AV_PIX_FMT_VAAPI;
133 #endif
134             break;
135         case AV_PIX_FMT_YUV420P10:
136         case AV_PIX_FMT_YUV420P12:
137 #if CONFIG_VP9_VAAPI_HWACCEL
138             *fmtp++ = AV_PIX_FMT_VAAPI;
139 #endif
140             break;
141         }
142
143         *fmtp++ = s->pix_fmt;
144         *fmtp = AV_PIX_FMT_NONE;
145
146         res = ff_thread_get_format(avctx, pix_fmts);
147         if (res < 0)
148             return res;
149
150         avctx->pix_fmt = res;
151         s->gf_fmt  = s->pix_fmt;
152         s->w = w;
153         s->h = h;
154     }
155
156     cols = (w + 7) >> 3;
157     rows = (h + 7) >> 3;
158
159     if (s->intra_pred_data[0] && cols == s->cols && rows == s->rows && s->pix_fmt == s->last_fmt)
160         return 0;
161
162     s->last_fmt  = s->pix_fmt;
163     s->sb_cols   = (w + 63) >> 6;
164     s->sb_rows   = (h + 63) >> 6;
165     s->cols      = (w + 7) >> 3;
166     s->rows      = (h + 7) >> 3;
167
168 #define assign(var, type, n) var = (type) p; p += s->sb_cols * (n) * sizeof(*var)
169     av_freep(&s->intra_pred_data[0]);
170     // FIXME we slightly over-allocate here for subsampled chroma, but a little
171     // bit of padding shouldn't affect performance...
172     p = av_malloc(s->sb_cols * (128 + 192 * bytesperpixel +
173                                 sizeof(*s->lflvl) + 16 * sizeof(*s->above_mv_ctx)));
174     if (!p)
175         return AVERROR(ENOMEM);
176     assign(s->intra_pred_data[0],  uint8_t *,             64 * bytesperpixel);
177     assign(s->intra_pred_data[1],  uint8_t *,             64 * bytesperpixel);
178     assign(s->intra_pred_data[2],  uint8_t *,             64 * bytesperpixel);
179     assign(s->above_y_nnz_ctx,     uint8_t *,             16);
180     assign(s->above_mode_ctx,      uint8_t *,             16);
181     assign(s->above_mv_ctx,        VP56mv(*)[2],          16);
182     assign(s->above_uv_nnz_ctx[0], uint8_t *,             16);
183     assign(s->above_uv_nnz_ctx[1], uint8_t *,             16);
184     assign(s->above_partition_ctx, uint8_t *,              8);
185     assign(s->above_skip_ctx,      uint8_t *,              8);
186     assign(s->above_txfm_ctx,      uint8_t *,              8);
187     assign(s->above_segpred_ctx,   uint8_t *,              8);
188     assign(s->above_intra_ctx,     uint8_t *,              8);
189     assign(s->above_comp_ctx,      uint8_t *,              8);
190     assign(s->above_ref_ctx,       uint8_t *,              8);
191     assign(s->above_filter_ctx,    uint8_t *,              8);
192     assign(s->lflvl,               struct VP9Filter *,     1);
193 #undef assign
194
195     // these will be re-allocated a little later
196     av_freep(&s->b_base);
197     av_freep(&s->block_base);
198
199     if (s->s.h.bpp != s->last_bpp) {
200         ff_vp9dsp_init(&s->dsp, s->s.h.bpp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
201         ff_videodsp_init(&s->vdsp, s->s.h.bpp);
202         s->last_bpp = s->s.h.bpp;
203     }
204
205     return 0;
206 }
207
208 static int update_block_buffers(AVCodecContext *avctx)
209 {
210     VP9Context *s = avctx->priv_data;
211     int chroma_blocks, chroma_eobs, bytesperpixel = s->bytesperpixel;
212
213     if (s->b_base && s->block_base && s->block_alloc_using_2pass == s->s.frames[CUR_FRAME].uses_2pass)
214         return 0;
215
216     av_free(s->b_base);
217     av_free(s->block_base);
218     chroma_blocks = 64 * 64 >> (s->ss_h + s->ss_v);
219     chroma_eobs   = 16 * 16 >> (s->ss_h + s->ss_v);
220     if (s->s.frames[CUR_FRAME].uses_2pass) {
221         int sbs = s->sb_cols * s->sb_rows;
222
223         s->b_base = av_malloc_array(s->cols * s->rows, sizeof(VP9Block));
224         s->block_base = av_mallocz(((64 * 64 + 2 * chroma_blocks) * bytesperpixel * sizeof(int16_t) +
225                                     16 * 16 + 2 * chroma_eobs) * sbs);
226         if (!s->b_base || !s->block_base)
227             return AVERROR(ENOMEM);
228         s->uvblock_base[0] = s->block_base + sbs * 64 * 64 * bytesperpixel;
229         s->uvblock_base[1] = s->uvblock_base[0] + sbs * chroma_blocks * bytesperpixel;
230         s->eob_base = (uint8_t *) (s->uvblock_base[1] + sbs * chroma_blocks * bytesperpixel);
231         s->uveob_base[0] = s->eob_base + 16 * 16 * sbs;
232         s->uveob_base[1] = s->uveob_base[0] + chroma_eobs * sbs;
233     } else {
234         s->b_base = av_malloc(sizeof(VP9Block));
235         s->block_base = av_mallocz((64 * 64 + 2 * chroma_blocks) * bytesperpixel * sizeof(int16_t) +
236                                    16 * 16 + 2 * chroma_eobs);
237         if (!s->b_base || !s->block_base)
238             return AVERROR(ENOMEM);
239         s->uvblock_base[0] = s->block_base + 64 * 64 * bytesperpixel;
240         s->uvblock_base[1] = s->uvblock_base[0] + chroma_blocks * bytesperpixel;
241         s->eob_base = (uint8_t *) (s->uvblock_base[1] + chroma_blocks * bytesperpixel);
242         s->uveob_base[0] = s->eob_base + 16 * 16;
243         s->uveob_base[1] = s->uveob_base[0] + chroma_eobs;
244     }
245     s->block_alloc_using_2pass = s->s.frames[CUR_FRAME].uses_2pass;
246
247     return 0;
248 }
249
250 // for some reason the sign bit is at the end, not the start, of a bit sequence
251 static av_always_inline int get_sbits_inv(GetBitContext *gb, int n)
252 {
253     int v = get_bits(gb, n);
254     return get_bits1(gb) ? -v : v;
255 }
256
257 static av_always_inline int inv_recenter_nonneg(int v, int m)
258 {
259     return v > 2 * m ? v : v & 1 ? m - ((v + 1) >> 1) : m + (v >> 1);
260 }
261
262 // differential forward probability updates
263 static int update_prob(VP56RangeCoder *c, int p)
264 {
265     static const int inv_map_table[255] = {
266           7,  20,  33,  46,  59,  72,  85,  98, 111, 124, 137, 150, 163, 176,
267         189, 202, 215, 228, 241, 254,   1,   2,   3,   4,   5,   6,   8,   9,
268          10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  21,  22,  23,  24,
269          25,  26,  27,  28,  29,  30,  31,  32,  34,  35,  36,  37,  38,  39,
270          40,  41,  42,  43,  44,  45,  47,  48,  49,  50,  51,  52,  53,  54,
271          55,  56,  57,  58,  60,  61,  62,  63,  64,  65,  66,  67,  68,  69,
272          70,  71,  73,  74,  75,  76,  77,  78,  79,  80,  81,  82,  83,  84,
273          86,  87,  88,  89,  90,  91,  92,  93,  94,  95,  96,  97,  99, 100,
274         101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 112, 113, 114, 115,
275         116, 117, 118, 119, 120, 121, 122, 123, 125, 126, 127, 128, 129, 130,
276         131, 132, 133, 134, 135, 136, 138, 139, 140, 141, 142, 143, 144, 145,
277         146, 147, 148, 149, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160,
278         161, 162, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
279         177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 190, 191,
280         192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 203, 204, 205, 206,
281         207, 208, 209, 210, 211, 212, 213, 214, 216, 217, 218, 219, 220, 221,
282         222, 223, 224, 225, 226, 227, 229, 230, 231, 232, 233, 234, 235, 236,
283         237, 238, 239, 240, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251,
284         252, 253, 253,
285     };
286     int d;
287
288     /* This code is trying to do a differential probability update. For a
289      * current probability A in the range [1, 255], the difference to a new
290      * probability of any value can be expressed differentially as 1-A,255-A
291      * where some part of this (absolute range) exists both in positive as
292      * well as the negative part, whereas another part only exists in one
293      * half. We're trying to code this shared part differentially, i.e.
294      * times two where the value of the lowest bit specifies the sign, and
295      * the single part is then coded on top of this. This absolute difference
296      * then again has a value of [0,254], but a bigger value in this range
297      * indicates that we're further away from the original value A, so we
298      * can code this as a VLC code, since higher values are increasingly
299      * unlikely. The first 20 values in inv_map_table[] allow 'cheap, rough'
300      * updates vs. the 'fine, exact' updates further down the range, which
301      * adds one extra dimension to this differential update model. */
302
303     if (!vp8_rac_get(c)) {
304         d = vp8_rac_get_uint(c, 4) + 0;
305     } else if (!vp8_rac_get(c)) {
306         d = vp8_rac_get_uint(c, 4) + 16;
307     } else if (!vp8_rac_get(c)) {
308         d = vp8_rac_get_uint(c, 5) + 32;
309     } else {
310         d = vp8_rac_get_uint(c, 7);
311         if (d >= 65)
312             d = (d << 1) - 65 + vp8_rac_get(c);
313         d += 64;
314         av_assert2(d < FF_ARRAY_ELEMS(inv_map_table));
315     }
316
317     return p <= 128 ? 1 + inv_recenter_nonneg(inv_map_table[d], p - 1) :
318                     255 - inv_recenter_nonneg(inv_map_table[d], 255 - p);
319 }
320
321 static int read_colorspace_details(AVCodecContext *avctx)
322 {
323     static const enum AVColorSpace colorspaces[8] = {
324         AVCOL_SPC_UNSPECIFIED, AVCOL_SPC_BT470BG, AVCOL_SPC_BT709, AVCOL_SPC_SMPTE170M,
325         AVCOL_SPC_SMPTE240M, AVCOL_SPC_BT2020_NCL, AVCOL_SPC_RESERVED, AVCOL_SPC_RGB,
326     };
327     VP9Context *s = avctx->priv_data;
328     int bits = avctx->profile <= 1 ? 0 : 1 + get_bits1(&s->gb); // 0:8, 1:10, 2:12
329
330     s->bpp_index = bits;
331     s->s.h.bpp = 8 + bits * 2;
332     s->bytesperpixel = (7 + s->s.h.bpp) >> 3;
333     avctx->colorspace = colorspaces[get_bits(&s->gb, 3)];
334     if (avctx->colorspace == AVCOL_SPC_RGB) { // RGB = profile 1
335         static const enum AVPixelFormat pix_fmt_rgb[3] = {
336             AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12
337         };
338         s->ss_h = s->ss_v = 0;
339         avctx->color_range = AVCOL_RANGE_JPEG;
340         s->pix_fmt = pix_fmt_rgb[bits];
341         if (avctx->profile & 1) {
342             if (get_bits1(&s->gb)) {
343                 av_log(avctx, AV_LOG_ERROR, "Reserved bit set in RGB\n");
344                 return AVERROR_INVALIDDATA;
345             }
346         } else {
347             av_log(avctx, AV_LOG_ERROR, "RGB not supported in profile %d\n",
348                    avctx->profile);
349             return AVERROR_INVALIDDATA;
350         }
351     } else {
352         static const enum AVPixelFormat pix_fmt_for_ss[3][2 /* v */][2 /* h */] = {
353             { { AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P },
354               { AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV420P } },
355             { { AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV422P10 },
356               { AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV420P10 } },
357             { { AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV422P12 },
358               { AV_PIX_FMT_YUV440P12, AV_PIX_FMT_YUV420P12 } }
359         };
360         avctx->color_range = get_bits1(&s->gb) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
361         if (avctx->profile & 1) {
362             s->ss_h = get_bits1(&s->gb);
363             s->ss_v = get_bits1(&s->gb);
364             s->pix_fmt = pix_fmt_for_ss[bits][s->ss_v][s->ss_h];
365             if (s->pix_fmt == AV_PIX_FMT_YUV420P) {
366                 av_log(avctx, AV_LOG_ERROR, "YUV 4:2:0 not supported in profile %d\n",
367                        avctx->profile);
368                 return AVERROR_INVALIDDATA;
369             } else if (get_bits1(&s->gb)) {
370                 av_log(avctx, AV_LOG_ERROR, "Profile %d color details reserved bit set\n",
371                        avctx->profile);
372                 return AVERROR_INVALIDDATA;
373             }
374         } else {
375             s->ss_h = s->ss_v = 1;
376             s->pix_fmt = pix_fmt_for_ss[bits][1][1];
377         }
378     }
379
380     return 0;
381 }
382
383 static int decode_frame_header(AVCodecContext *avctx,
384                                const uint8_t *data, int size, int *ref)
385 {
386     VP9Context *s = avctx->priv_data;
387     int c, i, j, k, l, m, n, w, h, max, size2, res, sharp;
388     int last_invisible;
389     const uint8_t *data2;
390
391     /* general header */
392     if ((res = init_get_bits8(&s->gb, data, size)) < 0) {
393         av_log(avctx, AV_LOG_ERROR, "Failed to initialize bitstream reader\n");
394         return res;
395     }
396     if (get_bits(&s->gb, 2) != 0x2) { // frame marker
397         av_log(avctx, AV_LOG_ERROR, "Invalid frame marker\n");
398         return AVERROR_INVALIDDATA;
399     }
400     avctx->profile  = get_bits1(&s->gb);
401     avctx->profile |= get_bits1(&s->gb) << 1;
402     if (avctx->profile == 3) avctx->profile += get_bits1(&s->gb);
403     if (avctx->profile > 3) {
404         av_log(avctx, AV_LOG_ERROR, "Profile %d is not yet supported\n", avctx->profile);
405         return AVERROR_INVALIDDATA;
406     }
407     s->s.h.profile = avctx->profile;
408     if (get_bits1(&s->gb)) {
409         *ref = get_bits(&s->gb, 3);
410         return 0;
411     }
412     s->last_keyframe  = s->s.h.keyframe;
413     s->s.h.keyframe     = !get_bits1(&s->gb);
414     last_invisible    = s->s.h.invisible;
415     s->s.h.invisible    = !get_bits1(&s->gb);
416     s->s.h.errorres     = get_bits1(&s->gb);
417     s->s.h.use_last_frame_mvs = !s->s.h.errorres && !last_invisible;
418     if (s->s.h.keyframe) {
419         if (get_bits_long(&s->gb, 24) != VP9_SYNCCODE) { // synccode
420             av_log(avctx, AV_LOG_ERROR, "Invalid sync code\n");
421             return AVERROR_INVALIDDATA;
422         }
423         if ((res = read_colorspace_details(avctx)) < 0)
424             return res;
425         // for profile 1, here follows the subsampling bits
426         s->s.h.refreshrefmask = 0xff;
427         w = get_bits(&s->gb, 16) + 1;
428         h = get_bits(&s->gb, 16) + 1;
429         if (get_bits1(&s->gb)) // display size
430             skip_bits(&s->gb, 32);
431     } else {
432         s->s.h.intraonly  = s->s.h.invisible ? get_bits1(&s->gb) : 0;
433         s->s.h.resetctx   = s->s.h.errorres ? 0 : get_bits(&s->gb, 2);
434         if (s->s.h.intraonly) {
435             if (get_bits_long(&s->gb, 24) != VP9_SYNCCODE) { // synccode
436                 av_log(avctx, AV_LOG_ERROR, "Invalid sync code\n");
437                 return AVERROR_INVALIDDATA;
438             }
439             if (avctx->profile >= 1) {
440                 if ((res = read_colorspace_details(avctx)) < 0)
441                     return res;
442             } else {
443                 s->ss_h = s->ss_v = 1;
444                 s->s.h.bpp = 8;
445                 s->bpp_index = 0;
446                 s->bytesperpixel = 1;
447                 s->pix_fmt = AV_PIX_FMT_YUV420P;
448                 avctx->colorspace = AVCOL_SPC_BT470BG;
449                 avctx->color_range = AVCOL_RANGE_JPEG;
450             }
451             s->s.h.refreshrefmask = get_bits(&s->gb, 8);
452             w = get_bits(&s->gb, 16) + 1;
453             h = get_bits(&s->gb, 16) + 1;
454             if (get_bits1(&s->gb)) // display size
455                 skip_bits(&s->gb, 32);
456         } else {
457             s->s.h.refreshrefmask = get_bits(&s->gb, 8);
458             s->s.h.refidx[0]      = get_bits(&s->gb, 3);
459             s->s.h.signbias[0]    = get_bits1(&s->gb) && !s->s.h.errorres;
460             s->s.h.refidx[1]      = get_bits(&s->gb, 3);
461             s->s.h.signbias[1]    = get_bits1(&s->gb) && !s->s.h.errorres;
462             s->s.h.refidx[2]      = get_bits(&s->gb, 3);
463             s->s.h.signbias[2]    = get_bits1(&s->gb) && !s->s.h.errorres;
464             if (!s->s.refs[s->s.h.refidx[0]].f->buf[0] ||
465                 !s->s.refs[s->s.h.refidx[1]].f->buf[0] ||
466                 !s->s.refs[s->s.h.refidx[2]].f->buf[0]) {
467                 av_log(avctx, AV_LOG_ERROR, "Not all references are available\n");
468                 return AVERROR_INVALIDDATA;
469             }
470             if (get_bits1(&s->gb)) {
471                 w = s->s.refs[s->s.h.refidx[0]].f->width;
472                 h = s->s.refs[s->s.h.refidx[0]].f->height;
473             } else if (get_bits1(&s->gb)) {
474                 w = s->s.refs[s->s.h.refidx[1]].f->width;
475                 h = s->s.refs[s->s.h.refidx[1]].f->height;
476             } else if (get_bits1(&s->gb)) {
477                 w = s->s.refs[s->s.h.refidx[2]].f->width;
478                 h = s->s.refs[s->s.h.refidx[2]].f->height;
479             } else {
480                 w = get_bits(&s->gb, 16) + 1;
481                 h = get_bits(&s->gb, 16) + 1;
482             }
483             // Note that in this code, "CUR_FRAME" is actually before we
484             // have formally allocated a frame, and thus actually represents
485             // the _last_ frame
486             s->s.h.use_last_frame_mvs &= s->s.frames[CUR_FRAME].tf.f->width == w &&
487                                        s->s.frames[CUR_FRAME].tf.f->height == h;
488             if (get_bits1(&s->gb)) // display size
489                 skip_bits(&s->gb, 32);
490             s->s.h.highprecisionmvs = get_bits1(&s->gb);
491             s->s.h.filtermode = get_bits1(&s->gb) ? FILTER_SWITCHABLE :
492                                                   get_bits(&s->gb, 2);
493             s->s.h.allowcompinter = s->s.h.signbias[0] != s->s.h.signbias[1] ||
494                                   s->s.h.signbias[0] != s->s.h.signbias[2];
495             if (s->s.h.allowcompinter) {
496                 if (s->s.h.signbias[0] == s->s.h.signbias[1]) {
497                     s->s.h.fixcompref    = 2;
498                     s->s.h.varcompref[0] = 0;
499                     s->s.h.varcompref[1] = 1;
500                 } else if (s->s.h.signbias[0] == s->s.h.signbias[2]) {
501                     s->s.h.fixcompref    = 1;
502                     s->s.h.varcompref[0] = 0;
503                     s->s.h.varcompref[1] = 2;
504                 } else {
505                     s->s.h.fixcompref    = 0;
506                     s->s.h.varcompref[0] = 1;
507                     s->s.h.varcompref[1] = 2;
508                 }
509             }
510         }
511     }
512     s->s.h.refreshctx   = s->s.h.errorres ? 0 : get_bits1(&s->gb);
513     s->s.h.parallelmode = s->s.h.errorres ? 1 : get_bits1(&s->gb);
514     s->s.h.framectxid   = c = get_bits(&s->gb, 2);
515     if (s->s.h.keyframe || s->s.h.intraonly)
516         s->s.h.framectxid = 0; // BUG: libvpx ignores this field in keyframes
517
518     /* loopfilter header data */
519     if (s->s.h.keyframe || s->s.h.errorres || s->s.h.intraonly) {
520         // reset loopfilter defaults
521         s->s.h.lf_delta.ref[0] = 1;
522         s->s.h.lf_delta.ref[1] = 0;
523         s->s.h.lf_delta.ref[2] = -1;
524         s->s.h.lf_delta.ref[3] = -1;
525         s->s.h.lf_delta.mode[0] = 0;
526         s->s.h.lf_delta.mode[1] = 0;
527         memset(s->s.h.segmentation.feat, 0, sizeof(s->s.h.segmentation.feat));
528     }
529     s->s.h.filter.level = get_bits(&s->gb, 6);
530     sharp = get_bits(&s->gb, 3);
531     // if sharpness changed, reinit lim/mblim LUTs. if it didn't change, keep
532     // the old cache values since they are still valid
533     if (s->s.h.filter.sharpness != sharp)
534         memset(s->filter_lut.lim_lut, 0, sizeof(s->filter_lut.lim_lut));
535     s->s.h.filter.sharpness = sharp;
536     if ((s->s.h.lf_delta.enabled = get_bits1(&s->gb))) {
537         if ((s->s.h.lf_delta.updated = get_bits1(&s->gb))) {
538             for (i = 0; i < 4; i++)
539                 if (get_bits1(&s->gb))
540                     s->s.h.lf_delta.ref[i] = get_sbits_inv(&s->gb, 6);
541             for (i = 0; i < 2; i++)
542                 if (get_bits1(&s->gb))
543                     s->s.h.lf_delta.mode[i] = get_sbits_inv(&s->gb, 6);
544         }
545     }
546
547     /* quantization header data */
548     s->s.h.yac_qi      = get_bits(&s->gb, 8);
549     s->s.h.ydc_qdelta  = get_bits1(&s->gb) ? get_sbits_inv(&s->gb, 4) : 0;
550     s->s.h.uvdc_qdelta = get_bits1(&s->gb) ? get_sbits_inv(&s->gb, 4) : 0;
551     s->s.h.uvac_qdelta = get_bits1(&s->gb) ? get_sbits_inv(&s->gb, 4) : 0;
552     s->s.h.lossless    = s->s.h.yac_qi == 0 && s->s.h.ydc_qdelta == 0 &&
553                        s->s.h.uvdc_qdelta == 0 && s->s.h.uvac_qdelta == 0;
554     if (s->s.h.lossless)
555         avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
556
557     /* segmentation header info */
558     if ((s->s.h.segmentation.enabled = get_bits1(&s->gb))) {
559         if ((s->s.h.segmentation.update_map = get_bits1(&s->gb))) {
560             for (i = 0; i < 7; i++)
561                 s->s.h.segmentation.prob[i] = get_bits1(&s->gb) ?
562                                  get_bits(&s->gb, 8) : 255;
563             if ((s->s.h.segmentation.temporal = get_bits1(&s->gb))) {
564                 for (i = 0; i < 3; i++)
565                     s->s.h.segmentation.pred_prob[i] = get_bits1(&s->gb) ?
566                                          get_bits(&s->gb, 8) : 255;
567             }
568         }
569
570         if (get_bits1(&s->gb)) {
571             s->s.h.segmentation.absolute_vals = get_bits1(&s->gb);
572             for (i = 0; i < 8; i++) {
573                 if ((s->s.h.segmentation.feat[i].q_enabled = get_bits1(&s->gb)))
574                     s->s.h.segmentation.feat[i].q_val = get_sbits_inv(&s->gb, 8);
575                 if ((s->s.h.segmentation.feat[i].lf_enabled = get_bits1(&s->gb)))
576                     s->s.h.segmentation.feat[i].lf_val = get_sbits_inv(&s->gb, 6);
577                 if ((s->s.h.segmentation.feat[i].ref_enabled = get_bits1(&s->gb)))
578                     s->s.h.segmentation.feat[i].ref_val = get_bits(&s->gb, 2);
579                 s->s.h.segmentation.feat[i].skip_enabled = get_bits1(&s->gb);
580             }
581         }
582     }
583
584     // set qmul[] based on Y/UV, AC/DC and segmentation Q idx deltas
585     for (i = 0; i < (s->s.h.segmentation.enabled ? 8 : 1); i++) {
586         int qyac, qydc, quvac, quvdc, lflvl, sh;
587
588         if (s->s.h.segmentation.enabled && s->s.h.segmentation.feat[i].q_enabled) {
589             if (s->s.h.segmentation.absolute_vals)
590                 qyac = av_clip_uintp2(s->s.h.segmentation.feat[i].q_val, 8);
591             else
592                 qyac = av_clip_uintp2(s->s.h.yac_qi + s->s.h.segmentation.feat[i].q_val, 8);
593         } else {
594             qyac  = s->s.h.yac_qi;
595         }
596         qydc  = av_clip_uintp2(qyac + s->s.h.ydc_qdelta, 8);
597         quvdc = av_clip_uintp2(qyac + s->s.h.uvdc_qdelta, 8);
598         quvac = av_clip_uintp2(qyac + s->s.h.uvac_qdelta, 8);
599         qyac  = av_clip_uintp2(qyac, 8);
600
601         s->s.h.segmentation.feat[i].qmul[0][0] = ff_vp9_dc_qlookup[s->bpp_index][qydc];
602         s->s.h.segmentation.feat[i].qmul[0][1] = ff_vp9_ac_qlookup[s->bpp_index][qyac];
603         s->s.h.segmentation.feat[i].qmul[1][0] = ff_vp9_dc_qlookup[s->bpp_index][quvdc];
604         s->s.h.segmentation.feat[i].qmul[1][1] = ff_vp9_ac_qlookup[s->bpp_index][quvac];
605
606         sh = s->s.h.filter.level >= 32;
607         if (s->s.h.segmentation.enabled && s->s.h.segmentation.feat[i].lf_enabled) {
608             if (s->s.h.segmentation.absolute_vals)
609                 lflvl = av_clip_uintp2(s->s.h.segmentation.feat[i].lf_val, 6);
610             else
611                 lflvl = av_clip_uintp2(s->s.h.filter.level + s->s.h.segmentation.feat[i].lf_val, 6);
612         } else {
613             lflvl  = s->s.h.filter.level;
614         }
615         if (s->s.h.lf_delta.enabled) {
616             s->s.h.segmentation.feat[i].lflvl[0][0] =
617             s->s.h.segmentation.feat[i].lflvl[0][1] =
618                 av_clip_uintp2(lflvl + (s->s.h.lf_delta.ref[0] * (1 << sh)), 6);
619             for (j = 1; j < 4; j++) {
620                 s->s.h.segmentation.feat[i].lflvl[j][0] =
621                     av_clip_uintp2(lflvl + ((s->s.h.lf_delta.ref[j] +
622                                              s->s.h.lf_delta.mode[0]) * (1 << sh)), 6);
623                 s->s.h.segmentation.feat[i].lflvl[j][1] =
624                     av_clip_uintp2(lflvl + ((s->s.h.lf_delta.ref[j] +
625                                              s->s.h.lf_delta.mode[1]) * (1 << sh)), 6);
626             }
627         } else {
628             memset(s->s.h.segmentation.feat[i].lflvl, lflvl,
629                    sizeof(s->s.h.segmentation.feat[i].lflvl));
630         }
631     }
632
633     /* tiling info */
634     if ((res = update_size(avctx, w, h)) < 0) {
635         av_log(avctx, AV_LOG_ERROR, "Failed to initialize decoder for %dx%d @ %d\n",
636                w, h, s->pix_fmt);
637         return res;
638     }
639     for (s->s.h.tiling.log2_tile_cols = 0;
640          s->sb_cols > (64 << s->s.h.tiling.log2_tile_cols);
641          s->s.h.tiling.log2_tile_cols++) ;
642     for (max = 0; (s->sb_cols >> max) >= 4; max++) ;
643     max = FFMAX(0, max - 1);
644     while (max > s->s.h.tiling.log2_tile_cols) {
645         if (get_bits1(&s->gb))
646             s->s.h.tiling.log2_tile_cols++;
647         else
648             break;
649     }
650     s->s.h.tiling.log2_tile_rows = decode012(&s->gb);
651     s->s.h.tiling.tile_rows = 1 << s->s.h.tiling.log2_tile_rows;
652     if (s->s.h.tiling.tile_cols != (1 << s->s.h.tiling.log2_tile_cols)) {
653         s->s.h.tiling.tile_cols = 1 << s->s.h.tiling.log2_tile_cols;
654         s->c_b = av_fast_realloc(s->c_b, &s->c_b_size,
655                                  sizeof(VP56RangeCoder) * s->s.h.tiling.tile_cols);
656         if (!s->c_b) {
657             av_log(avctx, AV_LOG_ERROR, "Ran out of memory during range coder init\n");
658             return AVERROR(ENOMEM);
659         }
660     }
661
662     /* check reference frames */
663     if (!s->s.h.keyframe && !s->s.h.intraonly) {
664         for (i = 0; i < 3; i++) {
665             AVFrame *ref = s->s.refs[s->s.h.refidx[i]].f;
666             int refw = ref->width, refh = ref->height;
667
668             if (ref->format != avctx->pix_fmt) {
669                 av_log(avctx, AV_LOG_ERROR,
670                        "Ref pixfmt (%s) did not match current frame (%s)",
671                        av_get_pix_fmt_name(ref->format),
672                        av_get_pix_fmt_name(avctx->pix_fmt));
673                 return AVERROR_INVALIDDATA;
674             } else if (refw == w && refh == h) {
675                 s->mvscale[i][0] = s->mvscale[i][1] = 0;
676             } else {
677                 if (w * 2 < refw || h * 2 < refh || w > 16 * refw || h > 16 * refh) {
678                     av_log(avctx, AV_LOG_ERROR,
679                            "Invalid ref frame dimensions %dx%d for frame size %dx%d\n",
680                            refw, refh, w, h);
681                     return AVERROR_INVALIDDATA;
682                 }
683                 s->mvscale[i][0] = (refw << 14) / w;
684                 s->mvscale[i][1] = (refh << 14) / h;
685                 s->mvstep[i][0] = 16 * s->mvscale[i][0] >> 14;
686                 s->mvstep[i][1] = 16 * s->mvscale[i][1] >> 14;
687             }
688         }
689     }
690
691     if (s->s.h.keyframe || s->s.h.errorres || (s->s.h.intraonly && s->s.h.resetctx == 3)) {
692         s->prob_ctx[0].p = s->prob_ctx[1].p = s->prob_ctx[2].p =
693                            s->prob_ctx[3].p = ff_vp9_default_probs;
694         memcpy(s->prob_ctx[0].coef, ff_vp9_default_coef_probs,
695                sizeof(ff_vp9_default_coef_probs));
696         memcpy(s->prob_ctx[1].coef, ff_vp9_default_coef_probs,
697                sizeof(ff_vp9_default_coef_probs));
698         memcpy(s->prob_ctx[2].coef, ff_vp9_default_coef_probs,
699                sizeof(ff_vp9_default_coef_probs));
700         memcpy(s->prob_ctx[3].coef, ff_vp9_default_coef_probs,
701                sizeof(ff_vp9_default_coef_probs));
702     } else if (s->s.h.intraonly && s->s.h.resetctx == 2) {
703         s->prob_ctx[c].p = ff_vp9_default_probs;
704         memcpy(s->prob_ctx[c].coef, ff_vp9_default_coef_probs,
705                sizeof(ff_vp9_default_coef_probs));
706     }
707
708     // next 16 bits is size of the rest of the header (arith-coded)
709     s->s.h.compressed_header_size = size2 = get_bits(&s->gb, 16);
710     s->s.h.uncompressed_header_size = (get_bits_count(&s->gb) + 7) / 8;
711
712     data2 = align_get_bits(&s->gb);
713     if (size2 > size - (data2 - data)) {
714         av_log(avctx, AV_LOG_ERROR, "Invalid compressed header size\n");
715         return AVERROR_INVALIDDATA;
716     }
717     res = ff_vp56_init_range_decoder(&s->c, data2, size2);
718     if (res < 0)
719         return res;
720
721     if (vp56_rac_get_prob_branchy(&s->c, 128)) { // marker bit
722         av_log(avctx, AV_LOG_ERROR, "Marker bit was set\n");
723         return AVERROR_INVALIDDATA;
724     }
725
726     if (s->s.h.keyframe || s->s.h.intraonly) {
727         memset(s->counts.coef, 0, sizeof(s->counts.coef));
728         memset(s->counts.eob,  0, sizeof(s->counts.eob));
729     } else {
730         memset(&s->counts, 0, sizeof(s->counts));
731     }
732     // FIXME is it faster to not copy here, but do it down in the fw updates
733     // as explicit copies if the fw update is missing (and skip the copy upon
734     // fw update)?
735     s->prob.p = s->prob_ctx[c].p;
736
737     // txfm updates
738     if (s->s.h.lossless) {
739         s->s.h.txfmmode = TX_4X4;
740     } else {
741         s->s.h.txfmmode = vp8_rac_get_uint(&s->c, 2);
742         if (s->s.h.txfmmode == 3)
743             s->s.h.txfmmode += vp8_rac_get(&s->c);
744
745         if (s->s.h.txfmmode == TX_SWITCHABLE) {
746             for (i = 0; i < 2; i++)
747                 if (vp56_rac_get_prob_branchy(&s->c, 252))
748                     s->prob.p.tx8p[i] = update_prob(&s->c, s->prob.p.tx8p[i]);
749             for (i = 0; i < 2; i++)
750                 for (j = 0; j < 2; j++)
751                     if (vp56_rac_get_prob_branchy(&s->c, 252))
752                         s->prob.p.tx16p[i][j] =
753                             update_prob(&s->c, s->prob.p.tx16p[i][j]);
754             for (i = 0; i < 2; i++)
755                 for (j = 0; j < 3; j++)
756                     if (vp56_rac_get_prob_branchy(&s->c, 252))
757                         s->prob.p.tx32p[i][j] =
758                             update_prob(&s->c, s->prob.p.tx32p[i][j]);
759         }
760     }
761
762     // coef updates
763     for (i = 0; i < 4; i++) {
764         uint8_t (*ref)[2][6][6][3] = s->prob_ctx[c].coef[i];
765         if (vp8_rac_get(&s->c)) {
766             for (j = 0; j < 2; j++)
767                 for (k = 0; k < 2; k++)
768                     for (l = 0; l < 6; l++)
769                         for (m = 0; m < 6; m++) {
770                             uint8_t *p = s->prob.coef[i][j][k][l][m];
771                             uint8_t *r = ref[j][k][l][m];
772                             if (m >= 3 && l == 0) // dc only has 3 pt
773                                 break;
774                             for (n = 0; n < 3; n++) {
775                                 if (vp56_rac_get_prob_branchy(&s->c, 252)) {
776                                     p[n] = update_prob(&s->c, r[n]);
777                                 } else {
778                                     p[n] = r[n];
779                                 }
780                             }
781                             p[3] = 0;
782                         }
783         } else {
784             for (j = 0; j < 2; j++)
785                 for (k = 0; k < 2; k++)
786                     for (l = 0; l < 6; l++)
787                         for (m = 0; m < 6; m++) {
788                             uint8_t *p = s->prob.coef[i][j][k][l][m];
789                             uint8_t *r = ref[j][k][l][m];
790                             if (m > 3 && l == 0) // dc only has 3 pt
791                                 break;
792                             memcpy(p, r, 3);
793                             p[3] = 0;
794                         }
795         }
796         if (s->s.h.txfmmode == i)
797             break;
798     }
799
800     // mode updates
801     for (i = 0; i < 3; i++)
802         if (vp56_rac_get_prob_branchy(&s->c, 252))
803             s->prob.p.skip[i] = update_prob(&s->c, s->prob.p.skip[i]);
804     if (!s->s.h.keyframe && !s->s.h.intraonly) {
805         for (i = 0; i < 7; i++)
806             for (j = 0; j < 3; j++)
807                 if (vp56_rac_get_prob_branchy(&s->c, 252))
808                     s->prob.p.mv_mode[i][j] =
809                         update_prob(&s->c, s->prob.p.mv_mode[i][j]);
810
811         if (s->s.h.filtermode == FILTER_SWITCHABLE)
812             for (i = 0; i < 4; i++)
813                 for (j = 0; j < 2; j++)
814                     if (vp56_rac_get_prob_branchy(&s->c, 252))
815                         s->prob.p.filter[i][j] =
816                             update_prob(&s->c, s->prob.p.filter[i][j]);
817
818         for (i = 0; i < 4; i++)
819             if (vp56_rac_get_prob_branchy(&s->c, 252))
820                 s->prob.p.intra[i] = update_prob(&s->c, s->prob.p.intra[i]);
821
822         if (s->s.h.allowcompinter) {
823             s->s.h.comppredmode = vp8_rac_get(&s->c);
824             if (s->s.h.comppredmode)
825                 s->s.h.comppredmode += vp8_rac_get(&s->c);
826             if (s->s.h.comppredmode == PRED_SWITCHABLE)
827                 for (i = 0; i < 5; i++)
828                     if (vp56_rac_get_prob_branchy(&s->c, 252))
829                         s->prob.p.comp[i] =
830                             update_prob(&s->c, s->prob.p.comp[i]);
831         } else {
832             s->s.h.comppredmode = PRED_SINGLEREF;
833         }
834
835         if (s->s.h.comppredmode != PRED_COMPREF) {
836             for (i = 0; i < 5; i++) {
837                 if (vp56_rac_get_prob_branchy(&s->c, 252))
838                     s->prob.p.single_ref[i][0] =
839                         update_prob(&s->c, s->prob.p.single_ref[i][0]);
840                 if (vp56_rac_get_prob_branchy(&s->c, 252))
841                     s->prob.p.single_ref[i][1] =
842                         update_prob(&s->c, s->prob.p.single_ref[i][1]);
843             }
844         }
845
846         if (s->s.h.comppredmode != PRED_SINGLEREF) {
847             for (i = 0; i < 5; i++)
848                 if (vp56_rac_get_prob_branchy(&s->c, 252))
849                     s->prob.p.comp_ref[i] =
850                         update_prob(&s->c, s->prob.p.comp_ref[i]);
851         }
852
853         for (i = 0; i < 4; i++)
854             for (j = 0; j < 9; j++)
855                 if (vp56_rac_get_prob_branchy(&s->c, 252))
856                     s->prob.p.y_mode[i][j] =
857                         update_prob(&s->c, s->prob.p.y_mode[i][j]);
858
859         for (i = 0; i < 4; i++)
860             for (j = 0; j < 4; j++)
861                 for (k = 0; k < 3; k++)
862                     if (vp56_rac_get_prob_branchy(&s->c, 252))
863                         s->prob.p.partition[3 - i][j][k] =
864                             update_prob(&s->c, s->prob.p.partition[3 - i][j][k]);
865
866         // mv fields don't use the update_prob subexp model for some reason
867         for (i = 0; i < 3; i++)
868             if (vp56_rac_get_prob_branchy(&s->c, 252))
869                 s->prob.p.mv_joint[i] = (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
870
871         for (i = 0; i < 2; i++) {
872             if (vp56_rac_get_prob_branchy(&s->c, 252))
873                 s->prob.p.mv_comp[i].sign = (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
874
875             for (j = 0; j < 10; j++)
876                 if (vp56_rac_get_prob_branchy(&s->c, 252))
877                     s->prob.p.mv_comp[i].classes[j] =
878                         (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
879
880             if (vp56_rac_get_prob_branchy(&s->c, 252))
881                 s->prob.p.mv_comp[i].class0 = (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].bits[j] =
886                         (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
887         }
888
889         for (i = 0; i < 2; i++) {
890             for (j = 0; j < 2; j++)
891                 for (k = 0; k < 3; k++)
892                     if (vp56_rac_get_prob_branchy(&s->c, 252))
893                         s->prob.p.mv_comp[i].class0_fp[j][k] =
894                             (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
895
896             for (j = 0; j < 3; j++)
897                 if (vp56_rac_get_prob_branchy(&s->c, 252))
898                     s->prob.p.mv_comp[i].fp[j] =
899                         (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
900         }
901
902         if (s->s.h.highprecisionmvs) {
903             for (i = 0; i < 2; i++) {
904                 if (vp56_rac_get_prob_branchy(&s->c, 252))
905                     s->prob.p.mv_comp[i].class0_hp =
906                         (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
907
908                 if (vp56_rac_get_prob_branchy(&s->c, 252))
909                     s->prob.p.mv_comp[i].hp =
910                         (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
911             }
912         }
913     }
914
915     return (data2 - data) + size2;
916 }
917
918 static void decode_sb(AVCodecContext *avctx, int row, int col, struct VP9Filter *lflvl,
919                       ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
920 {
921     VP9Context *s = avctx->priv_data;
922     int c = ((s->above_partition_ctx[col] >> (3 - bl)) & 1) |
923             (((s->left_partition_ctx[row & 0x7] >> (3 - bl)) & 1) << 1);
924     const uint8_t *p = s->s.h.keyframe || s->s.h.intraonly ? ff_vp9_default_kf_partition_probs[bl][c] :
925                                                      s->prob.p.partition[bl][c];
926     enum BlockPartition bp;
927     ptrdiff_t hbs = 4 >> bl;
928     AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
929     ptrdiff_t y_stride = f->linesize[0], uv_stride = f->linesize[1];
930     int bytesperpixel = s->bytesperpixel;
931
932     if (bl == BL_8X8) {
933         bp = vp8_rac_get_tree(&s->c, ff_vp9_partition_tree, p);
934         ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, bl, bp);
935     } else if (col + hbs < s->cols) { // FIXME why not <=?
936         if (row + hbs < s->rows) { // FIXME why not <=?
937             bp = vp8_rac_get_tree(&s->c, ff_vp9_partition_tree, p);
938             switch (bp) {
939             case PARTITION_NONE:
940                 ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, bl, bp);
941                 break;
942             case PARTITION_H:
943                 ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, bl, bp);
944                 yoff  += hbs * 8 * y_stride;
945                 uvoff += hbs * 8 * uv_stride >> s->ss_v;
946                 ff_vp9_decode_block(avctx, row + hbs, col, lflvl, yoff, uvoff, bl, bp);
947                 break;
948             case PARTITION_V:
949                 ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, bl, bp);
950                 yoff  += hbs * 8 * bytesperpixel;
951                 uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
952                 ff_vp9_decode_block(avctx, row, col + hbs, lflvl, yoff, uvoff, bl, bp);
953                 break;
954             case PARTITION_SPLIT:
955                 decode_sb(avctx, row, col, lflvl, yoff, uvoff, bl + 1);
956                 decode_sb(avctx, row, col + hbs, lflvl,
957                           yoff + 8 * hbs * bytesperpixel,
958                           uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
959                 yoff  += hbs * 8 * y_stride;
960                 uvoff += hbs * 8 * uv_stride >> s->ss_v;
961                 decode_sb(avctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
962                 decode_sb(avctx, row + hbs, col + hbs, lflvl,
963                           yoff + 8 * hbs * bytesperpixel,
964                           uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
965                 break;
966             default:
967                 av_assert0(0);
968             }
969         } else if (vp56_rac_get_prob_branchy(&s->c, p[1])) {
970             bp = PARTITION_SPLIT;
971             decode_sb(avctx, row, col, lflvl, yoff, uvoff, bl + 1);
972             decode_sb(avctx, row, col + hbs, lflvl,
973                       yoff + 8 * hbs * bytesperpixel,
974                       uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
975         } else {
976             bp = PARTITION_H;
977             ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, bl, bp);
978         }
979     } else if (row + hbs < s->rows) { // FIXME why not <=?
980         if (vp56_rac_get_prob_branchy(&s->c, p[2])) {
981             bp = PARTITION_SPLIT;
982             decode_sb(avctx, row, col, lflvl, yoff, uvoff, bl + 1);
983             yoff  += hbs * 8 * y_stride;
984             uvoff += hbs * 8 * uv_stride >> s->ss_v;
985             decode_sb(avctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
986         } else {
987             bp = PARTITION_V;
988             ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, bl, bp);
989         }
990     } else {
991         bp = PARTITION_SPLIT;
992         decode_sb(avctx, row, col, lflvl, yoff, uvoff, bl + 1);
993     }
994     s->counts.partition[bl][c][bp]++;
995 }
996
997 static void decode_sb_mem(AVCodecContext *avctx, int row, int col, struct VP9Filter *lflvl,
998                           ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
999 {
1000     VP9Context *s = avctx->priv_data;
1001     VP9Block *b = s->b;
1002     ptrdiff_t hbs = 4 >> bl;
1003     AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
1004     ptrdiff_t y_stride = f->linesize[0], uv_stride = f->linesize[1];
1005     int bytesperpixel = s->bytesperpixel;
1006
1007     if (bl == BL_8X8) {
1008         av_assert2(b->bl == BL_8X8);
1009         ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, b->bl, b->bp);
1010     } else if (s->b->bl == bl) {
1011         ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, b->bl, b->bp);
1012         if (b->bp == PARTITION_H && row + hbs < s->rows) {
1013             yoff  += hbs * 8 * y_stride;
1014             uvoff += hbs * 8 * uv_stride >> s->ss_v;
1015             ff_vp9_decode_block(avctx, row + hbs, col, lflvl, yoff, uvoff, b->bl, b->bp);
1016         } else if (b->bp == PARTITION_V && col + hbs < s->cols) {
1017             yoff  += hbs * 8 * bytesperpixel;
1018             uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
1019             ff_vp9_decode_block(avctx, row, col + hbs, lflvl, yoff, uvoff, b->bl, b->bp);
1020         }
1021     } else {
1022         decode_sb_mem(avctx, row, col, lflvl, yoff, uvoff, bl + 1);
1023         if (col + hbs < s->cols) { // FIXME why not <=?
1024             if (row + hbs < s->rows) {
1025                 decode_sb_mem(avctx, row, col + hbs, lflvl, yoff + 8 * hbs * bytesperpixel,
1026                               uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
1027                 yoff  += hbs * 8 * y_stride;
1028                 uvoff += hbs * 8 * uv_stride >> s->ss_v;
1029                 decode_sb_mem(avctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
1030                 decode_sb_mem(avctx, row + hbs, col + hbs, lflvl,
1031                               yoff + 8 * hbs * bytesperpixel,
1032                               uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
1033             } else {
1034                 yoff  += hbs * 8 * bytesperpixel;
1035                 uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
1036                 decode_sb_mem(avctx, row, col + hbs, lflvl, yoff, uvoff, bl + 1);
1037             }
1038         } else if (row + hbs < s->rows) {
1039             yoff  += hbs * 8 * y_stride;
1040             uvoff += hbs * 8 * uv_stride >> s->ss_v;
1041             decode_sb_mem(avctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
1042         }
1043     }
1044 }
1045
1046 static av_always_inline void filter_plane_cols(VP9Context *s, int col, int ss_h, int ss_v,
1047                                                uint8_t *lvl, uint8_t (*mask)[4],
1048                                                uint8_t *dst, ptrdiff_t ls)
1049 {
1050     int y, x, bytesperpixel = s->bytesperpixel;
1051
1052     // filter edges between columns (e.g. block1 | block2)
1053     for (y = 0; y < 8; y += 2 << ss_v, dst += 16 * ls, lvl += 16 << ss_v) {
1054         uint8_t *ptr = dst, *l = lvl, *hmask1 = mask[y], *hmask2 = mask[y + 1 + ss_v];
1055         unsigned hm1 = hmask1[0] | hmask1[1] | hmask1[2], hm13 = hmask1[3];
1056         unsigned hm2 = hmask2[1] | hmask2[2], hm23 = hmask2[3];
1057         unsigned hm = hm1 | hm2 | hm13 | hm23;
1058
1059         for (x = 1; hm & ~(x - 1); x <<= 1, ptr += 8 * bytesperpixel >> ss_h) {
1060             if (col || x > 1) {
1061                 if (hm1 & x) {
1062                     int L = *l, H = L >> 4;
1063                     int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
1064
1065                     if (hmask1[0] & x) {
1066                         if (hmask2[0] & x) {
1067                             av_assert2(l[8 << ss_v] == L);
1068                             s->dsp.loop_filter_16[0](ptr, ls, E, I, H);
1069                         } else {
1070                             s->dsp.loop_filter_8[2][0](ptr, ls, E, I, H);
1071                         }
1072                     } else if (hm2 & x) {
1073                         L = l[8 << ss_v];
1074                         H |= (L >> 4) << 8;
1075                         E |= s->filter_lut.mblim_lut[L] << 8;
1076                         I |= s->filter_lut.lim_lut[L] << 8;
1077                         s->dsp.loop_filter_mix2[!!(hmask1[1] & x)]
1078                                                [!!(hmask2[1] & x)]
1079                                                [0](ptr, ls, E, I, H);
1080                     } else {
1081                         s->dsp.loop_filter_8[!!(hmask1[1] & x)]
1082                                             [0](ptr, ls, E, I, H);
1083                     }
1084                 } else if (hm2 & x) {
1085                     int L = l[8 << ss_v], H = L >> 4;
1086                     int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
1087
1088                     s->dsp.loop_filter_8[!!(hmask2[1] & x)]
1089                                         [0](ptr + 8 * ls, ls, E, I, H);
1090                 }
1091             }
1092             if (ss_h) {
1093                 if (x & 0xAA)
1094                     l += 2;
1095             } else {
1096                 if (hm13 & x) {
1097                     int L = *l, H = L >> 4;
1098                     int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
1099
1100                     if (hm23 & x) {
1101                         L = l[8 << ss_v];
1102                         H |= (L >> 4) << 8;
1103                         E |= s->filter_lut.mblim_lut[L] << 8;
1104                         I |= s->filter_lut.lim_lut[L] << 8;
1105                         s->dsp.loop_filter_mix2[0][0][0](ptr + 4 * bytesperpixel, ls, E, I, H);
1106                     } else {
1107                         s->dsp.loop_filter_8[0][0](ptr + 4 * bytesperpixel, ls, E, I, H);
1108                     }
1109                 } else if (hm23 & x) {
1110                     int L = l[8 << ss_v], H = L >> 4;
1111                     int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
1112
1113                     s->dsp.loop_filter_8[0][0](ptr + 8 * ls + 4 * bytesperpixel, ls, E, I, H);
1114                 }
1115                 l++;
1116             }
1117         }
1118     }
1119 }
1120
1121 static av_always_inline void filter_plane_rows(VP9Context *s, int row, int ss_h, int ss_v,
1122                                                uint8_t *lvl, uint8_t (*mask)[4],
1123                                                uint8_t *dst, ptrdiff_t ls)
1124 {
1125     int y, x, bytesperpixel = s->bytesperpixel;
1126
1127     //                                 block1
1128     // filter edges between rows (e.g. ------)
1129     //                                 block2
1130     for (y = 0; y < 8; y++, dst += 8 * ls >> ss_v) {
1131         uint8_t *ptr = dst, *l = lvl, *vmask = mask[y];
1132         unsigned vm = vmask[0] | vmask[1] | vmask[2], vm3 = vmask[3];
1133
1134         for (x = 1; vm & ~(x - 1); x <<= (2 << ss_h), ptr += 16 * bytesperpixel, l += 2 << ss_h) {
1135             if (row || y) {
1136                 if (vm & x) {
1137                     int L = *l, H = L >> 4;
1138                     int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
1139
1140                     if (vmask[0] & x) {
1141                         if (vmask[0] & (x << (1 + ss_h))) {
1142                             av_assert2(l[1 + ss_h] == L);
1143                             s->dsp.loop_filter_16[1](ptr, ls, E, I, H);
1144                         } else {
1145                             s->dsp.loop_filter_8[2][1](ptr, ls, E, I, H);
1146                         }
1147                     } else if (vm & (x << (1 + ss_h))) {
1148                         L = l[1 + ss_h];
1149                         H |= (L >> 4) << 8;
1150                         E |= s->filter_lut.mblim_lut[L] << 8;
1151                         I |= s->filter_lut.lim_lut[L] << 8;
1152                         s->dsp.loop_filter_mix2[!!(vmask[1] &  x)]
1153                                                [!!(vmask[1] & (x << (1 + ss_h)))]
1154                                                [1](ptr, ls, E, I, H);
1155                     } else {
1156                         s->dsp.loop_filter_8[!!(vmask[1] & x)]
1157                                             [1](ptr, ls, E, I, H);
1158                     }
1159                 } else if (vm & (x << (1 + ss_h))) {
1160                     int L = l[1 + ss_h], H = L >> 4;
1161                     int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
1162
1163                     s->dsp.loop_filter_8[!!(vmask[1] & (x << (1 + ss_h)))]
1164                                         [1](ptr + 8 * bytesperpixel, ls, E, I, H);
1165                 }
1166             }
1167             if (!ss_v) {
1168                 if (vm3 & x) {
1169                     int L = *l, H = L >> 4;
1170                     int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
1171
1172                     if (vm3 & (x << (1 + ss_h))) {
1173                         L = l[1 + ss_h];
1174                         H |= (L >> 4) << 8;
1175                         E |= s->filter_lut.mblim_lut[L] << 8;
1176                         I |= s->filter_lut.lim_lut[L] << 8;
1177                         s->dsp.loop_filter_mix2[0][0][1](ptr + ls * 4, ls, E, I, H);
1178                     } else {
1179                         s->dsp.loop_filter_8[0][1](ptr + ls * 4, ls, E, I, H);
1180                     }
1181                 } else if (vm3 & (x << (1 + ss_h))) {
1182                     int L = l[1 + ss_h], H = L >> 4;
1183                     int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
1184
1185                     s->dsp.loop_filter_8[0][1](ptr + ls * 4 + 8 * bytesperpixel, ls, E, I, H);
1186                 }
1187             }
1188         }
1189         if (ss_v) {
1190             if (y & 1)
1191                 lvl += 16;
1192         } else {
1193             lvl += 8;
1194         }
1195     }
1196 }
1197
1198 static void loopfilter_sb(AVCodecContext *avctx, struct VP9Filter *lflvl,
1199                           int row, int col, ptrdiff_t yoff, ptrdiff_t uvoff)
1200 {
1201     VP9Context *s = avctx->priv_data;
1202     AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
1203     uint8_t *dst = f->data[0] + yoff;
1204     ptrdiff_t ls_y = f->linesize[0], ls_uv = f->linesize[1];
1205     uint8_t (*uv_masks)[8][4] = lflvl->mask[s->ss_h | s->ss_v];
1206     int p;
1207
1208     // FIXME in how far can we interleave the v/h loopfilter calls? E.g.
1209     // if you think of them as acting on a 8x8 block max, we can interleave
1210     // each v/h within the single x loop, but that only works if we work on
1211     // 8 pixel blocks, and we won't always do that (we want at least 16px
1212     // to use SSE2 optimizations, perhaps 32 for AVX2)
1213
1214     filter_plane_cols(s, col, 0, 0, lflvl->level, lflvl->mask[0][0], dst, ls_y);
1215     filter_plane_rows(s, row, 0, 0, lflvl->level, lflvl->mask[0][1], dst, ls_y);
1216
1217     for (p = 0; p < 2; p++) {
1218         dst = f->data[1 + p] + uvoff;
1219         filter_plane_cols(s, col, s->ss_h, s->ss_v, lflvl->level, uv_masks[0], dst, ls_uv);
1220         filter_plane_rows(s, row, s->ss_h, s->ss_v, lflvl->level, uv_masks[1], dst, ls_uv);
1221     }
1222 }
1223
1224 static void set_tile_offset(int *start, int *end, int idx, int log2_n, int n)
1225 {
1226     int sb_start = ( idx      * n) >> log2_n;
1227     int sb_end   = ((idx + 1) * n) >> log2_n;
1228     *start = FFMIN(sb_start, n) << 3;
1229     *end   = FFMIN(sb_end,   n) << 3;
1230 }
1231
1232 static void free_buffers(VP9Context *s)
1233 {
1234     av_freep(&s->intra_pred_data[0]);
1235     av_freep(&s->b_base);
1236     av_freep(&s->block_base);
1237 }
1238
1239 static av_cold int vp9_decode_free(AVCodecContext *avctx)
1240 {
1241     VP9Context *s = avctx->priv_data;
1242     int i;
1243
1244     for (i = 0; i < 3; i++) {
1245         if (s->s.frames[i].tf.f->buf[0])
1246             vp9_unref_frame(avctx, &s->s.frames[i]);
1247         av_frame_free(&s->s.frames[i].tf.f);
1248     }
1249     for (i = 0; i < 8; i++) {
1250         if (s->s.refs[i].f->buf[0])
1251             ff_thread_release_buffer(avctx, &s->s.refs[i]);
1252         av_frame_free(&s->s.refs[i].f);
1253         if (s->next_refs[i].f->buf[0])
1254             ff_thread_release_buffer(avctx, &s->next_refs[i]);
1255         av_frame_free(&s->next_refs[i].f);
1256     }
1257     free_buffers(s);
1258     av_freep(&s->c_b);
1259     s->c_b_size = 0;
1260
1261     return 0;
1262 }
1263
1264
1265 static int vp9_decode_frame(AVCodecContext *avctx, void *frame,
1266                             int *got_frame, AVPacket *pkt)
1267 {
1268     const uint8_t *data = pkt->data;
1269     int size = pkt->size;
1270     VP9Context *s = avctx->priv_data;
1271     int res, tile_row, tile_col, i, ref, row, col;
1272     int retain_segmap_ref = s->s.frames[REF_FRAME_SEGMAP].segmentation_map &&
1273                             (!s->s.h.segmentation.enabled || !s->s.h.segmentation.update_map);
1274     ptrdiff_t yoff, uvoff, ls_y, ls_uv;
1275     AVFrame *f;
1276     int bytesperpixel;
1277
1278     if ((res = decode_frame_header(avctx, data, size, &ref)) < 0) {
1279         return res;
1280     } else if (res == 0) {
1281         if (!s->s.refs[ref].f->buf[0]) {
1282             av_log(avctx, AV_LOG_ERROR, "Requested reference %d not available\n", ref);
1283             return AVERROR_INVALIDDATA;
1284         }
1285         if ((res = av_frame_ref(frame, s->s.refs[ref].f)) < 0)
1286             return res;
1287         ((AVFrame *)frame)->pts = pkt->pts;
1288 #if FF_API_PKT_PTS
1289 FF_DISABLE_DEPRECATION_WARNINGS
1290         ((AVFrame *)frame)->pkt_pts = pkt->pts;
1291 FF_ENABLE_DEPRECATION_WARNINGS
1292 #endif
1293         ((AVFrame *)frame)->pkt_dts = pkt->dts;
1294         for (i = 0; i < 8; i++) {
1295             if (s->next_refs[i].f->buf[0])
1296                 ff_thread_release_buffer(avctx, &s->next_refs[i]);
1297             if (s->s.refs[i].f->buf[0] &&
1298                 (res = ff_thread_ref_frame(&s->next_refs[i], &s->s.refs[i])) < 0)
1299                 return res;
1300         }
1301         *got_frame = 1;
1302         return pkt->size;
1303     }
1304     data += res;
1305     size -= res;
1306
1307     if (!retain_segmap_ref || s->s.h.keyframe || s->s.h.intraonly) {
1308         if (s->s.frames[REF_FRAME_SEGMAP].tf.f->buf[0])
1309             vp9_unref_frame(avctx, &s->s.frames[REF_FRAME_SEGMAP]);
1310         if (!s->s.h.keyframe && !s->s.h.intraonly && !s->s.h.errorres && s->s.frames[CUR_FRAME].tf.f->buf[0] &&
1311             (res = vp9_ref_frame(avctx, &s->s.frames[REF_FRAME_SEGMAP], &s->s.frames[CUR_FRAME])) < 0)
1312             return res;
1313     }
1314     if (s->s.frames[REF_FRAME_MVPAIR].tf.f->buf[0])
1315         vp9_unref_frame(avctx, &s->s.frames[REF_FRAME_MVPAIR]);
1316     if (!s->s.h.intraonly && !s->s.h.keyframe && !s->s.h.errorres && s->s.frames[CUR_FRAME].tf.f->buf[0] &&
1317         (res = vp9_ref_frame(avctx, &s->s.frames[REF_FRAME_MVPAIR], &s->s.frames[CUR_FRAME])) < 0)
1318         return res;
1319     if (s->s.frames[CUR_FRAME].tf.f->buf[0])
1320         vp9_unref_frame(avctx, &s->s.frames[CUR_FRAME]);
1321     if ((res = vp9_alloc_frame(avctx, &s->s.frames[CUR_FRAME])) < 0)
1322         return res;
1323     f = s->s.frames[CUR_FRAME].tf.f;
1324     f->key_frame = s->s.h.keyframe;
1325     f->pict_type = (s->s.h.keyframe || s->s.h.intraonly) ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
1326     ls_y = f->linesize[0];
1327     ls_uv =f->linesize[1];
1328
1329     if (s->s.frames[REF_FRAME_SEGMAP].tf.f->buf[0] &&
1330         (s->s.frames[REF_FRAME_MVPAIR].tf.f->width  != s->s.frames[CUR_FRAME].tf.f->width ||
1331          s->s.frames[REF_FRAME_MVPAIR].tf.f->height != s->s.frames[CUR_FRAME].tf.f->height)) {
1332         vp9_unref_frame(avctx, &s->s.frames[REF_FRAME_SEGMAP]);
1333     }
1334
1335     // ref frame setup
1336     for (i = 0; i < 8; i++) {
1337         if (s->next_refs[i].f->buf[0])
1338             ff_thread_release_buffer(avctx, &s->next_refs[i]);
1339         if (s->s.h.refreshrefmask & (1 << i)) {
1340             res = ff_thread_ref_frame(&s->next_refs[i], &s->s.frames[CUR_FRAME].tf);
1341         } else if (s->s.refs[i].f->buf[0]) {
1342             res = ff_thread_ref_frame(&s->next_refs[i], &s->s.refs[i]);
1343         }
1344         if (res < 0)
1345             return res;
1346     }
1347
1348     if (avctx->hwaccel) {
1349         res = avctx->hwaccel->start_frame(avctx, NULL, 0);
1350         if (res < 0)
1351             return res;
1352         res = avctx->hwaccel->decode_slice(avctx, pkt->data, pkt->size);
1353         if (res < 0)
1354             return res;
1355         res = avctx->hwaccel->end_frame(avctx);
1356         if (res < 0)
1357             return res;
1358         goto finish;
1359     }
1360
1361     // main tile decode loop
1362     bytesperpixel = s->bytesperpixel;
1363     memset(s->above_partition_ctx, 0, s->cols);
1364     memset(s->above_skip_ctx, 0, s->cols);
1365     if (s->s.h.keyframe || s->s.h.intraonly) {
1366         memset(s->above_mode_ctx, DC_PRED, s->cols * 2);
1367     } else {
1368         memset(s->above_mode_ctx, NEARESTMV, s->cols);
1369     }
1370     memset(s->above_y_nnz_ctx, 0, s->sb_cols * 16);
1371     memset(s->above_uv_nnz_ctx[0], 0, s->sb_cols * 16 >> s->ss_h);
1372     memset(s->above_uv_nnz_ctx[1], 0, s->sb_cols * 16 >> s->ss_h);
1373     memset(s->above_segpred_ctx, 0, s->cols);
1374     s->pass = s->s.frames[CUR_FRAME].uses_2pass =
1375         avctx->active_thread_type == FF_THREAD_FRAME && s->s.h.refreshctx && !s->s.h.parallelmode;
1376     if ((res = update_block_buffers(avctx)) < 0) {
1377         av_log(avctx, AV_LOG_ERROR,
1378                "Failed to allocate block buffers\n");
1379         return res;
1380     }
1381     if (s->s.h.refreshctx && s->s.h.parallelmode) {
1382         int j, k, l, m;
1383
1384         for (i = 0; i < 4; i++) {
1385             for (j = 0; j < 2; j++)
1386                 for (k = 0; k < 2; k++)
1387                     for (l = 0; l < 6; l++)
1388                         for (m = 0; m < 6; m++)
1389                             memcpy(s->prob_ctx[s->s.h.framectxid].coef[i][j][k][l][m],
1390                                    s->prob.coef[i][j][k][l][m], 3);
1391             if (s->s.h.txfmmode == i)
1392                 break;
1393         }
1394         s->prob_ctx[s->s.h.framectxid].p = s->prob.p;
1395         ff_thread_finish_setup(avctx);
1396     } else if (!s->s.h.refreshctx) {
1397         ff_thread_finish_setup(avctx);
1398     }
1399
1400     do {
1401         yoff = uvoff = 0;
1402         s->b = s->b_base;
1403         s->block = s->block_base;
1404         s->uvblock[0] = s->uvblock_base[0];
1405         s->uvblock[1] = s->uvblock_base[1];
1406         s->eob = s->eob_base;
1407         s->uveob[0] = s->uveob_base[0];
1408         s->uveob[1] = s->uveob_base[1];
1409
1410         for (tile_row = 0; tile_row < s->s.h.tiling.tile_rows; tile_row++) {
1411             set_tile_offset(&s->tile_row_start, &s->tile_row_end,
1412                             tile_row, s->s.h.tiling.log2_tile_rows, s->sb_rows);
1413             if (s->pass != 2) {
1414                 for (tile_col = 0; tile_col < s->s.h.tiling.tile_cols; tile_col++) {
1415                     int64_t tile_size;
1416
1417                     if (tile_col == s->s.h.tiling.tile_cols - 1 &&
1418                         tile_row == s->s.h.tiling.tile_rows - 1) {
1419                         tile_size = size;
1420                     } else {
1421                         tile_size = AV_RB32(data);
1422                         data += 4;
1423                         size -= 4;
1424                     }
1425                     if (tile_size > size) {
1426                         ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, INT_MAX, 0);
1427                         return AVERROR_INVALIDDATA;
1428                     }
1429                     res = ff_vp56_init_range_decoder(&s->c_b[tile_col], data, tile_size);
1430                     if (res < 0)
1431                         return res;
1432                     if (vp56_rac_get_prob_branchy(&s->c_b[tile_col], 128)) { // marker bit
1433                         ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, INT_MAX, 0);
1434                         return AVERROR_INVALIDDATA;
1435                     }
1436                     data += tile_size;
1437                     size -= tile_size;
1438                 }
1439             }
1440
1441             for (row = s->tile_row_start; row < s->tile_row_end;
1442                  row += 8, yoff += ls_y * 64, uvoff += ls_uv * 64 >> s->ss_v) {
1443                 struct VP9Filter *lflvl_ptr = s->lflvl;
1444                 ptrdiff_t yoff2 = yoff, uvoff2 = uvoff;
1445
1446                 for (tile_col = 0; tile_col < s->s.h.tiling.tile_cols; tile_col++) {
1447                     set_tile_offset(&s->tile_col_start, &s->tile_col_end,
1448                                     tile_col, s->s.h.tiling.log2_tile_cols, s->sb_cols);
1449
1450                     if (s->pass != 2) {
1451                         memset(s->left_partition_ctx, 0, 8);
1452                         memset(s->left_skip_ctx, 0, 8);
1453                         if (s->s.h.keyframe || s->s.h.intraonly) {
1454                             memset(s->left_mode_ctx, DC_PRED, 16);
1455                         } else {
1456                             memset(s->left_mode_ctx, NEARESTMV, 8);
1457                         }
1458                         memset(s->left_y_nnz_ctx, 0, 16);
1459                         memset(s->left_uv_nnz_ctx, 0, 32);
1460                         memset(s->left_segpred_ctx, 0, 8);
1461
1462                         memcpy(&s->c, &s->c_b[tile_col], sizeof(s->c));
1463                     }
1464
1465                     for (col = s->tile_col_start;
1466                          col < s->tile_col_end;
1467                          col += 8, yoff2 += 64 * bytesperpixel,
1468                          uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
1469                         // FIXME integrate with lf code (i.e. zero after each
1470                         // use, similar to invtxfm coefficients, or similar)
1471                         if (s->pass != 1) {
1472                             memset(lflvl_ptr->mask, 0, sizeof(lflvl_ptr->mask));
1473                         }
1474
1475                         if (s->pass == 2) {
1476                             decode_sb_mem(avctx, row, col, lflvl_ptr,
1477                                           yoff2, uvoff2, BL_64X64);
1478                         } else {
1479                             decode_sb(avctx, row, col, lflvl_ptr,
1480                                       yoff2, uvoff2, BL_64X64);
1481                         }
1482                     }
1483                     if (s->pass != 2) {
1484                         memcpy(&s->c_b[tile_col], &s->c, sizeof(s->c));
1485                     }
1486                 }
1487
1488                 if (s->pass == 1) {
1489                     continue;
1490                 }
1491
1492                 // backup pre-loopfilter reconstruction data for intra
1493                 // prediction of next row of sb64s
1494                 if (row + 8 < s->rows) {
1495                     memcpy(s->intra_pred_data[0],
1496                            f->data[0] + yoff + 63 * ls_y,
1497                            8 * s->cols * bytesperpixel);
1498                     memcpy(s->intra_pred_data[1],
1499                            f->data[1] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
1500                            8 * s->cols * bytesperpixel >> s->ss_h);
1501                     memcpy(s->intra_pred_data[2],
1502                            f->data[2] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
1503                            8 * s->cols * bytesperpixel >> s->ss_h);
1504                 }
1505
1506                 // loopfilter one row
1507                 if (s->s.h.filter.level) {
1508                     yoff2 = yoff;
1509                     uvoff2 = uvoff;
1510                     lflvl_ptr = s->lflvl;
1511                     for (col = 0; col < s->cols;
1512                          col += 8, yoff2 += 64 * bytesperpixel,
1513                          uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
1514                         loopfilter_sb(avctx, lflvl_ptr, row, col, yoff2, uvoff2);
1515                     }
1516                 }
1517
1518                 // FIXME maybe we can make this more finegrained by running the
1519                 // loopfilter per-block instead of after each sbrow
1520                 // In fact that would also make intra pred left preparation easier?
1521                 ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, row >> 3, 0);
1522             }
1523         }
1524
1525         if (s->pass < 2 && s->s.h.refreshctx && !s->s.h.parallelmode) {
1526             ff_vp9_adapt_probs(s);
1527             ff_thread_finish_setup(avctx);
1528         }
1529     } while (s->pass++ == 1);
1530     ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, INT_MAX, 0);
1531
1532 finish:
1533     // ref frame setup
1534     for (i = 0; i < 8; i++) {
1535         if (s->s.refs[i].f->buf[0])
1536             ff_thread_release_buffer(avctx, &s->s.refs[i]);
1537         if (s->next_refs[i].f->buf[0] &&
1538             (res = ff_thread_ref_frame(&s->s.refs[i], &s->next_refs[i])) < 0)
1539             return res;
1540     }
1541
1542     if (!s->s.h.invisible) {
1543         if ((res = av_frame_ref(frame, s->s.frames[CUR_FRAME].tf.f)) < 0)
1544             return res;
1545         *got_frame = 1;
1546     }
1547
1548     return pkt->size;
1549 }
1550
1551 static void vp9_decode_flush(AVCodecContext *avctx)
1552 {
1553     VP9Context *s = avctx->priv_data;
1554     int i;
1555
1556     for (i = 0; i < 3; i++)
1557         vp9_unref_frame(avctx, &s->s.frames[i]);
1558     for (i = 0; i < 8; i++)
1559         ff_thread_release_buffer(avctx, &s->s.refs[i]);
1560 }
1561
1562 static int init_frames(AVCodecContext *avctx)
1563 {
1564     VP9Context *s = avctx->priv_data;
1565     int i;
1566
1567     for (i = 0; i < 3; i++) {
1568         s->s.frames[i].tf.f = av_frame_alloc();
1569         if (!s->s.frames[i].tf.f) {
1570             vp9_decode_free(avctx);
1571             av_log(avctx, AV_LOG_ERROR, "Failed to allocate frame buffer %d\n", i);
1572             return AVERROR(ENOMEM);
1573         }
1574     }
1575     for (i = 0; i < 8; i++) {
1576         s->s.refs[i].f = av_frame_alloc();
1577         s->next_refs[i].f = av_frame_alloc();
1578         if (!s->s.refs[i].f || !s->next_refs[i].f) {
1579             vp9_decode_free(avctx);
1580             av_log(avctx, AV_LOG_ERROR, "Failed to allocate frame buffer %d\n", i);
1581             return AVERROR(ENOMEM);
1582         }
1583     }
1584
1585     return 0;
1586 }
1587
1588 static av_cold int vp9_decode_init(AVCodecContext *avctx)
1589 {
1590     VP9Context *s = avctx->priv_data;
1591
1592     avctx->internal->allocate_progress = 1;
1593     s->last_bpp = 0;
1594     s->s.h.filter.sharpness = -1;
1595
1596     return init_frames(avctx);
1597 }
1598
1599 #if HAVE_THREADS
1600 static av_cold int vp9_decode_init_thread_copy(AVCodecContext *avctx)
1601 {
1602     return init_frames(avctx);
1603 }
1604
1605 static int vp9_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
1606 {
1607     int i, res;
1608     VP9Context *s = dst->priv_data, *ssrc = src->priv_data;
1609
1610     for (i = 0; i < 3; i++) {
1611         if (s->s.frames[i].tf.f->buf[0])
1612             vp9_unref_frame(dst, &s->s.frames[i]);
1613         if (ssrc->s.frames[i].tf.f->buf[0]) {
1614             if ((res = vp9_ref_frame(dst, &s->s.frames[i], &ssrc->s.frames[i])) < 0)
1615                 return res;
1616         }
1617     }
1618     for (i = 0; i < 8; i++) {
1619         if (s->s.refs[i].f->buf[0])
1620             ff_thread_release_buffer(dst, &s->s.refs[i]);
1621         if (ssrc->next_refs[i].f->buf[0]) {
1622             if ((res = ff_thread_ref_frame(&s->s.refs[i], &ssrc->next_refs[i])) < 0)
1623                 return res;
1624         }
1625     }
1626
1627     s->s.h.invisible = ssrc->s.h.invisible;
1628     s->s.h.keyframe = ssrc->s.h.keyframe;
1629     s->s.h.intraonly = ssrc->s.h.intraonly;
1630     s->ss_v = ssrc->ss_v;
1631     s->ss_h = ssrc->ss_h;
1632     s->s.h.segmentation.enabled = ssrc->s.h.segmentation.enabled;
1633     s->s.h.segmentation.update_map = ssrc->s.h.segmentation.update_map;
1634     s->s.h.segmentation.absolute_vals = ssrc->s.h.segmentation.absolute_vals;
1635     s->bytesperpixel = ssrc->bytesperpixel;
1636     s->gf_fmt = ssrc->gf_fmt;
1637     s->w = ssrc->w;
1638     s->h = ssrc->h;
1639     s->s.h.bpp = ssrc->s.h.bpp;
1640     s->bpp_index = ssrc->bpp_index;
1641     s->pix_fmt = ssrc->pix_fmt;
1642     memcpy(&s->prob_ctx, &ssrc->prob_ctx, sizeof(s->prob_ctx));
1643     memcpy(&s->s.h.lf_delta, &ssrc->s.h.lf_delta, sizeof(s->s.h.lf_delta));
1644     memcpy(&s->s.h.segmentation.feat, &ssrc->s.h.segmentation.feat,
1645            sizeof(s->s.h.segmentation.feat));
1646
1647     return 0;
1648 }
1649 #endif
1650
1651 AVCodec ff_vp9_decoder = {
1652     .name                  = "vp9",
1653     .long_name             = NULL_IF_CONFIG_SMALL("Google VP9"),
1654     .type                  = AVMEDIA_TYPE_VIDEO,
1655     .id                    = AV_CODEC_ID_VP9,
1656     .priv_data_size        = sizeof(VP9Context),
1657     .init                  = vp9_decode_init,
1658     .close                 = vp9_decode_free,
1659     .decode                = vp9_decode_frame,
1660     .capabilities          = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
1661     .flush                 = vp9_decode_flush,
1662     .init_thread_copy      = ONLY_IF_THREADS_ENABLED(vp9_decode_init_thread_copy),
1663     .update_thread_context = ONLY_IF_THREADS_ENABLED(vp9_decode_update_thread_context),
1664     .profiles              = NULL_IF_CONFIG_SMALL(ff_vp9_profiles),
1665 };