avcodec/vp8: Check for the bitstream end per MB in decode_mb_row_no_filter()
[ffmpeg.git] / libavcodec / vp8.c
1 /*
2  * VP7/VP8 compatible video decoder
3  *
4  * Copyright (C) 2010 David Conrad
5  * Copyright (C) 2010 Ronald S. Bultje
6  * Copyright (C) 2010 Fiona Glaser
7  * Copyright (C) 2012 Daniel Kang
8  * Copyright (C) 2014 Peter Ross
9  *
10  * This file is part of FFmpeg.
11  *
12  * FFmpeg is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU Lesser General Public
14  * License as published by the Free Software Foundation; either
15  * version 2.1 of the License, or (at your option) any later version.
16  *
17  * FFmpeg is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20  * Lesser General Public License for more details.
21  *
22  * You should have received a copy of the GNU Lesser General Public
23  * License along with FFmpeg; if not, write to the Free Software
24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25  */
26
27 #include "libavutil/imgutils.h"
28
29 #include "avcodec.h"
30 #include "internal.h"
31 #include "mathops.h"
32 #include "rectangle.h"
33 #include "thread.h"
34 #include "vp8.h"
35 #include "vp8data.h"
36
37 #if ARCH_ARM
38 #   include "arm/vp8.h"
39 #endif
40
41 #if CONFIG_VP7_DECODER && CONFIG_VP8_DECODER
42 #define VPX(vp7, f) (vp7 ? vp7_ ## f : vp8_ ## f)
43 #elif CONFIG_VP7_DECODER
44 #define VPX(vp7, f) vp7_ ## f
45 #else // CONFIG_VP8_DECODER
46 #define VPX(vp7, f) vp8_ ## f
47 #endif
48
49 static void free_buffers(VP8Context *s)
50 {
51     int i;
52     if (s->thread_data)
53         for (i = 0; i < MAX_THREADS; i++) {
54 #if HAVE_THREADS
55             pthread_cond_destroy(&s->thread_data[i].cond);
56             pthread_mutex_destroy(&s->thread_data[i].lock);
57 #endif
58             av_freep(&s->thread_data[i].filter_strength);
59         }
60     av_freep(&s->thread_data);
61     av_freep(&s->macroblocks_base);
62     av_freep(&s->intra4x4_pred_mode_top);
63     av_freep(&s->top_nnz);
64     av_freep(&s->top_border);
65
66     s->macroblocks = NULL;
67 }
68
69 static int vp8_alloc_frame(VP8Context *s, VP8Frame *f, int ref)
70 {
71     int ret;
72     if ((ret = ff_thread_get_buffer(s->avctx, &f->tf,
73                                     ref ? AV_GET_BUFFER_FLAG_REF : 0)) < 0)
74         return ret;
75     if (!(f->seg_map = av_buffer_allocz(s->mb_width * s->mb_height))) {
76         ff_thread_release_buffer(s->avctx, &f->tf);
77         return AVERROR(ENOMEM);
78     }
79     return 0;
80 }
81
82 static void vp8_release_frame(VP8Context *s, VP8Frame *f)
83 {
84     av_buffer_unref(&f->seg_map);
85     ff_thread_release_buffer(s->avctx, &f->tf);
86 }
87
88 #if CONFIG_VP8_DECODER
89 static int vp8_ref_frame(VP8Context *s, VP8Frame *dst, VP8Frame *src)
90 {
91     int ret;
92
93     vp8_release_frame(s, dst);
94
95     if ((ret = ff_thread_ref_frame(&dst->tf, &src->tf)) < 0)
96         return ret;
97     if (src->seg_map &&
98         !(dst->seg_map = av_buffer_ref(src->seg_map))) {
99         vp8_release_frame(s, dst);
100         return AVERROR(ENOMEM);
101     }
102
103     return 0;
104 }
105 #endif /* CONFIG_VP8_DECODER */
106
107 static void vp8_decode_flush_impl(AVCodecContext *avctx, int free_mem)
108 {
109     VP8Context *s = avctx->priv_data;
110     int i;
111
112     for (i = 0; i < FF_ARRAY_ELEMS(s->frames); i++)
113         vp8_release_frame(s, &s->frames[i]);
114     memset(s->framep, 0, sizeof(s->framep));
115
116     if (free_mem)
117         free_buffers(s);
118 }
119
120 static void vp8_decode_flush(AVCodecContext *avctx)
121 {
122     vp8_decode_flush_impl(avctx, 0);
123 }
124
125 static VP8Frame *vp8_find_free_buffer(VP8Context *s)
126 {
127     VP8Frame *frame = NULL;
128     int i;
129
130     // find a free buffer
131     for (i = 0; i < 5; i++)
132         if (&s->frames[i] != s->framep[VP56_FRAME_CURRENT]  &&
133             &s->frames[i] != s->framep[VP56_FRAME_PREVIOUS] &&
134             &s->frames[i] != s->framep[VP56_FRAME_GOLDEN]   &&
135             &s->frames[i] != s->framep[VP56_FRAME_GOLDEN2]) {
136             frame = &s->frames[i];
137             break;
138         }
139     if (i == 5) {
140         av_log(s->avctx, AV_LOG_FATAL, "Ran out of free frames!\n");
141         abort();
142     }
143     if (frame->tf.f->data[0])
144         vp8_release_frame(s, frame);
145
146     return frame;
147 }
148
149 static av_always_inline
150 int update_dimensions(VP8Context *s, int width, int height, int is_vp7)
151 {
152     AVCodecContext *avctx = s->avctx;
153     int i, ret;
154
155     if (width  != s->avctx->width || ((width+15)/16 != s->mb_width || (height+15)/16 != s->mb_height) && s->macroblocks_base ||
156         height != s->avctx->height) {
157         vp8_decode_flush_impl(s->avctx, 1);
158
159         ret = ff_set_dimensions(s->avctx, width, height);
160         if (ret < 0)
161             return ret;
162     }
163
164     s->mb_width  = (s->avctx->coded_width  + 15) / 16;
165     s->mb_height = (s->avctx->coded_height + 15) / 16;
166
167     s->mb_layout = is_vp7 || avctx->active_thread_type == FF_THREAD_SLICE &&
168                    avctx->thread_count > 1;
169     if (!s->mb_layout) { // Frame threading and one thread
170         s->macroblocks_base       = av_mallocz((s->mb_width + s->mb_height * 2 + 1) *
171                                                sizeof(*s->macroblocks));
172         s->intra4x4_pred_mode_top = av_mallocz(s->mb_width * 4);
173     } else // Sliced threading
174         s->macroblocks_base = av_mallocz((s->mb_width + 2) * (s->mb_height + 2) *
175                                          sizeof(*s->macroblocks));
176     s->top_nnz     = av_mallocz(s->mb_width * sizeof(*s->top_nnz));
177     s->top_border  = av_mallocz((s->mb_width + 1) * sizeof(*s->top_border));
178     s->thread_data = av_mallocz(MAX_THREADS * sizeof(VP8ThreadData));
179
180     if (!s->macroblocks_base || !s->top_nnz || !s->top_border ||
181         !s->thread_data || (!s->intra4x4_pred_mode_top && !s->mb_layout)) {
182         free_buffers(s);
183         return AVERROR(ENOMEM);
184     }
185
186     for (i = 0; i < MAX_THREADS; i++) {
187         s->thread_data[i].filter_strength =
188             av_mallocz(s->mb_width * sizeof(*s->thread_data[0].filter_strength));
189         if (!s->thread_data[i].filter_strength) {
190             free_buffers(s);
191             return AVERROR(ENOMEM);
192         }
193 #if HAVE_THREADS
194         pthread_mutex_init(&s->thread_data[i].lock, NULL);
195         pthread_cond_init(&s->thread_data[i].cond, NULL);
196 #endif
197     }
198
199     s->macroblocks = s->macroblocks_base + 1;
200
201     return 0;
202 }
203
204 static int vp7_update_dimensions(VP8Context *s, int width, int height)
205 {
206     return update_dimensions(s, width, height, IS_VP7);
207 }
208
209 static int vp8_update_dimensions(VP8Context *s, int width, int height)
210 {
211     return update_dimensions(s, width, height, IS_VP8);
212 }
213
214
215 static void parse_segment_info(VP8Context *s)
216 {
217     VP56RangeCoder *c = &s->c;
218     int i;
219
220     s->segmentation.update_map = vp8_rac_get(c);
221
222     if (vp8_rac_get(c)) { // update segment feature data
223         s->segmentation.absolute_vals = vp8_rac_get(c);
224
225         for (i = 0; i < 4; i++)
226             s->segmentation.base_quant[i]   = vp8_rac_get_sint(c, 7);
227
228         for (i = 0; i < 4; i++)
229             s->segmentation.filter_level[i] = vp8_rac_get_sint(c, 6);
230     }
231     if (s->segmentation.update_map)
232         for (i = 0; i < 3; i++)
233             s->prob->segmentid[i] = vp8_rac_get(c) ? vp8_rac_get_uint(c, 8) : 255;
234 }
235
236 static void update_lf_deltas(VP8Context *s)
237 {
238     VP56RangeCoder *c = &s->c;
239     int i;
240
241     for (i = 0; i < 4; i++) {
242         if (vp8_rac_get(c)) {
243             s->lf_delta.ref[i] = vp8_rac_get_uint(c, 6);
244
245             if (vp8_rac_get(c))
246                 s->lf_delta.ref[i] = -s->lf_delta.ref[i];
247         }
248     }
249
250     for (i = MODE_I4x4; i <= VP8_MVMODE_SPLIT; i++) {
251         if (vp8_rac_get(c)) {
252             s->lf_delta.mode[i] = vp8_rac_get_uint(c, 6);
253
254             if (vp8_rac_get(c))
255                 s->lf_delta.mode[i] = -s->lf_delta.mode[i];
256         }
257     }
258 }
259
260 static int setup_partitions(VP8Context *s, const uint8_t *buf, int buf_size)
261 {
262     const uint8_t *sizes = buf;
263     int i;
264     int ret;
265
266     s->num_coeff_partitions = 1 << vp8_rac_get_uint(&s->c, 2);
267
268     buf      += 3 * (s->num_coeff_partitions - 1);
269     buf_size -= 3 * (s->num_coeff_partitions - 1);
270     if (buf_size < 0)
271         return -1;
272
273     for (i = 0; i < s->num_coeff_partitions - 1; i++) {
274         int size = AV_RL24(sizes + 3 * i);
275         if (buf_size - size < 0)
276             return -1;
277
278         ret = ff_vp56_init_range_decoder(&s->coeff_partition[i], buf, size);
279         if (ret < 0)
280             return ret;
281         buf      += size;
282         buf_size -= size;
283     }
284     return ff_vp56_init_range_decoder(&s->coeff_partition[i], buf, buf_size);
285 }
286
287 static void vp7_get_quants(VP8Context *s)
288 {
289     VP56RangeCoder *c = &s->c;
290
291     int yac_qi  = vp8_rac_get_uint(c, 7);
292     int ydc_qi  = vp8_rac_get(c) ? vp8_rac_get_uint(c, 7) : yac_qi;
293     int y2dc_qi = vp8_rac_get(c) ? vp8_rac_get_uint(c, 7) : yac_qi;
294     int y2ac_qi = vp8_rac_get(c) ? vp8_rac_get_uint(c, 7) : yac_qi;
295     int uvdc_qi = vp8_rac_get(c) ? vp8_rac_get_uint(c, 7) : yac_qi;
296     int uvac_qi = vp8_rac_get(c) ? vp8_rac_get_uint(c, 7) : yac_qi;
297
298     s->qmat[0].luma_qmul[0]    =       vp7_ydc_qlookup[ydc_qi];
299     s->qmat[0].luma_qmul[1]    =       vp7_yac_qlookup[yac_qi];
300     s->qmat[0].luma_dc_qmul[0] =       vp7_y2dc_qlookup[y2dc_qi];
301     s->qmat[0].luma_dc_qmul[1] =       vp7_y2ac_qlookup[y2ac_qi];
302     s->qmat[0].chroma_qmul[0]  = FFMIN(vp7_ydc_qlookup[uvdc_qi], 132);
303     s->qmat[0].chroma_qmul[1]  =       vp7_yac_qlookup[uvac_qi];
304 }
305
306 static void vp8_get_quants(VP8Context *s)
307 {
308     VP56RangeCoder *c = &s->c;
309     int i, base_qi;
310
311     int yac_qi     = vp8_rac_get_uint(c, 7);
312     int ydc_delta  = vp8_rac_get_sint(c, 4);
313     int y2dc_delta = vp8_rac_get_sint(c, 4);
314     int y2ac_delta = vp8_rac_get_sint(c, 4);
315     int uvdc_delta = vp8_rac_get_sint(c, 4);
316     int uvac_delta = vp8_rac_get_sint(c, 4);
317
318     for (i = 0; i < 4; i++) {
319         if (s->segmentation.enabled) {
320             base_qi = s->segmentation.base_quant[i];
321             if (!s->segmentation.absolute_vals)
322                 base_qi += yac_qi;
323         } else
324             base_qi = yac_qi;
325
326         s->qmat[i].luma_qmul[0]    = vp8_dc_qlookup[av_clip_uintp2(base_qi + ydc_delta,  7)];
327         s->qmat[i].luma_qmul[1]    = vp8_ac_qlookup[av_clip_uintp2(base_qi,              7)];
328         s->qmat[i].luma_dc_qmul[0] = vp8_dc_qlookup[av_clip_uintp2(base_qi + y2dc_delta, 7)] * 2;
329         /* 101581>>16 is equivalent to 155/100 */
330         s->qmat[i].luma_dc_qmul[1] = vp8_ac_qlookup[av_clip_uintp2(base_qi + y2ac_delta, 7)] * 101581 >> 16;
331         s->qmat[i].chroma_qmul[0]  = vp8_dc_qlookup[av_clip_uintp2(base_qi + uvdc_delta, 7)];
332         s->qmat[i].chroma_qmul[1]  = vp8_ac_qlookup[av_clip_uintp2(base_qi + uvac_delta, 7)];
333
334         s->qmat[i].luma_dc_qmul[1] = FFMAX(s->qmat[i].luma_dc_qmul[1], 8);
335         s->qmat[i].chroma_qmul[0]  = FFMIN(s->qmat[i].chroma_qmul[0], 132);
336     }
337 }
338
339 /**
340  * Determine which buffers golden and altref should be updated with after this frame.
341  * The spec isn't clear here, so I'm going by my understanding of what libvpx does
342  *
343  * Intra frames update all 3 references
344  * Inter frames update VP56_FRAME_PREVIOUS if the update_last flag is set
345  * If the update (golden|altref) flag is set, it's updated with the current frame
346  *      if update_last is set, and VP56_FRAME_PREVIOUS otherwise.
347  * If the flag is not set, the number read means:
348  *      0: no update
349  *      1: VP56_FRAME_PREVIOUS
350  *      2: update golden with altref, or update altref with golden
351  */
352 static VP56Frame ref_to_update(VP8Context *s, int update, VP56Frame ref)
353 {
354     VP56RangeCoder *c = &s->c;
355
356     if (update)
357         return VP56_FRAME_CURRENT;
358
359     switch (vp8_rac_get_uint(c, 2)) {
360     case 1:
361         return VP56_FRAME_PREVIOUS;
362     case 2:
363         return (ref == VP56_FRAME_GOLDEN) ? VP56_FRAME_GOLDEN2 : VP56_FRAME_GOLDEN;
364     }
365     return VP56_FRAME_NONE;
366 }
367
368 static void vp78_reset_probability_tables(VP8Context *s)
369 {
370     int i, j;
371     for (i = 0; i < 4; i++)
372         for (j = 0; j < 16; j++)
373             memcpy(s->prob->token[i][j], vp8_token_default_probs[i][vp8_coeff_band[j]],
374                    sizeof(s->prob->token[i][j]));
375 }
376
377 static void vp78_update_probability_tables(VP8Context *s)
378 {
379     VP56RangeCoder *c = &s->c;
380     int i, j, k, l, m;
381
382     for (i = 0; i < 4; i++)
383         for (j = 0; j < 8; j++)
384             for (k = 0; k < 3; k++)
385                 for (l = 0; l < NUM_DCT_TOKENS-1; l++)
386                     if (vp56_rac_get_prob_branchy(c, vp8_token_update_probs[i][j][k][l])) {
387                         int prob = vp8_rac_get_uint(c, 8);
388                         for (m = 0; vp8_coeff_band_indexes[j][m] >= 0; m++)
389                             s->prob->token[i][vp8_coeff_band_indexes[j][m]][k][l] = prob;
390                     }
391 }
392
393 #define VP7_MVC_SIZE 17
394 #define VP8_MVC_SIZE 19
395
396 static void vp78_update_pred16x16_pred8x8_mvc_probabilities(VP8Context *s,
397                                                             int mvc_size)
398 {
399     VP56RangeCoder *c = &s->c;
400     int i, j;
401
402     if (vp8_rac_get(c))
403         for (i = 0; i < 4; i++)
404             s->prob->pred16x16[i] = vp8_rac_get_uint(c, 8);
405     if (vp8_rac_get(c))
406         for (i = 0; i < 3; i++)
407             s->prob->pred8x8c[i]  = vp8_rac_get_uint(c, 8);
408
409     // 17.2 MV probability update
410     for (i = 0; i < 2; i++)
411         for (j = 0; j < mvc_size; j++)
412             if (vp56_rac_get_prob_branchy(c, vp8_mv_update_prob[i][j]))
413                 s->prob->mvc[i][j] = vp8_rac_get_nn(c);
414 }
415
416 static void update_refs(VP8Context *s)
417 {
418     VP56RangeCoder *c = &s->c;
419
420     int update_golden = vp8_rac_get(c);
421     int update_altref = vp8_rac_get(c);
422
423     s->update_golden = ref_to_update(s, update_golden, VP56_FRAME_GOLDEN);
424     s->update_altref = ref_to_update(s, update_altref, VP56_FRAME_GOLDEN2);
425 }
426
427 static void copy_chroma(AVFrame *dst, AVFrame *src, int width, int height)
428 {
429     int i, j;
430
431     for (j = 1; j < 3; j++) {
432         for (i = 0; i < height / 2; i++)
433             memcpy(dst->data[j] + i * dst->linesize[j],
434                    src->data[j] + i * src->linesize[j], width / 2);
435     }
436 }
437
438 static void fade(uint8_t *dst, int dst_linesize,
439                  const uint8_t *src, int src_linesize,
440                  int width, int height,
441                  int alpha, int beta)
442 {
443     int i, j;
444     for (j = 0; j < height; j++) {
445         for (i = 0; i < width; i++) {
446             uint8_t y = src[j * src_linesize + i];
447             dst[j * dst_linesize + i] = av_clip_uint8(y + ((y * beta) >> 8) + alpha);
448         }
449     }
450 }
451
452 static int vp7_fade_frame(VP8Context *s, VP56RangeCoder *c)
453 {
454     int alpha = (int8_t) vp8_rac_get_uint(c, 8);
455     int beta  = (int8_t) vp8_rac_get_uint(c, 8);
456     int ret;
457
458     if (!s->keyframe && (alpha || beta)) {
459         int width  = s->mb_width * 16;
460         int height = s->mb_height * 16;
461         AVFrame *src, *dst;
462
463         if (!s->framep[VP56_FRAME_PREVIOUS] ||
464             !s->framep[VP56_FRAME_GOLDEN]) {
465             av_log(s->avctx, AV_LOG_WARNING, "Discarding interframe without a prior keyframe!\n");
466             return AVERROR_INVALIDDATA;
467         }
468
469         dst =
470         src = s->framep[VP56_FRAME_PREVIOUS]->tf.f;
471
472         /* preserve the golden frame, write a new previous frame */
473         if (s->framep[VP56_FRAME_GOLDEN] == s->framep[VP56_FRAME_PREVIOUS]) {
474             s->framep[VP56_FRAME_PREVIOUS] = vp8_find_free_buffer(s);
475             if ((ret = vp8_alloc_frame(s, s->framep[VP56_FRAME_PREVIOUS], 1)) < 0)
476                 return ret;
477
478             dst = s->framep[VP56_FRAME_PREVIOUS]->tf.f;
479
480             copy_chroma(dst, src, width, height);
481         }
482
483         fade(dst->data[0], dst->linesize[0],
484              src->data[0], src->linesize[0],
485              width, height, alpha, beta);
486     }
487
488     return 0;
489 }
490
491 static int vp7_decode_frame_header(VP8Context *s, const uint8_t *buf, int buf_size)
492 {
493     VP56RangeCoder *c = &s->c;
494     int part1_size, hscale, vscale, i, j, ret;
495     int width  = s->avctx->width;
496     int height = s->avctx->height;
497
498     if (buf_size < 4) {
499         return AVERROR_INVALIDDATA;
500     }
501
502     s->profile = (buf[0] >> 1) & 7;
503     if (s->profile > 1) {
504         avpriv_request_sample(s->avctx, "Unknown profile %d", s->profile);
505         return AVERROR_INVALIDDATA;
506     }
507
508     s->keyframe  = !(buf[0] & 1);
509     s->invisible = 0;
510     part1_size   = AV_RL24(buf) >> 4;
511
512     if (buf_size < 4 - s->profile + part1_size) {
513         av_log(s->avctx, AV_LOG_ERROR, "Buffer size %d is too small, needed : %d\n", buf_size, 4 - s->profile + part1_size);
514         return AVERROR_INVALIDDATA;
515     }
516
517     buf      += 4 - s->profile;
518     buf_size -= 4 - s->profile;
519
520     memcpy(s->put_pixels_tab, s->vp8dsp.put_vp8_epel_pixels_tab, sizeof(s->put_pixels_tab));
521
522     ret = ff_vp56_init_range_decoder(c, buf, part1_size);
523     if (ret < 0)
524         return ret;
525     buf      += part1_size;
526     buf_size -= part1_size;
527
528     /* A. Dimension information (keyframes only) */
529     if (s->keyframe) {
530         width  = vp8_rac_get_uint(c, 12);
531         height = vp8_rac_get_uint(c, 12);
532         hscale = vp8_rac_get_uint(c, 2);
533         vscale = vp8_rac_get_uint(c, 2);
534         if (hscale || vscale)
535             avpriv_request_sample(s->avctx, "Upscaling");
536
537         s->update_golden = s->update_altref = VP56_FRAME_CURRENT;
538         vp78_reset_probability_tables(s);
539         memcpy(s->prob->pred16x16, vp8_pred16x16_prob_inter,
540                sizeof(s->prob->pred16x16));
541         memcpy(s->prob->pred8x8c, vp8_pred8x8c_prob_inter,
542                sizeof(s->prob->pred8x8c));
543         for (i = 0; i < 2; i++)
544             memcpy(s->prob->mvc[i], vp7_mv_default_prob[i],
545                    sizeof(vp7_mv_default_prob[i]));
546         memset(&s->segmentation, 0, sizeof(s->segmentation));
547         memset(&s->lf_delta, 0, sizeof(s->lf_delta));
548         memcpy(s->prob[0].scan, ff_zigzag_scan, sizeof(s->prob[0].scan));
549     }
550
551     if (s->keyframe || s->profile > 0)
552         memset(s->inter_dc_pred, 0 , sizeof(s->inter_dc_pred));
553
554     /* B. Decoding information for all four macroblock-level features */
555     for (i = 0; i < 4; i++) {
556         s->feature_enabled[i] = vp8_rac_get(c);
557         if (s->feature_enabled[i]) {
558              s->feature_present_prob[i] = vp8_rac_get_uint(c, 8);
559
560              for (j = 0; j < 3; j++)
561                  s->feature_index_prob[i][j] =
562                      vp8_rac_get(c) ? vp8_rac_get_uint(c, 8) : 255;
563
564              if (vp7_feature_value_size[s->profile][i])
565                  for (j = 0; j < 4; j++)
566                      s->feature_value[i][j] =
567                         vp8_rac_get(c) ? vp8_rac_get_uint(c, vp7_feature_value_size[s->profile][i]) : 0;
568         }
569     }
570
571     s->segmentation.enabled    = 0;
572     s->segmentation.update_map = 0;
573     s->lf_delta.enabled        = 0;
574
575     s->num_coeff_partitions = 1;
576     ret = ff_vp56_init_range_decoder(&s->coeff_partition[0], buf, buf_size);
577     if (ret < 0)
578         return ret;
579
580     if (!s->macroblocks_base || /* first frame */
581         width != s->avctx->width || height != s->avctx->height ||
582         (width + 15) / 16 != s->mb_width || (height + 15) / 16 != s->mb_height) {
583         if ((ret = vp7_update_dimensions(s, width, height)) < 0)
584             return ret;
585     }
586
587     /* C. Dequantization indices */
588     vp7_get_quants(s);
589
590     /* D. Golden frame update flag (a Flag) for interframes only */
591     if (!s->keyframe) {
592         s->update_golden = vp8_rac_get(c) ? VP56_FRAME_CURRENT : VP56_FRAME_NONE;
593         s->sign_bias[VP56_FRAME_GOLDEN] = 0;
594     }
595
596     s->update_last          = 1;
597     s->update_probabilities = 1;
598     s->fade_present         = 1;
599
600     if (s->profile > 0) {
601         s->update_probabilities = vp8_rac_get(c);
602         if (!s->update_probabilities)
603             s->prob[1] = s->prob[0];
604
605         if (!s->keyframe)
606             s->fade_present = vp8_rac_get(c);
607     }
608
609     /* E. Fading information for previous frame */
610     if (s->fade_present && vp8_rac_get(c)) {
611         if ((ret = vp7_fade_frame(s ,c)) < 0)
612             return ret;
613     }
614
615     /* F. Loop filter type */
616     if (!s->profile)
617         s->filter.simple = vp8_rac_get(c);
618
619     /* G. DCT coefficient ordering specification */
620     if (vp8_rac_get(c))
621         for (i = 1; i < 16; i++)
622             s->prob[0].scan[i] = ff_zigzag_scan[vp8_rac_get_uint(c, 4)];
623
624     /* H. Loop filter levels  */
625     if (s->profile > 0)
626         s->filter.simple = vp8_rac_get(c);
627     s->filter.level     = vp8_rac_get_uint(c, 6);
628     s->filter.sharpness = vp8_rac_get_uint(c, 3);
629
630     /* I. DCT coefficient probability update; 13.3 Token Probability Updates */
631     vp78_update_probability_tables(s);
632
633     s->mbskip_enabled = 0;
634
635     /* J. The remaining frame header data occurs ONLY FOR INTERFRAMES */
636     if (!s->keyframe) {
637         s->prob->intra  = vp8_rac_get_uint(c, 8);
638         s->prob->last   = vp8_rac_get_uint(c, 8);
639         vp78_update_pred16x16_pred8x8_mvc_probabilities(s, VP7_MVC_SIZE);
640     }
641
642     return 0;
643 }
644
645 static int vp8_decode_frame_header(VP8Context *s, const uint8_t *buf, int buf_size)
646 {
647     VP56RangeCoder *c = &s->c;
648     int header_size, hscale, vscale, ret;
649     int width  = s->avctx->width;
650     int height = s->avctx->height;
651
652     if (buf_size < 3) {
653         av_log(s->avctx, AV_LOG_ERROR, "Insufficent data (%d) for header\n", buf_size);
654         return AVERROR_INVALIDDATA;
655     }
656
657     s->keyframe  = !(buf[0] & 1);
658     s->profile   =  (buf[0]>>1) & 7;
659     s->invisible = !(buf[0] & 0x10);
660     header_size  = AV_RL24(buf) >> 5;
661     buf      += 3;
662     buf_size -= 3;
663
664     if (s->profile > 3)
665         av_log(s->avctx, AV_LOG_WARNING, "Unknown profile %d\n", s->profile);
666
667     if (!s->profile)
668         memcpy(s->put_pixels_tab, s->vp8dsp.put_vp8_epel_pixels_tab,
669                sizeof(s->put_pixels_tab));
670     else    // profile 1-3 use bilinear, 4+ aren't defined so whatever
671         memcpy(s->put_pixels_tab, s->vp8dsp.put_vp8_bilinear_pixels_tab,
672                sizeof(s->put_pixels_tab));
673
674     if (header_size > buf_size - 7 * s->keyframe) {
675         av_log(s->avctx, AV_LOG_ERROR, "Header size larger than data provided\n");
676         return AVERROR_INVALIDDATA;
677     }
678
679     if (s->keyframe) {
680         if (AV_RL24(buf) != 0x2a019d) {
681             av_log(s->avctx, AV_LOG_ERROR,
682                    "Invalid start code 0x%x\n", AV_RL24(buf));
683             return AVERROR_INVALIDDATA;
684         }
685         width     = AV_RL16(buf + 3) & 0x3fff;
686         height    = AV_RL16(buf + 5) & 0x3fff;
687         hscale    = buf[4] >> 6;
688         vscale    = buf[6] >> 6;
689         buf      += 7;
690         buf_size -= 7;
691
692         if (hscale || vscale)
693             avpriv_request_sample(s->avctx, "Upscaling");
694
695         s->update_golden = s->update_altref = VP56_FRAME_CURRENT;
696         vp78_reset_probability_tables(s);
697         memcpy(s->prob->pred16x16, vp8_pred16x16_prob_inter,
698                sizeof(s->prob->pred16x16));
699         memcpy(s->prob->pred8x8c, vp8_pred8x8c_prob_inter,
700                sizeof(s->prob->pred8x8c));
701         memcpy(s->prob->mvc, vp8_mv_default_prob,
702                sizeof(s->prob->mvc));
703         memset(&s->segmentation, 0, sizeof(s->segmentation));
704         memset(&s->lf_delta, 0, sizeof(s->lf_delta));
705     }
706
707     ret = ff_vp56_init_range_decoder(c, buf, header_size);
708     if (ret < 0)
709         return ret;
710     buf      += header_size;
711     buf_size -= header_size;
712
713     if (s->keyframe) {
714         s->colorspace = vp8_rac_get(c);
715         if (s->colorspace)
716             av_log(s->avctx, AV_LOG_WARNING, "Unspecified colorspace\n");
717         s->fullrange = vp8_rac_get(c);
718     }
719
720     if ((s->segmentation.enabled = vp8_rac_get(c)))
721         parse_segment_info(s);
722     else
723         s->segmentation.update_map = 0; // FIXME: move this to some init function?
724
725     s->filter.simple    = vp8_rac_get(c);
726     s->filter.level     = vp8_rac_get_uint(c, 6);
727     s->filter.sharpness = vp8_rac_get_uint(c, 3);
728
729     if ((s->lf_delta.enabled = vp8_rac_get(c)))
730         if (vp8_rac_get(c))
731             update_lf_deltas(s);
732
733     if (setup_partitions(s, buf, buf_size)) {
734         av_log(s->avctx, AV_LOG_ERROR, "Invalid partitions\n");
735         return AVERROR_INVALIDDATA;
736     }
737
738     if (!s->macroblocks_base || /* first frame */
739         width != s->avctx->width || height != s->avctx->height ||
740         (width+15)/16 != s->mb_width || (height+15)/16 != s->mb_height)
741         if ((ret = vp8_update_dimensions(s, width, height)) < 0)
742             return ret;
743
744     vp8_get_quants(s);
745
746     if (!s->keyframe) {
747         update_refs(s);
748         s->sign_bias[VP56_FRAME_GOLDEN]               = vp8_rac_get(c);
749         s->sign_bias[VP56_FRAME_GOLDEN2 /* altref */] = vp8_rac_get(c);
750     }
751
752     // if we aren't saving this frame's probabilities for future frames,
753     // make a copy of the current probabilities
754     if (!(s->update_probabilities = vp8_rac_get(c)))
755         s->prob[1] = s->prob[0];
756
757     s->update_last = s->keyframe || vp8_rac_get(c);
758
759     vp78_update_probability_tables(s);
760
761     if ((s->mbskip_enabled = vp8_rac_get(c)))
762         s->prob->mbskip = vp8_rac_get_uint(c, 8);
763
764     if (!s->keyframe) {
765         s->prob->intra  = vp8_rac_get_uint(c, 8);
766         s->prob->last   = vp8_rac_get_uint(c, 8);
767         s->prob->golden = vp8_rac_get_uint(c, 8);
768         vp78_update_pred16x16_pred8x8_mvc_probabilities(s, VP8_MVC_SIZE);
769     }
770
771     return 0;
772 }
773
774 static av_always_inline
775 void clamp_mv(VP8Context *s, VP56mv *dst, const VP56mv *src)
776 {
777     dst->x = av_clip(src->x, av_clip(s->mv_min.x, INT16_MIN, INT16_MAX),
778                              av_clip(s->mv_max.x, INT16_MIN, INT16_MAX));
779     dst->y = av_clip(src->y, av_clip(s->mv_min.y, INT16_MIN, INT16_MAX),
780                              av_clip(s->mv_max.y, INT16_MIN, INT16_MAX));
781 }
782
783 /**
784  * Motion vector coding, 17.1.
785  */
786 static av_always_inline int read_mv_component(VP56RangeCoder *c, const uint8_t *p, int vp7)
787 {
788     int bit, x = 0;
789
790     if (vp56_rac_get_prob_branchy(c, p[0])) {
791         int i;
792
793         for (i = 0; i < 3; i++)
794             x += vp56_rac_get_prob(c, p[9 + i]) << i;
795         for (i = (vp7 ? 7 : 9); i > 3; i--)
796             x += vp56_rac_get_prob(c, p[9 + i]) << i;
797         if (!(x & (vp7 ? 0xF0 : 0xFFF0)) || vp56_rac_get_prob(c, p[12]))
798             x += 8;
799     } else {
800         // small_mvtree
801         const uint8_t *ps = p + 2;
802         bit = vp56_rac_get_prob(c, *ps);
803         ps += 1 + 3 * bit;
804         x  += 4 * bit;
805         bit = vp56_rac_get_prob(c, *ps);
806         ps += 1 + bit;
807         x  += 2 * bit;
808         x  += vp56_rac_get_prob(c, *ps);
809     }
810
811     return (x && vp56_rac_get_prob(c, p[1])) ? -x : x;
812 }
813
814 static int vp7_read_mv_component(VP56RangeCoder *c, const uint8_t *p)
815 {
816     return read_mv_component(c, p, 1);
817 }
818
819 static int vp8_read_mv_component(VP56RangeCoder *c, const uint8_t *p)
820 {
821     return read_mv_component(c, p, 0);
822 }
823
824 static av_always_inline
825 const uint8_t *get_submv_prob(uint32_t left, uint32_t top, int is_vp7)
826 {
827     if (is_vp7)
828         return vp7_submv_prob;
829
830     if (left == top)
831         return vp8_submv_prob[4 - !!left];
832     if (!top)
833         return vp8_submv_prob[2];
834     return vp8_submv_prob[1 - !!left];
835 }
836
837 /**
838  * Split motion vector prediction, 16.4.
839  * @returns the number of motion vectors parsed (2, 4 or 16)
840  */
841 static av_always_inline
842 int decode_splitmvs(VP8Context *s, VP56RangeCoder *c, VP8Macroblock *mb,
843                     int layout, int is_vp7)
844 {
845     int part_idx;
846     int n, num;
847     VP8Macroblock *top_mb;
848     VP8Macroblock *left_mb = &mb[-1];
849     const uint8_t *mbsplits_left = vp8_mbsplits[left_mb->partitioning];
850     const uint8_t *mbsplits_top, *mbsplits_cur, *firstidx;
851     VP56mv *top_mv;
852     VP56mv *left_mv = left_mb->bmv;
853     VP56mv *cur_mv  = mb->bmv;
854
855     if (!layout) // layout is inlined, s->mb_layout is not
856         top_mb = &mb[2];
857     else
858         top_mb = &mb[-s->mb_width - 1];
859     mbsplits_top = vp8_mbsplits[top_mb->partitioning];
860     top_mv       = top_mb->bmv;
861
862     if (vp56_rac_get_prob_branchy(c, vp8_mbsplit_prob[0])) {
863         if (vp56_rac_get_prob_branchy(c, vp8_mbsplit_prob[1]))
864             part_idx = VP8_SPLITMVMODE_16x8 + vp56_rac_get_prob(c, vp8_mbsplit_prob[2]);
865         else
866             part_idx = VP8_SPLITMVMODE_8x8;
867     } else {
868         part_idx = VP8_SPLITMVMODE_4x4;
869     }
870
871     num              = vp8_mbsplit_count[part_idx];
872     mbsplits_cur     = vp8_mbsplits[part_idx],
873     firstidx         = vp8_mbfirstidx[part_idx];
874     mb->partitioning = part_idx;
875
876     for (n = 0; n < num; n++) {
877         int k = firstidx[n];
878         uint32_t left, above;
879         const uint8_t *submv_prob;
880
881         if (!(k & 3))
882             left = AV_RN32A(&left_mv[mbsplits_left[k + 3]]);
883         else
884             left = AV_RN32A(&cur_mv[mbsplits_cur[k - 1]]);
885         if (k <= 3)
886             above = AV_RN32A(&top_mv[mbsplits_top[k + 12]]);
887         else
888             above = AV_RN32A(&cur_mv[mbsplits_cur[k - 4]]);
889
890         submv_prob = get_submv_prob(left, above, is_vp7);
891
892         if (vp56_rac_get_prob_branchy(c, submv_prob[0])) {
893             if (vp56_rac_get_prob_branchy(c, submv_prob[1])) {
894                 if (vp56_rac_get_prob_branchy(c, submv_prob[2])) {
895                     mb->bmv[n].y = mb->mv.y +
896                                    read_mv_component(c, s->prob->mvc[0], is_vp7);
897                     mb->bmv[n].x = mb->mv.x +
898                                    read_mv_component(c, s->prob->mvc[1], is_vp7);
899                 } else {
900                     AV_ZERO32(&mb->bmv[n]);
901                 }
902             } else {
903                 AV_WN32A(&mb->bmv[n], above);
904             }
905         } else {
906             AV_WN32A(&mb->bmv[n], left);
907         }
908     }
909
910     return num;
911 }
912
913 /**
914  * The vp7 reference decoder uses a padding macroblock column (added to right
915  * edge of the frame) to guard against illegal macroblock offsets. The
916  * algorithm has bugs that permit offsets to straddle the padding column.
917  * This function replicates those bugs.
918  *
919  * @param[out] edge_x macroblock x address
920  * @param[out] edge_y macroblock y address
921  *
922  * @return macroblock offset legal (boolean)
923  */
924 static int vp7_calculate_mb_offset(int mb_x, int mb_y, int mb_width,
925                                    int xoffset, int yoffset, int boundary,
926                                    int *edge_x, int *edge_y)
927 {
928     int vwidth = mb_width + 1;
929     int new = (mb_y + yoffset) * vwidth + mb_x + xoffset;
930     if (new < boundary || new % vwidth == vwidth - 1)
931         return 0;
932     *edge_y = new / vwidth;
933     *edge_x = new % vwidth;
934     return 1;
935 }
936
937 static const VP56mv *get_bmv_ptr(const VP8Macroblock *mb, int subblock)
938 {
939     return &mb->bmv[mb->mode == VP8_MVMODE_SPLIT ? vp8_mbsplits[mb->partitioning][subblock] : 0];
940 }
941
942 static av_always_inline
943 void vp7_decode_mvs(VP8Context *s, VP8Macroblock *mb,
944                     int mb_x, int mb_y, int layout)
945 {
946     VP8Macroblock *mb_edge[12];
947     enum { CNT_ZERO, CNT_NEAREST, CNT_NEAR };
948     enum { VP8_EDGE_TOP, VP8_EDGE_LEFT, VP8_EDGE_TOPLEFT };
949     int idx = CNT_ZERO;
950     VP56mv near_mv[3];
951     uint8_t cnt[3] = { 0 };
952     VP56RangeCoder *c = &s->c;
953     int i;
954
955     AV_ZERO32(&near_mv[0]);
956     AV_ZERO32(&near_mv[1]);
957     AV_ZERO32(&near_mv[2]);
958
959     for (i = 0; i < VP7_MV_PRED_COUNT; i++) {
960         const VP7MVPred * pred = &vp7_mv_pred[i];
961         int edge_x, edge_y;
962
963         if (vp7_calculate_mb_offset(mb_x, mb_y, s->mb_width, pred->xoffset,
964                                     pred->yoffset, !s->profile, &edge_x, &edge_y)) {
965             VP8Macroblock *edge = mb_edge[i] = (s->mb_layout == 1)
966                                              ? s->macroblocks_base + 1 + edge_x +
967                                                (s->mb_width + 1) * (edge_y + 1)
968                                              : s->macroblocks + edge_x +
969                                                (s->mb_height - edge_y - 1) * 2;
970             uint32_t mv = AV_RN32A(get_bmv_ptr(edge, vp7_mv_pred[i].subblock));
971             if (mv) {
972                 if (AV_RN32A(&near_mv[CNT_NEAREST])) {
973                     if (mv == AV_RN32A(&near_mv[CNT_NEAREST])) {
974                         idx = CNT_NEAREST;
975                     } else if (AV_RN32A(&near_mv[CNT_NEAR])) {
976                         if (mv != AV_RN32A(&near_mv[CNT_NEAR]))
977                             continue;
978                         idx = CNT_NEAR;
979                     } else {
980                         AV_WN32A(&near_mv[CNT_NEAR], mv);
981                         idx = CNT_NEAR;
982                     }
983                 } else {
984                     AV_WN32A(&near_mv[CNT_NEAREST], mv);
985                     idx = CNT_NEAREST;
986                 }
987             } else {
988                 idx = CNT_ZERO;
989             }
990         } else {
991             idx = CNT_ZERO;
992         }
993         cnt[idx] += vp7_mv_pred[i].score;
994     }
995
996     mb->partitioning = VP8_SPLITMVMODE_NONE;
997
998     if (vp56_rac_get_prob_branchy(c, vp7_mode_contexts[cnt[CNT_ZERO]][0])) {
999         mb->mode = VP8_MVMODE_MV;
1000
1001         if (vp56_rac_get_prob_branchy(c, vp7_mode_contexts[cnt[CNT_NEAREST]][1])) {
1002
1003             if (vp56_rac_get_prob_branchy(c, vp7_mode_contexts[cnt[CNT_NEAR]][2])) {
1004
1005                 if (cnt[CNT_NEAREST] > cnt[CNT_NEAR])
1006                     AV_WN32A(&mb->mv, cnt[CNT_ZERO] > cnt[CNT_NEAREST] ? 0 : AV_RN32A(&near_mv[CNT_NEAREST]));
1007                 else
1008                     AV_WN32A(&mb->mv, cnt[CNT_ZERO] > cnt[CNT_NEAR]    ? 0 : AV_RN32A(&near_mv[CNT_NEAR]));
1009
1010                 if (vp56_rac_get_prob_branchy(c, vp7_mode_contexts[cnt[CNT_NEAR]][3])) {
1011                     mb->mode = VP8_MVMODE_SPLIT;
1012                     mb->mv = mb->bmv[decode_splitmvs(s, c, mb, layout, IS_VP7) - 1];
1013                 } else {
1014                     mb->mv.y += vp7_read_mv_component(c, s->prob->mvc[0]);
1015                     mb->mv.x += vp7_read_mv_component(c, s->prob->mvc[1]);
1016                     mb->bmv[0] = mb->mv;
1017                 }
1018             } else {
1019                 mb->mv = near_mv[CNT_NEAR];
1020                 mb->bmv[0] = mb->mv;
1021             }
1022         } else {
1023             mb->mv = near_mv[CNT_NEAREST];
1024             mb->bmv[0] = mb->mv;
1025         }
1026     } else {
1027         mb->mode = VP8_MVMODE_ZERO;
1028         AV_ZERO32(&mb->mv);
1029         mb->bmv[0] = mb->mv;
1030     }
1031 }
1032
1033 static av_always_inline
1034 void vp8_decode_mvs(VP8Context *s, VP8Macroblock *mb,
1035                     int mb_x, int mb_y, int layout)
1036 {
1037     VP8Macroblock *mb_edge[3] = { 0      /* top */,
1038                                   mb - 1 /* left */,
1039                                   0      /* top-left */ };
1040     enum { CNT_ZERO, CNT_NEAREST, CNT_NEAR, CNT_SPLITMV };
1041     enum { VP8_EDGE_TOP, VP8_EDGE_LEFT, VP8_EDGE_TOPLEFT };
1042     int idx = CNT_ZERO;
1043     int cur_sign_bias = s->sign_bias[mb->ref_frame];
1044     int8_t *sign_bias = s->sign_bias;
1045     VP56mv near_mv[4];
1046     uint8_t cnt[4] = { 0 };
1047     VP56RangeCoder *c = &s->c;
1048
1049     if (!layout) { // layout is inlined (s->mb_layout is not)
1050         mb_edge[0] = mb + 2;
1051         mb_edge[2] = mb + 1;
1052     } else {
1053         mb_edge[0] = mb - s->mb_width - 1;
1054         mb_edge[2] = mb - s->mb_width - 2;
1055     }
1056
1057     AV_ZERO32(&near_mv[0]);
1058     AV_ZERO32(&near_mv[1]);
1059     AV_ZERO32(&near_mv[2]);
1060
1061     /* Process MB on top, left and top-left */
1062 #define MV_EDGE_CHECK(n)                                                      \
1063     {                                                                         \
1064         VP8Macroblock *edge = mb_edge[n];                                     \
1065         int edge_ref = edge->ref_frame;                                       \
1066         if (edge_ref != VP56_FRAME_CURRENT) {                                 \
1067             uint32_t mv = AV_RN32A(&edge->mv);                                \
1068             if (mv) {                                                         \
1069                 if (cur_sign_bias != sign_bias[edge_ref]) {                   \
1070                     /* SWAR negate of the values in mv. */                    \
1071                     mv = ~mv;                                                 \
1072                     mv = ((mv & 0x7fff7fff) +                                 \
1073                           0x00010001) ^ (mv & 0x80008000);                    \
1074                 }                                                             \
1075                 if (!n || mv != AV_RN32A(&near_mv[idx]))                      \
1076                     AV_WN32A(&near_mv[++idx], mv);                            \
1077                 cnt[idx] += 1 + (n != 2);                                     \
1078             } else                                                            \
1079                 cnt[CNT_ZERO] += 1 + (n != 2);                                \
1080         }                                                                     \
1081     }
1082
1083     MV_EDGE_CHECK(0)
1084     MV_EDGE_CHECK(1)
1085     MV_EDGE_CHECK(2)
1086
1087     mb->partitioning = VP8_SPLITMVMODE_NONE;
1088     if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_ZERO]][0])) {
1089         mb->mode = VP8_MVMODE_MV;
1090
1091         /* If we have three distinct MVs, merge first and last if they're the same */
1092         if (cnt[CNT_SPLITMV] &&
1093             AV_RN32A(&near_mv[1 + VP8_EDGE_TOP]) == AV_RN32A(&near_mv[1 + VP8_EDGE_TOPLEFT]))
1094             cnt[CNT_NEAREST] += 1;
1095
1096         /* Swap near and nearest if necessary */
1097         if (cnt[CNT_NEAR] > cnt[CNT_NEAREST]) {
1098             FFSWAP(uint8_t,     cnt[CNT_NEAREST],     cnt[CNT_NEAR]);
1099             FFSWAP( VP56mv, near_mv[CNT_NEAREST], near_mv[CNT_NEAR]);
1100         }
1101
1102         if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_NEAREST]][1])) {
1103             if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_NEAR]][2])) {
1104                 /* Choose the best mv out of 0,0 and the nearest mv */
1105                 clamp_mv(s, &mb->mv, &near_mv[CNT_ZERO + (cnt[CNT_NEAREST] >= cnt[CNT_ZERO])]);
1106                 cnt[CNT_SPLITMV] = ((mb_edge[VP8_EDGE_LEFT]->mode    == VP8_MVMODE_SPLIT) +
1107                                     (mb_edge[VP8_EDGE_TOP]->mode     == VP8_MVMODE_SPLIT)) * 2 +
1108                                     (mb_edge[VP8_EDGE_TOPLEFT]->mode == VP8_MVMODE_SPLIT);
1109
1110                 if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_SPLITMV]][3])) {
1111                     mb->mode = VP8_MVMODE_SPLIT;
1112                     mb->mv = mb->bmv[decode_splitmvs(s, c, mb, layout, IS_VP8) - 1];
1113                 } else {
1114                     mb->mv.y  += vp8_read_mv_component(c, s->prob->mvc[0]);
1115                     mb->mv.x  += vp8_read_mv_component(c, s->prob->mvc[1]);
1116                     mb->bmv[0] = mb->mv;
1117                 }
1118             } else {
1119                 clamp_mv(s, &mb->mv, &near_mv[CNT_NEAR]);
1120                 mb->bmv[0] = mb->mv;
1121             }
1122         } else {
1123             clamp_mv(s, &mb->mv, &near_mv[CNT_NEAREST]);
1124             mb->bmv[0] = mb->mv;
1125         }
1126     } else {
1127         mb->mode = VP8_MVMODE_ZERO;
1128         AV_ZERO32(&mb->mv);
1129         mb->bmv[0] = mb->mv;
1130     }
1131 }
1132
1133 static av_always_inline
1134 void decode_intra4x4_modes(VP8Context *s, VP56RangeCoder *c, VP8Macroblock *mb,
1135                            int mb_x, int keyframe, int layout)
1136 {
1137     uint8_t *intra4x4 = mb->intra4x4_pred_mode_mb;
1138
1139     if (layout) {
1140         VP8Macroblock *mb_top = mb - s->mb_width - 1;
1141         memcpy(mb->intra4x4_pred_mode_top, mb_top->intra4x4_pred_mode_top, 4);
1142     }
1143     if (keyframe) {
1144         int x, y;
1145         uint8_t *top;
1146         uint8_t *const left = s->intra4x4_pred_mode_left;
1147         if (layout)
1148             top = mb->intra4x4_pred_mode_top;
1149         else
1150             top = s->intra4x4_pred_mode_top + 4 * mb_x;
1151         for (y = 0; y < 4; y++) {
1152             for (x = 0; x < 4; x++) {
1153                 const uint8_t *ctx;
1154                 ctx       = vp8_pred4x4_prob_intra[top[x]][left[y]];
1155                 *intra4x4 = vp8_rac_get_tree(c, vp8_pred4x4_tree, ctx);
1156                 left[y]   = top[x] = *intra4x4;
1157                 intra4x4++;
1158             }
1159         }
1160     } else {
1161         int i;
1162         for (i = 0; i < 16; i++)
1163             intra4x4[i] = vp8_rac_get_tree(c, vp8_pred4x4_tree,
1164                                            vp8_pred4x4_prob_inter);
1165     }
1166 }
1167
1168 static av_always_inline
1169 void decode_mb_mode(VP8Context *s, VP8Macroblock *mb, int mb_x, int mb_y,
1170                     uint8_t *segment, uint8_t *ref, int layout, int is_vp7)
1171 {
1172     VP56RangeCoder *c = &s->c;
1173     static const char *vp7_feature_name[] = { "q-index",
1174                                               "lf-delta",
1175                                               "partial-golden-update",
1176                                               "blit-pitch" };
1177     if (is_vp7) {
1178         int i;
1179         *segment = 0;
1180         for (i = 0; i < 4; i++) {
1181             if (s->feature_enabled[i]) {
1182                 if (vp56_rac_get_prob_branchy(c, s->feature_present_prob[i])) {
1183                       int index = vp8_rac_get_tree(c, vp7_feature_index_tree,
1184                                                    s->feature_index_prob[i]);
1185                       av_log(s->avctx, AV_LOG_WARNING,
1186                              "Feature %s present in macroblock (value 0x%x)\n",
1187                              vp7_feature_name[i], s->feature_value[i][index]);
1188                 }
1189            }
1190         }
1191     } else if (s->segmentation.update_map) {
1192         int bit  = vp56_rac_get_prob(c, s->prob->segmentid[0]);
1193         *segment = vp56_rac_get_prob(c, s->prob->segmentid[1+bit]) + 2*bit;
1194     } else if (s->segmentation.enabled)
1195         *segment = ref ? *ref : *segment;
1196     mb->segment = *segment;
1197
1198     mb->skip = s->mbskip_enabled ? vp56_rac_get_prob(c, s->prob->mbskip) : 0;
1199
1200     if (s->keyframe) {
1201         mb->mode = vp8_rac_get_tree(c, vp8_pred16x16_tree_intra,
1202                                     vp8_pred16x16_prob_intra);
1203
1204         if (mb->mode == MODE_I4x4) {
1205             decode_intra4x4_modes(s, c, mb, mb_x, 1, layout);
1206         } else {
1207             const uint32_t modes = (is_vp7 ? vp7_pred4x4_mode
1208                                            : vp8_pred4x4_mode)[mb->mode] * 0x01010101u;
1209             if (s->mb_layout)
1210                 AV_WN32A(mb->intra4x4_pred_mode_top, modes);
1211             else
1212                 AV_WN32A(s->intra4x4_pred_mode_top + 4 * mb_x, modes);
1213             AV_WN32A(s->intra4x4_pred_mode_left, modes);
1214         }
1215
1216         mb->chroma_pred_mode = vp8_rac_get_tree(c, vp8_pred8x8c_tree,
1217                                                 vp8_pred8x8c_prob_intra);
1218         mb->ref_frame        = VP56_FRAME_CURRENT;
1219     } else if (vp56_rac_get_prob_branchy(c, s->prob->intra)) {
1220         // inter MB, 16.2
1221         if (vp56_rac_get_prob_branchy(c, s->prob->last))
1222             mb->ref_frame =
1223                 (!is_vp7 && vp56_rac_get_prob(c, s->prob->golden)) ? VP56_FRAME_GOLDEN2 /* altref */
1224                                                                    : VP56_FRAME_GOLDEN;
1225         else
1226             mb->ref_frame = VP56_FRAME_PREVIOUS;
1227         s->ref_count[mb->ref_frame - 1]++;
1228
1229         // motion vectors, 16.3
1230         if (is_vp7)
1231             vp7_decode_mvs(s, mb, mb_x, mb_y, layout);
1232         else
1233             vp8_decode_mvs(s, mb, mb_x, mb_y, layout);
1234     } else {
1235         // intra MB, 16.1
1236         mb->mode = vp8_rac_get_tree(c, vp8_pred16x16_tree_inter, s->prob->pred16x16);
1237
1238         if (mb->mode == MODE_I4x4)
1239             decode_intra4x4_modes(s, c, mb, mb_x, 0, layout);
1240
1241         mb->chroma_pred_mode = vp8_rac_get_tree(c, vp8_pred8x8c_tree,
1242                                                 s->prob->pred8x8c);
1243         mb->ref_frame        = VP56_FRAME_CURRENT;
1244         mb->partitioning     = VP8_SPLITMVMODE_NONE;
1245         AV_ZERO32(&mb->bmv[0]);
1246     }
1247 }
1248
1249 /**
1250  * @param r     arithmetic bitstream reader context
1251  * @param block destination for block coefficients
1252  * @param probs probabilities to use when reading trees from the bitstream
1253  * @param i     initial coeff index, 0 unless a separate DC block is coded
1254  * @param qmul  array holding the dc/ac dequant factor at position 0/1
1255  *
1256  * @return 0 if no coeffs were decoded
1257  *         otherwise, the index of the last coeff decoded plus one
1258  */
1259 static av_always_inline
1260 int decode_block_coeffs_internal(VP56RangeCoder *r, int16_t block[16],
1261                                  uint8_t probs[16][3][NUM_DCT_TOKENS - 1],
1262                                  int i, uint8_t *token_prob, int16_t qmul[2],
1263                                  const uint8_t scan[16], int vp7)
1264 {
1265     VP56RangeCoder c = *r;
1266     goto skip_eob;
1267     do {
1268         int coeff;
1269 restart:
1270         if (!vp56_rac_get_prob_branchy(&c, token_prob[0]))   // DCT_EOB
1271             break;
1272
1273 skip_eob:
1274         if (!vp56_rac_get_prob_branchy(&c, token_prob[1])) { // DCT_0
1275             if (++i == 16)
1276                 break; // invalid input; blocks should end with EOB
1277             token_prob = probs[i][0];
1278             if (vp7)
1279                 goto restart;
1280             goto skip_eob;
1281         }
1282
1283         if (!vp56_rac_get_prob_branchy(&c, token_prob[2])) { // DCT_1
1284             coeff = 1;
1285             token_prob = probs[i + 1][1];
1286         } else {
1287             if (!vp56_rac_get_prob_branchy(&c, token_prob[3])) { // DCT 2,3,4
1288                 coeff = vp56_rac_get_prob_branchy(&c, token_prob[4]);
1289                 if (coeff)
1290                     coeff += vp56_rac_get_prob(&c, token_prob[5]);
1291                 coeff += 2;
1292             } else {
1293                 // DCT_CAT*
1294                 if (!vp56_rac_get_prob_branchy(&c, token_prob[6])) {
1295                     if (!vp56_rac_get_prob_branchy(&c, token_prob[7])) { // DCT_CAT1
1296                         coeff = 5 + vp56_rac_get_prob(&c, vp8_dct_cat1_prob[0]);
1297                     } else {                                    // DCT_CAT2
1298                         coeff  = 7;
1299                         coeff += vp56_rac_get_prob(&c, vp8_dct_cat2_prob[0]) << 1;
1300                         coeff += vp56_rac_get_prob(&c, vp8_dct_cat2_prob[1]);
1301                     }
1302                 } else {    // DCT_CAT3 and up
1303                     int a   = vp56_rac_get_prob(&c, token_prob[8]);
1304                     int b   = vp56_rac_get_prob(&c, token_prob[9 + a]);
1305                     int cat = (a << 1) + b;
1306                     coeff  = 3 + (8 << cat);
1307                     coeff += vp8_rac_get_coeff(&c, ff_vp8_dct_cat_prob[cat]);
1308                 }
1309             }
1310             token_prob = probs[i + 1][2];
1311         }
1312         block[scan[i]] = (vp8_rac_get(&c) ? -coeff : coeff) * qmul[!!i];
1313     } while (++i < 16);
1314
1315     *r = c;
1316     return i;
1317 }
1318
1319 static av_always_inline
1320 int inter_predict_dc(int16_t block[16], int16_t pred[2])
1321 {
1322     int16_t dc = block[0];
1323     int ret = 0;
1324
1325     if (pred[1] > 3) {
1326         dc += pred[0];
1327         ret = 1;
1328     }
1329
1330     if (!pred[0] | !dc | ((int32_t)pred[0] ^ (int32_t)dc) >> 31) {
1331         block[0] = pred[0] = dc;
1332         pred[1] = 0;
1333     } else {
1334         if (pred[0] == dc)
1335             pred[1]++;
1336         block[0] = pred[0] = dc;
1337     }
1338
1339     return ret;
1340 }
1341
1342 static int vp7_decode_block_coeffs_internal(VP56RangeCoder *r,
1343                                             int16_t block[16],
1344                                             uint8_t probs[16][3][NUM_DCT_TOKENS - 1],
1345                                             int i, uint8_t *token_prob,
1346                                             int16_t qmul[2],
1347                                             const uint8_t scan[16])
1348 {
1349     return decode_block_coeffs_internal(r, block, probs, i,
1350                                         token_prob, qmul, scan, IS_VP7);
1351 }
1352
1353 #ifndef vp8_decode_block_coeffs_internal
1354 static int vp8_decode_block_coeffs_internal(VP56RangeCoder *r,
1355                                             int16_t block[16],
1356                                             uint8_t probs[16][3][NUM_DCT_TOKENS - 1],
1357                                             int i, uint8_t *token_prob,
1358                                             int16_t qmul[2])
1359 {
1360     return decode_block_coeffs_internal(r, block, probs, i,
1361                                         token_prob, qmul, ff_zigzag_scan, IS_VP8);
1362 }
1363 #endif
1364
1365 /**
1366  * @param c          arithmetic bitstream reader context
1367  * @param block      destination for block coefficients
1368  * @param probs      probabilities to use when reading trees from the bitstream
1369  * @param i          initial coeff index, 0 unless a separate DC block is coded
1370  * @param zero_nhood the initial prediction context for number of surrounding
1371  *                   all-zero blocks (only left/top, so 0-2)
1372  * @param qmul       array holding the dc/ac dequant factor at position 0/1
1373  * @param scan       scan pattern (VP7 only)
1374  *
1375  * @return 0 if no coeffs were decoded
1376  *         otherwise, the index of the last coeff decoded plus one
1377  */
1378 static av_always_inline
1379 int decode_block_coeffs(VP56RangeCoder *c, int16_t block[16],
1380                         uint8_t probs[16][3][NUM_DCT_TOKENS - 1],
1381                         int i, int zero_nhood, int16_t qmul[2],
1382                         const uint8_t scan[16], int vp7)
1383 {
1384     uint8_t *token_prob = probs[i][zero_nhood];
1385     if (!vp56_rac_get_prob_branchy(c, token_prob[0]))   // DCT_EOB
1386         return 0;
1387     return vp7 ? vp7_decode_block_coeffs_internal(c, block, probs, i,
1388                                                   token_prob, qmul, scan)
1389                : vp8_decode_block_coeffs_internal(c, block, probs, i,
1390                                                   token_prob, qmul);
1391 }
1392
1393 static av_always_inline
1394 void decode_mb_coeffs(VP8Context *s, VP8ThreadData *td, VP56RangeCoder *c,
1395                       VP8Macroblock *mb, uint8_t t_nnz[9], uint8_t l_nnz[9],
1396                       int is_vp7)
1397 {
1398     int i, x, y, luma_start = 0, luma_ctx = 3;
1399     int nnz_pred, nnz, nnz_total = 0;
1400     int segment = mb->segment;
1401     int block_dc = 0;
1402
1403     if (mb->mode != MODE_I4x4 && (is_vp7 || mb->mode != VP8_MVMODE_SPLIT)) {
1404         nnz_pred = t_nnz[8] + l_nnz[8];
1405
1406         // decode DC values and do hadamard
1407         nnz = decode_block_coeffs(c, td->block_dc, s->prob->token[1], 0,
1408                                   nnz_pred, s->qmat[segment].luma_dc_qmul,
1409                                   ff_zigzag_scan, is_vp7);
1410         l_nnz[8] = t_nnz[8] = !!nnz;
1411
1412         if (is_vp7 && mb->mode > MODE_I4x4) {
1413             nnz |=  inter_predict_dc(td->block_dc,
1414                                      s->inter_dc_pred[mb->ref_frame - 1]);
1415         }
1416
1417         if (nnz) {
1418             nnz_total += nnz;
1419             block_dc   = 1;
1420             if (nnz == 1)
1421                 s->vp8dsp.vp8_luma_dc_wht_dc(td->block, td->block_dc);
1422             else
1423                 s->vp8dsp.vp8_luma_dc_wht(td->block, td->block_dc);
1424         }
1425         luma_start = 1;
1426         luma_ctx   = 0;
1427     }
1428
1429     // luma blocks
1430     for (y = 0; y < 4; y++)
1431         for (x = 0; x < 4; x++) {
1432             nnz_pred = l_nnz[y] + t_nnz[x];
1433             nnz = decode_block_coeffs(c, td->block[y][x],
1434                                       s->prob->token[luma_ctx],
1435                                       luma_start, nnz_pred,
1436                                       s->qmat[segment].luma_qmul,
1437                                       s->prob[0].scan, is_vp7);
1438             /* nnz+block_dc may be one more than the actual last index,
1439              * but we don't care */
1440             td->non_zero_count_cache[y][x] = nnz + block_dc;
1441             t_nnz[x] = l_nnz[y] = !!nnz;
1442             nnz_total += nnz;
1443         }
1444
1445     // chroma blocks
1446     // TODO: what to do about dimensions? 2nd dim for luma is x,
1447     // but for chroma it's (y<<1)|x
1448     for (i = 4; i < 6; i++)
1449         for (y = 0; y < 2; y++)
1450             for (x = 0; x < 2; x++) {
1451                 nnz_pred = l_nnz[i + 2 * y] + t_nnz[i + 2 * x];
1452                 nnz = decode_block_coeffs(c, td->block[i][(y << 1) + x],
1453                                           s->prob->token[2], 0, nnz_pred,
1454                                           s->qmat[segment].chroma_qmul,
1455                                           s->prob[0].scan, is_vp7);
1456                 td->non_zero_count_cache[i][(y << 1) + x] = nnz;
1457                 t_nnz[i + 2 * x] = l_nnz[i + 2 * y] = !!nnz;
1458                 nnz_total += nnz;
1459             }
1460
1461     // if there were no coded coeffs despite the macroblock not being marked skip,
1462     // we MUST not do the inner loop filter and should not do IDCT
1463     // Since skip isn't used for bitstream prediction, just manually set it.
1464     if (!nnz_total)
1465         mb->skip = 1;
1466 }
1467
1468 static av_always_inline
1469 void backup_mb_border(uint8_t *top_border, uint8_t *src_y,
1470                       uint8_t *src_cb, uint8_t *src_cr,
1471                       int linesize, int uvlinesize, int simple)
1472 {
1473     AV_COPY128(top_border, src_y + 15 * linesize);
1474     if (!simple) {
1475         AV_COPY64(top_border + 16, src_cb + 7 * uvlinesize);
1476         AV_COPY64(top_border + 24, src_cr + 7 * uvlinesize);
1477     }
1478 }
1479
1480 static av_always_inline
1481 void xchg_mb_border(uint8_t *top_border, uint8_t *src_y, uint8_t *src_cb,
1482                     uint8_t *src_cr, int linesize, int uvlinesize, int mb_x,
1483                     int mb_y, int mb_width, int simple, int xchg)
1484 {
1485     uint8_t *top_border_m1 = top_border - 32;     // for TL prediction
1486     src_y  -= linesize;
1487     src_cb -= uvlinesize;
1488     src_cr -= uvlinesize;
1489
1490 #define XCHG(a, b, xchg)                                                      \
1491     do {                                                                      \
1492         if (xchg)                                                             \
1493             AV_SWAP64(b, a);                                                  \
1494         else                                                                  \
1495             AV_COPY64(b, a);                                                  \
1496     } while (0)
1497
1498     XCHG(top_border_m1 + 8, src_y - 8, xchg);
1499     XCHG(top_border, src_y, xchg);
1500     XCHG(top_border + 8, src_y + 8, 1);
1501     if (mb_x < mb_width - 1)
1502         XCHG(top_border + 32, src_y + 16, 1);
1503
1504     // only copy chroma for normal loop filter
1505     // or to initialize the top row to 127
1506     if (!simple || !mb_y) {
1507         XCHG(top_border_m1 + 16, src_cb - 8, xchg);
1508         XCHG(top_border_m1 + 24, src_cr - 8, xchg);
1509         XCHG(top_border + 16, src_cb, 1);
1510         XCHG(top_border + 24, src_cr, 1);
1511     }
1512 }
1513
1514 static av_always_inline
1515 int check_dc_pred8x8_mode(int mode, int mb_x, int mb_y)
1516 {
1517     if (!mb_x)
1518         return mb_y ? TOP_DC_PRED8x8 : DC_128_PRED8x8;
1519     else
1520         return mb_y ? mode : LEFT_DC_PRED8x8;
1521 }
1522
1523 static av_always_inline
1524 int check_tm_pred8x8_mode(int mode, int mb_x, int mb_y, int vp7)
1525 {
1526     if (!mb_x)
1527         return mb_y ? VERT_PRED8x8 : (vp7 ? DC_128_PRED8x8 : DC_129_PRED8x8);
1528     else
1529         return mb_y ? mode : HOR_PRED8x8;
1530 }
1531
1532 static av_always_inline
1533 int check_intra_pred8x8_mode_emuedge(int mode, int mb_x, int mb_y, int vp7)
1534 {
1535     switch (mode) {
1536     case DC_PRED8x8:
1537         return check_dc_pred8x8_mode(mode, mb_x, mb_y);
1538     case VERT_PRED8x8:
1539         return !mb_y ? (vp7 ? DC_128_PRED8x8 : DC_127_PRED8x8) : mode;
1540     case HOR_PRED8x8:
1541         return !mb_x ? (vp7 ? DC_128_PRED8x8 : DC_129_PRED8x8) : mode;
1542     case PLANE_PRED8x8: /* TM */
1543         return check_tm_pred8x8_mode(mode, mb_x, mb_y, vp7);
1544     }
1545     return mode;
1546 }
1547
1548 static av_always_inline
1549 int check_tm_pred4x4_mode(int mode, int mb_x, int mb_y, int vp7)
1550 {
1551     if (!mb_x) {
1552         return mb_y ? VERT_VP8_PRED : (vp7 ? DC_128_PRED : DC_129_PRED);
1553     } else {
1554         return mb_y ? mode : HOR_VP8_PRED;
1555     }
1556 }
1557
1558 static av_always_inline
1559 int check_intra_pred4x4_mode_emuedge(int mode, int mb_x, int mb_y,
1560                                      int *copy_buf, int vp7)
1561 {
1562     switch (mode) {
1563     case VERT_PRED:
1564         if (!mb_x && mb_y) {
1565             *copy_buf = 1;
1566             return mode;
1567         }
1568         /* fall-through */
1569     case DIAG_DOWN_LEFT_PRED:
1570     case VERT_LEFT_PRED:
1571         return !mb_y ? (vp7 ? DC_128_PRED : DC_127_PRED) : mode;
1572     case HOR_PRED:
1573         if (!mb_y) {
1574             *copy_buf = 1;
1575             return mode;
1576         }
1577         /* fall-through */
1578     case HOR_UP_PRED:
1579         return !mb_x ? (vp7 ? DC_128_PRED : DC_129_PRED) : mode;
1580     case TM_VP8_PRED:
1581         return check_tm_pred4x4_mode(mode, mb_x, mb_y, vp7);
1582     case DC_PRED: /* 4x4 DC doesn't use the same "H.264-style" exceptions
1583                    * as 16x16/8x8 DC */
1584     case DIAG_DOWN_RIGHT_PRED:
1585     case VERT_RIGHT_PRED:
1586     case HOR_DOWN_PRED:
1587         if (!mb_y || !mb_x)
1588             *copy_buf = 1;
1589         return mode;
1590     }
1591     return mode;
1592 }
1593
1594 static av_always_inline
1595 void intra_predict(VP8Context *s, VP8ThreadData *td, uint8_t *dst[3],
1596                    VP8Macroblock *mb, int mb_x, int mb_y, int is_vp7)
1597 {
1598     int x, y, mode, nnz;
1599     uint32_t tr;
1600
1601     /* for the first row, we need to run xchg_mb_border to init the top edge
1602      * to 127 otherwise, skip it if we aren't going to deblock */
1603     if (mb_y && (s->deblock_filter || !mb_y) && td->thread_nr == 0)
1604         xchg_mb_border(s->top_border[mb_x + 1], dst[0], dst[1], dst[2],
1605                        s->linesize, s->uvlinesize, mb_x, mb_y, s->mb_width,
1606                        s->filter.simple, 1);
1607
1608     if (mb->mode < MODE_I4x4) {
1609         mode = check_intra_pred8x8_mode_emuedge(mb->mode, mb_x, mb_y, is_vp7);
1610         s->hpc.pred16x16[mode](dst[0], s->linesize);
1611     } else {
1612         uint8_t *ptr = dst[0];
1613         uint8_t *intra4x4 = mb->intra4x4_pred_mode_mb;
1614         const uint8_t lo = is_vp7 ? 128 : 127;
1615         const uint8_t hi = is_vp7 ? 128 : 129;
1616         uint8_t tr_top[4] = { lo, lo, lo, lo };
1617
1618         // all blocks on the right edge of the macroblock use bottom edge
1619         // the top macroblock for their topright edge
1620         uint8_t *tr_right = ptr - s->linesize + 16;
1621
1622         // if we're on the right edge of the frame, said edge is extended
1623         // from the top macroblock
1624         if (mb_y && mb_x == s->mb_width - 1) {
1625             tr       = tr_right[-1] * 0x01010101u;
1626             tr_right = (uint8_t *) &tr;
1627         }
1628
1629         if (mb->skip)
1630             AV_ZERO128(td->non_zero_count_cache);
1631
1632         for (y = 0; y < 4; y++) {
1633             uint8_t *topright = ptr + 4 - s->linesize;
1634             for (x = 0; x < 4; x++) {
1635                 int copy = 0, linesize = s->linesize;
1636                 uint8_t *dst = ptr + 4 * x;
1637                 LOCAL_ALIGNED(4, uint8_t, copy_dst, [5 * 8]);
1638
1639                 if ((y == 0 || x == 3) && mb_y == 0) {
1640                     topright = tr_top;
1641                 } else if (x == 3)
1642                     topright = tr_right;
1643
1644                 mode = check_intra_pred4x4_mode_emuedge(intra4x4[x], mb_x + x,
1645                                                         mb_y + y, &copy, is_vp7);
1646                 if (copy) {
1647                     dst      = copy_dst + 12;
1648                     linesize = 8;
1649                     if (!(mb_y + y)) {
1650                         copy_dst[3] = lo;
1651                         AV_WN32A(copy_dst + 4, lo * 0x01010101U);
1652                     } else {
1653                         AV_COPY32(copy_dst + 4, ptr + 4 * x - s->linesize);
1654                         if (!(mb_x + x)) {
1655                             copy_dst[3] = hi;
1656                         } else {
1657                             copy_dst[3] = ptr[4 * x - s->linesize - 1];
1658                         }
1659                     }
1660                     if (!(mb_x + x)) {
1661                         copy_dst[11] =
1662                         copy_dst[19] =
1663                         copy_dst[27] =
1664                         copy_dst[35] = hi;
1665                     } else {
1666                         copy_dst[11] = ptr[4 * x                   - 1];
1667                         copy_dst[19] = ptr[4 * x + s->linesize     - 1];
1668                         copy_dst[27] = ptr[4 * x + s->linesize * 2 - 1];
1669                         copy_dst[35] = ptr[4 * x + s->linesize * 3 - 1];
1670                     }
1671                 }
1672                 s->hpc.pred4x4[mode](dst, topright, linesize);
1673                 if (copy) {
1674                     AV_COPY32(ptr + 4 * x,                   copy_dst + 12);
1675                     AV_COPY32(ptr + 4 * x + s->linesize,     copy_dst + 20);
1676                     AV_COPY32(ptr + 4 * x + s->linesize * 2, copy_dst + 28);
1677                     AV_COPY32(ptr + 4 * x + s->linesize * 3, copy_dst + 36);
1678                 }
1679
1680                 nnz = td->non_zero_count_cache[y][x];
1681                 if (nnz) {
1682                     if (nnz == 1)
1683                         s->vp8dsp.vp8_idct_dc_add(ptr + 4 * x,
1684                                                   td->block[y][x], s->linesize);
1685                     else
1686                         s->vp8dsp.vp8_idct_add(ptr + 4 * x,
1687                                                td->block[y][x], s->linesize);
1688                 }
1689                 topright += 4;
1690             }
1691
1692             ptr      += 4 * s->linesize;
1693             intra4x4 += 4;
1694         }
1695     }
1696
1697     mode = check_intra_pred8x8_mode_emuedge(mb->chroma_pred_mode,
1698                                             mb_x, mb_y, is_vp7);
1699     s->hpc.pred8x8[mode](dst[1], s->uvlinesize);
1700     s->hpc.pred8x8[mode](dst[2], s->uvlinesize);
1701
1702     if (mb_y && (s->deblock_filter || !mb_y) && td->thread_nr == 0)
1703         xchg_mb_border(s->top_border[mb_x + 1], dst[0], dst[1], dst[2],
1704                        s->linesize, s->uvlinesize, mb_x, mb_y, s->mb_width,
1705                        s->filter.simple, 0);
1706 }
1707
1708 static const uint8_t subpel_idx[3][8] = {
1709     { 0, 1, 2, 1, 2, 1, 2, 1 }, // nr. of left extra pixels,
1710                                 // also function pointer index
1711     { 0, 3, 5, 3, 5, 3, 5, 3 }, // nr. of extra pixels required
1712     { 0, 2, 3, 2, 3, 2, 3, 2 }, // nr. of right extra pixels
1713 };
1714
1715 /**
1716  * luma MC function
1717  *
1718  * @param s        VP8 decoding context
1719  * @param dst      target buffer for block data at block position
1720  * @param ref      reference picture buffer at origin (0, 0)
1721  * @param mv       motion vector (relative to block position) to get pixel data from
1722  * @param x_off    horizontal position of block from origin (0, 0)
1723  * @param y_off    vertical position of block from origin (0, 0)
1724  * @param block_w  width of block (16, 8 or 4)
1725  * @param block_h  height of block (always same as block_w)
1726  * @param width    width of src/dst plane data
1727  * @param height   height of src/dst plane data
1728  * @param linesize size of a single line of plane data, including padding
1729  * @param mc_func  motion compensation function pointers (bilinear or sixtap MC)
1730  */
1731 static av_always_inline
1732 void vp8_mc_luma(VP8Context *s, VP8ThreadData *td, uint8_t *dst,
1733                  ThreadFrame *ref, const VP56mv *mv,
1734                  int x_off, int y_off, int block_w, int block_h,
1735                  int width, int height, ptrdiff_t linesize,
1736                  vp8_mc_func mc_func[3][3])
1737 {
1738     uint8_t *src = ref->f->data[0];
1739
1740     if (AV_RN32A(mv)) {
1741         int src_linesize = linesize;
1742
1743         int mx = (mv->x * 2) & 7, mx_idx = subpel_idx[0][mx];
1744         int my = (mv->y * 2) & 7, my_idx = subpel_idx[0][my];
1745
1746         x_off += mv->x >> 2;
1747         y_off += mv->y >> 2;
1748
1749         // edge emulation
1750         ff_thread_await_progress(ref, (3 + y_off + block_h + subpel_idx[2][my]) >> 4, 0);
1751         src += y_off * linesize + x_off;
1752         if (x_off < mx_idx || x_off >= width  - block_w - subpel_idx[2][mx] ||
1753             y_off < my_idx || y_off >= height - block_h - subpel_idx[2][my]) {
1754             s->vdsp.emulated_edge_mc(td->edge_emu_buffer,
1755                                      src - my_idx * linesize - mx_idx,
1756                                      EDGE_EMU_LINESIZE, linesize,
1757                                      block_w + subpel_idx[1][mx],
1758                                      block_h + subpel_idx[1][my],
1759                                      x_off - mx_idx, y_off - my_idx,
1760                                      width, height);
1761             src = td->edge_emu_buffer + mx_idx + EDGE_EMU_LINESIZE * my_idx;
1762             src_linesize = EDGE_EMU_LINESIZE;
1763         }
1764         mc_func[my_idx][mx_idx](dst, linesize, src, src_linesize, block_h, mx, my);
1765     } else {
1766         ff_thread_await_progress(ref, (3 + y_off + block_h) >> 4, 0);
1767         mc_func[0][0](dst, linesize, src + y_off * linesize + x_off,
1768                       linesize, block_h, 0, 0);
1769     }
1770 }
1771
1772 /**
1773  * chroma MC function
1774  *
1775  * @param s        VP8 decoding context
1776  * @param dst1     target buffer for block data at block position (U plane)
1777  * @param dst2     target buffer for block data at block position (V plane)
1778  * @param ref      reference picture buffer at origin (0, 0)
1779  * @param mv       motion vector (relative to block position) to get pixel data from
1780  * @param x_off    horizontal position of block from origin (0, 0)
1781  * @param y_off    vertical position of block from origin (0, 0)
1782  * @param block_w  width of block (16, 8 or 4)
1783  * @param block_h  height of block (always same as block_w)
1784  * @param width    width of src/dst plane data
1785  * @param height   height of src/dst plane data
1786  * @param linesize size of a single line of plane data, including padding
1787  * @param mc_func  motion compensation function pointers (bilinear or sixtap MC)
1788  */
1789 static av_always_inline
1790 void vp8_mc_chroma(VP8Context *s, VP8ThreadData *td, uint8_t *dst1,
1791                    uint8_t *dst2, ThreadFrame *ref, const VP56mv *mv,
1792                    int x_off, int y_off, int block_w, int block_h,
1793                    int width, int height, ptrdiff_t linesize,
1794                    vp8_mc_func mc_func[3][3])
1795 {
1796     uint8_t *src1 = ref->f->data[1], *src2 = ref->f->data[2];
1797
1798     if (AV_RN32A(mv)) {
1799         int mx = mv->x & 7, mx_idx = subpel_idx[0][mx];
1800         int my = mv->y & 7, my_idx = subpel_idx[0][my];
1801
1802         x_off += mv->x >> 3;
1803         y_off += mv->y >> 3;
1804
1805         // edge emulation
1806         src1 += y_off * linesize + x_off;
1807         src2 += y_off * linesize + x_off;
1808         ff_thread_await_progress(ref, (3 + y_off + block_h + subpel_idx[2][my]) >> 3, 0);
1809         if (x_off < mx_idx || x_off >= width  - block_w - subpel_idx[2][mx] ||
1810             y_off < my_idx || y_off >= height - block_h - subpel_idx[2][my]) {
1811             s->vdsp.emulated_edge_mc(td->edge_emu_buffer,
1812                                      src1 - my_idx * linesize - mx_idx,
1813                                      EDGE_EMU_LINESIZE, linesize,
1814                                      block_w + subpel_idx[1][mx],
1815                                      block_h + subpel_idx[1][my],
1816                                      x_off - mx_idx, y_off - my_idx, width, height);
1817             src1 = td->edge_emu_buffer + mx_idx + EDGE_EMU_LINESIZE * my_idx;
1818             mc_func[my_idx][mx_idx](dst1, linesize, src1, EDGE_EMU_LINESIZE, block_h, mx, my);
1819
1820             s->vdsp.emulated_edge_mc(td->edge_emu_buffer,
1821                                      src2 - my_idx * linesize - mx_idx,
1822                                      EDGE_EMU_LINESIZE, linesize,
1823                                      block_w + subpel_idx[1][mx],
1824                                      block_h + subpel_idx[1][my],
1825                                      x_off - mx_idx, y_off - my_idx, width, height);
1826             src2 = td->edge_emu_buffer + mx_idx + EDGE_EMU_LINESIZE * my_idx;
1827             mc_func[my_idx][mx_idx](dst2, linesize, src2, EDGE_EMU_LINESIZE, block_h, mx, my);
1828         } else {
1829             mc_func[my_idx][mx_idx](dst1, linesize, src1, linesize, block_h, mx, my);
1830             mc_func[my_idx][mx_idx](dst2, linesize, src2, linesize, block_h, mx, my);
1831         }
1832     } else {
1833         ff_thread_await_progress(ref, (3 + y_off + block_h) >> 3, 0);
1834         mc_func[0][0](dst1, linesize, src1 + y_off * linesize + x_off, linesize, block_h, 0, 0);
1835         mc_func[0][0](dst2, linesize, src2 + y_off * linesize + x_off, linesize, block_h, 0, 0);
1836     }
1837 }
1838
1839 static av_always_inline
1840 void vp8_mc_part(VP8Context *s, VP8ThreadData *td, uint8_t *dst[3],
1841                  ThreadFrame *ref_frame, int x_off, int y_off,
1842                  int bx_off, int by_off, int block_w, int block_h,
1843                  int width, int height, VP56mv *mv)
1844 {
1845     VP56mv uvmv = *mv;
1846
1847     /* Y */
1848     vp8_mc_luma(s, td, dst[0] + by_off * s->linesize + bx_off,
1849                 ref_frame, mv, x_off + bx_off, y_off + by_off,
1850                 block_w, block_h, width, height, s->linesize,
1851                 s->put_pixels_tab[block_w == 8]);
1852
1853     /* U/V */
1854     if (s->profile == 3) {
1855         /* this block only applies VP8; it is safe to check
1856          * only the profile, as VP7 profile <= 1 */
1857         uvmv.x &= ~7;
1858         uvmv.y &= ~7;
1859     }
1860     x_off   >>= 1;
1861     y_off   >>= 1;
1862     bx_off  >>= 1;
1863     by_off  >>= 1;
1864     width   >>= 1;
1865     height  >>= 1;
1866     block_w >>= 1;
1867     block_h >>= 1;
1868     vp8_mc_chroma(s, td, dst[1] + by_off * s->uvlinesize + bx_off,
1869                   dst[2] + by_off * s->uvlinesize + bx_off, ref_frame,
1870                   &uvmv, x_off + bx_off, y_off + by_off,
1871                   block_w, block_h, width, height, s->uvlinesize,
1872                   s->put_pixels_tab[1 + (block_w == 4)]);
1873 }
1874
1875 /* Fetch pixels for estimated mv 4 macroblocks ahead.
1876  * Optimized for 64-byte cache lines. Inspired by ffh264 prefetch_motion. */
1877 static av_always_inline
1878 void prefetch_motion(VP8Context *s, VP8Macroblock *mb, int mb_x, int mb_y,
1879                      int mb_xy, int ref)
1880 {
1881     /* Don't prefetch refs that haven't been used very often this frame. */
1882     if (s->ref_count[ref - 1] > (mb_xy >> 5)) {
1883         int x_off = mb_x << 4, y_off = mb_y << 4;
1884         int mx = (mb->mv.x >> 2) + x_off + 8;
1885         int my = (mb->mv.y >> 2) + y_off;
1886         uint8_t **src = s->framep[ref]->tf.f->data;
1887         int off = mx + (my + (mb_x & 3) * 4) * s->linesize + 64;
1888         /* For threading, a ff_thread_await_progress here might be useful, but
1889          * it actually slows down the decoder. Since a bad prefetch doesn't
1890          * generate bad decoder output, we don't run it here. */
1891         s->vdsp.prefetch(src[0] + off, s->linesize, 4);
1892         off = (mx >> 1) + ((my >> 1) + (mb_x & 7)) * s->uvlinesize + 64;
1893         s->vdsp.prefetch(src[1] + off, src[2] - src[1], 2);
1894     }
1895 }
1896
1897 /**
1898  * Apply motion vectors to prediction buffer, chapter 18.
1899  */
1900 static av_always_inline
1901 void inter_predict(VP8Context *s, VP8ThreadData *td, uint8_t *dst[3],
1902                    VP8Macroblock *mb, int mb_x, int mb_y)
1903 {
1904     int x_off = mb_x << 4, y_off = mb_y << 4;
1905     int width = 16 * s->mb_width, height = 16 * s->mb_height;
1906     ThreadFrame *ref = &s->framep[mb->ref_frame]->tf;
1907     VP56mv *bmv = mb->bmv;
1908
1909     switch (mb->partitioning) {
1910     case VP8_SPLITMVMODE_NONE:
1911         vp8_mc_part(s, td, dst, ref, x_off, y_off,
1912                     0, 0, 16, 16, width, height, &mb->mv);
1913         break;
1914     case VP8_SPLITMVMODE_4x4: {
1915         int x, y;
1916         VP56mv uvmv;
1917
1918         /* Y */
1919         for (y = 0; y < 4; y++) {
1920             for (x = 0; x < 4; x++) {
1921                 vp8_mc_luma(s, td, dst[0] + 4 * y * s->linesize + x * 4,
1922                             ref, &bmv[4 * y + x],
1923                             4 * x + x_off, 4 * y + y_off, 4, 4,
1924                             width, height, s->linesize,
1925                             s->put_pixels_tab[2]);
1926             }
1927         }
1928
1929         /* U/V */
1930         x_off  >>= 1;
1931         y_off  >>= 1;
1932         width  >>= 1;
1933         height >>= 1;
1934         for (y = 0; y < 2; y++) {
1935             for (x = 0; x < 2; x++) {
1936                 uvmv.x = mb->bmv[2 * y       * 4 + 2 * x    ].x +
1937                          mb->bmv[2 * y       * 4 + 2 * x + 1].x +
1938                          mb->bmv[(2 * y + 1) * 4 + 2 * x    ].x +
1939                          mb->bmv[(2 * y + 1) * 4 + 2 * x + 1].x;
1940                 uvmv.y = mb->bmv[2 * y       * 4 + 2 * x    ].y +
1941                          mb->bmv[2 * y       * 4 + 2 * x + 1].y +
1942                          mb->bmv[(2 * y + 1) * 4 + 2 * x    ].y +
1943                          mb->bmv[(2 * y + 1) * 4 + 2 * x + 1].y;
1944                 uvmv.x = (uvmv.x + 2 + FF_SIGNBIT(uvmv.x)) >> 2;
1945                 uvmv.y = (uvmv.y + 2 + FF_SIGNBIT(uvmv.y)) >> 2;
1946                 if (s->profile == 3) {
1947                     uvmv.x &= ~7;
1948                     uvmv.y &= ~7;
1949                 }
1950                 vp8_mc_chroma(s, td, dst[1] + 4 * y * s->uvlinesize + x * 4,
1951                               dst[2] + 4 * y * s->uvlinesize + x * 4, ref,
1952                               &uvmv, 4 * x + x_off, 4 * y + y_off, 4, 4,
1953                               width, height, s->uvlinesize,
1954                               s->put_pixels_tab[2]);
1955             }
1956         }
1957         break;
1958     }
1959     case VP8_SPLITMVMODE_16x8:
1960         vp8_mc_part(s, td, dst, ref, x_off, y_off,
1961                     0, 0, 16, 8, width, height, &bmv[0]);
1962         vp8_mc_part(s, td, dst, ref, x_off, y_off,
1963                     0, 8, 16, 8, width, height, &bmv[1]);
1964         break;
1965     case VP8_SPLITMVMODE_8x16:
1966         vp8_mc_part(s, td, dst, ref, x_off, y_off,
1967                     0, 0, 8, 16, width, height, &bmv[0]);
1968         vp8_mc_part(s, td, dst, ref, x_off, y_off,
1969                     8, 0, 8, 16, width, height, &bmv[1]);
1970         break;
1971     case VP8_SPLITMVMODE_8x8:
1972         vp8_mc_part(s, td, dst, ref, x_off, y_off,
1973                     0, 0, 8, 8, width, height, &bmv[0]);
1974         vp8_mc_part(s, td, dst, ref, x_off, y_off,
1975                     8, 0, 8, 8, width, height, &bmv[1]);
1976         vp8_mc_part(s, td, dst, ref, x_off, y_off,
1977                     0, 8, 8, 8, width, height, &bmv[2]);
1978         vp8_mc_part(s, td, dst, ref, x_off, y_off,
1979                     8, 8, 8, 8, width, height, &bmv[3]);
1980         break;
1981     }
1982 }
1983
1984 static av_always_inline
1985 void idct_mb(VP8Context *s, VP8ThreadData *td, uint8_t *dst[3], VP8Macroblock *mb)
1986 {
1987     int x, y, ch;
1988
1989     if (mb->mode != MODE_I4x4) {
1990         uint8_t *y_dst = dst[0];
1991         for (y = 0; y < 4; y++) {
1992             uint32_t nnz4 = AV_RL32(td->non_zero_count_cache[y]);
1993             if (nnz4) {
1994                 if (nnz4 & ~0x01010101) {
1995                     for (x = 0; x < 4; x++) {
1996                         if ((uint8_t) nnz4 == 1)
1997                             s->vp8dsp.vp8_idct_dc_add(y_dst + 4 * x,
1998                                                       td->block[y][x],
1999                                                       s->linesize);
2000                         else if ((uint8_t) nnz4 > 1)
2001                             s->vp8dsp.vp8_idct_add(y_dst + 4 * x,
2002                                                    td->block[y][x],
2003                                                    s->linesize);
2004                         nnz4 >>= 8;
2005                         if (!nnz4)
2006                             break;
2007                     }
2008                 } else {
2009                     s->vp8dsp.vp8_idct_dc_add4y(y_dst, td->block[y], s->linesize);
2010                 }
2011             }
2012             y_dst += 4 * s->linesize;
2013         }
2014     }
2015
2016     for (ch = 0; ch < 2; ch++) {
2017         uint32_t nnz4 = AV_RL32(td->non_zero_count_cache[4 + ch]);
2018         if (nnz4) {
2019             uint8_t *ch_dst = dst[1 + ch];
2020             if (nnz4 & ~0x01010101) {
2021                 for (y = 0; y < 2; y++) {
2022                     for (x = 0; x < 2; x++) {
2023                         if ((uint8_t) nnz4 == 1)
2024                             s->vp8dsp.vp8_idct_dc_add(ch_dst + 4 * x,
2025                                                       td->block[4 + ch][(y << 1) + x],
2026                                                       s->uvlinesize);
2027                         else if ((uint8_t) nnz4 > 1)
2028                             s->vp8dsp.vp8_idct_add(ch_dst + 4 * x,
2029                                                    td->block[4 + ch][(y << 1) + x],
2030                                                    s->uvlinesize);
2031                         nnz4 >>= 8;
2032                         if (!nnz4)
2033                             goto chroma_idct_end;
2034                     }
2035                     ch_dst += 4 * s->uvlinesize;
2036                 }
2037             } else {
2038                 s->vp8dsp.vp8_idct_dc_add4uv(ch_dst, td->block[4 + ch], s->uvlinesize);
2039             }
2040         }
2041 chroma_idct_end:
2042         ;
2043     }
2044 }
2045
2046 static av_always_inline
2047 void filter_level_for_mb(VP8Context *s, VP8Macroblock *mb,
2048                          VP8FilterStrength *f, int is_vp7)
2049 {
2050     int interior_limit, filter_level;
2051
2052     if (s->segmentation.enabled) {
2053         filter_level = s->segmentation.filter_level[mb->segment];
2054         if (!s->segmentation.absolute_vals)
2055             filter_level += s->filter.level;
2056     } else
2057         filter_level = s->filter.level;
2058
2059     if (s->lf_delta.enabled) {
2060         filter_level += s->lf_delta.ref[mb->ref_frame];
2061         filter_level += s->lf_delta.mode[mb->mode];
2062     }
2063
2064     filter_level = av_clip_uintp2(filter_level, 6);
2065
2066     interior_limit = filter_level;
2067     if (s->filter.sharpness) {
2068         interior_limit >>= (s->filter.sharpness + 3) >> 2;
2069         interior_limit = FFMIN(interior_limit, 9 - s->filter.sharpness);
2070     }
2071     interior_limit = FFMAX(interior_limit, 1);
2072
2073     f->filter_level = filter_level;
2074     f->inner_limit = interior_limit;
2075     f->inner_filter = is_vp7 || !mb->skip || mb->mode == MODE_I4x4 ||
2076                       mb->mode == VP8_MVMODE_SPLIT;
2077 }
2078
2079 static av_always_inline
2080 void filter_mb(VP8Context *s, uint8_t *dst[3], VP8FilterStrength *f,
2081                int mb_x, int mb_y, int is_vp7)
2082 {
2083     int mbedge_lim, bedge_lim_y, bedge_lim_uv, hev_thresh;
2084     int filter_level = f->filter_level;
2085     int inner_limit = f->inner_limit;
2086     int inner_filter = f->inner_filter;
2087     int linesize = s->linesize;
2088     int uvlinesize = s->uvlinesize;
2089     static const uint8_t hev_thresh_lut[2][64] = {
2090         { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
2091           2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2092           3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
2093           3, 3, 3, 3 },
2094         { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
2095           1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2096           2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2097           2, 2, 2, 2 }
2098     };
2099
2100     if (!filter_level)
2101         return;
2102
2103     if (is_vp7) {
2104         bedge_lim_y  = filter_level;
2105         bedge_lim_uv = filter_level * 2;
2106         mbedge_lim   = filter_level + 2;
2107     } else {
2108         bedge_lim_y  =
2109         bedge_lim_uv = filter_level * 2 + inner_limit;
2110         mbedge_lim   = bedge_lim_y + 4;
2111     }
2112
2113     hev_thresh = hev_thresh_lut[s->keyframe][filter_level];
2114
2115     if (mb_x) {
2116         s->vp8dsp.vp8_h_loop_filter16y(dst[0], linesize,
2117                                        mbedge_lim, inner_limit, hev_thresh);
2118         s->vp8dsp.vp8_h_loop_filter8uv(dst[1], dst[2], uvlinesize,
2119                                        mbedge_lim, inner_limit, hev_thresh);
2120     }
2121
2122 #define H_LOOP_FILTER_16Y_INNER(cond)                                         \
2123     if (cond && inner_filter) {                                               \
2124         s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0] +  4, linesize,           \
2125                                              bedge_lim_y, inner_limit,        \
2126                                              hev_thresh);                     \
2127         s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0] +  8, linesize,           \
2128                                              bedge_lim_y, inner_limit,        \
2129                                              hev_thresh);                     \
2130         s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0] + 12, linesize,           \
2131                                              bedge_lim_y, inner_limit,        \
2132                                              hev_thresh);                     \
2133         s->vp8dsp.vp8_h_loop_filter8uv_inner(dst[1] +  4, dst[2] + 4,         \
2134                                              uvlinesize,  bedge_lim_uv,       \
2135                                              inner_limit, hev_thresh);        \
2136     }
2137
2138     H_LOOP_FILTER_16Y_INNER(!is_vp7)
2139
2140     if (mb_y) {
2141         s->vp8dsp.vp8_v_loop_filter16y(dst[0], linesize,
2142                                        mbedge_lim, inner_limit, hev_thresh);
2143         s->vp8dsp.vp8_v_loop_filter8uv(dst[1], dst[2], uvlinesize,
2144                                        mbedge_lim, inner_limit, hev_thresh);
2145     }
2146
2147     if (inner_filter) {
2148         s->vp8dsp.vp8_v_loop_filter16y_inner(dst[0] +  4 * linesize,
2149                                              linesize, bedge_lim_y,
2150                                              inner_limit, hev_thresh);
2151         s->vp8dsp.vp8_v_loop_filter16y_inner(dst[0] +  8 * linesize,
2152                                              linesize, bedge_lim_y,
2153                                              inner_limit, hev_thresh);
2154         s->vp8dsp.vp8_v_loop_filter16y_inner(dst[0] + 12 * linesize,
2155                                              linesize, bedge_lim_y,
2156                                              inner_limit, hev_thresh);
2157         s->vp8dsp.vp8_v_loop_filter8uv_inner(dst[1] +  4 * uvlinesize,
2158                                              dst[2] +  4 * uvlinesize,
2159                                              uvlinesize, bedge_lim_uv,
2160                                              inner_limit, hev_thresh);
2161     }
2162
2163     H_LOOP_FILTER_16Y_INNER(is_vp7)
2164 }
2165
2166 static av_always_inline
2167 void filter_mb_simple(VP8Context *s, uint8_t *dst, VP8FilterStrength *f,
2168                       int mb_x, int mb_y)
2169 {
2170     int mbedge_lim, bedge_lim;
2171     int filter_level = f->filter_level;
2172     int inner_limit  = f->inner_limit;
2173     int inner_filter = f->inner_filter;
2174     int linesize     = s->linesize;
2175
2176     if (!filter_level)
2177         return;
2178
2179     bedge_lim  = 2 * filter_level + inner_limit;
2180     mbedge_lim = bedge_lim + 4;
2181
2182     if (mb_x)
2183         s->vp8dsp.vp8_h_loop_filter_simple(dst, linesize, mbedge_lim);
2184     if (inner_filter) {
2185         s->vp8dsp.vp8_h_loop_filter_simple(dst +  4, linesize, bedge_lim);
2186         s->vp8dsp.vp8_h_loop_filter_simple(dst +  8, linesize, bedge_lim);
2187         s->vp8dsp.vp8_h_loop_filter_simple(dst + 12, linesize, bedge_lim);
2188     }
2189
2190     if (mb_y)
2191         s->vp8dsp.vp8_v_loop_filter_simple(dst, linesize, mbedge_lim);
2192     if (inner_filter) {
2193         s->vp8dsp.vp8_v_loop_filter_simple(dst +  4 * linesize, linesize, bedge_lim);
2194         s->vp8dsp.vp8_v_loop_filter_simple(dst +  8 * linesize, linesize, bedge_lim);
2195         s->vp8dsp.vp8_v_loop_filter_simple(dst + 12 * linesize, linesize, bedge_lim);
2196     }
2197 }
2198
2199 #define MARGIN (16 << 2)
2200 static av_always_inline
2201 void vp78_decode_mv_mb_modes(AVCodecContext *avctx, VP8Frame *curframe,
2202                                     VP8Frame *prev_frame, int is_vp7)
2203 {
2204     VP8Context *s = avctx->priv_data;
2205     int mb_x, mb_y;
2206
2207     s->mv_min.y = -MARGIN;
2208     s->mv_max.y = ((s->mb_height - 1) << 6) + MARGIN;
2209     for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
2210         VP8Macroblock *mb = s->macroblocks_base +
2211                             ((s->mb_width + 1) * (mb_y + 1) + 1);
2212         int mb_xy = mb_y * s->mb_width;
2213
2214         AV_WN32A(s->intra4x4_pred_mode_left, DC_PRED * 0x01010101);
2215
2216         s->mv_min.x = -MARGIN;
2217         s->mv_max.x = ((s->mb_width - 1) << 6) + MARGIN;
2218         for (mb_x = 0; mb_x < s->mb_width; mb_x++, mb_xy++, mb++) {
2219             if (mb_y == 0)
2220                 AV_WN32A((mb - s->mb_width - 1)->intra4x4_pred_mode_top,
2221                          DC_PRED * 0x01010101);
2222             decode_mb_mode(s, mb, mb_x, mb_y, curframe->seg_map->data + mb_xy,
2223                            prev_frame && prev_frame->seg_map ?
2224                            prev_frame->seg_map->data + mb_xy : NULL, 1, is_vp7);
2225             s->mv_min.x -= 64;
2226             s->mv_max.x -= 64;
2227         }
2228         s->mv_min.y -= 64;
2229         s->mv_max.y -= 64;
2230     }
2231 }
2232
2233 static void vp7_decode_mv_mb_modes(AVCodecContext *avctx, VP8Frame *cur_frame,
2234                                    VP8Frame *prev_frame)
2235 {
2236     vp78_decode_mv_mb_modes(avctx, cur_frame, prev_frame, IS_VP7);
2237 }
2238
2239 static void vp8_decode_mv_mb_modes(AVCodecContext *avctx, VP8Frame *cur_frame,
2240                                    VP8Frame *prev_frame)
2241 {
2242     vp78_decode_mv_mb_modes(avctx, cur_frame, prev_frame, IS_VP8);
2243 }
2244
2245 #if HAVE_THREADS
2246 #define check_thread_pos(td, otd, mb_x_check, mb_y_check)                     \
2247     do {                                                                      \
2248         int tmp = (mb_y_check << 16) | (mb_x_check & 0xFFFF);                 \
2249         if (otd->thread_mb_pos < tmp) {                                       \
2250             pthread_mutex_lock(&otd->lock);                                   \
2251             td->wait_mb_pos = tmp;                                            \
2252             do {                                                              \
2253                 if (otd->thread_mb_pos >= tmp)                                \
2254                     break;                                                    \
2255                 pthread_cond_wait(&otd->cond, &otd->lock);                    \
2256             } while (1);                                                      \
2257             td->wait_mb_pos = INT_MAX;                                        \
2258             pthread_mutex_unlock(&otd->lock);                                 \
2259         }                                                                     \
2260     } while (0)
2261
2262 #define update_pos(td, mb_y, mb_x)                                            \
2263     do {                                                                      \
2264         int pos              = (mb_y << 16) | (mb_x & 0xFFFF);                \
2265         int sliced_threading = (avctx->active_thread_type == FF_THREAD_SLICE) && \
2266                                (num_jobs > 1);                                \
2267         int is_null          = !next_td || !prev_td;                          \
2268         int pos_check        = (is_null) ? 1                                  \
2269                                          : (next_td != td &&                  \
2270                                             pos >= next_td->wait_mb_pos) ||   \
2271                                            (prev_td != td &&                  \
2272                                             pos >= prev_td->wait_mb_pos);     \
2273         td->thread_mb_pos = pos;                                              \
2274         if (sliced_threading && pos_check) {                                  \
2275             pthread_mutex_lock(&td->lock);                                    \
2276             pthread_cond_broadcast(&td->cond);                                \
2277             pthread_mutex_unlock(&td->lock);                                  \
2278         }                                                                     \
2279     } while (0)
2280 #else
2281 #define check_thread_pos(td, otd, mb_x_check, mb_y_check) while(0)
2282 #define update_pos(td, mb_y, mb_x) while(0)
2283 #endif
2284
2285 static av_always_inline int decode_mb_row_no_filter(AVCodecContext *avctx, void *tdata,
2286                                         int jobnr, int threadnr, int is_vp7)
2287 {
2288     VP8Context *s = avctx->priv_data;
2289     VP8ThreadData *prev_td, *next_td, *td = &s->thread_data[threadnr];
2290     int mb_y = td->thread_mb_pos >> 16;
2291     int mb_x, mb_xy = mb_y * s->mb_width;
2292     int num_jobs = s->num_jobs;
2293     VP8Frame *curframe = s->curframe, *prev_frame = s->prev_frame;
2294     VP56RangeCoder *c  = &s->coeff_partition[mb_y & (s->num_coeff_partitions - 1)];
2295     VP8Macroblock *mb;
2296     uint8_t *dst[3] = {
2297         curframe->tf.f->data[0] + 16 * mb_y * s->linesize,
2298         curframe->tf.f->data[1] +  8 * mb_y * s->uvlinesize,
2299         curframe->tf.f->data[2] +  8 * mb_y * s->uvlinesize
2300     };
2301
2302     if (c->end <= c->buffer && c->bits >= 0)
2303          return AVERROR_INVALIDDATA;
2304
2305     if (mb_y == 0)
2306         prev_td = td;
2307     else
2308         prev_td = &s->thread_data[(jobnr + num_jobs - 1) % num_jobs];
2309     if (mb_y == s->mb_height - 1)
2310         next_td = td;
2311     else
2312         next_td = &s->thread_data[(jobnr + 1) % num_jobs];
2313     if (s->mb_layout == 1)
2314         mb = s->macroblocks_base + ((s->mb_width + 1) * (mb_y + 1) + 1);
2315     else {
2316         // Make sure the previous frame has read its segmentation map,
2317         // if we re-use the same map.
2318         if (prev_frame && s->segmentation.enabled &&
2319             !s->segmentation.update_map)
2320             ff_thread_await_progress(&prev_frame->tf, mb_y, 0);
2321         mb = s->macroblocks + (s->mb_height - mb_y - 1) * 2;
2322         memset(mb - 1, 0, sizeof(*mb)); // zero left macroblock
2323         AV_WN32A(s->intra4x4_pred_mode_left, DC_PRED * 0x01010101);
2324     }
2325
2326     if (!is_vp7 || mb_y == 0)
2327         memset(td->left_nnz, 0, sizeof(td->left_nnz));
2328
2329     s->mv_min.x = -MARGIN;
2330     s->mv_max.x = ((s->mb_width - 1) << 6) + MARGIN;
2331
2332     for (mb_x = 0; mb_x < s->mb_width; mb_x++, mb_xy++, mb++) {
2333         if (c->end <= c->buffer && c->bits >= 0)
2334             return AVERROR_INVALIDDATA;
2335         // Wait for previous thread to read mb_x+2, and reach mb_y-1.
2336         if (prev_td != td) {
2337             if (threadnr != 0) {
2338                 check_thread_pos(td, prev_td,
2339                                  mb_x + (is_vp7 ? 2 : 1),
2340                                  mb_y - (is_vp7 ? 2 : 1));
2341             } else {
2342                 check_thread_pos(td, prev_td,
2343                                  mb_x + (is_vp7 ? 2 : 1) + s->mb_width + 3,
2344                                  mb_y - (is_vp7 ? 2 : 1));
2345             }
2346         }
2347
2348         s->vdsp.prefetch(dst[0] + (mb_x & 3) * 4 * s->linesize + 64,
2349                          s->linesize, 4);
2350         s->vdsp.prefetch(dst[1] + (mb_x & 7) * s->uvlinesize + 64,
2351                          dst[2] - dst[1], 2);
2352
2353         if (!s->mb_layout)
2354             decode_mb_mode(s, mb, mb_x, mb_y, curframe->seg_map->data + mb_xy,
2355                            prev_frame && prev_frame->seg_map ?
2356                            prev_frame->seg_map->data + mb_xy : NULL, 0, is_vp7);
2357
2358         prefetch_motion(s, mb, mb_x, mb_y, mb_xy, VP56_FRAME_PREVIOUS);
2359
2360         if (!mb->skip)
2361             decode_mb_coeffs(s, td, c, mb, s->top_nnz[mb_x], td->left_nnz, is_vp7);
2362
2363         if (mb->mode <= MODE_I4x4)
2364             intra_predict(s, td, dst, mb, mb_x, mb_y, is_vp7);
2365         else
2366             inter_predict(s, td, dst, mb, mb_x, mb_y);
2367
2368         prefetch_motion(s, mb, mb_x, mb_y, mb_xy, VP56_FRAME_GOLDEN);
2369
2370         if (!mb->skip) {
2371             idct_mb(s, td, dst, mb);
2372         } else {
2373             AV_ZERO64(td->left_nnz);
2374             AV_WN64(s->top_nnz[mb_x], 0);   // array of 9, so unaligned
2375
2376             /* Reset DC block predictors if they would exist
2377              * if the mb had coefficients */
2378             if (mb->mode != MODE_I4x4 && mb->mode != VP8_MVMODE_SPLIT) {
2379                 td->left_nnz[8]     = 0;
2380                 s->top_nnz[mb_x][8] = 0;
2381             }
2382         }
2383
2384         if (s->deblock_filter)
2385             filter_level_for_mb(s, mb, &td->filter_strength[mb_x], is_vp7);
2386
2387         if (s->deblock_filter && num_jobs != 1 && threadnr == num_jobs - 1) {
2388             if (s->filter.simple)
2389                 backup_mb_border(s->top_border[mb_x + 1], dst[0],
2390                                  NULL, NULL, s->linesize, 0, 1);
2391             else
2392                 backup_mb_border(s->top_border[mb_x + 1], dst[0],
2393                                  dst[1], dst[2], s->linesize, s->uvlinesize, 0);
2394         }
2395
2396         prefetch_motion(s, mb, mb_x, mb_y, mb_xy, VP56_FRAME_GOLDEN2);
2397
2398         dst[0]      += 16;
2399         dst[1]      += 8;
2400         dst[2]      += 8;
2401         s->mv_min.x -= 64;
2402         s->mv_max.x -= 64;
2403
2404         if (mb_x == s->mb_width + 1) {
2405             update_pos(td, mb_y, s->mb_width + 3);
2406         } else {
2407             update_pos(td, mb_y, mb_x);
2408         }
2409     }
2410     return 0;
2411 }
2412
2413 static int vp7_decode_mb_row_no_filter(AVCodecContext *avctx, void *tdata,
2414                                         int jobnr, int threadnr)
2415 {
2416     return decode_mb_row_no_filter(avctx, tdata, jobnr, threadnr, 1);
2417 }
2418
2419 static int vp8_decode_mb_row_no_filter(AVCodecContext *avctx, void *tdata,
2420                                         int jobnr, int threadnr)
2421 {
2422     return decode_mb_row_no_filter(avctx, tdata, jobnr, threadnr, 0);
2423 }
2424
2425 static av_always_inline void filter_mb_row(AVCodecContext *avctx, void *tdata,
2426                               int jobnr, int threadnr, int is_vp7)
2427 {
2428     VP8Context *s = avctx->priv_data;
2429     VP8ThreadData *td = &s->thread_data[threadnr];
2430     int mb_x, mb_y = td->thread_mb_pos >> 16, num_jobs = s->num_jobs;
2431     AVFrame *curframe = s->curframe->tf.f;
2432     VP8Macroblock *mb;
2433     VP8ThreadData *prev_td, *next_td;
2434     uint8_t *dst[3] = {
2435         curframe->data[0] + 16 * mb_y * s->linesize,
2436         curframe->data[1] +  8 * mb_y * s->uvlinesize,
2437         curframe->data[2] +  8 * mb_y * s->uvlinesize
2438     };
2439
2440     if (s->mb_layout == 1)
2441         mb = s->macroblocks_base + ((s->mb_width + 1) * (mb_y + 1) + 1);
2442     else
2443         mb = s->macroblocks + (s->mb_height - mb_y - 1) * 2;
2444
2445     if (mb_y == 0)
2446         prev_td = td;
2447     else
2448         prev_td = &s->thread_data[(jobnr + num_jobs - 1) % num_jobs];
2449     if (mb_y == s->mb_height - 1)
2450         next_td = td;
2451     else
2452         next_td = &s->thread_data[(jobnr + 1) % num_jobs];
2453
2454     for (mb_x = 0; mb_x < s->mb_width; mb_x++, mb++) {
2455         VP8FilterStrength *f = &td->filter_strength[mb_x];
2456         if (prev_td != td)
2457             check_thread_pos(td, prev_td,
2458                              (mb_x + 1) + (s->mb_width + 3), mb_y - 1);
2459         if (next_td != td)
2460             if (next_td != &s->thread_data[0])
2461                 check_thread_pos(td, next_td, mb_x + 1, mb_y + 1);
2462
2463         if (num_jobs == 1) {
2464             if (s->filter.simple)
2465                 backup_mb_border(s->top_border[mb_x + 1], dst[0],
2466                                  NULL, NULL, s->linesize, 0, 1);
2467             else
2468                 backup_mb_border(s->top_border[mb_x + 1], dst[0],
2469                                  dst[1], dst[2], s->linesize, s->uvlinesize, 0);
2470         }
2471
2472         if (s->filter.simple)
2473             filter_mb_simple(s, dst[0], f, mb_x, mb_y);
2474         else
2475             filter_mb(s, dst, f, mb_x, mb_y, is_vp7);
2476         dst[0] += 16;
2477         dst[1] += 8;
2478         dst[2] += 8;
2479
2480         update_pos(td, mb_y, (s->mb_width + 3) + mb_x);
2481     }
2482 }
2483
2484 static void vp7_filter_mb_row(AVCodecContext *avctx, void *tdata,
2485                               int jobnr, int threadnr)
2486 {
2487     filter_mb_row(avctx, tdata, jobnr, threadnr, 1);
2488 }
2489
2490 static void vp8_filter_mb_row(AVCodecContext *avctx, void *tdata,
2491                               int jobnr, int threadnr)
2492 {
2493     filter_mb_row(avctx, tdata, jobnr, threadnr, 0);
2494 }
2495
2496 static av_always_inline
2497 int vp78_decode_mb_row_sliced(AVCodecContext *avctx, void *tdata, int jobnr,
2498                               int threadnr, int is_vp7)
2499 {
2500     VP8Context *s = avctx->priv_data;
2501     VP8ThreadData *td = &s->thread_data[jobnr];
2502     VP8ThreadData *next_td = NULL, *prev_td = NULL;
2503     VP8Frame *curframe = s->curframe;
2504     int mb_y, num_jobs = s->num_jobs;
2505     int ret;
2506
2507     td->thread_nr = threadnr;
2508     for (mb_y = jobnr; mb_y < s->mb_height; mb_y += num_jobs) {
2509         td->thread_mb_pos = mb_y << 16;
2510         ret = s->decode_mb_row_no_filter(avctx, tdata, jobnr, threadnr);
2511         if (ret < 0)
2512             return ret;
2513         if (s->deblock_filter)
2514             s->filter_mb_row(avctx, tdata, jobnr, threadnr);
2515         update_pos(td, mb_y, INT_MAX & 0xFFFF);
2516
2517         s->mv_min.y -= 64;
2518         s->mv_max.y -= 64;
2519
2520         if (avctx->active_thread_type == FF_THREAD_FRAME)
2521             ff_thread_report_progress(&curframe->tf, mb_y, 0);
2522     }
2523
2524     return 0;
2525 }
2526
2527 static int vp7_decode_mb_row_sliced(AVCodecContext *avctx, void *tdata,
2528                                     int jobnr, int threadnr)
2529 {
2530     return vp78_decode_mb_row_sliced(avctx, tdata, jobnr, threadnr, IS_VP7);
2531 }
2532
2533 static int vp8_decode_mb_row_sliced(AVCodecContext *avctx, void *tdata,
2534                                     int jobnr, int threadnr)
2535 {
2536     return vp78_decode_mb_row_sliced(avctx, tdata, jobnr, threadnr, IS_VP8);
2537 }
2538
2539
2540 static av_always_inline
2541 int vp78_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
2542                       AVPacket *avpkt, int is_vp7)
2543 {
2544     VP8Context *s = avctx->priv_data;
2545     int ret, i, referenced, num_jobs;
2546     enum AVDiscard skip_thresh;
2547     VP8Frame *av_uninit(curframe), *prev_frame;
2548
2549     if (is_vp7)
2550         ret = vp7_decode_frame_header(s, avpkt->data, avpkt->size);
2551     else
2552         ret = vp8_decode_frame_header(s, avpkt->data, avpkt->size);
2553
2554     if (ret < 0)
2555         goto err;
2556
2557     prev_frame = s->framep[VP56_FRAME_CURRENT];
2558
2559     referenced = s->update_last || s->update_golden == VP56_FRAME_CURRENT ||
2560                  s->update_altref == VP56_FRAME_CURRENT;
2561
2562     skip_thresh = !referenced ? AVDISCARD_NONREF
2563                               : !s->keyframe ? AVDISCARD_NONKEY
2564                                              : AVDISCARD_ALL;
2565
2566     if (avctx->skip_frame >= skip_thresh) {
2567         s->invisible = 1;
2568         memcpy(&s->next_framep[0], &s->framep[0], sizeof(s->framep[0]) * 4);
2569         goto skip_decode;
2570     }
2571     s->deblock_filter = s->filter.level && avctx->skip_loop_filter < skip_thresh;
2572
2573     // release no longer referenced frames
2574     for (i = 0; i < 5; i++)
2575         if (s->frames[i].tf.f->data[0] &&
2576             &s->frames[i] != prev_frame &&
2577             &s->frames[i] != s->framep[VP56_FRAME_PREVIOUS] &&
2578             &s->frames[i] != s->framep[VP56_FRAME_GOLDEN]   &&
2579             &s->frames[i] != s->framep[VP56_FRAME_GOLDEN2])
2580             vp8_release_frame(s, &s->frames[i]);
2581
2582     curframe = s->framep[VP56_FRAME_CURRENT] = vp8_find_free_buffer(s);
2583
2584     if (!s->colorspace)
2585         avctx->colorspace = AVCOL_SPC_BT470BG;
2586     if (s->fullrange)
2587         avctx->color_range = AVCOL_RANGE_JPEG;
2588     else
2589         avctx->color_range = AVCOL_RANGE_MPEG;
2590
2591     /* Given that arithmetic probabilities are updated every frame, it's quite
2592      * likely that the values we have on a random interframe are complete
2593      * junk if we didn't start decode on a keyframe. So just don't display
2594      * anything rather than junk. */
2595     if (!s->keyframe && (!s->framep[VP56_FRAME_PREVIOUS] ||
2596                          !s->framep[VP56_FRAME_GOLDEN]   ||
2597                          !s->framep[VP56_FRAME_GOLDEN2])) {
2598         av_log(avctx, AV_LOG_WARNING,
2599                "Discarding interframe without a prior keyframe!\n");
2600         ret = AVERROR_INVALIDDATA;
2601         goto err;
2602     }
2603
2604     curframe->tf.f->key_frame = s->keyframe;
2605     curframe->tf.f->pict_type = s->keyframe ? AV_PICTURE_TYPE_I
2606                                             : AV_PICTURE_TYPE_P;
2607     if ((ret = vp8_alloc_frame(s, curframe, referenced)) < 0)
2608         goto err;
2609
2610     // check if golden and altref are swapped
2611     if (s->update_altref != VP56_FRAME_NONE)
2612         s->next_framep[VP56_FRAME_GOLDEN2] = s->framep[s->update_altref];
2613     else
2614         s->next_framep[VP56_FRAME_GOLDEN2] = s->framep[VP56_FRAME_GOLDEN2];
2615
2616     if (s->update_golden != VP56_FRAME_NONE)
2617         s->next_framep[VP56_FRAME_GOLDEN] = s->framep[s->update_golden];
2618     else
2619         s->next_framep[VP56_FRAME_GOLDEN] = s->framep[VP56_FRAME_GOLDEN];
2620
2621     if (s->update_last)
2622         s->next_framep[VP56_FRAME_PREVIOUS] = curframe;
2623     else
2624         s->next_framep[VP56_FRAME_PREVIOUS] = s->framep[VP56_FRAME_PREVIOUS];
2625
2626     s->next_framep[VP56_FRAME_CURRENT] = curframe;
2627
2628     if (avctx->codec->update_thread_context)
2629         ff_thread_finish_setup(avctx);
2630
2631     s->linesize   = curframe->tf.f->linesize[0];
2632     s->uvlinesize = curframe->tf.f->linesize[1];
2633
2634     memset(s->top_nnz, 0, s->mb_width * sizeof(*s->top_nnz));
2635     /* Zero macroblock structures for top/top-left prediction
2636      * from outside the frame. */
2637     if (!s->mb_layout)
2638         memset(s->macroblocks + s->mb_height * 2 - 1, 0,
2639                (s->mb_width + 1) * sizeof(*s->macroblocks));
2640     if (!s->mb_layout && s->keyframe)
2641         memset(s->intra4x4_pred_mode_top, DC_PRED, s->mb_width * 4);
2642
2643     memset(s->ref_count, 0, sizeof(s->ref_count));
2644
2645     if (s->mb_layout == 1) {
2646         // Make sure the previous frame has read its segmentation map,
2647         // if we re-use the same map.
2648         if (prev_frame && s->segmentation.enabled &&
2649             !s->segmentation.update_map)
2650             ff_thread_await_progress(&prev_frame->tf, 1, 0);
2651         if (is_vp7)
2652             vp7_decode_mv_mb_modes(avctx, curframe, prev_frame);
2653         else
2654             vp8_decode_mv_mb_modes(avctx, curframe, prev_frame);
2655     }
2656
2657     if (avctx->active_thread_type == FF_THREAD_FRAME)
2658         num_jobs = 1;
2659     else
2660         num_jobs = FFMIN(s->num_coeff_partitions, avctx->thread_count);
2661     s->num_jobs   = num_jobs;
2662     s->curframe   = curframe;
2663     s->prev_frame = prev_frame;
2664     s->mv_min.y   = -MARGIN;
2665     s->mv_max.y   = ((s->mb_height - 1) << 6) + MARGIN;
2666     for (i = 0; i < MAX_THREADS; i++) {
2667         s->thread_data[i].thread_mb_pos = 0;
2668         s->thread_data[i].wait_mb_pos   = INT_MAX;
2669     }
2670     if (is_vp7)
2671         avctx->execute2(avctx, vp7_decode_mb_row_sliced, s->thread_data, NULL,
2672                         num_jobs);
2673     else
2674         avctx->execute2(avctx, vp8_decode_mb_row_sliced, s->thread_data, NULL,
2675                         num_jobs);
2676
2677     ff_thread_report_progress(&curframe->tf, INT_MAX, 0);
2678     memcpy(&s->framep[0], &s->next_framep[0], sizeof(s->framep[0]) * 4);
2679
2680 skip_decode:
2681     // if future frames don't use the updated probabilities,
2682     // reset them to the values we saved
2683     if (!s->update_probabilities)
2684         s->prob[0] = s->prob[1];
2685
2686     if (!s->invisible) {
2687         if ((ret = av_frame_ref(data, curframe->tf.f)) < 0)
2688             return ret;
2689         *got_frame = 1;
2690     }
2691
2692     return avpkt->size;
2693 err:
2694     memcpy(&s->next_framep[0], &s->framep[0], sizeof(s->framep[0]) * 4);
2695     return ret;
2696 }
2697
2698 int ff_vp8_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
2699                         AVPacket *avpkt)
2700 {
2701     return vp78_decode_frame(avctx, data, got_frame, avpkt, IS_VP8);
2702 }
2703
2704 #if CONFIG_VP7_DECODER
2705 static int vp7_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
2706                             AVPacket *avpkt)
2707 {
2708     return vp78_decode_frame(avctx, data, got_frame, avpkt, IS_VP7);
2709 }
2710 #endif /* CONFIG_VP7_DECODER */
2711
2712 av_cold int ff_vp8_decode_free(AVCodecContext *avctx)
2713 {
2714     VP8Context *s = avctx->priv_data;
2715     int i;
2716
2717     if (!s)
2718         return 0;
2719
2720     vp8_decode_flush_impl(avctx, 1);
2721     for (i = 0; i < FF_ARRAY_ELEMS(s->frames); i++)
2722         av_frame_free(&s->frames[i].tf.f);
2723
2724     return 0;
2725 }
2726
2727 static av_cold int vp8_init_frames(VP8Context *s)
2728 {
2729     int i;
2730     for (i = 0; i < FF_ARRAY_ELEMS(s->frames); i++) {
2731         s->frames[i].tf.f = av_frame_alloc();
2732         if (!s->frames[i].tf.f)
2733             return AVERROR(ENOMEM);
2734     }
2735     return 0;
2736 }
2737
2738 static av_always_inline
2739 int vp78_decode_init(AVCodecContext *avctx, int is_vp7)
2740 {
2741     VP8Context *s = avctx->priv_data;
2742     int ret;
2743
2744     s->avctx = avctx;
2745     s->vp7   = avctx->codec->id == AV_CODEC_ID_VP7;
2746     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
2747     avctx->internal->allocate_progress = 1;
2748
2749     ff_videodsp_init(&s->vdsp, 8);
2750
2751     ff_vp78dsp_init(&s->vp8dsp);
2752     if (CONFIG_VP7_DECODER && is_vp7) {
2753         ff_h264_pred_init(&s->hpc, AV_CODEC_ID_VP7, 8, 1);
2754         ff_vp7dsp_init(&s->vp8dsp);
2755         s->decode_mb_row_no_filter = vp7_decode_mb_row_no_filter;
2756         s->filter_mb_row           = vp7_filter_mb_row;
2757     } else if (CONFIG_VP8_DECODER && !is_vp7) {
2758         ff_h264_pred_init(&s->hpc, AV_CODEC_ID_VP8, 8, 1);
2759         ff_vp8dsp_init(&s->vp8dsp);
2760         s->decode_mb_row_no_filter = vp8_decode_mb_row_no_filter;
2761         s->filter_mb_row           = vp8_filter_mb_row;
2762     }
2763
2764     /* does not change for VP8 */
2765     memcpy(s->prob[0].scan, ff_zigzag_scan, sizeof(s->prob[0].scan));
2766
2767     if ((ret = vp8_init_frames(s)) < 0) {
2768         ff_vp8_decode_free(avctx);
2769         return ret;
2770     }
2771
2772     return 0;
2773 }
2774
2775 #if CONFIG_VP7_DECODER
2776 static int vp7_decode_init(AVCodecContext *avctx)
2777 {
2778     return vp78_decode_init(avctx, IS_VP7);
2779 }
2780 #endif /* CONFIG_VP7_DECODER */
2781
2782 av_cold int ff_vp8_decode_init(AVCodecContext *avctx)
2783 {
2784     return vp78_decode_init(avctx, IS_VP8);
2785 }
2786
2787 #if CONFIG_VP8_DECODER
2788 #if HAVE_THREADS
2789 static av_cold int vp8_decode_init_thread_copy(AVCodecContext *avctx)
2790 {
2791     VP8Context *s = avctx->priv_data;
2792     int ret;
2793
2794     s->avctx = avctx;
2795
2796     if ((ret = vp8_init_frames(s)) < 0) {
2797         ff_vp8_decode_free(avctx);
2798         return ret;
2799     }
2800
2801     return 0;
2802 }
2803
2804 #define REBASE(pic) ((pic) ? (pic) - &s_src->frames[0] + &s->frames[0] : NULL)
2805
2806 static int vp8_decode_update_thread_context(AVCodecContext *dst,
2807                                             const AVCodecContext *src)
2808 {
2809     VP8Context *s = dst->priv_data, *s_src = src->priv_data;
2810     int i;
2811
2812     if (s->macroblocks_base &&
2813         (s_src->mb_width != s->mb_width || s_src->mb_height != s->mb_height)) {
2814         free_buffers(s);
2815         s->mb_width  = s_src->mb_width;
2816         s->mb_height = s_src->mb_height;
2817     }
2818
2819     s->prob[0]      = s_src->prob[!s_src->update_probabilities];
2820     s->segmentation = s_src->segmentation;
2821     s->lf_delta     = s_src->lf_delta;
2822     memcpy(s->sign_bias, s_src->sign_bias, sizeof(s->sign_bias));
2823
2824     for (i = 0; i < FF_ARRAY_ELEMS(s_src->frames); i++) {
2825         if (s_src->frames[i].tf.f->data[0]) {
2826             int ret = vp8_ref_frame(s, &s->frames[i], &s_src->frames[i]);
2827             if (ret < 0)
2828                 return ret;
2829         }
2830     }
2831
2832     s->framep[0] = REBASE(s_src->next_framep[0]);
2833     s->framep[1] = REBASE(s_src->next_framep[1]);
2834     s->framep[2] = REBASE(s_src->next_framep[2]);
2835     s->framep[3] = REBASE(s_src->next_framep[3]);
2836
2837     return 0;
2838 }
2839 #endif /* HAVE_THREADS */
2840 #endif /* CONFIG_VP8_DECODER */
2841
2842 #if CONFIG_VP7_DECODER
2843 AVCodec ff_vp7_decoder = {
2844     .name                  = "vp7",
2845     .long_name             = NULL_IF_CONFIG_SMALL("On2 VP7"),
2846     .type                  = AVMEDIA_TYPE_VIDEO,
2847     .id                    = AV_CODEC_ID_VP7,
2848     .priv_data_size        = sizeof(VP8Context),
2849     .init                  = vp7_decode_init,
2850     .close                 = ff_vp8_decode_free,
2851     .decode                = vp7_decode_frame,
2852     .capabilities          = AV_CODEC_CAP_DR1,
2853     .flush                 = vp8_decode_flush,
2854 };
2855 #endif /* CONFIG_VP7_DECODER */
2856
2857 #if CONFIG_VP8_DECODER
2858 AVCodec ff_vp8_decoder = {
2859     .name                  = "vp8",
2860     .long_name             = NULL_IF_CONFIG_SMALL("On2 VP8"),
2861     .type                  = AVMEDIA_TYPE_VIDEO,
2862     .id                    = AV_CODEC_ID_VP8,
2863     .priv_data_size        = sizeof(VP8Context),
2864     .init                  = ff_vp8_decode_init,
2865     .close                 = ff_vp8_decode_free,
2866     .decode                = ff_vp8_decode_frame,
2867     .capabilities          = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS |
2868                              AV_CODEC_CAP_SLICE_THREADS,
2869     .flush                 = vp8_decode_flush,
2870     .init_thread_copy      = ONLY_IF_THREADS_ENABLED(vp8_decode_init_thread_copy),
2871     .update_thread_context = ONLY_IF_THREADS_ENABLED(vp8_decode_update_thread_context),
2872 };
2873 #endif /* CONFIG_VP7_DECODER */