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