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