FFmpeg
vp56.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2006 Aurelien Jacobs <aurel@gnuage.org>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * VP5 and VP6 compatible video decoder (common features)
24  */
25 
26 #include "libavutil/mem.h"
27 #include "avcodec.h"
28 #include "bytestream.h"
29 #include "decode.h"
30 #include "h264chroma.h"
31 #include "vp56.h"
32 #include "vp56data.h"
33 #include "vpx_rac.h"
34 
35 
36 void ff_vp56_init_dequant(VP56Context *s, int quantizer)
37 {
38  if (s->quantizer != quantizer)
39  ff_vp3dsp_set_bounding_values(s->bounding_values_array, ff_vp56_filter_threshold[quantizer]);
40  s->quantizer = quantizer;
41  s->dequant_dc = ff_vp56_dc_dequant[quantizer] << 2;
42  s->dequant_ac = ff_vp56_ac_dequant[quantizer] << 2;
43 }
44 
45 static int vp56_get_vectors_predictors(VP56Context *s, int row, int col,
47 {
48  int nb_pred = 0;
49  VP56mv vect[2] = {{0,0}, {0,0}};
50  int pos, offset;
51  VP56mv mvp;
52 
53  for (pos=0; pos<12; pos++) {
56  if (mvp.x < 0 || mvp.x >= s->mb_width ||
57  mvp.y < 0 || mvp.y >= s->mb_height)
58  continue;
59  offset = mvp.x + s->mb_width*mvp.y;
60 
61  if (ff_vp56_reference_frame[s->macroblocks[offset].type] != ref_frame)
62  continue;
63  if ((s->macroblocks[offset].mv.x == vect[0].x &&
64  s->macroblocks[offset].mv.y == vect[0].y) ||
65  (s->macroblocks[offset].mv.x == 0 &&
66  s->macroblocks[offset].mv.y == 0))
67  continue;
68 
69  vect[nb_pred++] = s->macroblocks[offset].mv;
70  if (nb_pred > 1) {
71  nb_pred = -1;
72  break;
73  }
74  s->vector_candidate_pos = pos;
75  }
76 
77  s->vector_candidate[0] = vect[0];
78  s->vector_candidate[1] = vect[1];
79 
80  return nb_pred+1;
81 }
82 
83 static void vp56_parse_mb_type_models(VP56Context *s)
84 {
85  VPXRangeCoder *c = &s->c;
86  VP56Model *model = s->modelp;
87  int i, ctx, type;
88 
89  for (ctx=0; ctx<3; ctx++) {
90  if (vpx_rac_get_prob_branchy(c, 174)) {
91  int idx = vp56_rac_gets(c, 4);
92  memcpy(model->mb_types_stats[ctx],
94  sizeof(model->mb_types_stats[ctx]));
95  }
96  if (vpx_rac_get_prob_branchy(c, 254)) {
97  for (type=0; type<10; type++) {
98  for(i=0; i<2; i++) {
99  if (vpx_rac_get_prob_branchy(c, 205)) {
100  int delta, sign = vpx_rac_get(c);
101 
104  if (!delta)
105  delta = 4 * vp56_rac_gets(c, 7);
106  model->mb_types_stats[ctx][type][i] += (delta ^ -sign) + sign;
107  }
108  }
109  }
110  }
111  }
112 
113  /* compute MB type probability tables based on previous MB type */
114  for (ctx=0; ctx<3; ctx++) {
115  int p[10];
116 
117  for (type=0; type<10; type++)
118  p[type] = 100 * model->mb_types_stats[ctx][type][1];
119 
120  for (type=0; type<10; type++) {
121  int p02, p34, p0234, p17, p56, p89, p5689, p156789;
122 
123  /* conservative MB type probability */
124  model->mb_type[ctx][type][0] = 255 - (255 * model->mb_types_stats[ctx][type][0]) / (1 + model->mb_types_stats[ctx][type][0] + model->mb_types_stats[ctx][type][1]);
125 
126  p[type] = 0; /* same MB type => weight is null */
127 
128  /* binary tree parsing probabilities */
129  p02 = p[0] + p[2];
130  p34 = p[3] + p[4];
131  p0234 = p02 + p34;
132  p17 = p[1] + p[7];
133  p56 = p[5] + p[6];
134  p89 = p[8] + p[9];
135  p5689 = p56 + p89;
136  p156789 = p17 + p5689;
137 
138  model->mb_type[ctx][type][1] = 1 + 255 * p0234/(1+p0234+p156789);
139  model->mb_type[ctx][type][2] = 1 + 255 * p02 / (1+p0234);
140  model->mb_type[ctx][type][3] = 1 + 255 * p17 / (1+p156789);
141  model->mb_type[ctx][type][4] = 1 + 255 * p[0] / (1+p02);
142  model->mb_type[ctx][type][5] = 1 + 255 * p[3] / (1+p34);
143  model->mb_type[ctx][type][6] = 1 + 255 * p[1] / (1+p17);
144  model->mb_type[ctx][type][7] = 1 + 255 * p56 / (1+p5689);
145  model->mb_type[ctx][type][8] = 1 + 255 * p[5] / (1+p56);
146  model->mb_type[ctx][type][9] = 1 + 255 * p[8] / (1+p89);
147 
148  /* restore initial value */
149  p[type] = 100 * model->mb_types_stats[ctx][type][1];
150  }
151  }
152 }
153 
154 static VP56mb vp56_parse_mb_type(VP56Context *s,
155  VP56mb prev_type, int ctx)
156 {
157  uint8_t *mb_type_model = s->modelp->mb_type[ctx][prev_type];
158  VPXRangeCoder *c = &s->c;
159 
160  if (vpx_rac_get_prob_branchy(c, mb_type_model[0]))
161  return prev_type;
162  else
163  return vp56_rac_get_tree(c, ff_vp56_pmbt_tree, mb_type_model);
164 }
165 
166 static void vp56_decode_4mv(VP56Context *s, int row, int col)
167 {
168  VP56mv mv = {0,0};
169  int type[4];
170  int b;
171 
172  /* parse each block type */
173  for (b=0; b<4; b++) {
174  type[b] = vp56_rac_gets(&s->c, 2);
175  if (type[b])
176  type[b]++; /* only returns 0, 2, 3 or 4 (all INTER_PF) */
177  }
178 
179  /* get vectors */
180  for (b=0; b<4; b++) {
181  switch (type[b]) {
183  s->mv[b] = (VP56mv) {0,0};
184  break;
186  s->parse_vector_adjustment(s, &s->mv[b]);
187  break;
188  case VP56_MB_INTER_V1_PF:
189  s->mv[b] = s->vector_candidate[0];
190  break;
191  case VP56_MB_INTER_V2_PF:
192  s->mv[b] = s->vector_candidate[1];
193  break;
194  }
195  mv.x += s->mv[b].x;
196  mv.y += s->mv[b].y;
197  }
198 
199  /* this is the one selected for the whole MB for prediction */
200  s->macroblocks[row * s->mb_width + col].mv = s->mv[3];
201 
202  /* chroma vectors are average luma vectors */
203  s->mv[4].x = s->mv[5].x = RSHIFT(mv.x,2);
204  s->mv[4].y = s->mv[5].y = RSHIFT(mv.y,2);
205 }
206 
207 static VP56mb vp56_decode_mv(VP56Context *s, int row, int col)
208 {
209  VP56mv *mv, vect = {0,0};
210  int ctx, b;
211 
213  s->mb_type = vp56_parse_mb_type(s, s->mb_type, ctx);
214  s->macroblocks[row * s->mb_width + col].type = s->mb_type;
215 
216  switch (s->mb_type) {
217  case VP56_MB_INTER_V1_PF:
218  mv = &s->vector_candidate[0];
219  break;
220 
221  case VP56_MB_INTER_V2_PF:
222  mv = &s->vector_candidate[1];
223  break;
224 
225  case VP56_MB_INTER_V1_GF:
227  mv = &s->vector_candidate[0];
228  break;
229 
230  case VP56_MB_INTER_V2_GF:
232  mv = &s->vector_candidate[1];
233  break;
234 
236  s->parse_vector_adjustment(s, &vect);
237  mv = &vect;
238  break;
239 
242  s->parse_vector_adjustment(s, &vect);
243  mv = &vect;
244  break;
245 
246  case VP56_MB_INTER_4V:
247  vp56_decode_4mv(s, row, col);
248  return s->mb_type;
249 
250  default:
251  mv = &vect;
252  break;
253  }
254 
255  s->macroblocks[row*s->mb_width + col].mv = *mv;
256 
257  /* same vector for all blocks */
258  for (b=0; b<6; b++)
259  s->mv[b] = *mv;
260 
261  return s->mb_type;
262 }
263 
264 static VP56mb vp56_conceal_mv(VP56Context *s, int row, int col)
265 {
266  VP56mv *mv, vect = {0,0};
267  int b;
268 
269  s->mb_type = VP56_MB_INTER_NOVEC_PF;
270  s->macroblocks[row * s->mb_width + col].type = s->mb_type;
271 
272  mv = &vect;
273 
274  s->macroblocks[row*s->mb_width + col].mv = *mv;
275 
276  /* same vector for all blocks */
277  for (b=0; b<6; b++)
278  s->mv[b] = *mv;
279 
280  return s->mb_type;
281 }
282 
283 static void vp56_add_predictors_dc(VP56Context *s, VP56Frame ref_frame)
284 {
285  int idx = s->idct_scantable[0];
286  int b;
287 
288  for (b=0; b<6; b++) {
289  VP56RefDc *ab = &s->above_blocks[s->above_block_idx[b]];
290  VP56RefDc *lb = &s->left_block[ff_vp56_b6to4[b]];
291  int count = 0;
292  int dc = 0;
293  int i;
294 
295  if (ref_frame == lb->ref_frame) {
296  dc += lb->dc_coeff;
297  count++;
298  }
299  if (ref_frame == ab->ref_frame) {
300  dc += ab->dc_coeff;
301  count++;
302  }
303  if (s->avctx->codec->id == AV_CODEC_ID_VP5)
304  for (i=0; i<2; i++)
305  if (count < 2 && ref_frame == ab[-1+2*i].ref_frame) {
306  dc += ab[-1+2*i].dc_coeff;
307  count++;
308  }
309  if (count == 0)
310  dc = s->prev_dc[ff_vp56_b2p[b]][ref_frame];
311  else if (count == 2)
312  dc /= 2;
313 
314  s->block_coeff[b][idx] += dc;
315  s->prev_dc[ff_vp56_b2p[b]][ref_frame] = s->block_coeff[b][idx];
316  ab->dc_coeff = s->block_coeff[b][idx];
317  ab->ref_frame = ref_frame;
318  lb->dc_coeff = s->block_coeff[b][idx];
319  lb->ref_frame = ref_frame;
320  s->block_coeff[b][idx] *= s->dequant_dc;
321  }
322 }
323 
324 static void vp56_deblock_filter(VP56Context *s, uint8_t *yuv,
325  ptrdiff_t stride, int dx, int dy)
326 {
327  if (s->avctx->codec->id == AV_CODEC_ID_VP5) {
328  int t = ff_vp56_filter_threshold[s->quantizer];
329  if (dx) s->vp56dsp.edge_filter_hor(yuv + 10-dx , stride, t);
330  if (dy) s->vp56dsp.edge_filter_ver(yuv + stride*(10-dy), stride, t);
331  } else {
332  int * bounding_values = s->bounding_values_array + 127;
333  if (dx)
334  ff_vp3dsp_h_loop_filter_12(yuv + 10-dx, stride, bounding_values);
335  if (dy)
336  ff_vp3dsp_v_loop_filter_12(yuv + stride*(10-dy), stride, bounding_values);
337  }
338 }
339 
340 static void vp56_mc(VP56Context *s, int b, int plane, uint8_t *src,
341  ptrdiff_t stride, int x, int y)
342 {
343  uint8_t *dst = s->frames[VP56_FRAME_CURRENT]->data[plane] + s->block_offset[b];
344  uint8_t *src_block;
345  int src_offset;
346  int overlap_offset = 0;
347  int mask = s->vp56_coord_div[b] - 1;
348  int deblock_filtering = s->deblock_filtering;
349  int dx;
350  int dy;
351 
352  if (s->avctx->skip_loop_filter >= AVDISCARD_ALL ||
353  (s->avctx->skip_loop_filter >= AVDISCARD_NONKEY
354  && !(s->frames[VP56_FRAME_CURRENT]->flags & AV_FRAME_FLAG_KEY)))
355  deblock_filtering = 0;
356 
357  dx = s->mv[b].x / s->vp56_coord_div[b];
358  dy = s->mv[b].y / s->vp56_coord_div[b];
359 
360  if (b >= 4) {
361  x /= 2;
362  y /= 2;
363  }
364  x += dx - 2;
365  y += dy - 2;
366 
367  if (x<0 || x+12>=s->plane_width[plane] ||
368  y<0 || y+12>=s->plane_height[plane]) {
369  s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
370  src + s->block_offset[b] + (dy-2)*stride + (dx-2),
371  stride, stride,
372  12, 12, x, y,
373  s->plane_width[plane],
374  s->plane_height[plane]);
375  src_block = s->edge_emu_buffer;
376  src_offset = 2 + 2*stride;
377  } else if (deblock_filtering) {
378  /* only need a 12x12 block, but there is no such dsp function, */
379  /* so copy a 16x12 block */
380  s->hdsp.put_pixels_tab[0][0](s->edge_emu_buffer,
381  src + s->block_offset[b] + (dy-2)*stride + (dx-2),
382  stride, 12);
383  src_block = s->edge_emu_buffer;
384  src_offset = 2 + 2*stride;
385  } else {
386  src_block = src;
387  src_offset = s->block_offset[b] + dy*stride + dx;
388  }
389 
390  if (deblock_filtering)
391  vp56_deblock_filter(s, src_block, stride, dx&7, dy&7);
392 
393  if (s->mv[b].x & mask)
394  overlap_offset += (s->mv[b].x > 0) ? 1 : -1;
395  if (s->mv[b].y & mask)
396  overlap_offset += (s->mv[b].y > 0) ? stride : -stride;
397 
398  if (overlap_offset) {
399  if (s->filter)
400  s->filter(s, dst, src_block, src_offset, src_offset+overlap_offset,
401  stride, s->mv[b], mask, s->filter_selection, b<4);
402  else
403  s->vp3dsp.put_no_rnd_pixels_l2(dst, src_block+src_offset,
404  src_block+src_offset+overlap_offset,
405  stride, 8);
406  } else {
407  s->hdsp.put_pixels_tab[1][0](dst, src_block+src_offset, stride, 8);
408  }
409 }
410 
411 static void vp56_idct_put(VP56Context *s, uint8_t * dest, ptrdiff_t stride, int16_t *block, int selector)
412 {
413  if (selector > 10 || selector == 1)
414  s->vp3dsp.idct_put(dest, stride, block);
415  else
417 }
418 
419 static void vp56_idct_add(VP56Context *s, uint8_t * dest, ptrdiff_t stride, int16_t *block, int selector)
420 {
421  if (selector > 10)
422  s->vp3dsp.idct_add(dest, stride, block);
423  else if (selector > 1)
425  else
426  s->vp3dsp.idct_dc_add(dest, stride, block);
427 }
428 
429 static av_always_inline void vp56_render_mb(VP56Context *s, int row, int col, int is_alpha, VP56mb mb_type)
430 {
431  int b, ab, b_max, plane, off;
432  AVFrame *frame_current, *frame_ref;
434 
436 
437  frame_current = s->frames[VP56_FRAME_CURRENT];
438  frame_ref = s->frames[ref_frame];
439  if (mb_type != VP56_MB_INTRA && !frame_ref->data[0])
440  return;
441 
442  ab = 6*is_alpha;
443  b_max = 6 - 2*is_alpha;
444 
445  switch (mb_type) {
446  case VP56_MB_INTRA:
447  for (b=0; b<b_max; b++) {
448  plane = ff_vp56_b2p[b+ab];
449  vp56_idct_put(s, frame_current->data[plane] + s->block_offset[b],
450  s->stride[plane], s->block_coeff[b], s->idct_selector[b]);
451  }
452  break;
453 
456  for (b=0; b<b_max; b++) {
457  plane = ff_vp56_b2p[b+ab];
458  off = s->block_offset[b];
459  s->hdsp.put_pixels_tab[1][0](frame_current->data[plane] + off,
460  frame_ref->data[plane] + off,
461  s->stride[plane], 8);
462  vp56_idct_add(s, frame_current->data[plane] + off,
463  s->stride[plane], s->block_coeff[b], s->idct_selector[b]);
464  }
465  break;
466 
468  case VP56_MB_INTER_V1_PF:
469  case VP56_MB_INTER_V2_PF:
471  case VP56_MB_INTER_4V:
472  case VP56_MB_INTER_V1_GF:
473  case VP56_MB_INTER_V2_GF:
474  for (b=0; b<b_max; b++) {
475  int x_off = b==1 || b==3 ? 8 : 0;
476  int y_off = b==2 || b==3 ? 8 : 0;
477  plane = ff_vp56_b2p[b+ab];
478  vp56_mc(s, b, plane, frame_ref->data[plane], s->stride[plane],
479  16*col+x_off, 16*row+y_off);
480  vp56_idct_add(s, frame_current->data[plane] + s->block_offset[b],
481  s->stride[plane], s->block_coeff[b], s->idct_selector[b]);
482  }
483  break;
484  }
485 
486  if (is_alpha) {
487  s->block_coeff[4][0] = 0;
488  s->block_coeff[5][0] = 0;
489  }
490 }
491 
492 static int vp56_decode_mb(VP56Context *s, int row, int col, int is_alpha)
493 {
494  VP56mb mb_type;
495  int ret;
496 
497  if (s->frames[VP56_FRAME_CURRENT]->flags & AV_FRAME_FLAG_KEY)
498  mb_type = VP56_MB_INTRA;
499  else
500  mb_type = vp56_decode_mv(s, row, col);
501 
502  ret = s->parse_coeff(s);
503  if (ret < 0)
504  return ret;
505 
506  vp56_render_mb(s, row, col, is_alpha, mb_type);
507 
508  return 0;
509 }
510 
511 static int vp56_conceal_mb(VP56Context *s, int row, int col, int is_alpha)
512 {
513  VP56mb mb_type;
514 
515  if (s->frames[VP56_FRAME_CURRENT]->flags & AV_FRAME_FLAG_KEY)
516  mb_type = VP56_MB_INTRA;
517  else
518  mb_type = vp56_conceal_mv(s, row, col);
519 
520  vp56_render_mb(s, row, col, is_alpha, mb_type);
521 
522  return 0;
523 }
524 
525 static int vp56_size_changed(VP56Context *s)
526 {
527  AVCodecContext *avctx = s->avctx;
528  int stride = s->frames[VP56_FRAME_CURRENT]->linesize[0];
529  int i;
530 
531  s->plane_width[0] = s->plane_width[3] = avctx->coded_width;
532  s->plane_width[1] = s->plane_width[2] = avctx->coded_width/2;
533  s->plane_height[0] = s->plane_height[3] = avctx->coded_height;
534  s->plane_height[1] = s->plane_height[2] = avctx->coded_height/2;
535 
536  s->have_undamaged_frame = 0;
537 
538  for (i=0; i<4; i++)
539  s->stride[i] = s->flip * s->frames[VP56_FRAME_CURRENT]->linesize[i];
540 
541  s->mb_width = (avctx->coded_width +15) / 16;
542  s->mb_height = (avctx->coded_height+15) / 16;
543 
544  if (s->mb_width > 1000 || s->mb_height > 1000) {
545  ff_set_dimensions(avctx, 0, 0);
546  av_log(avctx, AV_LOG_ERROR, "picture too big\n");
547  return AVERROR_INVALIDDATA;
548  }
549 
550  av_reallocp_array(&s->above_blocks, 4*s->mb_width+6,
551  sizeof(*s->above_blocks));
552  av_reallocp_array(&s->macroblocks, s->mb_width*s->mb_height,
553  sizeof(*s->macroblocks));
554  av_free(s->edge_emu_buffer_alloc);
555  s->edge_emu_buffer_alloc = av_malloc(16*stride);
556  s->edge_emu_buffer = s->edge_emu_buffer_alloc;
557  if (!s->above_blocks || !s->macroblocks || !s->edge_emu_buffer_alloc)
558  return AVERROR(ENOMEM);
559  if (s->flip < 0)
560  s->edge_emu_buffer += 15 * stride;
561 
562  if (s->alpha_context)
563  return vp56_size_changed(s->alpha_context);
564 
565  return 0;
566 }
567 
568 static int ff_vp56_decode_mbs(AVCodecContext *avctx, void *, int, int);
569 
571  int *got_frame, AVPacket *avpkt)
572 {
573  const uint8_t *buf = avpkt->data;
574  VP56Context *s = avctx->priv_data;
575  AVFrame *const p = s->frames[VP56_FRAME_CURRENT];
576  int remaining_buf_size = avpkt->size;
577  int alpha_offset = remaining_buf_size;
578  int i, res;
579  int ret;
580 
581  if (s->has_alpha) {
582  if (remaining_buf_size < 3)
583  return AVERROR_INVALIDDATA;
584  alpha_offset = bytestream_get_be24(&buf);
585  remaining_buf_size -= 3;
586  if (remaining_buf_size < alpha_offset)
587  return AVERROR_INVALIDDATA;
588  }
589 
590  res = s->parse_header(s, buf, alpha_offset);
591  if (res < 0)
592  return res;
593 
594  if (res == VP56_SIZE_CHANGE) {
595  for (i = 0; i < 4; i++) {
596  av_frame_unref(s->frames[i]);
597  if (s->alpha_context)
598  av_frame_unref(s->alpha_context->frames[i]);
599  }
600  s->frames[VP56_FRAME_CURRENT]->flags |= AV_FRAME_FLAG_KEY; //FIXME
601  }
602 
604  if (ret < 0) {
605  if (res == VP56_SIZE_CHANGE)
606  ff_set_dimensions(avctx, 0, 0);
607  return ret;
608  }
609 
610  if (avctx->pix_fmt == AV_PIX_FMT_YUVA420P) {
611  if ((ret = av_frame_replace(s->alpha_context->frames[VP56_FRAME_CURRENT], p)) < 0) {
612  av_frame_unref(p);
613  if (res == VP56_SIZE_CHANGE)
614  ff_set_dimensions(avctx, 0, 0);
615  return ret;
616  }
617  }
618 
619  if (res == VP56_SIZE_CHANGE) {
620  if (vp56_size_changed(s)) {
621  av_frame_unref(p);
622  return AVERROR_INVALIDDATA;
623  }
624  }
625 
626  if (avctx->pix_fmt == AV_PIX_FMT_YUVA420P) {
627  int bak_w = avctx->width;
628  int bak_h = avctx->height;
629  int bak_cw = avctx->coded_width;
630  int bak_ch = avctx->coded_height;
631  buf += alpha_offset;
632  remaining_buf_size -= alpha_offset;
633 
634  res = s->alpha_context->parse_header(s->alpha_context, buf, remaining_buf_size);
635  if (res != 0) {
636  if(res==VP56_SIZE_CHANGE) {
637  av_log(avctx, AV_LOG_ERROR, "Alpha reconfiguration\n");
638  avctx->width = bak_w;
639  avctx->height = bak_h;
640  avctx->coded_width = bak_cw;
641  avctx->coded_height = bak_ch;
642  }
643  av_frame_unref(p);
644  return AVERROR_INVALIDDATA;
645  }
646  }
647 
648  s->discard_frame = 0;
649  avctx->execute2(avctx, ff_vp56_decode_mbs, 0, 0, (avctx->pix_fmt == AV_PIX_FMT_YUVA420P) + 1);
650 
651  if (s->discard_frame)
652  return AVERROR_INVALIDDATA;
653 
654  if ((res = av_frame_ref(rframe, p)) < 0)
655  return res;
656  *got_frame = 1;
657 
658  return avpkt->size;
659 }
660 
661 static int ff_vp56_decode_mbs(AVCodecContext *avctx, void *data,
662  int jobnr, int threadnr)
663 {
664  VP56Context *s0 = avctx->priv_data;
665  int is_alpha = (jobnr == 1);
666  VP56Context *s = is_alpha ? s0->alpha_context : s0;
667  AVFrame *const p = s->frames[VP56_FRAME_CURRENT];
668  int mb_row, mb_col, mb_row_flip, mb_offset = 0;
669  int block, y, uv;
670  ptrdiff_t stride_y, stride_uv;
671  int res;
672  int damaged = 0;
673 
674  if (p->flags & AV_FRAME_FLAG_KEY) {
676  s->default_models_init(s);
677  for (block=0; block<s->mb_height*s->mb_width; block++)
678  s->macroblocks[block].type = VP56_MB_INTRA;
679  } else {
682  s->parse_vector_models(s);
683  s->mb_type = VP56_MB_INTER_NOVEC_PF;
684  }
685 
686  if (s->parse_coeff_models(s))
687  goto next;
688 
689  memset(s->prev_dc, 0, sizeof(s->prev_dc));
690  s->prev_dc[1][VP56_FRAME_CURRENT] = 128;
691  s->prev_dc[2][VP56_FRAME_CURRENT] = 128;
692 
693  for (block=0; block < 4*s->mb_width+6; block++) {
694  s->above_blocks[block].ref_frame = VP56_FRAME_NONE;
695  s->above_blocks[block].dc_coeff = 0;
696  s->above_blocks[block].not_null_dc = 0;
697  }
698  s->above_blocks[2*s->mb_width + 2].ref_frame = VP56_FRAME_CURRENT;
699  s->above_blocks[3*s->mb_width + 4].ref_frame = VP56_FRAME_CURRENT;
700 
701  stride_y = p->linesize[0];
702  stride_uv = p->linesize[1];
703 
704  if (s->flip < 0)
705  mb_offset = 7;
706 
707  /* main macroblocks loop */
708  for (mb_row=0; mb_row<s->mb_height; mb_row++) {
709  if (s->flip < 0)
710  mb_row_flip = s->mb_height - mb_row - 1;
711  else
712  mb_row_flip = mb_row;
713 
714  for (block=0; block<4; block++) {
715  s->left_block[block].ref_frame = VP56_FRAME_NONE;
716  s->left_block[block].dc_coeff = 0;
717  s->left_block[block].not_null_dc = 0;
718  }
719  memset(s->coeff_ctx, 0, sizeof(s->coeff_ctx));
720  memset(s->coeff_ctx_last, 24, sizeof(s->coeff_ctx_last));
721 
722  s->above_block_idx[0] = 1;
723  s->above_block_idx[1] = 2;
724  s->above_block_idx[2] = 1;
725  s->above_block_idx[3] = 2;
726  s->above_block_idx[4] = 2*s->mb_width + 2 + 1;
727  s->above_block_idx[5] = 3*s->mb_width + 4 + 1;
728 
729  s->block_offset[s->frbi] = (mb_row_flip*16 + mb_offset) * stride_y;
730  s->block_offset[s->srbi] = s->block_offset[s->frbi] + 8*stride_y;
731  s->block_offset[1] = s->block_offset[0] + 8;
732  s->block_offset[3] = s->block_offset[2] + 8;
733  s->block_offset[4] = (mb_row_flip*8 + mb_offset) * stride_uv;
734  s->block_offset[5] = s->block_offset[4];
735 
736  for (mb_col=0; mb_col<s->mb_width; mb_col++) {
737  if (!damaged) {
738  int ret = vp56_decode_mb(s, mb_row, mb_col, is_alpha);
739  if (ret < 0) {
740  damaged = 1;
741  if (!s->have_undamaged_frame || !avctx->error_concealment) {
742  s->discard_frame = 1;
743  return AVERROR_INVALIDDATA;
744  }
745  }
746  }
747  if (damaged)
748  vp56_conceal_mb(s, mb_row, mb_col, is_alpha);
749 
750  for (y=0; y<4; y++) {
751  s->above_block_idx[y] += 2;
752  s->block_offset[y] += 16;
753  }
754 
755  for (uv=4; uv<6; uv++) {
756  s->above_block_idx[uv] += 1;
757  s->block_offset[uv] += 8;
758  }
759  }
760  }
761 
762  if (!damaged)
763  s->have_undamaged_frame = 1;
764 
765 next:
766  if ((p->flags & AV_FRAME_FLAG_KEY) || s->golden_frame) {
767  if ((res = av_frame_replace(s->frames[VP56_FRAME_GOLDEN], p)) < 0)
768  return res;
769  }
770 
772  FFSWAP(AVFrame *, s->frames[VP56_FRAME_CURRENT],
773  s->frames[VP56_FRAME_PREVIOUS]);
774  return 0;
775 }
776 
777 av_cold int ff_vp56_init_context(AVCodecContext *avctx, VP56Context *s,
778  int flip, int has_alpha)
779 {
780  int i;
781 
782  s->avctx = avctx;
783  avctx->pix_fmt = has_alpha ? AV_PIX_FMT_YUVA420P : AV_PIX_FMT_YUV420P;
784  if (avctx->skip_alpha) avctx->pix_fmt = AV_PIX_FMT_YUV420P;
785 
786  ff_h264chroma_init(&s->h264chroma, 8);
787  ff_hpeldsp_init(&s->hdsp, avctx->flags);
788  ff_videodsp_init(&s->vdsp, 8);
789  ff_vp3dsp_init(&s->vp3dsp, avctx->flags);
790  for (i = 0; i < 64; i++) {
791 #define TRANSPOSE(x) (((x) >> 3) | (((x) & 7) << 3))
792  s->idct_scantable[i] = TRANSPOSE(ff_zigzag_direct[i]);
793 #undef TRANSPOSE
794  }
795 
796  for (i = 0; i < FF_ARRAY_ELEMS(s->frames); i++) {
797  s->frames[i] = av_frame_alloc();
798  if (!s->frames[i])
799  return AVERROR(ENOMEM);
800  }
801  s->edge_emu_buffer_alloc = NULL;
802 
803  s->above_blocks = NULL;
804  s->macroblocks = NULL;
805  s->quantizer = -1;
806  s->deblock_filtering = 1;
807  s->golden_frame = 0;
808 
809  s->filter = NULL;
810 
811  s->has_alpha = has_alpha;
812 
813  s->modelp = &s->model;
814 
815  if (flip) {
816  s->flip = -1;
817  s->frbi = 2;
818  s->srbi = 0;
819  } else {
820  s->flip = 1;
821  s->frbi = 0;
822  s->srbi = 2;
823  }
824 
825  return 0;
826 }
827 
828 av_cold int ff_vp56_free_context(VP56Context *s)
829 {
830  int i;
831 
832  av_freep(&s->above_blocks);
833  av_freep(&s->macroblocks);
834  av_freep(&s->edge_emu_buffer_alloc);
835 
836  for (i = 0; i < FF_ARRAY_ELEMS(s->frames); i++)
837  av_frame_free(&s->frames[i]);
838 
839  return 0;
840 }
vp56_rac_get_tree
static av_always_inline int vp56_rac_get_tree(VPXRangeCoder *c, const VP56Tree *tree, const uint8_t *probs)
Definition: vp56.h:243
vp56_add_predictors_dc
static void vp56_add_predictors_dc(VP56Context *s, VP56Frame ref_frame)
Definition: vp56.c:283
vp56_conceal_mb
static int vp56_conceal_mb(VP56Context *s, int row, int col, int is_alpha)
Definition: vp56.c:511
vp56_parse_mb_type_models
static void vp56_parse_mb_type_models(VP56Context *s)
Definition: vp56.c:83
VP56mv::x
int16_t x
Definition: vp56.h:68
vp56data.h
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
VP56_MB_INTER_DELTA_GF
@ VP56_MB_INTER_DELTA_GF
Inter MB, above/left vector + delta, from golden frame.
Definition: vp56.h:56
ff_vp3dsp_idct10_put
void ff_vp3dsp_idct10_put(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition: vp3dsp.c:341
ff_vp3dsp_idct10_add
void ff_vp3dsp_idct10_add(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition: vp3dsp.c:347
VP56Model::mb_types_stats
uint8_t mb_types_stats[3][10][2]
Definition: vp56.h:112
VP56_MB_INTER_V2_GF
@ VP56_MB_INTER_V2_GF
Inter MB, second vector, from golden frame.
Definition: vp56.h:59
ff_vp56_decode_mbs
static int ff_vp56_decode_mbs(AVCodecContext *avctx, void *, int, int)
Definition: vp56.c:661
vp56_conceal_mv
static VP56mb vp56_conceal_mv(VP56Context *s, int row, int col)
Definition: vp56.c:264
mv
static const int8_t mv[256][2]
Definition: 4xm.c:81
ff_vp56_pmbtm_tree
const VP56Tree ff_vp56_pmbtm_tree[]
Definition: vp56data.c:219
ff_vp56_reference_frame
const VP56Frame ff_vp56_reference_frame[]
Definition: vp56data.c:70
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:160
vp56_decode_4mv
static void vp56_decode_4mv(VP56Context *s, int row, int col)
Definition: vp56.c:166
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
AVPacket::data
uint8_t * data
Definition: packet.h:520
ff_vp3dsp_set_bounding_values
void ff_vp3dsp_set_bounding_values(int *bounding_values_array, int filter_limit)
Definition: vp3dsp.c:477
ff_vp56_init_context
av_cold int ff_vp56_init_context(AVCodecContext *avctx, VP56Context *s, int flip, int has_alpha)
Initializes an VP56Context.
Definition: vp56.c:777
VP56RefDc::ref_frame
VP56Frame ref_frame
Definition: vp56.h:88
b
#define b
Definition: input.c:41
data
const char data[16]
Definition: mxf.c:148
ff_vp56_pmbt_tree
const VP56Tree ff_vp56_pmbt_tree[]
Definition: vp56data.c:228
TRANSPOSE
#define TRANSPOSE(x)
ff_vp56_filter_threshold
const uint8_t ff_vp56_filter_threshold[]
Definition: vp56data.c:204
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:646
vp56_size_changed
static int vp56_size_changed(VP56Context *s)
Definition: vp56.c:525
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:94
VPXRangeCoder
Definition: vpx_rac.h:35
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:395
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
VP56_MB_INTRA
@ VP56_MB_INTRA
Intra MB.
Definition: vp56.h:51
VP56RefDc
Definition: vp56.h:86
mvp
static void mvp(const VVCLocalContext *lc, const int mvp_lx_flag, const int lx, const int8_t *ref_idx, const int amvr_shift, Mv *mv)
Definition: mvs.c:1575
ref_frame
static int ref_frame(VVCFrame *dst, const VVCFrame *src)
Definition: dec.c:559
VP56_MB_INTER_NOVEC_PF
@ VP56_MB_INTER_NOVEC_PF
Inter MB, no vector, from previous frame.
Definition: vp56.h:50
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
ff_videodsp_init
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:39
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:633
ff_vp56_b6to4
const uint8_t ff_vp56_b6to4[]
Definition: vp56data.c:29
vp56_deblock_filter
static void vp56_deblock_filter(VP56Context *s, uint8_t *yuv, ptrdiff_t stride, int dx, int dy)
Definition: vp56.c:324
VP56_MB_INTER_V1_PF
@ VP56_MB_INTER_V1_PF
Inter MB, first vector, from previous frame.
Definition: vp56.h:53
vp56_idct_add
static void vp56_idct_add(VP56Context *s, uint8_t *dest, ptrdiff_t stride, int16_t *block, int selector)
Definition: vp56.c:419
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:148
VP56_SIZE_CHANGE
#define VP56_SIZE_CHANGE
Definition: vp56.h:72
VP56RefDc::dc_coeff
int16_t dc_coeff
Definition: vp56.h:89
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
ff_vp56_dc_dequant
const uint8_t ff_vp56_dc_dequant[64]
Definition: vp56data.c:94
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:625
VP56Model::mb_type
uint8_t mb_type[3][10][10]
Definition: vp56.h:111
mask
static const uint16_t mask[17]
Definition: lzw.c:38
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:108
vp56_mc
static void vp56_mc(VP56Context *s, int b, int plane, uint8_t *src, ptrdiff_t stride, int x, int y)
Definition: vp56.c:340
vp56_get_vectors_predictors
static int vp56_get_vectors_predictors(VP56Context *s, int row, int col, VP56Frame ref_frame)
Definition: vp56.c:45
VP56_MB_INTER_4V
@ VP56_MB_INTER_4V
Inter MB, 4 vectors, from previous frame.
Definition: vp56.h:57
AV_GET_BUFFER_FLAG_REF
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:425
AVCodecContext::error_concealment
int error_concealment
error concealment flags
Definition: avcodec.h:1386
ctx
AVFormatContext * ctx
Definition: movenc.c:49
decode.h
ff_vp56_free_context
av_cold int ff_vp56_free_context(VP56Context *s)
Definition: vp56.c:828
VP56mv::y
int16_t y
Definition: vp56.h:69
VP56mv
Definition: vp56.h:67
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
RSHIFT
#define RSHIFT(a, b)
Definition: common.h:56
ff_hpeldsp_init
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:338
vp56.h
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:220
NULL
#define NULL
Definition: coverity.c:32
VP56_MB_INTER_DELTA_PF
@ VP56_MB_INTER_DELTA_PF
Inter MB, above/left vector + delta, from previous frame.
Definition: vp56.h:52
ff_vp3dsp_h_loop_filter_12
void ff_vp3dsp_h_loop_filter_12(uint8_t *first_pixel, ptrdiff_t stride, int *bounding_values)
ff_vp56_mb_type_model_model
const uint8_t ff_vp56_mb_type_model_model[]
Definition: vp56data.c:215
VP56_MB_INTER_NOVEC_GF
@ VP56_MB_INTER_NOVEC_GF
Inter MB, no vector, from golden frame.
Definition: vp56.h:55
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
ff_vp56_pre_def_mb_type_stats
const uint8_t ff_vp56_pre_def_mb_type_stats[16][3][10][2]
Definition: vp56data.c:105
VP56_MB_INTER_V2_PF
@ VP56_MB_INTER_V2_PF
Inter MB, second vector, from previous frame.
Definition: vp56.h:54
vp56_parse_mb_type
static VP56mb vp56_parse_mb_type(VP56Context *s, VP56mb prev_type, int ctx)
Definition: vp56.c:154
vp56_render_mb
static av_always_inline void vp56_render_mb(VP56Context *s, int row, int col, int is_alpha, VP56mb mb_type)
Definition: vp56.c:429
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
ff_vp3dsp_v_loop_filter_12
void ff_vp3dsp_v_loop_filter_12(uint8_t *first_pixel, ptrdiff_t stride, int *bounding_values)
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:219
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:476
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1575
flip
static void flip(AVCodecContext *avctx, AVFrame *frame)
Definition: rawdec.c:131
AVPacket::size
int size
Definition: packet.h:521
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
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:384
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
h264chroma.h
AVCodecContext::skip_alpha
int skip_alpha
Skip processing alpha if supported by codec.
Definition: avcodec.h:1834
VP56_FRAME_NONE
@ VP56_FRAME_NONE
Definition: vp56.h:43
av_reallocp_array
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate an array through a pointer to a pointer.
Definition: mem.c:225
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
vp56_rac_gets
static int vp56_rac_gets(VPXRangeCoder *c, int bits)
vp56 specific range coder implementation
Definition: vp56.h:224
VP56_MB_INTER_V1_GF
@ VP56_MB_INTER_V1_GF
Inter MB, first vector, from golden frame.
Definition: vp56.h:58
AV_CODEC_ID_VP5
@ AV_CODEC_ID_VP5
Definition: codec_id.h:142
ff_vp3dsp_init
av_cold void ff_vp3dsp_init(VP3DSPContext *c, int flags)
Definition: vp3dsp.c:448
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
vpx_rac.h
VP56_FRAME_GOLDEN
@ VP56_FRAME_GOLDEN
Definition: vp56.h:46
delta
float delta
Definition: vorbis_enc_data.h:430
av_always_inline
#define av_always_inline
Definition: attributes.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
VP56mb
VP56mb
Definition: vp56.h:49
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:606
AVCodecContext::height
int height
Definition: avcodec.h:618
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
ret
ret
Definition: filter_design.txt:187
VP56Frame
VP56Frame
Definition: vp56.h:42
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
pos
unsigned int pos
Definition: spdifenc.c:414
ff_vp56_decode_frame
int ff_vp56_decode_frame(AVCodecContext *avctx, AVFrame *rframe, int *got_frame, AVPacket *avpkt)
Definition: vp56.c:570
ff_vp56_candidate_predictor_pos
const int8_t ff_vp56_candidate_predictor_pos[12][2]
Definition: vp56data.c:241
VP56_FRAME_CURRENT
@ VP56_FRAME_CURRENT
Definition: vp56.h:44
av_frame_replace
int av_frame_replace(AVFrame *dst, const AVFrame *src)
Ensure the destination frame refers to the same data described by the source frame,...
Definition: frame.c:483
AVCodecContext
main external API structure.
Definition: avcodec.h:445
ff_vp56_b2p
const uint8_t ff_vp56_b2p[]
Definition: vp56data.c:28
VP56Model
Definition: vp56.h:97
VP56_FRAME_PREVIOUS
@ VP56_FRAME_PREVIOUS
Definition: vp56.h:45
ff_vp56_init_dequant
void ff_vp56_init_dequant(VP56Context *s, int quantizer)
Definition: vp56.c:36
ff_h264chroma_init
av_cold void ff_h264chroma_init(H264ChromaContext *c, int bit_depth)
Definition: h264chroma.c:41
ff_vp56_ac_dequant
const uint8_t ff_vp56_ac_dequant[64]
Definition: vp56data.c:83
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:633
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
vpx_rac_get
static av_always_inline int vpx_rac_get(VPXRangeCoder *c)
Definition: vpx_rac.h:117
mem.h
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AVPacket
This structure stores compressed data.
Definition: packet.h:497
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
bytestream.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:419
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
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
vp56_idct_put
static void vp56_idct_put(VP56Context *s, uint8_t *dest, ptrdiff_t stride, int16_t *block, int selector)
Definition: vp56.c:411
vp56_decode_mv
static VP56mb vp56_decode_mv(VP56Context *s, int row, int col)
Definition: vp56.c:207
vp56_decode_mb
static int vp56_decode_mb(VP56Context *s, int row, int col, int is_alpha)
Definition: vp56.c:492
AVCodecContext::execute2
int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)
The codec may call this to execute several independent things.
Definition: avcodec.h:1632