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