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