vp8: force reallocation in update_thread_context after frame size change
[ffmpeg.git] / libavcodec / vp8.c
1 /**
2  * VP8 compatible video decoder
3  *
4  * Copyright (C) 2010 David Conrad
5  * Copyright (C) 2010 Ronald S. Bultje
6  * Copyright (C) 2010 Jason Garrett-Glaser
7  *
8  * This file is part of Libav.
9  *
10  * Libav is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * Libav is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with Libav; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24
25 #include "libavutil/imgutils.h"
26 #include "avcodec.h"
27 #include "vp8.h"
28 #include "vp8data.h"
29 #include "rectangle.h"
30 #include "thread.h"
31
32 #if ARCH_ARM
33 #   include "arm/vp8.h"
34 #endif
35
36 static void free_buffers(VP8Context *s)
37 {
38     av_freep(&s->macroblocks_base);
39     av_freep(&s->filter_strength);
40     av_freep(&s->intra4x4_pred_mode_top);
41     av_freep(&s->top_nnz);
42     av_freep(&s->edge_emu_buffer);
43     av_freep(&s->top_border);
44     av_freep(&s->segmentation_map);
45
46     s->macroblocks = NULL;
47 }
48
49 static void vp8_decode_flush(AVCodecContext *avctx)
50 {
51     VP8Context *s = avctx->priv_data;
52     int i;
53
54     if (!avctx->is_copy) {
55         for (i = 0; i < 5; i++)
56             if (s->frames[i].data[0])
57                 ff_thread_release_buffer(avctx, &s->frames[i]);
58     }
59     memset(s->framep, 0, sizeof(s->framep));
60
61     free_buffers(s);
62 }
63
64 static int update_dimensions(VP8Context *s, int width, int height)
65 {
66     if (width  != s->avctx->width ||
67         height != s->avctx->height) {
68         if (av_image_check_size(width, height, 0, s->avctx))
69             return AVERROR_INVALIDDATA;
70
71         vp8_decode_flush(s->avctx);
72
73         avcodec_set_dimensions(s->avctx, width, height);
74     }
75
76     s->mb_width  = (s->avctx->coded_width +15) / 16;
77     s->mb_height = (s->avctx->coded_height+15) / 16;
78
79     s->macroblocks_base        = av_mallocz((s->mb_width+s->mb_height*2+1)*sizeof(*s->macroblocks));
80     s->filter_strength         = av_mallocz(s->mb_width*sizeof(*s->filter_strength));
81     s->intra4x4_pred_mode_top  = av_mallocz(s->mb_width*4);
82     s->top_nnz                 = av_mallocz(s->mb_width*sizeof(*s->top_nnz));
83     s->top_border              = av_mallocz((s->mb_width+1)*sizeof(*s->top_border));
84     s->segmentation_map        = av_mallocz(s->mb_width*s->mb_height);
85
86     if (!s->macroblocks_base || !s->filter_strength || !s->intra4x4_pred_mode_top ||
87         !s->top_nnz || !s->top_border || !s->segmentation_map)
88         return AVERROR(ENOMEM);
89
90     s->macroblocks        = s->macroblocks_base + 1;
91
92     return 0;
93 }
94
95 static void parse_segment_info(VP8Context *s)
96 {
97     VP56RangeCoder *c = &s->c;
98     int i;
99
100     s->segmentation.update_map = vp8_rac_get(c);
101
102     if (vp8_rac_get(c)) { // update segment feature data
103         s->segmentation.absolute_vals = vp8_rac_get(c);
104
105         for (i = 0; i < 4; i++)
106             s->segmentation.base_quant[i]   = vp8_rac_get_sint(c, 7);
107
108         for (i = 0; i < 4; i++)
109             s->segmentation.filter_level[i] = vp8_rac_get_sint(c, 6);
110     }
111     if (s->segmentation.update_map)
112         for (i = 0; i < 3; i++)
113             s->prob->segmentid[i] = vp8_rac_get(c) ? vp8_rac_get_uint(c, 8) : 255;
114 }
115
116 static void update_lf_deltas(VP8Context *s)
117 {
118     VP56RangeCoder *c = &s->c;
119     int i;
120
121     for (i = 0; i < 4; i++)
122         s->lf_delta.ref[i]  = vp8_rac_get_sint(c, 6);
123
124     for (i = MODE_I4x4; i <= VP8_MVMODE_SPLIT; i++)
125         s->lf_delta.mode[i] = vp8_rac_get_sint(c, 6);
126 }
127
128 static int setup_partitions(VP8Context *s, const uint8_t *buf, int buf_size)
129 {
130     const uint8_t *sizes = buf;
131     int i;
132
133     s->num_coeff_partitions = 1 << vp8_rac_get_uint(&s->c, 2);
134
135     buf      += 3*(s->num_coeff_partitions-1);
136     buf_size -= 3*(s->num_coeff_partitions-1);
137     if (buf_size < 0)
138         return -1;
139
140     for (i = 0; i < s->num_coeff_partitions-1; i++) {
141         int size = AV_RL24(sizes + 3*i);
142         if (buf_size - size < 0)
143             return -1;
144
145         ff_vp56_init_range_decoder(&s->coeff_partition[i], buf, size);
146         buf      += size;
147         buf_size -= size;
148     }
149     ff_vp56_init_range_decoder(&s->coeff_partition[i], buf, buf_size);
150
151     return 0;
152 }
153
154 static void get_quants(VP8Context *s)
155 {
156     VP56RangeCoder *c = &s->c;
157     int i, base_qi;
158
159     int yac_qi     = vp8_rac_get_uint(c, 7);
160     int ydc_delta  = vp8_rac_get_sint(c, 4);
161     int y2dc_delta = vp8_rac_get_sint(c, 4);
162     int y2ac_delta = vp8_rac_get_sint(c, 4);
163     int uvdc_delta = vp8_rac_get_sint(c, 4);
164     int uvac_delta = vp8_rac_get_sint(c, 4);
165
166     for (i = 0; i < 4; i++) {
167         if (s->segmentation.enabled) {
168             base_qi = s->segmentation.base_quant[i];
169             if (!s->segmentation.absolute_vals)
170                 base_qi += yac_qi;
171         } else
172             base_qi = yac_qi;
173
174         s->qmat[i].luma_qmul[0]    =       vp8_dc_qlookup[av_clip_uintp2(base_qi + ydc_delta , 7)];
175         s->qmat[i].luma_qmul[1]    =       vp8_ac_qlookup[av_clip_uintp2(base_qi             , 7)];
176         s->qmat[i].luma_dc_qmul[0] =   2 * vp8_dc_qlookup[av_clip_uintp2(base_qi + y2dc_delta, 7)];
177         s->qmat[i].luma_dc_qmul[1] = 155 * vp8_ac_qlookup[av_clip_uintp2(base_qi + y2ac_delta, 7)] / 100;
178         s->qmat[i].chroma_qmul[0]  =       vp8_dc_qlookup[av_clip_uintp2(base_qi + uvdc_delta, 7)];
179         s->qmat[i].chroma_qmul[1]  =       vp8_ac_qlookup[av_clip_uintp2(base_qi + uvac_delta, 7)];
180
181         s->qmat[i].luma_dc_qmul[1] = FFMAX(s->qmat[i].luma_dc_qmul[1], 8);
182         s->qmat[i].chroma_qmul[0]  = FFMIN(s->qmat[i].chroma_qmul[0], 132);
183     }
184 }
185
186 /**
187  * Determine which buffers golden and altref should be updated with after this frame.
188  * The spec isn't clear here, so I'm going by my understanding of what libvpx does
189  *
190  * Intra frames update all 3 references
191  * Inter frames update VP56_FRAME_PREVIOUS if the update_last flag is set
192  * If the update (golden|altref) flag is set, it's updated with the current frame
193  *      if update_last is set, and VP56_FRAME_PREVIOUS otherwise.
194  * If the flag is not set, the number read means:
195  *      0: no update
196  *      1: VP56_FRAME_PREVIOUS
197  *      2: update golden with altref, or update altref with golden
198  */
199 static VP56Frame ref_to_update(VP8Context *s, int update, VP56Frame ref)
200 {
201     VP56RangeCoder *c = &s->c;
202
203     if (update)
204         return VP56_FRAME_CURRENT;
205
206     switch (vp8_rac_get_uint(c, 2)) {
207     case 1:
208         return VP56_FRAME_PREVIOUS;
209     case 2:
210         return (ref == VP56_FRAME_GOLDEN) ? VP56_FRAME_GOLDEN2 : VP56_FRAME_GOLDEN;
211     }
212     return VP56_FRAME_NONE;
213 }
214
215 static void update_refs(VP8Context *s)
216 {
217     VP56RangeCoder *c = &s->c;
218
219     int update_golden = vp8_rac_get(c);
220     int update_altref = vp8_rac_get(c);
221
222     s->update_golden = ref_to_update(s, update_golden, VP56_FRAME_GOLDEN);
223     s->update_altref = ref_to_update(s, update_altref, VP56_FRAME_GOLDEN2);
224 }
225
226 static int decode_frame_header(VP8Context *s, const uint8_t *buf, int buf_size)
227 {
228     VP56RangeCoder *c = &s->c;
229     int header_size, hscale, vscale, i, j, k, l, m, ret;
230     int width  = s->avctx->width;
231     int height = s->avctx->height;
232
233     s->keyframe  = !(buf[0] & 1);
234     s->profile   =  (buf[0]>>1) & 7;
235     s->invisible = !(buf[0] & 0x10);
236     header_size  = AV_RL24(buf) >> 5;
237     buf      += 3;
238     buf_size -= 3;
239
240     if (s->profile > 3)
241         av_log(s->avctx, AV_LOG_WARNING, "Unknown profile %d\n", s->profile);
242
243     if (!s->profile)
244         memcpy(s->put_pixels_tab, s->vp8dsp.put_vp8_epel_pixels_tab, sizeof(s->put_pixels_tab));
245     else    // profile 1-3 use bilinear, 4+ aren't defined so whatever
246         memcpy(s->put_pixels_tab, s->vp8dsp.put_vp8_bilinear_pixels_tab, sizeof(s->put_pixels_tab));
247
248     if (header_size > buf_size - 7*s->keyframe) {
249         av_log(s->avctx, AV_LOG_ERROR, "Header size larger than data provided\n");
250         return AVERROR_INVALIDDATA;
251     }
252
253     if (s->keyframe) {
254         if (AV_RL24(buf) != 0x2a019d) {
255             av_log(s->avctx, AV_LOG_ERROR, "Invalid start code 0x%x\n", AV_RL24(buf));
256             return AVERROR_INVALIDDATA;
257         }
258         width  = AV_RL16(buf+3) & 0x3fff;
259         height = AV_RL16(buf+5) & 0x3fff;
260         hscale = buf[4] >> 6;
261         vscale = buf[6] >> 6;
262         buf      += 7;
263         buf_size -= 7;
264
265         if (hscale || vscale)
266             av_log_missing_feature(s->avctx, "Upscaling", 1);
267
268         s->update_golden = s->update_altref = VP56_FRAME_CURRENT;
269         for (i = 0; i < 4; i++)
270             for (j = 0; j < 16; j++)
271                 memcpy(s->prob->token[i][j], vp8_token_default_probs[i][vp8_coeff_band[j]],
272                        sizeof(s->prob->token[i][j]));
273         memcpy(s->prob->pred16x16, vp8_pred16x16_prob_inter, sizeof(s->prob->pred16x16));
274         memcpy(s->prob->pred8x8c , vp8_pred8x8c_prob_inter , sizeof(s->prob->pred8x8c));
275         memcpy(s->prob->mvc      , vp8_mv_default_prob     , sizeof(s->prob->mvc));
276         memset(&s->segmentation, 0, sizeof(s->segmentation));
277     }
278
279     if (!s->macroblocks_base || /* first frame */
280         width != s->avctx->width || height != s->avctx->height) {
281         if ((ret = update_dimensions(s, width, height)) < 0)
282             return ret;
283     }
284
285     ff_vp56_init_range_decoder(c, buf, header_size);
286     buf      += header_size;
287     buf_size -= header_size;
288
289     if (s->keyframe) {
290         if (vp8_rac_get(c))
291             av_log(s->avctx, AV_LOG_WARNING, "Unspecified colorspace\n");
292         vp8_rac_get(c); // whether we can skip clamping in dsp functions
293     }
294
295     if ((s->segmentation.enabled = vp8_rac_get(c)))
296         parse_segment_info(s);
297     else
298         s->segmentation.update_map = 0; // FIXME: move this to some init function?
299
300     s->filter.simple    = vp8_rac_get(c);
301     s->filter.level     = vp8_rac_get_uint(c, 6);
302     s->filter.sharpness = vp8_rac_get_uint(c, 3);
303
304     if ((s->lf_delta.enabled = vp8_rac_get(c)))
305         if (vp8_rac_get(c))
306             update_lf_deltas(s);
307
308     if (setup_partitions(s, buf, buf_size)) {
309         av_log(s->avctx, AV_LOG_ERROR, "Invalid partitions\n");
310         return AVERROR_INVALIDDATA;
311     }
312
313     get_quants(s);
314
315     if (!s->keyframe) {
316         update_refs(s);
317         s->sign_bias[VP56_FRAME_GOLDEN]               = vp8_rac_get(c);
318         s->sign_bias[VP56_FRAME_GOLDEN2 /* altref */] = vp8_rac_get(c);
319     }
320
321     // if we aren't saving this frame's probabilities for future frames,
322     // make a copy of the current probabilities
323     if (!(s->update_probabilities = vp8_rac_get(c)))
324         s->prob[1] = s->prob[0];
325
326     s->update_last = s->keyframe || vp8_rac_get(c);
327
328     for (i = 0; i < 4; i++)
329         for (j = 0; j < 8; j++)
330             for (k = 0; k < 3; k++)
331                 for (l = 0; l < NUM_DCT_TOKENS-1; l++)
332                     if (vp56_rac_get_prob_branchy(c, vp8_token_update_probs[i][j][k][l])) {
333                         int prob = vp8_rac_get_uint(c, 8);
334                         for (m = 0; vp8_coeff_band_indexes[j][m] >= 0; m++)
335                             s->prob->token[i][vp8_coeff_band_indexes[j][m]][k][l] = prob;
336                     }
337
338     if ((s->mbskip_enabled = vp8_rac_get(c)))
339         s->prob->mbskip = vp8_rac_get_uint(c, 8);
340
341     if (!s->keyframe) {
342         s->prob->intra  = vp8_rac_get_uint(c, 8);
343         s->prob->last   = vp8_rac_get_uint(c, 8);
344         s->prob->golden = vp8_rac_get_uint(c, 8);
345
346         if (vp8_rac_get(c))
347             for (i = 0; i < 4; i++)
348                 s->prob->pred16x16[i] = vp8_rac_get_uint(c, 8);
349         if (vp8_rac_get(c))
350             for (i = 0; i < 3; i++)
351                 s->prob->pred8x8c[i]  = vp8_rac_get_uint(c, 8);
352
353         // 17.2 MV probability update
354         for (i = 0; i < 2; i++)
355             for (j = 0; j < 19; j++)
356                 if (vp56_rac_get_prob_branchy(c, vp8_mv_update_prob[i][j]))
357                     s->prob->mvc[i][j] = vp8_rac_get_nn(c);
358     }
359
360     return 0;
361 }
362
363 static av_always_inline void clamp_mv(VP8Context *s, VP56mv *dst, const VP56mv *src)
364 {
365     dst->x = av_clip(src->x, s->mv_min.x, s->mv_max.x);
366     dst->y = av_clip(src->y, s->mv_min.y, s->mv_max.y);
367 }
368
369 /**
370  * Motion vector coding, 17.1.
371  */
372 static int read_mv_component(VP56RangeCoder *c, const uint8_t *p)
373 {
374     int bit, x = 0;
375
376     if (vp56_rac_get_prob_branchy(c, p[0])) {
377         int i;
378
379         for (i = 0; i < 3; i++)
380             x += vp56_rac_get_prob(c, p[9 + i]) << i;
381         for (i = 9; i > 3; i--)
382             x += vp56_rac_get_prob(c, p[9 + i]) << i;
383         if (!(x & 0xFFF0) || vp56_rac_get_prob(c, p[12]))
384             x += 8;
385     } else {
386         // small_mvtree
387         const uint8_t *ps = p+2;
388         bit = vp56_rac_get_prob(c, *ps);
389         ps += 1 + 3*bit;
390         x  += 4*bit;
391         bit = vp56_rac_get_prob(c, *ps);
392         ps += 1 + bit;
393         x  += 2*bit;
394         x  += vp56_rac_get_prob(c, *ps);
395     }
396
397     return (x && vp56_rac_get_prob(c, p[1])) ? -x : x;
398 }
399
400 static av_always_inline
401 const uint8_t *get_submv_prob(uint32_t left, uint32_t top)
402 {
403     if (left == top)
404         return vp8_submv_prob[4-!!left];
405     if (!top)
406         return vp8_submv_prob[2];
407     return vp8_submv_prob[1-!!left];
408 }
409
410 /**
411  * Split motion vector prediction, 16.4.
412  * @returns the number of motion vectors parsed (2, 4 or 16)
413  */
414 static av_always_inline
415 int decode_splitmvs(VP8Context *s, VP56RangeCoder *c, VP8Macroblock *mb)
416 {
417     int part_idx;
418     int n, num;
419     VP8Macroblock *top_mb  = &mb[2];
420     VP8Macroblock *left_mb = &mb[-1];
421     const uint8_t *mbsplits_left = vp8_mbsplits[left_mb->partitioning],
422                   *mbsplits_top = vp8_mbsplits[top_mb->partitioning],
423                   *mbsplits_cur, *firstidx;
424     VP56mv *top_mv  = top_mb->bmv;
425     VP56mv *left_mv = left_mb->bmv;
426     VP56mv *cur_mv  = mb->bmv;
427
428     if (vp56_rac_get_prob_branchy(c, vp8_mbsplit_prob[0])) {
429         if (vp56_rac_get_prob_branchy(c, vp8_mbsplit_prob[1])) {
430             part_idx = VP8_SPLITMVMODE_16x8 + vp56_rac_get_prob(c, vp8_mbsplit_prob[2]);
431         } else {
432             part_idx = VP8_SPLITMVMODE_8x8;
433         }
434     } else {
435         part_idx = VP8_SPLITMVMODE_4x4;
436     }
437
438     num = vp8_mbsplit_count[part_idx];
439     mbsplits_cur = vp8_mbsplits[part_idx],
440     firstidx = vp8_mbfirstidx[part_idx];
441     mb->partitioning = part_idx;
442
443     for (n = 0; n < num; n++) {
444         int k = firstidx[n];
445         uint32_t left, above;
446         const uint8_t *submv_prob;
447
448         if (!(k & 3))
449             left = AV_RN32A(&left_mv[mbsplits_left[k + 3]]);
450         else
451             left  = AV_RN32A(&cur_mv[mbsplits_cur[k - 1]]);
452         if (k <= 3)
453             above = AV_RN32A(&top_mv[mbsplits_top[k + 12]]);
454         else
455             above = AV_RN32A(&cur_mv[mbsplits_cur[k - 4]]);
456
457         submv_prob = get_submv_prob(left, above);
458
459         if (vp56_rac_get_prob_branchy(c, submv_prob[0])) {
460             if (vp56_rac_get_prob_branchy(c, submv_prob[1])) {
461                 if (vp56_rac_get_prob_branchy(c, submv_prob[2])) {
462                     mb->bmv[n].y = mb->mv.y + read_mv_component(c, s->prob->mvc[0]);
463                     mb->bmv[n].x = mb->mv.x + read_mv_component(c, s->prob->mvc[1]);
464                 } else {
465                     AV_ZERO32(&mb->bmv[n]);
466                 }
467             } else {
468                 AV_WN32A(&mb->bmv[n], above);
469             }
470         } else {
471             AV_WN32A(&mb->bmv[n], left);
472         }
473     }
474
475     return num;
476 }
477
478 static av_always_inline
479 void decode_mvs(VP8Context *s, VP8Macroblock *mb, int mb_x, int mb_y)
480 {
481     VP8Macroblock *mb_edge[3] = { mb + 2 /* top */,
482                                   mb - 1 /* left */,
483                                   mb + 1 /* top-left */ };
484     enum { CNT_ZERO, CNT_NEAREST, CNT_NEAR, CNT_SPLITMV };
485     enum { VP8_EDGE_TOP, VP8_EDGE_LEFT, VP8_EDGE_TOPLEFT };
486     int idx = CNT_ZERO;
487     int cur_sign_bias = s->sign_bias[mb->ref_frame];
488     int8_t *sign_bias = s->sign_bias;
489     VP56mv near_mv[4];
490     uint8_t cnt[4] = { 0 };
491     VP56RangeCoder *c = &s->c;
492
493     AV_ZERO32(&near_mv[0]);
494     AV_ZERO32(&near_mv[1]);
495
496     /* Process MB on top, left and top-left */
497     #define MV_EDGE_CHECK(n)\
498     {\
499         VP8Macroblock *edge = mb_edge[n];\
500         int edge_ref = edge->ref_frame;\
501         if (edge_ref != VP56_FRAME_CURRENT) {\
502             uint32_t mv = AV_RN32A(&edge->mv);\
503             if (mv) {\
504                 if (cur_sign_bias != sign_bias[edge_ref]) {\
505                     /* SWAR negate of the values in mv. */\
506                     mv = ~mv;\
507                     mv = ((mv&0x7fff7fff) + 0x00010001) ^ (mv&0x80008000);\
508                 }\
509                 if (!n || mv != AV_RN32A(&near_mv[idx]))\
510                     AV_WN32A(&near_mv[++idx], mv);\
511                 cnt[idx]      += 1 + (n != 2);\
512             } else\
513                 cnt[CNT_ZERO] += 1 + (n != 2);\
514         }\
515     }
516
517     MV_EDGE_CHECK(0)
518     MV_EDGE_CHECK(1)
519     MV_EDGE_CHECK(2)
520
521     mb->partitioning = VP8_SPLITMVMODE_NONE;
522     if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_ZERO]][0])) {
523         mb->mode = VP8_MVMODE_MV;
524
525         /* If we have three distinct MVs, merge first and last if they're the same */
526         if (cnt[CNT_SPLITMV] && AV_RN32A(&near_mv[1 + VP8_EDGE_TOP]) == AV_RN32A(&near_mv[1 + VP8_EDGE_TOPLEFT]))
527             cnt[CNT_NEAREST] += 1;
528
529         /* Swap near and nearest if necessary */
530         if (cnt[CNT_NEAR] > cnt[CNT_NEAREST]) {
531             FFSWAP(uint8_t,     cnt[CNT_NEAREST],     cnt[CNT_NEAR]);
532             FFSWAP( VP56mv, near_mv[CNT_NEAREST], near_mv[CNT_NEAR]);
533         }
534
535         if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_NEAREST]][1])) {
536             if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_NEAR]][2])) {
537
538                 /* Choose the best mv out of 0,0 and the nearest mv */
539                 clamp_mv(s, &mb->mv, &near_mv[CNT_ZERO + (cnt[CNT_NEAREST] >= cnt[CNT_ZERO])]);
540                 cnt[CNT_SPLITMV] = ((mb_edge[VP8_EDGE_LEFT]->mode    == VP8_MVMODE_SPLIT) +
541                                     (mb_edge[VP8_EDGE_TOP]->mode     == VP8_MVMODE_SPLIT)) * 2 +
542                                     (mb_edge[VP8_EDGE_TOPLEFT]->mode == VP8_MVMODE_SPLIT);
543
544                 if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_SPLITMV]][3])) {
545                     mb->mode = VP8_MVMODE_SPLIT;
546                     mb->mv = mb->bmv[decode_splitmvs(s, c, mb) - 1];
547                 } else {
548                     mb->mv.y += read_mv_component(c, s->prob->mvc[0]);
549                     mb->mv.x += read_mv_component(c, s->prob->mvc[1]);
550                     mb->bmv[0] = mb->mv;
551                 }
552             } else {
553                 clamp_mv(s, &mb->mv, &near_mv[CNT_NEAR]);
554                 mb->bmv[0] = mb->mv;
555             }
556         } else {
557             clamp_mv(s, &mb->mv, &near_mv[CNT_NEAREST]);
558             mb->bmv[0] = mb->mv;
559         }
560     } else {
561         mb->mode = VP8_MVMODE_ZERO;
562         AV_ZERO32(&mb->mv);
563         mb->bmv[0] = mb->mv;
564     }
565 }
566
567 static av_always_inline
568 void decode_intra4x4_modes(VP8Context *s, VP56RangeCoder *c,
569                            int mb_x, int keyframe)
570 {
571     uint8_t *intra4x4 = s->intra4x4_pred_mode_mb;
572     if (keyframe) {
573         int x, y;
574         uint8_t* const top = s->intra4x4_pred_mode_top + 4 * mb_x;
575         uint8_t* const left = s->intra4x4_pred_mode_left;
576         for (y = 0; y < 4; y++) {
577             for (x = 0; x < 4; x++) {
578                 const uint8_t *ctx;
579                 ctx = vp8_pred4x4_prob_intra[top[x]][left[y]];
580                 *intra4x4 = vp8_rac_get_tree(c, vp8_pred4x4_tree, ctx);
581                 left[y] = top[x] = *intra4x4;
582                 intra4x4++;
583             }
584         }
585     } else {
586         int i;
587         for (i = 0; i < 16; i++)
588             intra4x4[i] = vp8_rac_get_tree(c, vp8_pred4x4_tree, vp8_pred4x4_prob_inter);
589     }
590 }
591
592 static av_always_inline
593 void decode_mb_mode(VP8Context *s, VP8Macroblock *mb, int mb_x, int mb_y, uint8_t *segment, uint8_t *ref)
594 {
595     VP56RangeCoder *c = &s->c;
596
597     if (s->segmentation.update_map)
598         *segment = vp8_rac_get_tree(c, vp8_segmentid_tree, s->prob->segmentid);
599     else
600         *segment = ref ? *ref : *segment;
601     s->segment = *segment;
602
603     mb->skip = s->mbskip_enabled ? vp56_rac_get_prob(c, s->prob->mbskip) : 0;
604
605     if (s->keyframe) {
606         mb->mode = vp8_rac_get_tree(c, vp8_pred16x16_tree_intra, vp8_pred16x16_prob_intra);
607
608         if (mb->mode == MODE_I4x4) {
609             decode_intra4x4_modes(s, c, mb_x, 1);
610         } else {
611             const uint32_t modes = vp8_pred4x4_mode[mb->mode] * 0x01010101u;
612             AV_WN32A(s->intra4x4_pred_mode_top + 4 * mb_x, modes);
613             AV_WN32A(s->intra4x4_pred_mode_left, modes);
614         }
615
616         s->chroma_pred_mode = vp8_rac_get_tree(c, vp8_pred8x8c_tree, vp8_pred8x8c_prob_intra);
617         mb->ref_frame = VP56_FRAME_CURRENT;
618     } else if (vp56_rac_get_prob_branchy(c, s->prob->intra)) {
619         // inter MB, 16.2
620         if (vp56_rac_get_prob_branchy(c, s->prob->last))
621             mb->ref_frame = vp56_rac_get_prob(c, s->prob->golden) ?
622                 VP56_FRAME_GOLDEN2 /* altref */ : VP56_FRAME_GOLDEN;
623         else
624             mb->ref_frame = VP56_FRAME_PREVIOUS;
625         s->ref_count[mb->ref_frame-1]++;
626
627         // motion vectors, 16.3
628         decode_mvs(s, mb, mb_x, mb_y);
629     } else {
630         // intra MB, 16.1
631         mb->mode = vp8_rac_get_tree(c, vp8_pred16x16_tree_inter, s->prob->pred16x16);
632
633         if (mb->mode == MODE_I4x4)
634             decode_intra4x4_modes(s, c, mb_x, 0);
635
636         s->chroma_pred_mode = vp8_rac_get_tree(c, vp8_pred8x8c_tree, s->prob->pred8x8c);
637         mb->ref_frame = VP56_FRAME_CURRENT;
638         mb->partitioning = VP8_SPLITMVMODE_NONE;
639         AV_ZERO32(&mb->bmv[0]);
640     }
641 }
642
643 #ifndef decode_block_coeffs_internal
644 /**
645  * @param c arithmetic bitstream reader context
646  * @param block destination for block coefficients
647  * @param probs probabilities to use when reading trees from the bitstream
648  * @param i initial coeff index, 0 unless a separate DC block is coded
649  * @param qmul array holding the dc/ac dequant factor at position 0/1
650  * @return 0 if no coeffs were decoded
651  *         otherwise, the index of the last coeff decoded plus one
652  */
653 static int decode_block_coeffs_internal(VP56RangeCoder *c, DCTELEM block[16],
654                                         uint8_t probs[16][3][NUM_DCT_TOKENS-1],
655                                         int i, uint8_t *token_prob, int16_t qmul[2])
656 {
657     goto skip_eob;
658     do {
659         int coeff;
660         if (!vp56_rac_get_prob_branchy(c, token_prob[0]))   // DCT_EOB
661             return i;
662
663 skip_eob:
664         if (!vp56_rac_get_prob_branchy(c, token_prob[1])) { // DCT_0
665             if (++i == 16)
666                 return i; // invalid input; blocks should end with EOB
667             token_prob = probs[i][0];
668             goto skip_eob;
669         }
670
671         if (!vp56_rac_get_prob_branchy(c, token_prob[2])) { // DCT_1
672             coeff = 1;
673             token_prob = probs[i+1][1];
674         } else {
675             if (!vp56_rac_get_prob_branchy(c, token_prob[3])) { // DCT 2,3,4
676                 coeff = vp56_rac_get_prob_branchy(c, token_prob[4]);
677                 if (coeff)
678                     coeff += vp56_rac_get_prob(c, token_prob[5]);
679                 coeff += 2;
680             } else {
681                 // DCT_CAT*
682                 if (!vp56_rac_get_prob_branchy(c, token_prob[6])) {
683                     if (!vp56_rac_get_prob_branchy(c, token_prob[7])) { // DCT_CAT1
684                         coeff  = 5 + vp56_rac_get_prob(c, vp8_dct_cat1_prob[0]);
685                     } else {                                    // DCT_CAT2
686                         coeff  = 7;
687                         coeff += vp56_rac_get_prob(c, vp8_dct_cat2_prob[0]) << 1;
688                         coeff += vp56_rac_get_prob(c, vp8_dct_cat2_prob[1]);
689                     }
690                 } else {    // DCT_CAT3 and up
691                     int a = vp56_rac_get_prob(c, token_prob[8]);
692                     int b = vp56_rac_get_prob(c, token_prob[9+a]);
693                     int cat = (a<<1) + b;
694                     coeff  = 3 + (8<<cat);
695                     coeff += vp8_rac_get_coeff(c, ff_vp8_dct_cat_prob[cat]);
696                 }
697             }
698             token_prob = probs[i+1][2];
699         }
700         block[zigzag_scan[i]] = (vp8_rac_get(c) ? -coeff : coeff) * qmul[!!i];
701     } while (++i < 16);
702
703     return i;
704 }
705 #endif
706
707 /**
708  * @param c arithmetic bitstream reader context
709  * @param block destination for block coefficients
710  * @param probs probabilities to use when reading trees from the bitstream
711  * @param i initial coeff index, 0 unless a separate DC block is coded
712  * @param zero_nhood the initial prediction context for number of surrounding
713  *                   all-zero blocks (only left/top, so 0-2)
714  * @param qmul array holding the dc/ac dequant factor at position 0/1
715  * @return 0 if no coeffs were decoded
716  *         otherwise, the index of the last coeff decoded plus one
717  */
718 static av_always_inline
719 int decode_block_coeffs(VP56RangeCoder *c, DCTELEM block[16],
720                         uint8_t probs[16][3][NUM_DCT_TOKENS-1],
721                         int i, int zero_nhood, int16_t qmul[2])
722 {
723     uint8_t *token_prob = probs[i][zero_nhood];
724     if (!vp56_rac_get_prob_branchy(c, token_prob[0]))   // DCT_EOB
725         return 0;
726     return decode_block_coeffs_internal(c, block, probs, i, token_prob, qmul);
727 }
728
729 static av_always_inline
730 void decode_mb_coeffs(VP8Context *s, VP56RangeCoder *c, VP8Macroblock *mb,
731                       uint8_t t_nnz[9], uint8_t l_nnz[9])
732 {
733     int i, x, y, luma_start = 0, luma_ctx = 3;
734     int nnz_pred, nnz, nnz_total = 0;
735     int segment = s->segment;
736     int block_dc = 0;
737
738     if (mb->mode != MODE_I4x4 && mb->mode != VP8_MVMODE_SPLIT) {
739         nnz_pred = t_nnz[8] + l_nnz[8];
740
741         // decode DC values and do hadamard
742         nnz = decode_block_coeffs(c, s->block_dc, s->prob->token[1], 0, nnz_pred,
743                                   s->qmat[segment].luma_dc_qmul);
744         l_nnz[8] = t_nnz[8] = !!nnz;
745         if (nnz) {
746             nnz_total += nnz;
747             block_dc = 1;
748             if (nnz == 1)
749                 s->vp8dsp.vp8_luma_dc_wht_dc(s->block, s->block_dc);
750             else
751                 s->vp8dsp.vp8_luma_dc_wht(s->block, s->block_dc);
752         }
753         luma_start = 1;
754         luma_ctx = 0;
755     }
756
757     // luma blocks
758     for (y = 0; y < 4; y++)
759         for (x = 0; x < 4; x++) {
760             nnz_pred = l_nnz[y] + t_nnz[x];
761             nnz = decode_block_coeffs(c, s->block[y][x], s->prob->token[luma_ctx], luma_start,
762                                       nnz_pred, s->qmat[segment].luma_qmul);
763             // nnz+block_dc may be one more than the actual last index, but we don't care
764             s->non_zero_count_cache[y][x] = nnz + block_dc;
765             t_nnz[x] = l_nnz[y] = !!nnz;
766             nnz_total += nnz;
767         }
768
769     // chroma blocks
770     // TODO: what to do about dimensions? 2nd dim for luma is x,
771     // but for chroma it's (y<<1)|x
772     for (i = 4; i < 6; i++)
773         for (y = 0; y < 2; y++)
774             for (x = 0; x < 2; x++) {
775                 nnz_pred = l_nnz[i+2*y] + t_nnz[i+2*x];
776                 nnz = decode_block_coeffs(c, s->block[i][(y<<1)+x], s->prob->token[2], 0,
777                                           nnz_pred, s->qmat[segment].chroma_qmul);
778                 s->non_zero_count_cache[i][(y<<1)+x] = nnz;
779                 t_nnz[i+2*x] = l_nnz[i+2*y] = !!nnz;
780                 nnz_total += nnz;
781             }
782
783     // if there were no coded coeffs despite the macroblock not being marked skip,
784     // we MUST not do the inner loop filter and should not do IDCT
785     // Since skip isn't used for bitstream prediction, just manually set it.
786     if (!nnz_total)
787         mb->skip = 1;
788 }
789
790 static av_always_inline
791 void backup_mb_border(uint8_t *top_border, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr,
792                       int linesize, int uvlinesize, int simple)
793 {
794     AV_COPY128(top_border, src_y + 15*linesize);
795     if (!simple) {
796         AV_COPY64(top_border+16, src_cb + 7*uvlinesize);
797         AV_COPY64(top_border+24, src_cr + 7*uvlinesize);
798     }
799 }
800
801 static av_always_inline
802 void xchg_mb_border(uint8_t *top_border, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr,
803                     int linesize, int uvlinesize, int mb_x, int mb_y, int mb_width,
804                     int simple, int xchg)
805 {
806     uint8_t *top_border_m1 = top_border-32;     // for TL prediction
807     src_y  -=   linesize;
808     src_cb -= uvlinesize;
809     src_cr -= uvlinesize;
810
811 #define XCHG(a,b,xchg) do {                     \
812         if (xchg) AV_SWAP64(b,a);               \
813         else      AV_COPY64(b,a);               \
814     } while (0)
815
816     XCHG(top_border_m1+8, src_y-8, xchg);
817     XCHG(top_border,      src_y,   xchg);
818     XCHG(top_border+8,    src_y+8, 1);
819     if (mb_x < mb_width-1)
820         XCHG(top_border+32, src_y+16, 1);
821
822     // only copy chroma for normal loop filter
823     // or to initialize the top row to 127
824     if (!simple || !mb_y) {
825         XCHG(top_border_m1+16, src_cb-8, xchg);
826         XCHG(top_border_m1+24, src_cr-8, xchg);
827         XCHG(top_border+16,    src_cb, 1);
828         XCHG(top_border+24,    src_cr, 1);
829     }
830 }
831
832 static av_always_inline
833 int check_dc_pred8x8_mode(int mode, int mb_x, int mb_y)
834 {
835     if (!mb_x) {
836         return mb_y ? TOP_DC_PRED8x8 : DC_128_PRED8x8;
837     } else {
838         return mb_y ? mode : LEFT_DC_PRED8x8;
839     }
840 }
841
842 static av_always_inline
843 int check_tm_pred8x8_mode(int mode, int mb_x, int mb_y)
844 {
845     if (!mb_x) {
846         return mb_y ? VERT_PRED8x8 : DC_129_PRED8x8;
847     } else {
848         return mb_y ? mode : HOR_PRED8x8;
849     }
850 }
851
852 static av_always_inline
853 int check_intra_pred8x8_mode(int mode, int mb_x, int mb_y)
854 {
855     if (mode == DC_PRED8x8) {
856         return check_dc_pred8x8_mode(mode, mb_x, mb_y);
857     } else {
858         return mode;
859     }
860 }
861
862 static av_always_inline
863 int check_intra_pred8x8_mode_emuedge(int mode, int mb_x, int mb_y)
864 {
865     switch (mode) {
866     case DC_PRED8x8:
867         return check_dc_pred8x8_mode(mode, mb_x, mb_y);
868     case VERT_PRED8x8:
869         return !mb_y ? DC_127_PRED8x8 : mode;
870     case HOR_PRED8x8:
871         return !mb_x ? DC_129_PRED8x8 : mode;
872     case PLANE_PRED8x8 /*TM*/:
873         return check_tm_pred8x8_mode(mode, mb_x, mb_y);
874     }
875     return mode;
876 }
877
878 static av_always_inline
879 int check_tm_pred4x4_mode(int mode, int mb_x, int mb_y)
880 {
881     if (!mb_x) {
882         return mb_y ? VERT_VP8_PRED : DC_129_PRED;
883     } else {
884         return mb_y ? mode : HOR_VP8_PRED;
885     }
886 }
887
888 static av_always_inline
889 int check_intra_pred4x4_mode_emuedge(int mode, int mb_x, int mb_y, int *copy_buf)
890 {
891     switch (mode) {
892     case VERT_PRED:
893         if (!mb_x && mb_y) {
894             *copy_buf = 1;
895             return mode;
896         }
897         /* fall-through */
898     case DIAG_DOWN_LEFT_PRED:
899     case VERT_LEFT_PRED:
900         return !mb_y ? DC_127_PRED : mode;
901     case HOR_PRED:
902         if (!mb_y) {
903             *copy_buf = 1;
904             return mode;
905         }
906         /* fall-through */
907     case HOR_UP_PRED:
908         return !mb_x ? DC_129_PRED : mode;
909     case TM_VP8_PRED:
910         return check_tm_pred4x4_mode(mode, mb_x, mb_y);
911     case DC_PRED: // 4x4 DC doesn't use the same "H.264-style" exceptions as 16x16/8x8 DC
912     case DIAG_DOWN_RIGHT_PRED:
913     case VERT_RIGHT_PRED:
914     case HOR_DOWN_PRED:
915         if (!mb_y || !mb_x)
916             *copy_buf = 1;
917         return mode;
918     }
919     return mode;
920 }
921
922 static av_always_inline
923 void intra_predict(VP8Context *s, uint8_t *dst[3], VP8Macroblock *mb,
924                    int mb_x, int mb_y)
925 {
926     AVCodecContext *avctx = s->avctx;
927     int x, y, mode, nnz;
928     uint32_t tr;
929
930     // for the first row, we need to run xchg_mb_border to init the top edge to 127
931     // otherwise, skip it if we aren't going to deblock
932     if (!(avctx->flags & CODEC_FLAG_EMU_EDGE && !mb_y) && (s->deblock_filter || !mb_y))
933         xchg_mb_border(s->top_border[mb_x+1], dst[0], dst[1], dst[2],
934                        s->linesize, s->uvlinesize, mb_x, mb_y, s->mb_width,
935                        s->filter.simple, 1);
936
937     if (mb->mode < MODE_I4x4) {
938         if (avctx->flags & CODEC_FLAG_EMU_EDGE) { // tested
939             mode = check_intra_pred8x8_mode_emuedge(mb->mode, mb_x, mb_y);
940         } else {
941             mode = check_intra_pred8x8_mode(mb->mode, mb_x, mb_y);
942         }
943         s->hpc.pred16x16[mode](dst[0], s->linesize);
944     } else {
945         uint8_t *ptr = dst[0];
946         uint8_t *intra4x4 = s->intra4x4_pred_mode_mb;
947         uint8_t tr_top[4] = { 127, 127, 127, 127 };
948
949         // all blocks on the right edge of the macroblock use bottom edge
950         // the top macroblock for their topright edge
951         uint8_t *tr_right = ptr - s->linesize + 16;
952
953         // if we're on the right edge of the frame, said edge is extended
954         // from the top macroblock
955         if (!(!mb_y && avctx->flags & CODEC_FLAG_EMU_EDGE) &&
956             mb_x == s->mb_width-1) {
957             tr = tr_right[-1]*0x01010101u;
958             tr_right = (uint8_t *)&tr;
959         }
960
961         if (mb->skip)
962             AV_ZERO128(s->non_zero_count_cache);
963
964         for (y = 0; y < 4; y++) {
965             uint8_t *topright = ptr + 4 - s->linesize;
966             for (x = 0; x < 4; x++) {
967                 int copy = 0, linesize = s->linesize;
968                 uint8_t *dst = ptr+4*x;
969                 DECLARE_ALIGNED(4, uint8_t, copy_dst)[5*8];
970
971                 if ((y == 0 || x == 3) && mb_y == 0 && avctx->flags & CODEC_FLAG_EMU_EDGE) {
972                     topright = tr_top;
973                 } else if (x == 3)
974                     topright = tr_right;
975
976                 if (avctx->flags & CODEC_FLAG_EMU_EDGE) { // mb_x+x or mb_y+y is a hack but works
977                     mode = check_intra_pred4x4_mode_emuedge(intra4x4[x], mb_x + x, mb_y + y, &copy);
978                     if (copy) {
979                         dst = copy_dst + 12;
980                         linesize = 8;
981                         if (!(mb_y + y)) {
982                             copy_dst[3] = 127U;
983                             AV_WN32A(copy_dst+4, 127U * 0x01010101U);
984                         } else {
985                             AV_COPY32(copy_dst+4, ptr+4*x-s->linesize);
986                             if (!(mb_x + x)) {
987                                 copy_dst[3] = 129U;
988                             } else {
989                                 copy_dst[3] = ptr[4*x-s->linesize-1];
990                             }
991                         }
992                         if (!(mb_x + x)) {
993                             copy_dst[11] =
994                             copy_dst[19] =
995                             copy_dst[27] =
996                             copy_dst[35] = 129U;
997                         } else {
998                             copy_dst[11] = ptr[4*x              -1];
999                             copy_dst[19] = ptr[4*x+s->linesize  -1];
1000                             copy_dst[27] = ptr[4*x+s->linesize*2-1];
1001                             copy_dst[35] = ptr[4*x+s->linesize*3-1];
1002                         }
1003                     }
1004                 } else {
1005                     mode = intra4x4[x];
1006                 }
1007                 s->hpc.pred4x4[mode](dst, topright, linesize);
1008                 if (copy) {
1009                     AV_COPY32(ptr+4*x              , copy_dst+12);
1010                     AV_COPY32(ptr+4*x+s->linesize  , copy_dst+20);
1011                     AV_COPY32(ptr+4*x+s->linesize*2, copy_dst+28);
1012                     AV_COPY32(ptr+4*x+s->linesize*3, copy_dst+36);
1013                 }
1014
1015                 nnz = s->non_zero_count_cache[y][x];
1016                 if (nnz) {
1017                     if (nnz == 1)
1018                         s->vp8dsp.vp8_idct_dc_add(ptr+4*x, s->block[y][x], s->linesize);
1019                     else
1020                         s->vp8dsp.vp8_idct_add(ptr+4*x, s->block[y][x], s->linesize);
1021                 }
1022                 topright += 4;
1023             }
1024
1025             ptr   += 4*s->linesize;
1026             intra4x4 += 4;
1027         }
1028     }
1029
1030     if (avctx->flags & CODEC_FLAG_EMU_EDGE) {
1031         mode = check_intra_pred8x8_mode_emuedge(s->chroma_pred_mode, mb_x, mb_y);
1032     } else {
1033         mode = check_intra_pred8x8_mode(s->chroma_pred_mode, mb_x, mb_y);
1034     }
1035     s->hpc.pred8x8[mode](dst[1], s->uvlinesize);
1036     s->hpc.pred8x8[mode](dst[2], s->uvlinesize);
1037
1038     if (!(avctx->flags & CODEC_FLAG_EMU_EDGE && !mb_y) && (s->deblock_filter || !mb_y))
1039         xchg_mb_border(s->top_border[mb_x+1], dst[0], dst[1], dst[2],
1040                        s->linesize, s->uvlinesize, mb_x, mb_y, s->mb_width,
1041                        s->filter.simple, 0);
1042 }
1043
1044 static const uint8_t subpel_idx[3][8] = {
1045     { 0, 1, 2, 1, 2, 1, 2, 1 }, // nr. of left extra pixels,
1046                                 // also function pointer index
1047     { 0, 3, 5, 3, 5, 3, 5, 3 }, // nr. of extra pixels required
1048     { 0, 2, 3, 2, 3, 2, 3, 2 }, // nr. of right extra pixels
1049 };
1050
1051 /**
1052  * luma MC function
1053  *
1054  * @param s VP8 decoding context
1055  * @param dst target buffer for block data at block position
1056  * @param ref reference picture buffer at origin (0, 0)
1057  * @param mv motion vector (relative to block position) to get pixel data from
1058  * @param x_off horizontal position of block from origin (0, 0)
1059  * @param y_off vertical position of block from origin (0, 0)
1060  * @param block_w width of block (16, 8 or 4)
1061  * @param block_h height of block (always same as block_w)
1062  * @param width width of src/dst plane data
1063  * @param height height of src/dst plane data
1064  * @param linesize size of a single line of plane data, including padding
1065  * @param mc_func motion compensation function pointers (bilinear or sixtap MC)
1066  */
1067 static av_always_inline
1068 void vp8_mc_luma(VP8Context *s, uint8_t *dst, AVFrame *ref, const VP56mv *mv,
1069                  int x_off, int y_off, int block_w, int block_h,
1070                  int width, int height, int linesize,
1071                  vp8_mc_func mc_func[3][3])
1072 {
1073     uint8_t *src = ref->data[0];
1074
1075     if (AV_RN32A(mv)) {
1076
1077         int mx = (mv->x << 1)&7, mx_idx = subpel_idx[0][mx];
1078         int my = (mv->y << 1)&7, my_idx = subpel_idx[0][my];
1079
1080         x_off += mv->x >> 2;
1081         y_off += mv->y >> 2;
1082
1083         // edge emulation
1084         ff_thread_await_progress(ref, (3 + y_off + block_h + subpel_idx[2][my]) >> 4, 0);
1085         src += y_off * linesize + x_off;
1086         if (x_off < mx_idx || x_off >= width  - block_w - subpel_idx[2][mx] ||
1087             y_off < my_idx || y_off >= height - block_h - subpel_idx[2][my]) {
1088             s->dsp.emulated_edge_mc(s->edge_emu_buffer, src - my_idx * linesize - mx_idx, linesize,
1089                                     block_w + subpel_idx[1][mx], block_h + subpel_idx[1][my],
1090                                     x_off - mx_idx, y_off - my_idx, width, height);
1091             src = s->edge_emu_buffer + mx_idx + linesize * my_idx;
1092         }
1093         mc_func[my_idx][mx_idx](dst, linesize, src, linesize, block_h, mx, my);
1094     } else {
1095         ff_thread_await_progress(ref, (3 + y_off + block_h) >> 4, 0);
1096         mc_func[0][0](dst, linesize, src + y_off * linesize + x_off, linesize, block_h, 0, 0);
1097     }
1098 }
1099
1100 /**
1101  * chroma MC function
1102  *
1103  * @param s VP8 decoding context
1104  * @param dst1 target buffer for block data at block position (U plane)
1105  * @param dst2 target buffer for block data at block position (V plane)
1106  * @param ref reference picture buffer at origin (0, 0)
1107  * @param mv motion vector (relative to block position) to get pixel data from
1108  * @param x_off horizontal position of block from origin (0, 0)
1109  * @param y_off vertical position of block from origin (0, 0)
1110  * @param block_w width of block (16, 8 or 4)
1111  * @param block_h height of block (always same as block_w)
1112  * @param width width of src/dst plane data
1113  * @param height height of src/dst plane data
1114  * @param linesize size of a single line of plane data, including padding
1115  * @param mc_func motion compensation function pointers (bilinear or sixtap MC)
1116  */
1117 static av_always_inline
1118 void vp8_mc_chroma(VP8Context *s, uint8_t *dst1, uint8_t *dst2, AVFrame *ref,
1119                    const VP56mv *mv, int x_off, int y_off,
1120                    int block_w, int block_h, int width, int height, int linesize,
1121                    vp8_mc_func mc_func[3][3])
1122 {
1123     uint8_t *src1 = ref->data[1], *src2 = ref->data[2];
1124
1125     if (AV_RN32A(mv)) {
1126         int mx = mv->x&7, mx_idx = subpel_idx[0][mx];
1127         int my = mv->y&7, my_idx = subpel_idx[0][my];
1128
1129         x_off += mv->x >> 3;
1130         y_off += mv->y >> 3;
1131
1132         // edge emulation
1133         src1 += y_off * linesize + x_off;
1134         src2 += y_off * linesize + x_off;
1135         ff_thread_await_progress(ref, (3 + y_off + block_h + subpel_idx[2][my]) >> 3, 0);
1136         if (x_off < mx_idx || x_off >= width  - block_w - subpel_idx[2][mx] ||
1137             y_off < my_idx || y_off >= height - block_h - subpel_idx[2][my]) {
1138             s->dsp.emulated_edge_mc(s->edge_emu_buffer, src1 - my_idx * linesize - mx_idx, linesize,
1139                                     block_w + subpel_idx[1][mx], block_h + subpel_idx[1][my],
1140                                     x_off - mx_idx, y_off - my_idx, width, height);
1141             src1 = s->edge_emu_buffer + mx_idx + linesize * my_idx;
1142             mc_func[my_idx][mx_idx](dst1, linesize, src1, linesize, block_h, mx, my);
1143
1144             s->dsp.emulated_edge_mc(s->edge_emu_buffer, src2 - my_idx * linesize - mx_idx, linesize,
1145                                     block_w + subpel_idx[1][mx], block_h + subpel_idx[1][my],
1146                                     x_off - mx_idx, y_off - my_idx, width, height);
1147             src2 = s->edge_emu_buffer + mx_idx + linesize * my_idx;
1148             mc_func[my_idx][mx_idx](dst2, linesize, src2, linesize, block_h, mx, my);
1149         } else {
1150             mc_func[my_idx][mx_idx](dst1, linesize, src1, linesize, block_h, mx, my);
1151             mc_func[my_idx][mx_idx](dst2, linesize, src2, linesize, block_h, mx, my);
1152         }
1153     } else {
1154         ff_thread_await_progress(ref, (3 + y_off + block_h) >> 3, 0);
1155         mc_func[0][0](dst1, linesize, src1 + y_off * linesize + x_off, linesize, block_h, 0, 0);
1156         mc_func[0][0](dst2, linesize, src2 + y_off * linesize + x_off, linesize, block_h, 0, 0);
1157     }
1158 }
1159
1160 static av_always_inline
1161 void vp8_mc_part(VP8Context *s, uint8_t *dst[3],
1162                  AVFrame *ref_frame, int x_off, int y_off,
1163                  int bx_off, int by_off,
1164                  int block_w, int block_h,
1165                  int width, int height, VP56mv *mv)
1166 {
1167     VP56mv uvmv = *mv;
1168
1169     /* Y */
1170     vp8_mc_luma(s, dst[0] + by_off * s->linesize + bx_off,
1171                 ref_frame, mv, x_off + bx_off, y_off + by_off,
1172                 block_w, block_h, width, height, s->linesize,
1173                 s->put_pixels_tab[block_w == 8]);
1174
1175     /* U/V */
1176     if (s->profile == 3) {
1177         uvmv.x &= ~7;
1178         uvmv.y &= ~7;
1179     }
1180     x_off   >>= 1; y_off   >>= 1;
1181     bx_off  >>= 1; by_off  >>= 1;
1182     width   >>= 1; height  >>= 1;
1183     block_w >>= 1; block_h >>= 1;
1184     vp8_mc_chroma(s, dst[1] + by_off * s->uvlinesize + bx_off,
1185                   dst[2] + by_off * s->uvlinesize + bx_off, ref_frame,
1186                   &uvmv, x_off + bx_off, y_off + by_off,
1187                   block_w, block_h, width, height, s->uvlinesize,
1188                   s->put_pixels_tab[1 + (block_w == 4)]);
1189 }
1190
1191 /* Fetch pixels for estimated mv 4 macroblocks ahead.
1192  * Optimized for 64-byte cache lines.  Inspired by ffh264 prefetch_motion. */
1193 static av_always_inline void prefetch_motion(VP8Context *s, VP8Macroblock *mb, int mb_x, int mb_y, int mb_xy, int ref)
1194 {
1195     /* Don't prefetch refs that haven't been used very often this frame. */
1196     if (s->ref_count[ref-1] > (mb_xy >> 5)) {
1197         int x_off = mb_x << 4, y_off = mb_y << 4;
1198         int mx = (mb->mv.x>>2) + x_off + 8;
1199         int my = (mb->mv.y>>2) + y_off;
1200         uint8_t **src= s->framep[ref]->data;
1201         int off= mx + (my + (mb_x&3)*4)*s->linesize + 64;
1202         /* For threading, a ff_thread_await_progress here might be useful, but
1203          * it actually slows down the decoder. Since a bad prefetch doesn't
1204          * generate bad decoder output, we don't run it here. */
1205         s->dsp.prefetch(src[0]+off, s->linesize, 4);
1206         off= (mx>>1) + ((my>>1) + (mb_x&7))*s->uvlinesize + 64;
1207         s->dsp.prefetch(src[1]+off, src[2]-src[1], 2);
1208     }
1209 }
1210
1211 /**
1212  * Apply motion vectors to prediction buffer, chapter 18.
1213  */
1214 static av_always_inline
1215 void inter_predict(VP8Context *s, uint8_t *dst[3], VP8Macroblock *mb,
1216                    int mb_x, int mb_y)
1217 {
1218     int x_off = mb_x << 4, y_off = mb_y << 4;
1219     int width = 16*s->mb_width, height = 16*s->mb_height;
1220     AVFrame *ref = s->framep[mb->ref_frame];
1221     VP56mv *bmv = mb->bmv;
1222
1223     switch (mb->partitioning) {
1224     case VP8_SPLITMVMODE_NONE:
1225         vp8_mc_part(s, dst, ref, x_off, y_off,
1226                     0, 0, 16, 16, width, height, &mb->mv);
1227         break;
1228     case VP8_SPLITMVMODE_4x4: {
1229         int x, y;
1230         VP56mv uvmv;
1231
1232         /* Y */
1233         for (y = 0; y < 4; y++) {
1234             for (x = 0; x < 4; x++) {
1235                 vp8_mc_luma(s, dst[0] + 4*y*s->linesize + x*4,
1236                             ref, &bmv[4*y + x],
1237                             4*x + x_off, 4*y + y_off, 4, 4,
1238                             width, height, s->linesize,
1239                             s->put_pixels_tab[2]);
1240             }
1241         }
1242
1243         /* U/V */
1244         x_off >>= 1; y_off >>= 1; width >>= 1; height >>= 1;
1245         for (y = 0; y < 2; y++) {
1246             for (x = 0; x < 2; x++) {
1247                 uvmv.x = mb->bmv[ 2*y    * 4 + 2*x  ].x +
1248                          mb->bmv[ 2*y    * 4 + 2*x+1].x +
1249                          mb->bmv[(2*y+1) * 4 + 2*x  ].x +
1250                          mb->bmv[(2*y+1) * 4 + 2*x+1].x;
1251                 uvmv.y = mb->bmv[ 2*y    * 4 + 2*x  ].y +
1252                          mb->bmv[ 2*y    * 4 + 2*x+1].y +
1253                          mb->bmv[(2*y+1) * 4 + 2*x  ].y +
1254                          mb->bmv[(2*y+1) * 4 + 2*x+1].y;
1255                 uvmv.x = (uvmv.x + 2 + (uvmv.x >> (INT_BIT-1))) >> 2;
1256                 uvmv.y = (uvmv.y + 2 + (uvmv.y >> (INT_BIT-1))) >> 2;
1257                 if (s->profile == 3) {
1258                     uvmv.x &= ~7;
1259                     uvmv.y &= ~7;
1260                 }
1261                 vp8_mc_chroma(s, dst[1] + 4*y*s->uvlinesize + x*4,
1262                               dst[2] + 4*y*s->uvlinesize + x*4, ref, &uvmv,
1263                               4*x + x_off, 4*y + y_off, 4, 4,
1264                               width, height, s->uvlinesize,
1265                               s->put_pixels_tab[2]);
1266             }
1267         }
1268         break;
1269     }
1270     case VP8_SPLITMVMODE_16x8:
1271         vp8_mc_part(s, dst, ref, x_off, y_off,
1272                     0, 0, 16, 8, width, height, &bmv[0]);
1273         vp8_mc_part(s, dst, ref, x_off, y_off,
1274                     0, 8, 16, 8, width, height, &bmv[1]);
1275         break;
1276     case VP8_SPLITMVMODE_8x16:
1277         vp8_mc_part(s, dst, ref, x_off, y_off,
1278                     0, 0, 8, 16, width, height, &bmv[0]);
1279         vp8_mc_part(s, dst, ref, x_off, y_off,
1280                     8, 0, 8, 16, width, height, &bmv[1]);
1281         break;
1282     case VP8_SPLITMVMODE_8x8:
1283         vp8_mc_part(s, dst, ref, x_off, y_off,
1284                     0, 0, 8, 8, width, height, &bmv[0]);
1285         vp8_mc_part(s, dst, ref, x_off, y_off,
1286                     8, 0, 8, 8, width, height, &bmv[1]);
1287         vp8_mc_part(s, dst, ref, x_off, y_off,
1288                     0, 8, 8, 8, width, height, &bmv[2]);
1289         vp8_mc_part(s, dst, ref, x_off, y_off,
1290                     8, 8, 8, 8, width, height, &bmv[3]);
1291         break;
1292     }
1293 }
1294
1295 static av_always_inline void idct_mb(VP8Context *s, uint8_t *dst[3], VP8Macroblock *mb)
1296 {
1297     int x, y, ch;
1298
1299     if (mb->mode != MODE_I4x4) {
1300         uint8_t *y_dst = dst[0];
1301         for (y = 0; y < 4; y++) {
1302             uint32_t nnz4 = AV_RL32(s->non_zero_count_cache[y]);
1303             if (nnz4) {
1304                 if (nnz4&~0x01010101) {
1305                     for (x = 0; x < 4; x++) {
1306                         if ((uint8_t)nnz4 == 1)
1307                             s->vp8dsp.vp8_idct_dc_add(y_dst+4*x, s->block[y][x], s->linesize);
1308                         else if((uint8_t)nnz4 > 1)
1309                             s->vp8dsp.vp8_idct_add(y_dst+4*x, s->block[y][x], s->linesize);
1310                         nnz4 >>= 8;
1311                         if (!nnz4)
1312                             break;
1313                     }
1314                 } else {
1315                     s->vp8dsp.vp8_idct_dc_add4y(y_dst, s->block[y], s->linesize);
1316                 }
1317             }
1318             y_dst += 4*s->linesize;
1319         }
1320     }
1321
1322     for (ch = 0; ch < 2; ch++) {
1323         uint32_t nnz4 = AV_RL32(s->non_zero_count_cache[4+ch]);
1324         if (nnz4) {
1325             uint8_t *ch_dst = dst[1+ch];
1326             if (nnz4&~0x01010101) {
1327                 for (y = 0; y < 2; y++) {
1328                     for (x = 0; x < 2; x++) {
1329                         if ((uint8_t)nnz4 == 1)
1330                             s->vp8dsp.vp8_idct_dc_add(ch_dst+4*x, s->block[4+ch][(y<<1)+x], s->uvlinesize);
1331                         else if((uint8_t)nnz4 > 1)
1332                             s->vp8dsp.vp8_idct_add(ch_dst+4*x, s->block[4+ch][(y<<1)+x], s->uvlinesize);
1333                         nnz4 >>= 8;
1334                         if (!nnz4)
1335                             goto chroma_idct_end;
1336                     }
1337                     ch_dst += 4*s->uvlinesize;
1338                 }
1339             } else {
1340                 s->vp8dsp.vp8_idct_dc_add4uv(ch_dst, s->block[4+ch], s->uvlinesize);
1341             }
1342         }
1343 chroma_idct_end: ;
1344     }
1345 }
1346
1347 static av_always_inline void filter_level_for_mb(VP8Context *s, VP8Macroblock *mb, VP8FilterStrength *f )
1348 {
1349     int interior_limit, filter_level;
1350
1351     if (s->segmentation.enabled) {
1352         filter_level = s->segmentation.filter_level[s->segment];
1353         if (!s->segmentation.absolute_vals)
1354             filter_level += s->filter.level;
1355     } else
1356         filter_level = s->filter.level;
1357
1358     if (s->lf_delta.enabled) {
1359         filter_level += s->lf_delta.ref[mb->ref_frame];
1360         filter_level += s->lf_delta.mode[mb->mode];
1361     }
1362
1363     filter_level = av_clip_uintp2(filter_level, 6);
1364
1365     interior_limit = filter_level;
1366     if (s->filter.sharpness) {
1367         interior_limit >>= (s->filter.sharpness + 3) >> 2;
1368         interior_limit = FFMIN(interior_limit, 9 - s->filter.sharpness);
1369     }
1370     interior_limit = FFMAX(interior_limit, 1);
1371
1372     f->filter_level = filter_level;
1373     f->inner_limit = interior_limit;
1374     f->inner_filter = !mb->skip || mb->mode == MODE_I4x4 || mb->mode == VP8_MVMODE_SPLIT;
1375 }
1376
1377 static av_always_inline void filter_mb(VP8Context *s, uint8_t *dst[3], VP8FilterStrength *f, int mb_x, int mb_y)
1378 {
1379     int mbedge_lim, bedge_lim, hev_thresh;
1380     int filter_level = f->filter_level;
1381     int inner_limit = f->inner_limit;
1382     int inner_filter = f->inner_filter;
1383     int linesize = s->linesize;
1384     int uvlinesize = s->uvlinesize;
1385     static const uint8_t hev_thresh_lut[2][64] = {
1386         { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
1387           2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1388           3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1389           3, 3, 3, 3 },
1390         { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
1391           1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1392           2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1393           2, 2, 2, 2 }
1394     };
1395
1396     if (!filter_level)
1397         return;
1398
1399      bedge_lim = 2*filter_level + inner_limit;
1400     mbedge_lim = bedge_lim + 4;
1401
1402     hev_thresh = hev_thresh_lut[s->keyframe][filter_level];
1403
1404     if (mb_x) {
1405         s->vp8dsp.vp8_h_loop_filter16y(dst[0],     linesize,
1406                                        mbedge_lim, inner_limit, hev_thresh);
1407         s->vp8dsp.vp8_h_loop_filter8uv(dst[1],     dst[2],      uvlinesize,
1408                                        mbedge_lim, inner_limit, hev_thresh);
1409     }
1410
1411     if (inner_filter) {
1412         s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0]+ 4, linesize, bedge_lim,
1413                                              inner_limit, hev_thresh);
1414         s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0]+ 8, linesize, bedge_lim,
1415                                              inner_limit, hev_thresh);
1416         s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0]+12, linesize, bedge_lim,
1417                                              inner_limit, hev_thresh);
1418         s->vp8dsp.vp8_h_loop_filter8uv_inner(dst[1] + 4, dst[2] + 4,
1419                                              uvlinesize,  bedge_lim,
1420                                              inner_limit, hev_thresh);
1421     }
1422
1423     if (mb_y) {
1424         s->vp8dsp.vp8_v_loop_filter16y(dst[0],     linesize,
1425                                        mbedge_lim, inner_limit, hev_thresh);
1426         s->vp8dsp.vp8_v_loop_filter8uv(dst[1],     dst[2],      uvlinesize,
1427                                        mbedge_lim, inner_limit, hev_thresh);
1428     }
1429
1430     if (inner_filter) {
1431         s->vp8dsp.vp8_v_loop_filter16y_inner(dst[0]+ 4*linesize,
1432                                              linesize,    bedge_lim,
1433                                              inner_limit, hev_thresh);
1434         s->vp8dsp.vp8_v_loop_filter16y_inner(dst[0]+ 8*linesize,
1435                                              linesize,    bedge_lim,
1436                                              inner_limit, hev_thresh);
1437         s->vp8dsp.vp8_v_loop_filter16y_inner(dst[0]+12*linesize,
1438                                              linesize,    bedge_lim,
1439                                              inner_limit, hev_thresh);
1440         s->vp8dsp.vp8_v_loop_filter8uv_inner(dst[1] + 4 * uvlinesize,
1441                                              dst[2] + 4 * uvlinesize,
1442                                              uvlinesize,  bedge_lim,
1443                                              inner_limit, hev_thresh);
1444     }
1445 }
1446
1447 static av_always_inline void filter_mb_simple(VP8Context *s, uint8_t *dst, VP8FilterStrength *f, int mb_x, int mb_y)
1448 {
1449     int mbedge_lim, bedge_lim;
1450     int filter_level = f->filter_level;
1451     int inner_limit = f->inner_limit;
1452     int inner_filter = f->inner_filter;
1453     int linesize = s->linesize;
1454
1455     if (!filter_level)
1456         return;
1457
1458      bedge_lim = 2*filter_level + inner_limit;
1459     mbedge_lim = bedge_lim + 4;
1460
1461     if (mb_x)
1462         s->vp8dsp.vp8_h_loop_filter_simple(dst, linesize, mbedge_lim);
1463     if (inner_filter) {
1464         s->vp8dsp.vp8_h_loop_filter_simple(dst+ 4, linesize, bedge_lim);
1465         s->vp8dsp.vp8_h_loop_filter_simple(dst+ 8, linesize, bedge_lim);
1466         s->vp8dsp.vp8_h_loop_filter_simple(dst+12, linesize, bedge_lim);
1467     }
1468
1469     if (mb_y)
1470         s->vp8dsp.vp8_v_loop_filter_simple(dst, linesize, mbedge_lim);
1471     if (inner_filter) {
1472         s->vp8dsp.vp8_v_loop_filter_simple(dst+ 4*linesize, linesize, bedge_lim);
1473         s->vp8dsp.vp8_v_loop_filter_simple(dst+ 8*linesize, linesize, bedge_lim);
1474         s->vp8dsp.vp8_v_loop_filter_simple(dst+12*linesize, linesize, bedge_lim);
1475     }
1476 }
1477
1478 static void filter_mb_row(VP8Context *s, AVFrame *curframe, int mb_y)
1479 {
1480     VP8FilterStrength *f = s->filter_strength;
1481     uint8_t *dst[3] = {
1482         curframe->data[0] + 16*mb_y*s->linesize,
1483         curframe->data[1] +  8*mb_y*s->uvlinesize,
1484         curframe->data[2] +  8*mb_y*s->uvlinesize
1485     };
1486     int mb_x;
1487
1488     for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1489         backup_mb_border(s->top_border[mb_x+1], dst[0], dst[1], dst[2], s->linesize, s->uvlinesize, 0);
1490         filter_mb(s, dst, f++, mb_x, mb_y);
1491         dst[0] += 16;
1492         dst[1] += 8;
1493         dst[2] += 8;
1494     }
1495 }
1496
1497 static void filter_mb_row_simple(VP8Context *s, AVFrame *curframe, int mb_y)
1498 {
1499     VP8FilterStrength *f = s->filter_strength;
1500     uint8_t *dst = curframe->data[0] + 16*mb_y*s->linesize;
1501     int mb_x;
1502
1503     for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1504         backup_mb_border(s->top_border[mb_x+1], dst, NULL, NULL, s->linesize, 0, 1);
1505         filter_mb_simple(s, dst, f++, mb_x, mb_y);
1506         dst += 16;
1507     }
1508 }
1509
1510 static int vp8_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
1511                             AVPacket *avpkt)
1512 {
1513     VP8Context *s = avctx->priv_data;
1514     int ret, mb_x, mb_y, i, y, referenced;
1515     enum AVDiscard skip_thresh;
1516     AVFrame *av_uninit(curframe), *prev_frame = s->framep[VP56_FRAME_CURRENT];
1517
1518     if ((ret = decode_frame_header(s, avpkt->data, avpkt->size)) < 0)
1519         return ret;
1520
1521     referenced = s->update_last || s->update_golden == VP56_FRAME_CURRENT
1522                                 || s->update_altref == VP56_FRAME_CURRENT;
1523
1524     skip_thresh = !referenced ? AVDISCARD_NONREF :
1525                     !s->keyframe ? AVDISCARD_NONKEY : AVDISCARD_ALL;
1526
1527     if (avctx->skip_frame >= skip_thresh) {
1528         s->invisible = 1;
1529         goto skip_decode;
1530     }
1531     s->deblock_filter = s->filter.level && avctx->skip_loop_filter < skip_thresh;
1532
1533     // release no longer referenced frames
1534     for (i = 0; i < 5; i++)
1535         if (s->frames[i].data[0] &&
1536             &s->frames[i] != prev_frame &&
1537             &s->frames[i] != s->framep[VP56_FRAME_PREVIOUS] &&
1538             &s->frames[i] != s->framep[VP56_FRAME_GOLDEN] &&
1539             &s->frames[i] != s->framep[VP56_FRAME_GOLDEN2])
1540             ff_thread_release_buffer(avctx, &s->frames[i]);
1541
1542     // find a free buffer
1543     for (i = 0; i < 5; i++)
1544         if (&s->frames[i] != prev_frame &&
1545             &s->frames[i] != s->framep[VP56_FRAME_PREVIOUS] &&
1546             &s->frames[i] != s->framep[VP56_FRAME_GOLDEN] &&
1547             &s->frames[i] != s->framep[VP56_FRAME_GOLDEN2]) {
1548             curframe = s->framep[VP56_FRAME_CURRENT] = &s->frames[i];
1549             break;
1550         }
1551     if (i == 5) {
1552         av_log(avctx, AV_LOG_FATAL, "Ran out of free frames!\n");
1553         abort();
1554     }
1555     if (curframe->data[0])
1556         ff_thread_release_buffer(avctx, curframe);
1557
1558     curframe->key_frame = s->keyframe;
1559     curframe->pict_type = s->keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
1560     curframe->reference = referenced ? 3 : 0;
1561     curframe->ref_index[0] = s->segmentation_map;
1562     if ((ret = ff_thread_get_buffer(avctx, curframe))) {
1563         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed!\n");
1564         return ret;
1565     }
1566
1567     // check if golden and altref are swapped
1568     if (s->update_altref != VP56_FRAME_NONE) {
1569         s->next_framep[VP56_FRAME_GOLDEN2]  = s->framep[s->update_altref];
1570     } else {
1571         s->next_framep[VP56_FRAME_GOLDEN2]  = s->framep[VP56_FRAME_GOLDEN2];
1572     }
1573     if (s->update_golden != VP56_FRAME_NONE) {
1574         s->next_framep[VP56_FRAME_GOLDEN]   = s->framep[s->update_golden];
1575     } else {
1576         s->next_framep[VP56_FRAME_GOLDEN]   = s->framep[VP56_FRAME_GOLDEN];
1577     }
1578     if (s->update_last) {
1579         s->next_framep[VP56_FRAME_PREVIOUS] = curframe;
1580     } else {
1581         s->next_framep[VP56_FRAME_PREVIOUS] = s->framep[VP56_FRAME_PREVIOUS];
1582     }
1583     s->next_framep[VP56_FRAME_CURRENT]      = curframe;
1584
1585     ff_thread_finish_setup(avctx);
1586
1587     // Given that arithmetic probabilities are updated every frame, it's quite likely
1588     // that the values we have on a random interframe are complete junk if we didn't
1589     // start decode on a keyframe. So just don't display anything rather than junk.
1590     if (!s->keyframe && (!s->framep[VP56_FRAME_PREVIOUS] ||
1591                          !s->framep[VP56_FRAME_GOLDEN] ||
1592                          !s->framep[VP56_FRAME_GOLDEN2])) {
1593         av_log(avctx, AV_LOG_WARNING, "Discarding interframe without a prior keyframe!\n");
1594         return AVERROR_INVALIDDATA;
1595     }
1596
1597     s->linesize   = curframe->linesize[0];
1598     s->uvlinesize = curframe->linesize[1];
1599
1600     if (!s->edge_emu_buffer)
1601         s->edge_emu_buffer = av_malloc(21*s->linesize);
1602
1603     memset(s->top_nnz, 0, s->mb_width*sizeof(*s->top_nnz));
1604
1605     /* Zero macroblock structures for top/top-left prediction from outside the frame. */
1606     memset(s->macroblocks + s->mb_height*2 - 1, 0, (s->mb_width+1)*sizeof(*s->macroblocks));
1607
1608     // top edge of 127 for intra prediction
1609     if (!(avctx->flags & CODEC_FLAG_EMU_EDGE)) {
1610         s->top_border[0][15] = s->top_border[0][23] = 127;
1611         memset(s->top_border[1]-1, 127, s->mb_width*sizeof(*s->top_border)+1);
1612     }
1613     memset(s->ref_count, 0, sizeof(s->ref_count));
1614     if (s->keyframe)
1615         memset(s->intra4x4_pred_mode_top, DC_PRED, s->mb_width*4);
1616
1617 #define MARGIN (16 << 2)
1618     s->mv_min.y = -MARGIN;
1619     s->mv_max.y = ((s->mb_height - 1) << 6) + MARGIN;
1620
1621     for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1622         VP56RangeCoder *c = &s->coeff_partition[mb_y & (s->num_coeff_partitions-1)];
1623         VP8Macroblock *mb = s->macroblocks + (s->mb_height - mb_y - 1)*2;
1624         int mb_xy = mb_y*s->mb_width;
1625         uint8_t *dst[3] = {
1626             curframe->data[0] + 16*mb_y*s->linesize,
1627             curframe->data[1] +  8*mb_y*s->uvlinesize,
1628             curframe->data[2] +  8*mb_y*s->uvlinesize
1629         };
1630
1631         memset(mb - 1, 0, sizeof(*mb));   // zero left macroblock
1632         memset(s->left_nnz, 0, sizeof(s->left_nnz));
1633         AV_WN32A(s->intra4x4_pred_mode_left, DC_PRED*0x01010101);
1634
1635         // left edge of 129 for intra prediction
1636         if (!(avctx->flags & CODEC_FLAG_EMU_EDGE)) {
1637             for (i = 0; i < 3; i++)
1638                 for (y = 0; y < 16>>!!i; y++)
1639                     dst[i][y*curframe->linesize[i]-1] = 129;
1640             if (mb_y == 1) // top left edge is also 129
1641                 s->top_border[0][15] = s->top_border[0][23] = s->top_border[0][31] = 129;
1642         }
1643
1644         s->mv_min.x = -MARGIN;
1645         s->mv_max.x = ((s->mb_width  - 1) << 6) + MARGIN;
1646         if (prev_frame && s->segmentation.enabled && !s->segmentation.update_map)
1647             ff_thread_await_progress(prev_frame, mb_y, 0);
1648
1649         for (mb_x = 0; mb_x < s->mb_width; mb_x++, mb_xy++, mb++) {
1650             /* Prefetch the current frame, 4 MBs ahead */
1651             s->dsp.prefetch(dst[0] + (mb_x&3)*4*s->linesize + 64, s->linesize, 4);
1652             s->dsp.prefetch(dst[1] + (mb_x&7)*s->uvlinesize + 64, dst[2] - dst[1], 2);
1653
1654             decode_mb_mode(s, mb, mb_x, mb_y, s->segmentation_map + mb_xy,
1655                            prev_frame ? prev_frame->ref_index[0] + mb_xy : NULL);
1656
1657             prefetch_motion(s, mb, mb_x, mb_y, mb_xy, VP56_FRAME_PREVIOUS);
1658
1659             if (!mb->skip)
1660                 decode_mb_coeffs(s, c, mb, s->top_nnz[mb_x], s->left_nnz);
1661
1662             if (mb->mode <= MODE_I4x4)
1663                 intra_predict(s, dst, mb, mb_x, mb_y);
1664             else
1665                 inter_predict(s, dst, mb, mb_x, mb_y);
1666
1667             prefetch_motion(s, mb, mb_x, mb_y, mb_xy, VP56_FRAME_GOLDEN);
1668
1669             if (!mb->skip) {
1670                 idct_mb(s, dst, mb);
1671             } else {
1672                 AV_ZERO64(s->left_nnz);
1673                 AV_WN64(s->top_nnz[mb_x], 0);   // array of 9, so unaligned
1674
1675                 // Reset DC block predictors if they would exist if the mb had coefficients
1676                 if (mb->mode != MODE_I4x4 && mb->mode != VP8_MVMODE_SPLIT) {
1677                     s->left_nnz[8]      = 0;
1678                     s->top_nnz[mb_x][8] = 0;
1679                 }
1680             }
1681
1682             if (s->deblock_filter)
1683                 filter_level_for_mb(s, mb, &s->filter_strength[mb_x]);
1684
1685             prefetch_motion(s, mb, mb_x, mb_y, mb_xy, VP56_FRAME_GOLDEN2);
1686
1687             dst[0] += 16;
1688             dst[1] += 8;
1689             dst[2] += 8;
1690             s->mv_min.x -= 64;
1691             s->mv_max.x -= 64;
1692         }
1693         if (s->deblock_filter) {
1694             if (s->filter.simple)
1695                 filter_mb_row_simple(s, curframe, mb_y);
1696             else
1697                 filter_mb_row(s, curframe, mb_y);
1698         }
1699         s->mv_min.y -= 64;
1700         s->mv_max.y -= 64;
1701
1702         ff_thread_report_progress(curframe, mb_y, 0);
1703     }
1704
1705     ff_thread_report_progress(curframe, INT_MAX, 0);
1706 skip_decode:
1707     // if future frames don't use the updated probabilities,
1708     // reset them to the values we saved
1709     if (!s->update_probabilities)
1710         s->prob[0] = s->prob[1];
1711
1712     memcpy(&s->framep[0], &s->next_framep[0], sizeof(s->framep[0]) * 4);
1713
1714     if (!s->invisible) {
1715         *(AVFrame*)data = *curframe;
1716         *data_size = sizeof(AVFrame);
1717     }
1718
1719     return avpkt->size;
1720 }
1721
1722 static av_cold int vp8_decode_init(AVCodecContext *avctx)
1723 {
1724     VP8Context *s = avctx->priv_data;
1725
1726     s->avctx = avctx;
1727     avctx->pix_fmt = PIX_FMT_YUV420P;
1728
1729     dsputil_init(&s->dsp, avctx);
1730     ff_h264_pred_init(&s->hpc, CODEC_ID_VP8, 8);
1731     ff_vp8dsp_init(&s->vp8dsp);
1732
1733     return 0;
1734 }
1735
1736 static av_cold int vp8_decode_free(AVCodecContext *avctx)
1737 {
1738     vp8_decode_flush(avctx);
1739     return 0;
1740 }
1741
1742 static av_cold int vp8_decode_init_thread_copy(AVCodecContext *avctx)
1743 {
1744     VP8Context *s = avctx->priv_data;
1745
1746     s->avctx = avctx;
1747
1748     return 0;
1749 }
1750
1751 #define REBASE(pic) \
1752     pic ? pic - &s_src->frames[0] + &s->frames[0] : NULL
1753
1754 static int vp8_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
1755 {
1756     VP8Context *s = dst->priv_data, *s_src = src->priv_data;
1757
1758     if (s->macroblocks_base &&
1759         (s_src->mb_width != s->mb_width || s_src->mb_height != s->mb_height)) {
1760         free_buffers(s);
1761     }
1762
1763     s->prob[0] = s_src->prob[!s_src->update_probabilities];
1764     s->segmentation = s_src->segmentation;
1765     s->lf_delta = s_src->lf_delta;
1766     memcpy(s->sign_bias, s_src->sign_bias, sizeof(s->sign_bias));
1767
1768     memcpy(&s->frames, &s_src->frames, sizeof(s->frames));
1769     s->framep[0] = REBASE(s_src->next_framep[0]);
1770     s->framep[1] = REBASE(s_src->next_framep[1]);
1771     s->framep[2] = REBASE(s_src->next_framep[2]);
1772     s->framep[3] = REBASE(s_src->next_framep[3]);
1773
1774     return 0;
1775 }
1776
1777 AVCodec ff_vp8_decoder = {
1778     .name           = "vp8",
1779     .type           = AVMEDIA_TYPE_VIDEO,
1780     .id             = CODEC_ID_VP8,
1781     .priv_data_size = sizeof(VP8Context),
1782     .init           = vp8_decode_init,
1783     .close          = vp8_decode_free,
1784     .decode         = vp8_decode_frame,
1785     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
1786     .flush = vp8_decode_flush,
1787     .long_name = NULL_IF_CONFIG_SMALL("On2 VP8"),
1788     .init_thread_copy      = ONLY_IF_THREADS_ENABLED(vp8_decode_init_thread_copy),
1789     .update_thread_context = ONLY_IF_THREADS_ENABLED(vp8_decode_update_thread_context),
1790 };