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