FFmpeg
vp6.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  * VP6 compatible video decoder
24  *
25  * The VP6F decoder accepts an optional 1 byte extradata. It is composed of:
26  * - upper 4 bits: difference between encoded width and visible width
27  * - lower 4 bits: difference between encoded height and visible height
28  */
29 
30 #include <stdlib.h>
31 
32 #include "avcodec.h"
33 #include "codec_internal.h"
34 #include "get_bits.h"
35 #include "huffman.h"
36 #include "internal.h"
37 
38 #include "vp56.h"
39 #include "vp56data.h"
40 #include "vp6data.h"
41 #include "vpx_rac.h"
42 
43 #define VP6_MAX_HUFF_SIZE 12
44 
45 static int vp6_parse_coeff(VP56Context *s);
46 static int vp6_parse_coeff_huffman(VP56Context *s);
47 
48 static int vp6_parse_header(VP56Context *s, const uint8_t *buf, int buf_size)
49 {
50  VPXRangeCoder *c = &s->c;
51  int parse_filter_info = 0;
52  int coeff_offset = 0;
53  int vrt_shift = 0;
54  int sub_version;
55  int rows, cols;
56  int res = 0;
57  int ret;
58  int separated_coeff = buf[0] & 1;
59 
60  s->frames[VP56_FRAME_CURRENT]->key_frame = !(buf[0] & 0x80);
61  ff_vp56_init_dequant(s, (buf[0] >> 1) & 0x3F);
62 
63  if (s->frames[VP56_FRAME_CURRENT]->key_frame) {
64  sub_version = buf[1] >> 3;
65  if (sub_version > 8)
66  return AVERROR_INVALIDDATA;
67  s->filter_header = buf[1] & 0x06;
68  if (buf[1] & 1) {
69  avpriv_report_missing_feature(s->avctx, "Interlacing");
70  return AVERROR_PATCHWELCOME;
71  }
72  if (separated_coeff || !s->filter_header) {
73  coeff_offset = AV_RB16(buf+2) - 2;
74  buf += 2;
75  buf_size -= 2;
76  }
77 
78  rows = buf[2]; /* number of stored macroblock rows */
79  cols = buf[3]; /* number of stored macroblock cols */
80  /* buf[4] is number of displayed macroblock rows */
81  /* buf[5] is number of displayed macroblock cols */
82  if (!rows || !cols) {
83  av_log(s->avctx, AV_LOG_ERROR, "Invalid size %dx%d\n", cols << 4, rows << 4);
84  return AVERROR_INVALIDDATA;
85  }
86 
87  if (!s->macroblocks || /* first frame */
88  16*cols != s->avctx->coded_width ||
89  16*rows != s->avctx->coded_height) {
90  if (s->avctx->extradata_size == 0 &&
91  FFALIGN(s->avctx->width, 16) == 16 * cols &&
92  FFALIGN(s->avctx->height, 16) == 16 * rows) {
93  // We assume this is properly signalled container cropping,
94  // in an F4V file. Just set the coded_width/height, don't
95  // touch the cropped ones.
96  s->avctx->coded_width = 16 * cols;
97  s->avctx->coded_height = 16 * rows;
98  } else {
99  ret = ff_set_dimensions(s->avctx, 16 * cols, 16 * rows);
100  if (ret < 0)
101  return ret;
102 
103  if (s->avctx->extradata_size == 1) {
104  s->avctx->width -= s->avctx->extradata[0] >> 4;
105  s->avctx->height -= s->avctx->extradata[0] & 0x0F;
106  }
107  }
108  res = VP56_SIZE_CHANGE;
109  }
110 
111  ret = ff_vpx_init_range_decoder(c, buf+6, buf_size-6);
112  if (ret < 0)
113  goto fail;
114  vp56_rac_gets(c, 2);
115 
116  parse_filter_info = s->filter_header;
117  if (sub_version < 8)
118  vrt_shift = 5;
119  s->sub_version = sub_version;
120  s->golden_frame = 0;
121  } else {
122  if (!s->sub_version || !s->avctx->coded_width || !s->avctx->coded_height)
123  return AVERROR_INVALIDDATA;
124 
125  if (separated_coeff || !s->filter_header) {
126  coeff_offset = AV_RB16(buf+1) - 2;
127  buf += 2;
128  buf_size -= 2;
129  }
130  ret = ff_vpx_init_range_decoder(c, buf+1, buf_size-1);
131  if (ret < 0)
132  return ret;
133 
134  s->golden_frame = vpx_rac_get(c);
135  if (s->filter_header) {
136  s->deblock_filtering = vpx_rac_get(c);
137  if (s->deblock_filtering)
138  vpx_rac_get(c);
139  if (s->sub_version > 7)
140  parse_filter_info = vpx_rac_get(c);
141  }
142  }
143 
144  if (parse_filter_info) {
145  if (vpx_rac_get(c)) {
146  s->filter_mode = 2;
147  s->sample_variance_threshold = vp56_rac_gets(c, 5) << vrt_shift;
148  s->max_vector_length = 2 << vp56_rac_gets(c, 3);
149  } else if (vpx_rac_get(c)) {
150  s->filter_mode = 1;
151  } else {
152  s->filter_mode = 0;
153  }
154  if (s->sub_version > 7)
155  s->filter_selection = vp56_rac_gets(c, 4);
156  else
157  s->filter_selection = 16;
158  }
159 
160  s->use_huffman = vpx_rac_get(c);
161 
162  s->parse_coeff = vp6_parse_coeff;
163  if (coeff_offset) {
164  buf += coeff_offset;
165  buf_size -= coeff_offset;
166  if (buf_size < 0) {
168  goto fail;
169  }
170  if (s->use_huffman) {
171  s->parse_coeff = vp6_parse_coeff_huffman;
172  ret = init_get_bits8(&s->gb, buf, buf_size);
173  if (ret < 0)
174  return ret;
175  } else {
176  ret = ff_vpx_init_range_decoder(&s->cc, buf, buf_size);
177  if (ret < 0)
178  goto fail;
179  s->ccp = &s->cc;
180  }
181  } else {
182  s->ccp = &s->c;
183  }
184 
185  return res;
186 fail:
187  if (res == VP56_SIZE_CHANGE)
188  ff_set_dimensions(s->avctx, 0, 0);
189  return ret;
190 }
191 
192 static void vp6_coeff_order_table_init(VP56Context *s)
193 {
194  int i, pos, idx = 1;
195 
196  s->modelp->coeff_index_to_pos[0] = 0;
197  for (i=0; i<16; i++)
198  for (pos=1; pos<64; pos++)
199  if (s->modelp->coeff_reorder[pos] == i)
200  s->modelp->coeff_index_to_pos[idx++] = pos;
201 
202  for (idx = 0; idx < 64; idx++) {
203  int max = 0;
204  for (i = 0; i <= idx; i++) {
205  int v = s->modelp->coeff_index_to_pos[i];
206  if (v > max)
207  max = v;
208  }
209  if (s->sub_version > 6)
210  max++;
211  s->modelp->coeff_index_to_idct_selector[idx] = max;
212  }
213 }
214 
215 static void vp6_default_models_init(VP56Context *s)
216 {
217  VP56Model *model = s->modelp;
218 
219  model->vector_dct[0] = 0xA2;
220  model->vector_dct[1] = 0xA4;
221  model->vector_sig[0] = 0x80;
222  model->vector_sig[1] = 0x80;
223 
224  memcpy(model->mb_types_stats, ff_vp56_def_mb_types_stats, sizeof(model->mb_types_stats));
225  memcpy(model->vector_fdv, vp6_def_fdv_vector_model, sizeof(model->vector_fdv));
226  memcpy(model->vector_pdv, vp6_def_pdv_vector_model, sizeof(model->vector_pdv));
227  memcpy(model->coeff_runv, vp6_def_runv_coeff_model, sizeof(model->coeff_runv));
228  memcpy(model->coeff_reorder, vp6_def_coeff_reorder, sizeof(model->coeff_reorder));
229 
231 }
232 
233 static void vp6_parse_vector_models(VP56Context *s)
234 {
235  VPXRangeCoder *c = &s->c;
236  VP56Model *model = s->modelp;
237  int comp, node;
238 
239  for (comp=0; comp<2; comp++) {
241  model->vector_dct[comp] = vp56_rac_gets_nn(c, 7);
243  model->vector_sig[comp] = vp56_rac_gets_nn(c, 7);
244  }
245 
246  for (comp=0; comp<2; comp++)
247  for (node=0; node<7; node++)
249  model->vector_pdv[comp][node] = vp56_rac_gets_nn(c, 7);
250 
251  for (comp=0; comp<2; comp++)
252  for (node=0; node<8; node++)
254  model->vector_fdv[comp][node] = vp56_rac_gets_nn(c, 7);
255 }
256 
257 /* nodes must ascend by count, but with descending symbol order */
258 static int vp6_huff_cmp(const void *va, const void *vb)
259 {
260  const Node *a = va, *b = vb;
261  return (a->count - b->count)*16 + (b->sym - a->sym);
262 }
263 
264 static int vp6_build_huff_tree(VP56Context *s, uint8_t coeff_model[],
265  const uint8_t *map, unsigned size, VLC *vlc)
266 {
267  Node nodes[2*VP6_MAX_HUFF_SIZE], *tmp = &nodes[size];
268  int a, b, i;
269 
270  /* first compute probabilities from model */
271  tmp[0].count = 256;
272  for (i=0; i<size-1; i++) {
273  a = tmp[i].count * coeff_model[i] >> 8;
274  b = tmp[i].count * (255 - coeff_model[i]) >> 8;
275  nodes[map[2*i ]].count = a + !a;
276  nodes[map[2*i+1]].count = b + !b;
277  }
278 
279  ff_free_vlc(vlc);
280  /* then build the huffman tree according to probabilities */
281  return ff_huff_build_tree(s->avctx, vlc, size, FF_HUFFMAN_BITS,
282  nodes, vp6_huff_cmp,
284 }
285 
286 static int vp6_parse_coeff_models(VP56Context *s)
287 {
288  VPXRangeCoder *c = &s->c;
289  VP56Model *model = s->modelp;
290  int def_prob[11];
291  int node, cg, ctx, pos;
292  int ct; /* code type */
293  int pt; /* plane type (0 for Y, 1 for U or V) */
294 
295  memset(def_prob, 0x80, sizeof(def_prob));
296 
297  for (pt=0; pt<2; pt++)
298  for (node=0; node<11; node++)
299  if (vpx_rac_get_prob_branchy(c, vp6_dccv_pct[pt][node])) {
300  def_prob[node] = vp56_rac_gets_nn(c, 7);
301  model->coeff_dccv[pt][node] = def_prob[node];
302  } else if (s->frames[VP56_FRAME_CURRENT]->key_frame) {
303  model->coeff_dccv[pt][node] = def_prob[node];
304  }
305 
306  if (vpx_rac_get(c)) {
307  for (pos=1; pos<64; pos++)
309  model->coeff_reorder[pos] = vp56_rac_gets(c, 4);
311  }
312 
313  for (cg=0; cg<2; cg++)
314  for (node=0; node<14; node++)
315  if (vpx_rac_get_prob_branchy(c, vp6_runv_pct[cg][node]))
316  model->coeff_runv[cg][node] = vp56_rac_gets_nn(c, 7);
317 
318  for (ct=0; ct<3; ct++)
319  for (pt=0; pt<2; pt++)
320  for (cg=0; cg<6; cg++)
321  for (node=0; node<11; node++)
322  if (vpx_rac_get_prob_branchy(c, vp6_ract_pct[ct][pt][cg][node])) {
323  def_prob[node] = vp56_rac_gets_nn(c, 7);
324  model->coeff_ract[pt][ct][cg][node] = def_prob[node];
325  } else if (s->frames[VP56_FRAME_CURRENT]->key_frame) {
326  model->coeff_ract[pt][ct][cg][node] = def_prob[node];
327  }
328 
329  if (s->use_huffman) {
330  for (pt=0; pt<2; pt++) {
331  if (vp6_build_huff_tree(s, model->coeff_dccv[pt],
332  vp6_huff_coeff_map, 12, &s->dccv_vlc[pt]))
333  return -1;
334  if (vp6_build_huff_tree(s, model->coeff_runv[pt],
335  vp6_huff_run_map, 9, &s->runv_vlc[pt]))
336  return -1;
337  for (ct=0; ct<3; ct++)
338  for (cg = 0; cg < 6; cg++)
339  if (vp6_build_huff_tree(s, model->coeff_ract[pt][ct][cg],
340  vp6_huff_coeff_map, 12,
341  &s->ract_vlc[pt][ct][cg]))
342  return -1;
343  }
344  memset(s->nb_null, 0, sizeof(s->nb_null));
345  } else {
346  /* coeff_dcct is a linear combination of coeff_dccv */
347  for (pt=0; pt<2; pt++)
348  for (ctx=0; ctx<3; ctx++)
349  for (node=0; node<5; node++)
350  model->coeff_dcct[pt][ctx][node] = av_clip(((model->coeff_dccv[pt][node] * vp6_dccv_lc[ctx][node][0] + 128) >> 8) + vp6_dccv_lc[ctx][node][1], 1, 255);
351  }
352  return 0;
353 }
354 
355 static void vp6_parse_vector_adjustment(VP56Context *s, VP56mv *vect)
356 {
357  VPXRangeCoder *c = &s->c;
358  VP56Model *model = s->modelp;
359  int comp;
360 
361  *vect = (VP56mv) {0,0};
362  if (s->vector_candidate_pos < 2)
363  *vect = s->vector_candidate[0];
364 
365  for (comp=0; comp<2; comp++) {
366  int i, delta = 0;
367 
368  if (vpx_rac_get_prob_branchy(c, model->vector_dct[comp])) {
369  static const uint8_t prob_order[] = {0, 1, 2, 7, 6, 5, 4};
370  for (i=0; i<sizeof(prob_order); i++) {
371  int j = prob_order[i];
372  delta |= vpx_rac_get_prob(c, model->vector_fdv[comp][j])<<j;
373  }
374  if (delta & 0xF0)
375  delta |= vpx_rac_get_prob(c, model->vector_fdv[comp][3])<<3;
376  else
377  delta |= 8;
378  } else {
380  model->vector_pdv[comp]);
381  }
382 
384  delta = -delta;
385 
386  if (!comp)
387  vect->x += delta;
388  else
389  vect->y += delta;
390  }
391 }
392 
393 /**
394  * Read number of consecutive blocks with null DC or AC.
395  * This value is < 74.
396  */
397 static unsigned vp6_get_nb_null(VP56Context *s)
398 {
399  unsigned val = get_bits(&s->gb, 2);
400  if (val == 2)
401  val += get_bits(&s->gb, 2);
402  else if (val == 3) {
403  val = get_bits1(&s->gb) << 2;
404  val = 6+val + get_bits(&s->gb, 2+val);
405  }
406  return val;
407 }
408 
409 static int vp6_parse_coeff_huffman(VP56Context *s)
410 {
411  VP56Model *model = s->modelp;
412  uint8_t *permute = s->idct_scantable;
413  VLC *vlc_coeff;
414  int coeff, sign, coeff_idx;
415  int b, cg, idx;
416  int pt = 0; /* plane type (0 for Y, 1 for U or V) */
417 
418  for (b=0; b<6; b++) {
419  int ct = 0; /* code type */
420  if (b > 3) pt = 1;
421  vlc_coeff = &s->dccv_vlc[pt];
422 
423  for (coeff_idx = 0;;) {
424  int run = 1;
425  if (coeff_idx<2 && s->nb_null[coeff_idx][pt]) {
426  s->nb_null[coeff_idx][pt]--;
427  if (coeff_idx)
428  break;
429  } else {
430  if (get_bits_left(&s->gb) <= 0)
431  return AVERROR_INVALIDDATA;
432  coeff = get_vlc2(&s->gb, vlc_coeff->table, FF_HUFFMAN_BITS, 3);
433  if (coeff == 0) {
434  if (coeff_idx) {
435  int pt = (coeff_idx >= 6);
436  run += get_vlc2(&s->gb, s->runv_vlc[pt].table, FF_HUFFMAN_BITS, 3);
437  if (run >= 9)
438  run += get_bits(&s->gb, 6);
439  } else
440  s->nb_null[0][pt] = vp6_get_nb_null(s);
441  ct = 0;
442  } else if (coeff == 11) { /* end of block */
443  if (coeff_idx == 1) /* first AC coeff ? */
444  s->nb_null[1][pt] = vp6_get_nb_null(s);
445  break;
446  } else {
447  int coeff2 = ff_vp56_coeff_bias[coeff];
448  if (coeff > 4)
449  coeff2 += get_bits(&s->gb, coeff <= 9 ? coeff - 4 : 11);
450  ct = 1 + (coeff2 > 1);
451  sign = get_bits1(&s->gb);
452  coeff2 = (coeff2 ^ -sign) + sign;
453  if (coeff_idx)
454  coeff2 *= s->dequant_ac;
455  idx = model->coeff_index_to_pos[coeff_idx];
456  s->block_coeff[b][permute[idx]] = coeff2;
457  }
458  }
459  coeff_idx+=run;
460  if (coeff_idx >= 64)
461  break;
462  cg = FFMIN(vp6_coeff_groups[coeff_idx], 3);
463  vlc_coeff = &s->ract_vlc[pt][ct][cg];
464  }
465  s->idct_selector[b] = model->coeff_index_to_idct_selector[FFMIN(coeff_idx, 63)];
466  }
467  return 0;
468 }
469 
470 static int vp6_parse_coeff(VP56Context *s)
471 {
472  VPXRangeCoder *c = s->ccp;
473  VP56Model *model = s->modelp;
474  uint8_t *permute = s->idct_scantable;
475  uint8_t *model1, *model2, *model3;
476  int coeff, sign, coeff_idx;
477  int b, i, cg, idx, ctx;
478  int pt = 0; /* plane type (0 for Y, 1 for U or V) */
479 
480  if (vpx_rac_is_end(c)) {
481  av_log(s->avctx, AV_LOG_ERROR, "End of AC stream reached in vp6_parse_coeff\n");
482  return AVERROR_INVALIDDATA;
483  }
484 
485  for (b=0; b<6; b++) {
486  int ct = 1; /* code type */
487  int run = 1;
488 
489  if (b > 3) pt = 1;
490 
491  ctx = s->left_block[ff_vp56_b6to4[b]].not_null_dc
492  + s->above_blocks[s->above_block_idx[b]].not_null_dc;
493  model1 = model->coeff_dccv[pt];
494  model2 = model->coeff_dcct[pt][ctx];
495 
496  coeff_idx = 0;
497  for (;;) {
498  if ((coeff_idx>1 && ct==0) || vpx_rac_get_prob_branchy(c, model2[0])) {
499  /* parse a coeff */
500  if (vpx_rac_get_prob_branchy(c, model2[2])) {
501  if (vpx_rac_get_prob_branchy(c, model2[3])) {
502  idx = vp56_rac_get_tree(c, ff_vp56_pc_tree, model1);
503  coeff = ff_vp56_coeff_bias[idx+5];
504  for (i=ff_vp56_coeff_bit_length[idx]; i>=0; i--)
506  } else {
507  if (vpx_rac_get_prob_branchy(c, model2[4]))
508  coeff = 3 + vpx_rac_get_prob(c, model1[5]);
509  else
510  coeff = 2;
511  }
512  ct = 2;
513  } else {
514  ct = 1;
515  coeff = 1;
516  }
517  sign = vpx_rac_get(c);
518  coeff = (coeff ^ -sign) + sign;
519  if (coeff_idx)
520  coeff *= s->dequant_ac;
521  idx = model->coeff_index_to_pos[coeff_idx];
522  s->block_coeff[b][permute[idx]] = coeff;
523  run = 1;
524  } else {
525  /* parse a run */
526  ct = 0;
527  if (coeff_idx > 0) {
528  if (!vpx_rac_get_prob_branchy(c, model2[1]))
529  break;
530 
531  model3 = model->coeff_runv[coeff_idx >= 6];
532  run = vp56_rac_get_tree(c, vp6_pcr_tree, model3);
533  if (!run)
534  for (run=9, i=0; i<6; i++)
535  run += vpx_rac_get_prob(c, model3[i+8]) << i;
536  }
537  }
538  coeff_idx += run;
539  if (coeff_idx >= 64)
540  break;
541  cg = vp6_coeff_groups[coeff_idx];
542  model1 = model2 = model->coeff_ract[pt][ct][cg];
543  }
544 
545  s->left_block[ff_vp56_b6to4[b]].not_null_dc =
546  s->above_blocks[s->above_block_idx[b]].not_null_dc = !!s->block_coeff[b][0];
547  s->idct_selector[b] = model->coeff_index_to_idct_selector[FFMIN(coeff_idx, 63)];
548  }
549  return 0;
550 }
551 
552 static int vp6_block_variance(uint8_t *src, ptrdiff_t stride)
553 {
554  int sum = 0, square_sum = 0;
555  int y, x;
556 
557  for (y=0; y<8; y+=2) {
558  for (x=0; x<8; x+=2) {
559  sum += src[x];
560  square_sum += src[x]*src[x];
561  }
562  src += 2*stride;
563  }
564  return (16*square_sum - sum*sum) >> 8;
565 }
566 
567 static void vp6_filter_hv4(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
568  int delta, const int16_t *weights)
569 {
570  int x, y;
571 
572  for (y=0; y<8; y++) {
573  for (x=0; x<8; x++) {
574  dst[x] = av_clip_uint8(( src[x-delta ] * weights[0]
575  + src[x ] * weights[1]
576  + src[x+delta ] * weights[2]
577  + src[x+2*delta] * weights[3] + 64) >> 7);
578  }
579  src += stride;
580  dst += stride;
581  }
582 }
583 
584 static void vp6_filter_diag2(VP56Context *s, uint8_t *dst, uint8_t *src,
585  ptrdiff_t stride, int h_weight, int v_weight)
586 {
587  uint8_t *tmp = s->edge_emu_buffer+16;
588  s->h264chroma.put_h264_chroma_pixels_tab[0](tmp, src, stride, 9, h_weight, 0);
589  s->h264chroma.put_h264_chroma_pixels_tab[0](dst, tmp, stride, 8, 0, v_weight);
590 }
591 
592 static void vp6_filter(VP56Context *s, uint8_t *dst, uint8_t *src,
593  int offset1, int offset2, ptrdiff_t stride,
594  VP56mv mv, int mask, int select, int luma)
595 {
596  int filter4 = 0;
597  int x8 = mv.x & mask;
598  int y8 = mv.y & mask;
599 
600  if (luma) {
601  x8 *= 2;
602  y8 *= 2;
603  filter4 = s->filter_mode;
604  if (filter4 == 2) {
605  if (s->max_vector_length &&
606  (FFABS(mv.x) > s->max_vector_length ||
607  FFABS(mv.y) > s->max_vector_length)) {
608  filter4 = 0;
609  } else if (s->sample_variance_threshold
610  && (vp6_block_variance(src+offset1, stride)
611  < s->sample_variance_threshold)) {
612  filter4 = 0;
613  }
614  }
615  }
616 
617  if ((y8 && (offset2-offset1)*s->flip<0) || (!y8 && offset1 > offset2)) {
618  offset1 = offset2;
619  }
620 
621  if (filter4) {
622  if (!y8) { /* left or right combine */
623  vp6_filter_hv4(dst, src+offset1, stride, 1,
624  vp6_block_copy_filter[select][x8]);
625  } else if (!x8) { /* above or below combine */
626  vp6_filter_hv4(dst, src+offset1, stride, stride,
627  vp6_block_copy_filter[select][y8]);
628  } else {
629  s->vp56dsp.vp6_filter_diag4(dst, src+offset1+((mv.x^mv.y)>>31), stride,
630  vp6_block_copy_filter[select][x8],
631  vp6_block_copy_filter[select][y8]);
632  }
633  } else {
634  if (!x8 || !y8) {
635  s->h264chroma.put_h264_chroma_pixels_tab[0](dst, src + offset1, stride, 8, x8, y8);
636  } else {
637  vp6_filter_diag2(s, dst, src+offset1 + ((mv.x^mv.y)>>31), stride, x8, y8);
638  }
639  }
640 }
641 
643  VP56Context *s, int flip, int has_alpha)
644 {
645  int ret = ff_vp56_init_context(avctx, s, flip, has_alpha);
646  if (ret < 0)
647  return ret;
648 
649  ff_vp6dsp_init(&s->vp56dsp);
650 
651  s->deblock_filtering = 0;
652  s->vp56_coord_div = vp6_coord_div;
653  s->parse_vector_adjustment = vp6_parse_vector_adjustment;
654  s->filter = vp6_filter;
655  s->default_models_init = vp6_default_models_init;
656  s->parse_vector_models = vp6_parse_vector_models;
657  s->parse_coeff_models = vp6_parse_coeff_models;
658  s->parse_header = vp6_parse_header;
659 
660  return 0;
661 }
662 
664 {
665  VP56Context *s = avctx->priv_data;
666  int ret;
667 
669  avctx->codec_id == AV_CODEC_ID_VP6A);
670  if (ret < 0)
671  return ret;
672 
673  if (s->has_alpha) {
674  /* Can only happen for ff_vp6a_decoder */
675  s->alpha_context = &s[1];
676  ret = vp6_decode_init_context(avctx, s->alpha_context,
677  s->flip == -1, s->has_alpha);
678  if (ret < 0)
679  return ret;
680  }
681 
682  return 0;
683 }
684 
685 static av_cold void vp6_decode_free_context(VP56Context *s);
686 
688 {
689  VP56Context *s = avctx->priv_data;
690 
692 
693  if (s->alpha_context) {
694  vp6_decode_free_context(s->alpha_context);
695  s->alpha_context = NULL;
696  }
697 
698  return 0;
699 }
700 
701 static av_cold void vp6_decode_free_context(VP56Context *s)
702 {
703  int pt, ct, cg;
704 
706 
707  for (pt=0; pt<2; pt++) {
708  ff_free_vlc(&s->dccv_vlc[pt]);
709  ff_free_vlc(&s->runv_vlc[pt]);
710  for (ct=0; ct<3; ct++)
711  for (cg=0; cg<6; cg++)
712  ff_free_vlc(&s->ract_vlc[pt][ct][cg]);
713  }
714 }
715 
717  .p.name = "vp6",
718  .p.long_name = NULL_IF_CONFIG_SMALL("On2 VP6"),
719  .p.type = AVMEDIA_TYPE_VIDEO,
720  .p.id = AV_CODEC_ID_VP6,
721  .priv_data_size = sizeof(VP56Context),
723  .close = vp6_decode_free,
725  .p.capabilities = AV_CODEC_CAP_DR1,
726  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
727 };
728 
729 /* flash version, not flipped upside-down */
731  .p.name = "vp6f",
732  .p.long_name = NULL_IF_CONFIG_SMALL("On2 VP6 (Flash version)"),
733  .p.type = AVMEDIA_TYPE_VIDEO,
734  .p.id = AV_CODEC_ID_VP6F,
735  .priv_data_size = sizeof(VP56Context),
737  .close = vp6_decode_free,
739  .p.capabilities = AV_CODEC_CAP_DR1,
740  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
741 };
742 
743 /* flash version, not flipped upside-down, with alpha channel */
745  .p.name = "vp6a",
746  .p.long_name = NULL_IF_CONFIG_SMALL("On2 VP6 (Flash version, with alpha channel)"),
747  .p.type = AVMEDIA_TYPE_VIDEO,
748  .p.id = AV_CODEC_ID_VP6A,
749  .priv_data_size = 2 /* Main context + alpha context */ * sizeof(VP56Context),
751  .close = vp6_decode_free,
753  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SLICE_THREADS,
754  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
755 };
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
AV_CODEC_ID_VP6F
@ AV_CODEC_ID_VP6F
Definition: codec_id.h:142
vp6_def_fdv_vector_model
static const uint8_t vp6_def_fdv_vector_model[2][8]
Definition: vp6data.h:33
vp6_block_copy_filter
static const int16_t vp6_block_copy_filter[17][8][4]
Definition: vp6data.h:151
av_clip
#define av_clip
Definition: common.h:95
VP56mv::x
int16_t x
Definition: vp56.h:68
vp56data.h
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:41
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:839
vp6_decode_free
static av_cold int vp6_decode_free(AVCodecContext *avctx)
Definition: vp6.c:687
Node
Definition: agm.c:916
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:86
VP56Model::mb_types_stats
uint8_t mb_types_stats[3][10][2]
Definition: vp56.h:112
vp6_coeff_order_table_init
static void vp6_coeff_order_table_init(VP56Context *s)
Definition: vp6.c:192
ff_vp56_coeff_bit_length
const uint8_t ff_vp56_coeff_bit_length[]
Definition: vp56data.c:68
mv
static const int8_t mv[256][2]
Definition: 4xm.c:80
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
internal.h
AV_CODEC_ID_VP6
@ AV_CODEC_ID_VP6
Definition: codec_id.h:141
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
b
#define b
Definition: input.c:34
FFCodec
Definition: codec_internal.h:118
ff_vp6f_decoder
const FFCodec ff_vp6f_decoder
Definition: vp6.c:730
max
#define max(a, b)
Definition: cuda_runtime.h:33
vp6_filter_diag2
static void vp6_filter_diag2(VP56Context *s, uint8_t *dst, uint8_t *src, ptrdiff_t stride, int h_weight, int v_weight)
Definition: vp6.c:584
VP56Model::coeff_index_to_pos
uint8_t coeff_index_to_pos[64]
Definition: vp56.h:99
VP56Model::coeff_ract
uint8_t coeff_ract[2][3][6][11]
Definition: vp56.h:107
VPXRangeCoder
Definition: vpx_rac.h:35
ff_vp6_decoder
const FFCodec ff_vp6_decoder
Definition: vp6.c:716
vp6_def_coeff_reorder
static const uint8_t vp6_def_coeff_reorder[]
Definition: vp6data.h:43
init
static int init
Definition: av_tx.c:47
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:122
fail
#define fail()
Definition: checkasm.h:131
val
static double val(void *priv, double ch)
Definition: aeval.c:77
ff_vp56_b6to4
const uint8_t ff_vp56_b6to4[]
Definition: vp56data.c:29
VP56_SIZE_CHANGE
#define VP56_SIZE_CHANGE
Definition: vp56.h:72
vp6_huff_cmp
static int vp6_huff_cmp(const void *va, const void *vb)
Definition: vp6.c:258
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:667
vp56_rac_gets_nn
static av_unused int vp56_rac_gets_nn(VPXRangeCoder *c, int bits)
Definition: vp56.h:236
mask
static const uint16_t mask[17]
Definition: lzw.c:38
vp6_huff_coeff_map
static const uint8_t vp6_huff_coeff_map[]
Definition: vp6data.h:304
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:260
s
#define s(width, name)
Definition: cbs_vp9.c:256
vp6_huff_run_map
static const uint8_t vp6_huff_run_map[]
Definition: vp6data.h:308
permute
static void permute(uint8_t *dst, const uint8_t *src, const uint8_t permutation[64])
Definition: proresdec2.c:48
vp6_dccv_pct
static const uint8_t vp6_dccv_pct[2][11]
Definition: vp6data.h:74
vp6_def_runv_coeff_model
static const uint8_t vp6_def_runv_coeff_model[2][14]
Definition: vp6data.h:54
ff_vp6a_decoder
const FFCodec ff_vp6a_decoder
Definition: vp6.c:744
ctx
AVFormatContext * ctx
Definition: movenc.c:48
ff_vp56_free_context
av_cold int ff_vp56_free_context(VP56Context *s)
Definition: vp56.c:828
get_bits.h
VP56mv::y
int16_t y
Definition: vp56.h:69
VP56mv
Definition: vp56.h:67
VP56Model::coeff_dccv
uint8_t coeff_dccv[2][11]
Definition: vp56.h:106
VP56Model::coeff_dcct
uint8_t coeff_dcct[2][36][5]
Definition: vp56.h:109
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:408
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:64
vp56.h
vp6_pcr_tree
static const VP56Tree vp6_pcr_tree[]
Definition: vp6data.h:290
vp6_get_nb_null
static unsigned vp6_get_nb_null(VP56Context *s)
Read number of consecutive blocks with null DC or AC.
Definition: vp6.c:397
VP56Model::vector_sig
uint8_t vector_sig[2]
Definition: vp56.h:101
VP56Model::coeff_runv
uint8_t coeff_runv[2][14]
Definition: vp56.h:110
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
run
uint8_t run
Definition: svq3.c:205
ff_vp56_def_mb_types_stats
const uint8_t ff_vp56_def_mb_types_stats[3][10][2]
Definition: vp56data.c:40
vp6_parse_header
static int vp6_parse_header(VP56Context *s, const uint8_t *buf, int buf_size)
Definition: vp6.c:48
vp6_decode_init_context
static av_cold int vp6_decode_init_context(AVCodecContext *avctx, VP56Context *s, int flip, int has_alpha)
Definition: vp6.c:642
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
ff_vp6dsp_init
void ff_vp6dsp_init(VP56DSPContext *s)
vp6_parse_vector_adjustment
static void vp6_parse_vector_adjustment(VP56Context *s, VP56mv *vect)
Definition: vp6.c:355
vp6_sig_dct_pct
static const uint8_t vp6_sig_dct_pct[2][2]
Definition: vp6data.h:59
vp6_fdv_pct
static const uint8_t vp6_fdv_pct[2][8]
Definition: vp6data.h:69
AV_CODEC_ID_VP6A
@ AV_CODEC_ID_VP6A
Definition: codec_id.h:156
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:787
vp6_coord_div
static const uint8_t vp6_coord_div[]
Definition: vp6data.h:302
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
vp6_filter_hv4
static void vp6_filter_hv4(uint8_t *dst, uint8_t *src, ptrdiff_t stride, int delta, const int16_t *weights)
Definition: vp6.c:567
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
flip
static void flip(AVCodecContext *avctx, AVFrame *frame)
Definition: rawdec.c:132
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
codec_internal.h
vp6_default_models_init
static void vp6_default_models_init(VP56Context *s)
Definition: vp6.c:215
ff_vp56_coeff_parse_table
const uint8_t ff_vp56_coeff_parse_table[6][11]
Definition: vp56data.c:31
size
int size
Definition: twinvq_data.h:10344
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
vp6_parse_coeff_models
static int vp6_parse_coeff_models(VP56Context *s)
Definition: vp6.c:286
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
VP6_MAX_HUFF_SIZE
#define VP6_MAX_HUFF_SIZE
Definition: vp6.c:43
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:117
pt
int pt
Definition: rtp.c:35
vp56_rac_gets
static int vp56_rac_gets(VPXRangeCoder *c, int bits)
vp56 specific range coder implementation
Definition: vp56.h:224
ff_vp56_pva_tree
const VP56Tree ff_vp56_pva_tree[]
Definition: vp56data.c:49
VP56Model::coeff_index_to_idct_selector
uint8_t coeff_index_to_idct_selector[64]
Definition: vp56.h:100
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
FF_HUFFMAN_BITS
#define FF_HUFFMAN_BITS
Definition: huffman.h:41
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
vp6_decode_init
static av_cold int vp6_decode_init(AVCodecContext *avctx)
Definition: vp6.c:663
vpx_rac.h
weights
static const int weights[]
Definition: hevc_pel.c:32
delta
float delta
Definition: vorbis_enc_data.h:430
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
ff_vp56_pc_tree
const VP56Tree ff_vp56_pc_tree[]
Definition: vp56data.c:59
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
ff_free_vlc
void ff_free_vlc(VLC *vlc)
Definition: vlc.c:375
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
ret
ret
Definition: filter_design.txt:187
ff_huff_build_tree
int ff_huff_build_tree(void *logctx, VLC *vlc, int nb_codes, int nb_bits, Node *nodes, HuffCmp cmp, int flags)
nodes size must be 2*nb_codes first nb_codes nodes.count must be set
Definition: huffman.c:159
vp6_filter
static void vp6_filter(VP56Context *s, uint8_t *dst, uint8_t *src, int offset1, int offset2, ptrdiff_t stride, VP56mv mv, int mask, int select, int luma)
Definition: vp6.c:592
ff_vp56_coeff_bias
const uint8_t ff_vp56_coeff_bias[]
Definition: vp56data.c:67
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
pos
unsigned int pos
Definition: spdifenc.c:412
VP56Model::vector_fdv
uint8_t vector_fdv[2][8]
Definition: vp56.h:105
ff_vp56_decode_frame
int ff_vp56_decode_frame(AVCodecContext *avctx, AVFrame *rframe, int *got_frame, AVPacket *avpkt)
Definition: vp56.c:569
VP56_FRAME_CURRENT
@ VP56_FRAME_CURRENT
Definition: vp56.h:44
AVCodecContext
main external API structure.
Definition: avcodec.h:398
vp6_block_variance
static int vp6_block_variance(uint8_t *src, ptrdiff_t stride)
Definition: vp6.c:552
vp6_coeff_reorder_pct
static const uint8_t vp6_coeff_reorder_pct[]
Definition: vp6data.h:79
vp6_parse_vector_models
static void vp6_parse_vector_models(VP56Context *s)
Definition: vp6.c:233
VP56Model
Definition: vp56.h:97
VLC
Definition: vlc.h:31
ff_vp56_init_dequant
void ff_vp56_init_dequant(VP56Context *s, int quantizer)
Definition: vp56.c:35
vp6_dccv_lc
static const int vp6_dccv_lc[3][5][2]
Definition: vp6data.h:134
huffman.h
vp6_pdv_pct
static const uint8_t vp6_pdv_pct[2][7]
Definition: vp6data.h:64
VLC::table
VLCElem * table
Definition: vlc.h:33
av_clip_uint8
#define av_clip_uint8
Definition: common.h:101
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
vpx_rac_get
static av_always_inline int vpx_rac_get(VPXRangeCoder *c)
Definition: vpx_rac.h:117
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:90
vp6_build_huff_tree
static int vp6_build_huff_tree(VP56Context *s, uint8_t coeff_model[], const uint8_t *map, unsigned size, VLC *vlc)
Definition: vp6.c:264
map
const VDPAUPixFmtMap * map
Definition: hwcontext_vdpau.c:71
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
VP56Model::vector_dct
uint8_t vector_dct[2]
Definition: vp56.h:102
vp6data.h
vp6_coeff_groups
static const uint8_t vp6_coeff_groups[]
Definition: vp6data.h:140
vp6_def_pdv_vector_model
static const uint8_t vp6_def_pdv_vector_model[2][7]
Definition: vp6data.h:38
coeff
static const double coeff[2][5]
Definition: vf_owdenoise.c:78
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
vp6_parse_coeff_huffman
static int vp6_parse_coeff_huffman(VP56Context *s)
Definition: vp6.c:409
Node::count
uint32_t count
Definition: huffman.h:36
vp6_decode_free_context
static av_cold void vp6_decode_free_context(VP56Context *s)
Definition: vp6.c:701
vp6_parse_coeff
static int vp6_parse_coeff(VP56Context *s)
Definition: vp6.c:470
vpx_rac_get_prob
#define vpx_rac_get_prob
Definition: vpx_rac.h:82
FF_HUFFMAN_FLAG_HNODE_FIRST
#define FF_HUFFMAN_FLAG_HNODE_FIRST
Definition: huffman.h:39
VP56Model::vector_pdv
uint8_t vector_pdv[2][7]
Definition: vp56.h:104
vp6_runv_pct
static const uint8_t vp6_runv_pct[2][14]
Definition: vp6data.h:90
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98
vp6_ract_pct
static const uint8_t vp6_ract_pct[3][2][6][11]
Definition: vp6data.h:95
VP56Model::coeff_reorder
uint8_t coeff_reorder[64]
Definition: vp56.h:98