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