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) {
166  goto fail;
167  }
168  if (s->use_huffman) {
169  s->parse_coeff = vp6_parse_coeff_huffman;
170  ret = init_get_bits8(&s->gb, buf, buf_size);
171  if (ret < 0)
172  return ret;
173  } else {
174  ret = ff_vp56_init_range_decoder(&s->cc, buf, buf_size);
175  if (ret < 0)
176  goto fail;
177  s->ccp = &s->cc;
178  }
179  } else {
180  s->ccp = &s->c;
181  }
182 
183  return res;
184 fail:
185  if (res == VP56_SIZE_CHANGE)
186  ff_set_dimensions(s->avctx, 0, 0);
187  return ret;
188 }
189 
190 static void vp6_coeff_order_table_init(VP56Context *s)
191 {
192  int i, pos, idx = 1;
193 
194  s->modelp->coeff_index_to_pos[0] = 0;
195  for (i=0; i<16; i++)
196  for (pos=1; pos<64; pos++)
197  if (s->modelp->coeff_reorder[pos] == i)
198  s->modelp->coeff_index_to_pos[idx++] = pos;
199 
200  for (idx = 0; idx < 64; idx++) {
201  int max = 0;
202  for (i = 0; i <= idx; i++) {
203  int v = s->modelp->coeff_index_to_pos[i];
204  if (v > max)
205  max = v;
206  }
207  if (s->sub_version > 6)
208  max++;
209  s->modelp->coeff_index_to_idct_selector[idx] = max;
210  }
211 }
212 
213 static void vp6_default_models_init(VP56Context *s)
214 {
215  VP56Model *model = s->modelp;
216 
217  model->vector_dct[0] = 0xA2;
218  model->vector_dct[1] = 0xA4;
219  model->vector_sig[0] = 0x80;
220  model->vector_sig[1] = 0x80;
221 
222  memcpy(model->mb_types_stats, ff_vp56_def_mb_types_stats, sizeof(model->mb_types_stats));
223  memcpy(model->vector_fdv, vp6_def_fdv_vector_model, sizeof(model->vector_fdv));
224  memcpy(model->vector_pdv, vp6_def_pdv_vector_model, sizeof(model->vector_pdv));
225  memcpy(model->coeff_runv, vp6_def_runv_coeff_model, sizeof(model->coeff_runv));
226  memcpy(model->coeff_reorder, vp6_def_coeff_reorder, sizeof(model->coeff_reorder));
227 
229 }
230 
231 static void vp6_parse_vector_models(VP56Context *s)
232 {
233  VP56RangeCoder *c = &s->c;
234  VP56Model *model = s->modelp;
235  int comp, node;
236 
237  for (comp=0; comp<2; comp++) {
239  model->vector_dct[comp] = vp56_rac_gets_nn(c, 7);
241  model->vector_sig[comp] = vp56_rac_gets_nn(c, 7);
242  }
243 
244  for (comp=0; comp<2; comp++)
245  for (node=0; node<7; node++)
247  model->vector_pdv[comp][node] = vp56_rac_gets_nn(c, 7);
248 
249  for (comp=0; comp<2; comp++)
250  for (node=0; node<8; node++)
252  model->vector_fdv[comp][node] = vp56_rac_gets_nn(c, 7);
253 }
254 
255 /* nodes must ascend by count, but with descending symbol order */
256 static int vp6_huff_cmp(const void *va, const void *vb)
257 {
258  const Node *a = va, *b = vb;
259  return (a->count - b->count)*16 + (b->sym - a->sym);
260 }
261 
262 static int vp6_build_huff_tree(VP56Context *s, uint8_t coeff_model[],
263  const uint8_t *map, unsigned size, VLC *vlc)
264 {
265  Node nodes[2*VP6_MAX_HUFF_SIZE], *tmp = &nodes[size];
266  int a, b, i;
267 
268  /* first compute probabilities from model */
269  tmp[0].count = 256;
270  for (i=0; i<size-1; i++) {
271  a = tmp[i].count * coeff_model[i] >> 8;
272  b = tmp[i].count * (255 - coeff_model[i]) >> 8;
273  nodes[map[2*i ]].count = a + !a;
274  nodes[map[2*i+1]].count = b + !b;
275  }
276 
277  ff_free_vlc(vlc);
278  /* then build the huffman tree according to probabilities */
279  return ff_huff_build_tree(s->avctx, vlc, size, FF_HUFFMAN_BITS,
280  nodes, vp6_huff_cmp,
282 }
283 
284 static int vp6_parse_coeff_models(VP56Context *s)
285 {
286  VP56RangeCoder *c = &s->c;
287  VP56Model *model = s->modelp;
288  int def_prob[11];
289  int node, cg, ctx, pos;
290  int ct; /* code type */
291  int pt; /* plane type (0 for Y, 1 for U or V) */
292 
293  memset(def_prob, 0x80, sizeof(def_prob));
294 
295  for (pt=0; pt<2; pt++)
296  for (node=0; node<11; node++)
298  def_prob[node] = vp56_rac_gets_nn(c, 7);
299  model->coeff_dccv[pt][node] = def_prob[node];
300  } else if (s->frames[VP56_FRAME_CURRENT]->key_frame) {
301  model->coeff_dccv[pt][node] = def_prob[node];
302  }
303 
304  if (vp56_rac_get(c)) {
305  for (pos=1; pos<64; pos++)
307  model->coeff_reorder[pos] = vp56_rac_gets(c, 4);
309  }
310 
311  for (cg=0; cg<2; cg++)
312  for (node=0; node<14; node++)
313  if (vp56_rac_get_prob_branchy(c, vp6_runv_pct[cg][node]))
314  model->coeff_runv[cg][node] = vp56_rac_gets_nn(c, 7);
315 
316  for (ct=0; ct<3; ct++)
317  for (pt=0; pt<2; pt++)
318  for (cg=0; cg<6; cg++)
319  for (node=0; node<11; node++)
320  if (vp56_rac_get_prob_branchy(c, vp6_ract_pct[ct][pt][cg][node])) {
321  def_prob[node] = vp56_rac_gets_nn(c, 7);
322  model->coeff_ract[pt][ct][cg][node] = def_prob[node];
323  } else if (s->frames[VP56_FRAME_CURRENT]->key_frame) {
324  model->coeff_ract[pt][ct][cg][node] = def_prob[node];
325  }
326 
327  if (s->use_huffman) {
328  for (pt=0; pt<2; pt++) {
329  if (vp6_build_huff_tree(s, model->coeff_dccv[pt],
330  vp6_huff_coeff_map, 12, &s->dccv_vlc[pt]))
331  return -1;
332  if (vp6_build_huff_tree(s, model->coeff_runv[pt],
333  vp6_huff_run_map, 9, &s->runv_vlc[pt]))
334  return -1;
335  for (ct=0; ct<3; ct++)
336  for (cg = 0; cg < 6; cg++)
337  if (vp6_build_huff_tree(s, model->coeff_ract[pt][ct][cg],
338  vp6_huff_coeff_map, 12,
339  &s->ract_vlc[pt][ct][cg]))
340  return -1;
341  }
342  memset(s->nb_null, 0, sizeof(s->nb_null));
343  } else {
344  /* coeff_dcct is a linear combination of coeff_dccv */
345  for (pt=0; pt<2; pt++)
346  for (ctx=0; ctx<3; ctx++)
347  for (node=0; node<5; node++)
348  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);
349  }
350  return 0;
351 }
352 
353 static void vp6_parse_vector_adjustment(VP56Context *s, VP56mv *vect)
354 {
355  VP56RangeCoder *c = &s->c;
356  VP56Model *model = s->modelp;
357  int comp;
358 
359  *vect = (VP56mv) {0,0};
360  if (s->vector_candidate_pos < 2)
361  *vect = s->vector_candidate[0];
362 
363  for (comp=0; comp<2; comp++) {
364  int i, delta = 0;
365 
366  if (vp56_rac_get_prob_branchy(c, model->vector_dct[comp])) {
367  static const uint8_t prob_order[] = {0, 1, 2, 7, 6, 5, 4};
368  for (i=0; i<sizeof(prob_order); i++) {
369  int j = prob_order[i];
370  delta |= vp56_rac_get_prob(c, model->vector_fdv[comp][j])<<j;
371  }
372  if (delta & 0xF0)
373  delta |= vp56_rac_get_prob(c, model->vector_fdv[comp][3])<<3;
374  else
375  delta |= 8;
376  } else {
378  model->vector_pdv[comp]);
379  }
380 
382  delta = -delta;
383 
384  if (!comp)
385  vect->x += delta;
386  else
387  vect->y += delta;
388  }
389 }
390 
391 /**
392  * Read number of consecutive blocks with null DC or AC.
393  * This value is < 74.
394  */
395 static unsigned vp6_get_nb_null(VP56Context *s)
396 {
397  unsigned val = get_bits(&s->gb, 2);
398  if (val == 2)
399  val += get_bits(&s->gb, 2);
400  else if (val == 3) {
401  val = get_bits1(&s->gb) << 2;
402  val = 6+val + get_bits(&s->gb, 2+val);
403  }
404  return val;
405 }
406 
407 static int vp6_parse_coeff_huffman(VP56Context *s)
408 {
409  VP56Model *model = s->modelp;
410  uint8_t *permute = s->idct_scantable;
411  VLC *vlc_coeff;
412  int coeff, sign, coeff_idx;
413  int b, cg, idx;
414  int pt = 0; /* plane type (0 for Y, 1 for U or V) */
415 
416  for (b=0; b<6; b++) {
417  int ct = 0; /* code type */
418  if (b > 3) pt = 1;
419  vlc_coeff = &s->dccv_vlc[pt];
420 
421  for (coeff_idx = 0;;) {
422  int run = 1;
423  if (coeff_idx<2 && s->nb_null[coeff_idx][pt]) {
424  s->nb_null[coeff_idx][pt]--;
425  if (coeff_idx)
426  break;
427  } else {
428  if (get_bits_left(&s->gb) <= 0)
429  return AVERROR_INVALIDDATA;
430  coeff = get_vlc2(&s->gb, vlc_coeff->table, FF_HUFFMAN_BITS, 3);
431  if (coeff == 0) {
432  if (coeff_idx) {
433  int pt = (coeff_idx >= 6);
434  run += get_vlc2(&s->gb, s->runv_vlc[pt].table, FF_HUFFMAN_BITS, 3);
435  if (run >= 9)
436  run += get_bits(&s->gb, 6);
437  } else
438  s->nb_null[0][pt] = vp6_get_nb_null(s);
439  ct = 0;
440  } else if (coeff == 11) { /* end of block */
441  if (coeff_idx == 1) /* first AC coeff ? */
442  s->nb_null[1][pt] = vp6_get_nb_null(s);
443  break;
444  } else {
445  int coeff2 = ff_vp56_coeff_bias[coeff];
446  if (coeff > 4)
447  coeff2 += get_bits(&s->gb, coeff <= 9 ? coeff - 4 : 11);
448  ct = 1 + (coeff2 > 1);
449  sign = get_bits1(&s->gb);
450  coeff2 = (coeff2 ^ -sign) + sign;
451  if (coeff_idx)
452  coeff2 *= s->dequant_ac;
453  idx = model->coeff_index_to_pos[coeff_idx];
454  s->block_coeff[b][permute[idx]] = coeff2;
455  }
456  }
457  coeff_idx+=run;
458  if (coeff_idx >= 64)
459  break;
460  cg = FFMIN(vp6_coeff_groups[coeff_idx], 3);
461  vlc_coeff = &s->ract_vlc[pt][ct][cg];
462  }
463  s->idct_selector[b] = model->coeff_index_to_idct_selector[FFMIN(coeff_idx, 63)];
464  }
465  return 0;
466 }
467 
468 static int vp6_parse_coeff(VP56Context *s)
469 {
470  VP56RangeCoder *c = s->ccp;
471  VP56Model *model = s->modelp;
472  uint8_t *permute = s->idct_scantable;
473  uint8_t *model1, *model2, *model3;
474  int coeff, sign, coeff_idx;
475  int b, i, cg, idx, ctx;
476  int pt = 0; /* plane type (0 for Y, 1 for U or V) */
477 
478  if (vpX_rac_is_end(c)) {
479  av_log(s->avctx, AV_LOG_ERROR, "End of AC stream reached in vp6_parse_coeff\n");
480  return AVERROR_INVALIDDATA;
481  }
482 
483  for (b=0; b<6; b++) {
484  int ct = 1; /* code type */
485  int run = 1;
486 
487  if (b > 3) pt = 1;
488 
489  ctx = s->left_block[ff_vp56_b6to4[b]].not_null_dc
490  + s->above_blocks[s->above_block_idx[b]].not_null_dc;
491  model1 = model->coeff_dccv[pt];
492  model2 = model->coeff_dcct[pt][ctx];
493 
494  coeff_idx = 0;
495  for (;;) {
496  if ((coeff_idx>1 && ct==0) || vp56_rac_get_prob_branchy(c, model2[0])) {
497  /* parse a coeff */
498  if (vp56_rac_get_prob_branchy(c, model2[2])) {
499  if (vp56_rac_get_prob_branchy(c, model2[3])) {
500  idx = vp56_rac_get_tree(c, ff_vp56_pc_tree, model1);
501  coeff = ff_vp56_coeff_bias[idx+5];
502  for (i=ff_vp56_coeff_bit_length[idx]; i>=0; i--)
504  } else {
505  if (vp56_rac_get_prob_branchy(c, model2[4]))
506  coeff = 3 + vp56_rac_get_prob(c, model1[5]);
507  else
508  coeff = 2;
509  }
510  ct = 2;
511  } else {
512  ct = 1;
513  coeff = 1;
514  }
515  sign = vp56_rac_get(c);
516  coeff = (coeff ^ -sign) + sign;
517  if (coeff_idx)
518  coeff *= s->dequant_ac;
519  idx = model->coeff_index_to_pos[coeff_idx];
520  s->block_coeff[b][permute[idx]] = coeff;
521  run = 1;
522  } else {
523  /* parse a run */
524  ct = 0;
525  if (coeff_idx > 0) {
526  if (!vp56_rac_get_prob_branchy(c, model2[1]))
527  break;
528 
529  model3 = model->coeff_runv[coeff_idx >= 6];
530  run = vp56_rac_get_tree(c, vp6_pcr_tree, model3);
531  if (!run)
532  for (run=9, i=0; i<6; i++)
533  run += vp56_rac_get_prob(c, model3[i+8]) << i;
534  }
535  }
536  coeff_idx += run;
537  if (coeff_idx >= 64)
538  break;
539  cg = vp6_coeff_groups[coeff_idx];
540  model1 = model2 = model->coeff_ract[pt][ct][cg];
541  }
542 
543  s->left_block[ff_vp56_b6to4[b]].not_null_dc =
544  s->above_blocks[s->above_block_idx[b]].not_null_dc = !!s->block_coeff[b][0];
545  s->idct_selector[b] = model->coeff_index_to_idct_selector[FFMIN(coeff_idx, 63)];
546  }
547  return 0;
548 }
549 
550 static int vp6_block_variance(uint8_t *src, ptrdiff_t stride)
551 {
552  int sum = 0, square_sum = 0;
553  int y, x;
554 
555  for (y=0; y<8; y+=2) {
556  for (x=0; x<8; x+=2) {
557  sum += src[x];
558  square_sum += src[x]*src[x];
559  }
560  src += 2*stride;
561  }
562  return (16*square_sum - sum*sum) >> 8;
563 }
564 
565 static void vp6_filter_hv4(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
566  int delta, const int16_t *weights)
567 {
568  int x, y;
569 
570  for (y=0; y<8; y++) {
571  for (x=0; x<8; x++) {
572  dst[x] = av_clip_uint8(( src[x-delta ] * weights[0]
573  + src[x ] * weights[1]
574  + src[x+delta ] * weights[2]
575  + src[x+2*delta] * weights[3] + 64) >> 7);
576  }
577  src += stride;
578  dst += stride;
579  }
580 }
581 
582 static void vp6_filter_diag2(VP56Context *s, uint8_t *dst, uint8_t *src,
583  ptrdiff_t stride, int h_weight, int v_weight)
584 {
585  uint8_t *tmp = s->edge_emu_buffer+16;
586  s->h264chroma.put_h264_chroma_pixels_tab[0](tmp, src, stride, 9, h_weight, 0);
587  s->h264chroma.put_h264_chroma_pixels_tab[0](dst, tmp, stride, 8, 0, v_weight);
588 }
589 
590 static void vp6_filter(VP56Context *s, uint8_t *dst, uint8_t *src,
591  int offset1, int offset2, ptrdiff_t stride,
592  VP56mv mv, int mask, int select, int luma)
593 {
594  int filter4 = 0;
595  int x8 = mv.x & mask;
596  int y8 = mv.y & mask;
597 
598  if (luma) {
599  x8 *= 2;
600  y8 *= 2;
601  filter4 = s->filter_mode;
602  if (filter4 == 2) {
603  if (s->max_vector_length &&
604  (FFABS(mv.x) > s->max_vector_length ||
605  FFABS(mv.y) > s->max_vector_length)) {
606  filter4 = 0;
607  } else if (s->sample_variance_threshold
608  && (vp6_block_variance(src+offset1, stride)
609  < s->sample_variance_threshold)) {
610  filter4 = 0;
611  }
612  }
613  }
614 
615  if ((y8 && (offset2-offset1)*s->flip<0) || (!y8 && offset1 > offset2)) {
616  offset1 = offset2;
617  }
618 
619  if (filter4) {
620  if (!y8) { /* left or right combine */
621  vp6_filter_hv4(dst, src+offset1, stride, 1,
622  vp6_block_copy_filter[select][x8]);
623  } else if (!x8) { /* above or below combine */
624  vp6_filter_hv4(dst, src+offset1, stride, stride,
625  vp6_block_copy_filter[select][y8]);
626  } else {
627  s->vp56dsp.vp6_filter_diag4(dst, src+offset1+((mv.x^mv.y)>>31), stride,
628  vp6_block_copy_filter[select][x8],
629  vp6_block_copy_filter[select][y8]);
630  }
631  } else {
632  if (!x8 || !y8) {
633  s->h264chroma.put_h264_chroma_pixels_tab[0](dst, src + offset1, stride, 8, x8, y8);
634  } else {
635  vp6_filter_diag2(s, dst, src+offset1 + ((mv.x^mv.y)>>31), stride, x8, y8);
636  }
637  }
638 }
639 
640 static av_cold void vp6_decode_init_context(VP56Context *s);
641 
643 {
644  VP56Context *s = avctx->priv_data;
645  int ret;
646 
647  if ((ret = ff_vp56_init(avctx, avctx->codec->id == AV_CODEC_ID_VP6,
648  avctx->codec->id == AV_CODEC_ID_VP6A)) < 0)
649  return ret;
650  ff_vp6dsp_init(&s->vp56dsp);
651 
653 
654  if (s->has_alpha) {
655  s->alpha_context = av_mallocz(sizeof(VP56Context));
656  ff_vp56_init_context(avctx, s->alpha_context,
657  s->flip == -1, s->has_alpha);
658  ff_vp6dsp_init(&s->alpha_context->vp56dsp);
659  vp6_decode_init_context(s->alpha_context);
660  }
661 
662  return 0;
663 }
664 
665 static av_cold void vp6_decode_init_context(VP56Context *s)
666 {
667  s->deblock_filtering = 0;
668  s->vp56_coord_div = vp6_coord_div;
669  s->parse_vector_adjustment = vp6_parse_vector_adjustment;
670  s->filter = vp6_filter;
671  s->default_models_init = vp6_default_models_init;
672  s->parse_vector_models = vp6_parse_vector_models;
673  s->parse_coeff_models = vp6_parse_coeff_models;
674  s->parse_header = vp6_parse_header;
675 }
676 
677 static av_cold void vp6_decode_free_context(VP56Context *s);
678 
680 {
681  VP56Context *s = avctx->priv_data;
682 
683  ff_vp56_free(avctx);
685 
686  if (s->alpha_context) {
687  ff_vp56_free_context(s->alpha_context);
688  vp6_decode_free_context(s->alpha_context);
689  av_freep(&s->alpha_context);
690  }
691 
692  return 0;
693 }
694 
695 static av_cold void vp6_decode_free_context(VP56Context *s)
696 {
697  int pt, ct, cg;
698 
699  for (pt=0; pt<2; pt++) {
700  ff_free_vlc(&s->dccv_vlc[pt]);
701  ff_free_vlc(&s->runv_vlc[pt]);
702  for (ct=0; ct<3; ct++)
703  for (cg=0; cg<6; cg++)
704  ff_free_vlc(&s->ract_vlc[pt][ct][cg]);
705  }
706 }
707 
709  .name = "vp6",
710  .long_name = NULL_IF_CONFIG_SMALL("On2 VP6"),
711  .type = AVMEDIA_TYPE_VIDEO,
712  .id = AV_CODEC_ID_VP6,
713  .priv_data_size = sizeof(VP56Context),
715  .close = vp6_decode_free,
717  .capabilities = AV_CODEC_CAP_DR1,
718 };
719 
720 /* flash version, not flipped upside-down */
722  .name = "vp6f",
723  .long_name = NULL_IF_CONFIG_SMALL("On2 VP6 (Flash version)"),
724  .type = AVMEDIA_TYPE_VIDEO,
725  .id = AV_CODEC_ID_VP6F,
726  .priv_data_size = sizeof(VP56Context),
728  .close = vp6_decode_free,
730  .capabilities = AV_CODEC_CAP_DR1,
731 };
732 
733 /* flash version, not flipped upside-down, with alpha channel */
735  .name = "vp6a",
736  .long_name = NULL_IF_CONFIG_SMALL("On2 VP6 (Flash version, with alpha channel)"),
737  .type = AVMEDIA_TYPE_VIDEO,
738  .id = AV_CODEC_ID_VP6A,
739  .priv_data_size = sizeof(VP56Context),
741  .close = vp6_decode_free,
744 };
AVCodec
AVCodec.
Definition: codec.h:202
vp56_rac_get
static av_always_inline int vp56_rac_get(VP56RangeCoder *c)
Definition: vp56.h:305
stride
int stride
Definition: mace.c:144
ff_vp56_init
av_cold int ff_vp56_init(AVCodecContext *avctx, int flip, int has_alpha)
Definition: vp56.c:776
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:96
VP56mv::x
int16_t x
Definition: vp56.h:69
vp56data.h
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:850
vp6_decode_free
static av_cold int vp6_decode_free(AVCodecContext *avctx)
Definition: vp6.c:679
vpX_rac_is_end
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:239
Node
Definition: agm.c:915
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:85
VP56Model::mb_types_stats
uint8_t mb_types_stats[3][10][2]
Definition: vp56.h:123
vp6_coeff_order_table_init
static void vp6_coeff_order_table_init(VP56Context *s)
Definition: vp6.c:190
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:79
ff_vp6f_decoder
const AVCodec ff_vp6f_decoder
Definition: vp6.c:721
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
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)
Definition: vp56.c:782
b
#define b
Definition: input.c:40
get_vlc2
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:798
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:582
VP56Model::coeff_index_to_pos
uint8_t coeff_index_to_pos[64]
Definition: vp56.h:110
VP56Model::coeff_ract
uint8_t coeff_ract[2][3][6][11]
Definition: vp56.h:118
vp56_rac_gets_nn
static av_unused int vp56_rac_gets_nn(VP56RangeCoder *c, int bits)
Definition: vp56.h:368
vp6_def_coeff_reorder
static const uint8_t vp6_def_coeff_reorder[]
Definition: vp6data.h:43
vp56_rac_get_prob_branchy
static av_always_inline int vp56_rac_get_prob_branchy(VP56RangeCoder *c, int prob)
Definition: vp56.h:287
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:392
fail
#define fail()
Definition: checkasm.h:127
val
static double val(void *priv, double ch)
Definition: aeval.c:76
ff_vp56_b6to4
const uint8_t ff_vp56_b6to4[]
Definition: vp56data.c:29
square_sum
static float square_sum(const float *x, const float *y, int size)
Definition: af_axcorrelate.c:76
VP56_SIZE_CHANGE
#define VP56_SIZE_CHANGE
Definition: vp56.h:73
vp6_huff_cmp
static int vp6_huff_cmp(const void *va, const void *vb)
Definition: vp6.c:256
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:678
mask
static const uint16_t mask[17]
Definition: lzw.c:38
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
vp6_huff_coeff_map
static const uint8_t vp6_huff_coeff_map[]
Definition: vp6data.h:304
s
#define s(width, name)
Definition: cbs_vp9.c:257
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:44
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
vp56_rac_gets
static int vp56_rac_gets(VP56RangeCoder *c, int bits)
Definition: vp56.h:329
ctx
AVFormatContext * ctx
Definition: movenc.c:48
ff_vp56_free_context
av_cold int ff_vp56_free_context(VP56Context *s)
Definition: vp56.c:841
get_bits.h
VP56mv::y
int16_t y
Definition: vp56.h:70
VP56mv
Definition: vp56.h:68
ff_free_vlc
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:431
VP56Model::coeff_dccv
uint8_t coeff_dccv[2][11]
Definition: vp56.h:117
VP56Model::coeff_dcct
uint8_t coeff_dcct[2][36][5]
Definition: vp56.h:120
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:65
vp56.h
vp6_pcr_tree
static const VP56Tree vp6_pcr_tree[]
Definition: vp6data.h:290
vp6_decode_init_context
static av_cold void vp6_decode_init_context(VP56Context *s)
Definition: vp6.c:665
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:395
VP56Model::vector_sig
uint8_t vector_sig[2]
Definition: vp56.h:112
VP56Model::coeff_runv
uint8_t coeff_runv[2][14]
Definition: vp56.h:121
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
run
uint8_t run
Definition: svq3.c:203
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:46
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:499
src
#define src
Definition: vp8dsp.c:255
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:353
ff_vp6a_decoder
const AVCodec ff_vp6a_decoder
Definition: vp6.c:734
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
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:565
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
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
vp6_default_models_init
static void vp6_default_models_init(VP56Context *s)
Definition: vp6.c:213
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:284
vp56_rac_get_tree
static av_always_inline int vp56_rac_get_tree(VP56RangeCoder *c, const VP56Tree *tree, const uint8_t *probs)
Definition: vp56.h:381
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:41
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
ff_vp56_pva_tree
const VP56Tree ff_vp56_pva_tree[]
Definition: vp56data.c:49
ff_vp56_init_range_decoder
int ff_vp56_init_range_decoder(VP56RangeCoder *c, const uint8_t *buf, int buf_size)
Definition: vp56rac.c:40
VP56Model::coeff_index_to_idct_selector
uint8_t coeff_index_to_idct_selector[64]
Definition: vp56.h:111
FF_HUFFMAN_BITS
#define FF_HUFFMAN_BITS
Definition: huffman.h:41
AVCodec::id
enum AVCodecID id
Definition: codec.h:216
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
vp6_decode_init
static av_cold int vp6_decode_init(AVCodecContext *avctx)
Definition: vp6.c:642
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
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:263
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:209
avcodec.h
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:156
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:590
ff_vp56_coeff_bias
const uint8_t ff_vp56_coeff_bias[]
Definition: vp56data.c:67
pos
unsigned int pos
Definition: spdifenc.c:412
VP56Model::vector_fdv
uint8_t vector_fdv[2][8]
Definition: vp56.h:116
VP56_FRAME_CURRENT
@ VP56_FRAME_CURRENT
Definition: vp56.h:44
VP56RangeCoder
Definition: vp56.h:87
AVCodecContext
main external API structure.
Definition: avcodec.h:383
vp6_block_variance
static int vp6_block_variance(uint8_t *src, ptrdiff_t stride)
Definition: vp6.c:550
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:231
VP56Model
Definition: vp56.h:108
VLC
Definition: vlc.h:26
ff_vp56_init_dequant
void ff_vp56_init_dequant(VP56Context *s, int quantizer)
Definition: vp56.c:34
vp6_dccv_lc
static const int vp6_dccv_lc[3][5][2]
Definition: vp6data.h:134
ff_vp6_decoder
const AVCodec ff_vp6_decoder
Definition: vp6.c:708
huffman.h
vp6_pdv_pct
static const uint8_t vp6_pdv_pct[2][7]
Definition: vp6data.h:64
ff_vp56_decode_frame
int ff_vp56_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: vp56.c:568
ff_vp56_free
av_cold int ff_vp56_free(AVCodecContext *avctx)
Definition: vp56.c:835
av_clip_uint8
#define av_clip_uint8
Definition: common.h:102
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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:86
vp56_rac_get_prob
#define vp56_rac_get_prob
Definition: vp56.h:270
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:262
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:410
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
VP56Model::vector_dct
uint8_t vector_dct[2]
Definition: vp56.h:113
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:73
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
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:407
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:695
vp6_parse_coeff
static int vp6_parse_coeff(VP56Context *s)
Definition: vp6.c:468
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
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:115
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:109