FFmpeg
vp3.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2003-2004 The FFmpeg project
3  * Copyright (C) 2019 Peter Ross
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * On2 VP3/VP4 Video Decoder
25  *
26  * VP3 Video Decoder by Mike Melanson (mike at multimedia.cx)
27  * For more information about the VP3 coding process, visit:
28  * http://wiki.multimedia.cx/index.php?title=On2_VP3
29  *
30  * Theora decoder by Alex Beregszaszi
31  */
32 
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36 
37 #include "libavutil/imgutils.h"
38 
39 #include "avcodec.h"
40 #include "get_bits.h"
41 #include "hpeldsp.h"
42 #include "internal.h"
43 #include "mathops.h"
44 #include "thread.h"
45 #include "videodsp.h"
46 #include "vp3data.h"
47 #include "vp4data.h"
48 #include "vp3dsp.h"
49 #include "xiph.h"
50 
51 #define FRAGMENT_PIXELS 8
52 
53 // FIXME split things out into their own arrays
54 typedef struct Vp3Fragment {
55  int16_t dc;
58 } Vp3Fragment;
59 
60 #define SB_NOT_CODED 0
61 #define SB_PARTIALLY_CODED 1
62 #define SB_FULLY_CODED 2
63 
64 // This is the maximum length of a single long bit run that can be encoded
65 // for superblock coding or block qps. Theora special-cases this to read a
66 // bit instead of flipping the current bit to allow for runs longer than 4129.
67 #define MAXIMUM_LONG_BIT_RUN 4129
68 
69 #define MODE_INTER_NO_MV 0
70 #define MODE_INTRA 1
71 #define MODE_INTER_PLUS_MV 2
72 #define MODE_INTER_LAST_MV 3
73 #define MODE_INTER_PRIOR_LAST 4
74 #define MODE_USING_GOLDEN 5
75 #define MODE_GOLDEN_MV 6
76 #define MODE_INTER_FOURMV 7
77 #define CODING_MODE_COUNT 8
78 
79 /* special internal mode */
80 #define MODE_COPY 8
81 
82 static int theora_decode_header(AVCodecContext *avctx, GetBitContext *gb);
83 static int theora_decode_tables(AVCodecContext *avctx, GetBitContext *gb);
84 
85 
86 /* There are 6 preset schemes, plus a free-form scheme */
87 static const int ModeAlphabet[6][CODING_MODE_COUNT] = {
88  /* scheme 1: Last motion vector dominates */
93 
94  /* scheme 2 */
98  MODE_GOLDEN_MV, MODE_INTER_FOURMV },
99 
100  /* scheme 3 */
104  MODE_GOLDEN_MV, MODE_INTER_FOURMV },
105 
106  /* scheme 4 */
110  MODE_GOLDEN_MV, MODE_INTER_FOURMV },
111 
112  /* scheme 5: No motion vector dominates */
116  MODE_GOLDEN_MV, MODE_INTER_FOURMV },
117 
118  /* scheme 6 */
122  MODE_GOLDEN_MV, MODE_INTER_FOURMV },
123 };
124 
125 static const uint8_t hilbert_offset[16][2] = {
126  { 0, 0 }, { 1, 0 }, { 1, 1 }, { 0, 1 },
127  { 0, 2 }, { 0, 3 }, { 1, 3 }, { 1, 2 },
128  { 2, 2 }, { 2, 3 }, { 3, 3 }, { 3, 2 },
129  { 3, 1 }, { 2, 1 }, { 2, 0 }, { 3, 0 }
130 };
131 
132 enum {
138 };
139 
140 static const uint8_t vp4_pred_block_type_map[8] = {
149 };
150 
151 typedef struct {
152  int dc;
153  int type;
154 } VP4Predictor;
155 
156 #define MIN_DEQUANT_VAL 2
157 
158 typedef struct Vp3DecodeContext {
161  int version;
162  int width, height;
163  int chroma_x_shift, chroma_y_shift;
167  int keyframe;
168  uint8_t idct_permutation[64];
169  uint8_t idct_scantable[64];
173  DECLARE_ALIGNED(16, int16_t, block)[64];
177 
178  int qps[3];
179  int nqps;
180  int last_qps[3];
181 
191  unsigned char *superblock_coding;
192 
193  int macroblock_count; /* y macroblock count */
199  int yuv_macroblock_count; /* y+u+v macroblock count */
200 
202  int fragment_width[2];
203  int fragment_height[2];
204 
206  int fragment_start[3];
207  int data_offset[3];
211 
212  int8_t (*motion_val[2])[2];
213 
214  /* tables */
215  uint16_t coded_dc_scale_factor[2][64];
216  uint32_t coded_ac_scale_factor[64];
217  uint8_t base_matrix[384][64];
218  uint8_t qr_count[2][3];
219  uint8_t qr_size[2][3][64];
220  uint16_t qr_base[2][3][64];
221 
222  /**
223  * This is a list of all tokens in bitstream order. Reordering takes place
224  * by pulling from each level during IDCT. As a consequence, IDCT must be
225  * in Hilbert order, making the minimum slice height 64 for 4:2:0 and 32
226  * otherwise. The 32 different tokens with up to 12 bits of extradata are
227  * collapsed into 3 types, packed as follows:
228  * (from the low to high bits)
229  *
230  * 2 bits: type (0,1,2)
231  * 0: EOB run, 14 bits for run length (12 needed)
232  * 1: zero run, 7 bits for run length
233  * 7 bits for the next coefficient (3 needed)
234  * 2: coefficient, 14 bits (11 needed)
235  *
236  * Coefficients are signed, so are packed in the highest bits for automatic
237  * sign extension.
238  */
239  int16_t *dct_tokens[3][64];
240  int16_t *dct_tokens_base;
241 #define TOKEN_EOB(eob_run) ((eob_run) << 2)
242 #define TOKEN_ZERO_RUN(coeff, zero_run) (((coeff) * 512) + ((zero_run) << 2) + 1)
243 #define TOKEN_COEFF(coeff) (((coeff) * 4) + 2)
244 
245  /**
246  * number of blocks that contain DCT coefficients at
247  * the given level or higher
248  */
249  int num_coded_frags[3][64];
251 
252  /* this is a list of indexes into the all_fragments array indicating
253  * which of the fragments are coded */
254  int *coded_fragment_list[3];
255 
258  int num_kf_coded_fragment[3];
259 
260  VLC dc_vlc[16];
261  VLC ac_vlc_1[16];
262  VLC ac_vlc_2[16];
263  VLC ac_vlc_3[16];
264  VLC ac_vlc_4[16];
265 
266  VLC superblock_run_length_vlc; /* version < 2 */
267  VLC fragment_run_length_vlc; /* version < 2 */
268  VLC block_pattern_vlc[2]; /* version >= 2*/
270  VLC motion_vector_vlc; /* version < 2 */
271  VLC vp4_mv_vlc[2][7]; /* version >=2 */
272 
273  /* these arrays need to be on 16-byte boundaries since SSE2 operations
274  * index into them */
275  DECLARE_ALIGNED(16, int16_t, qmat)[3][2][3][64]; ///< qmat[qpi][is_inter][plane]
276 
277  /* This table contains superblock_count * 16 entries. Each set of 16
278  * numbers corresponds to the fragment indexes 0..15 of the superblock.
279  * An entry will be -1 to indicate that no entry corresponds to that
280  * index. */
282 
283  /* This is an array that indicates how a particular macroblock
284  * is coded. */
285  unsigned char *macroblock_coding;
286 
288 
289  /* Huffman decode */
290  int hti;
291  unsigned int hbits;
292  int entries;
294  uint32_t huffman_table[80][32][2];
295 
296  uint8_t filter_limit_values[64];
297  DECLARE_ALIGNED(8, int, bounding_values_array)[256 + 2];
298 
299  VP4Predictor * dc_pred_row; /* dc_pred_row[y_superblock_width * 4] */
301 
302 /************************************************************************
303  * VP3 specific functions
304  ************************************************************************/
305 
306 static av_cold void free_tables(AVCodecContext *avctx)
307 {
308  Vp3DecodeContext *s = avctx->priv_data;
309 
311  av_freep(&s->all_fragments);
317  av_freep(&s->dc_pred_row);
318  av_freep(&s->motion_val[0]);
319  av_freep(&s->motion_val[1]);
320 }
321 
322 static void vp3_decode_flush(AVCodecContext *avctx)
323 {
324  Vp3DecodeContext *s = avctx->priv_data;
325 
326  if (s->golden_frame.f)
328  if (s->last_frame.f)
330  if (s->current_frame.f)
332 }
333 
335 {
336  Vp3DecodeContext *s = avctx->priv_data;
337  int i, j;
338 
339  free_tables(avctx);
341 
342  s->theora_tables = 0;
343 
344  /* release all frames */
345  vp3_decode_flush(avctx);
349 
350  for (i = 0; i < 16; i++) {
351  ff_free_vlc(&s->dc_vlc[i]);
352  ff_free_vlc(&s->ac_vlc_1[i]);
353  ff_free_vlc(&s->ac_vlc_2[i]);
354  ff_free_vlc(&s->ac_vlc_3[i]);
355  ff_free_vlc(&s->ac_vlc_4[i]);
356  }
357 
362 
363  for (j = 0; j < 2; j++)
364  for (i = 0; i < 7; i++)
365  ff_free_vlc(&s->vp4_mv_vlc[j][i]);
366 
367  for (i = 0; i < 2; i++)
369  return 0;
370 }
371 
372 /**
373  * This function sets up all of the various blocks mappings:
374  * superblocks <-> fragments, macroblocks <-> fragments,
375  * superblocks <-> macroblocks
376  *
377  * @return 0 is successful; returns 1 if *anything* went wrong.
378  */
380 {
381  int sb_x, sb_y, plane;
382  int x, y, i, j = 0;
383 
384  for (plane = 0; plane < 3; plane++) {
385  int sb_width = plane ? s->c_superblock_width
386  : s->y_superblock_width;
387  int sb_height = plane ? s->c_superblock_height
388  : s->y_superblock_height;
389  int frag_width = s->fragment_width[!!plane];
390  int frag_height = s->fragment_height[!!plane];
391 
392  for (sb_y = 0; sb_y < sb_height; sb_y++)
393  for (sb_x = 0; sb_x < sb_width; sb_x++)
394  for (i = 0; i < 16; i++) {
395  x = 4 * sb_x + hilbert_offset[i][0];
396  y = 4 * sb_y + hilbert_offset[i][1];
397 
398  if (x < frag_width && y < frag_height)
399  s->superblock_fragments[j++] = s->fragment_start[plane] +
400  y * frag_width + x;
401  else
402  s->superblock_fragments[j++] = -1;
403  }
404  }
405 
406  return 0; /* successful path out */
407 }
408 
409 /*
410  * This function sets up the dequantization tables used for a particular
411  * frame.
412  */
414 {
415  int ac_scale_factor = s->coded_ac_scale_factor[s->qps[qpi]];
416  int i, plane, inter, qri, bmi, bmj, qistart;
417 
418  for (inter = 0; inter < 2; inter++) {
419  for (plane = 0; plane < 3; plane++) {
420  int dc_scale_factor = s->coded_dc_scale_factor[!!plane][s->qps[qpi]];
421  int sum = 0;
422  for (qri = 0; qri < s->qr_count[inter][plane]; qri++) {
423  sum += s->qr_size[inter][plane][qri];
424  if (s->qps[qpi] <= sum)
425  break;
426  }
427  qistart = sum - s->qr_size[inter][plane][qri];
428  bmi = s->qr_base[inter][plane][qri];
429  bmj = s->qr_base[inter][plane][qri + 1];
430  for (i = 0; i < 64; i++) {
431  int coeff = (2 * (sum - s->qps[qpi]) * s->base_matrix[bmi][i] -
432  2 * (qistart - s->qps[qpi]) * s->base_matrix[bmj][i] +
433  s->qr_size[inter][plane][qri]) /
434  (2 * s->qr_size[inter][plane][qri]);
435 
436  int qmin = 8 << (inter + !i);
437  int qscale = i ? ac_scale_factor : dc_scale_factor;
438  int qbias = (1 + inter) * 3;
439  s->qmat[qpi][inter][plane][s->idct_permutation[i]] =
440  (i == 0 || s->version < 2) ? av_clip((qscale * coeff) / 100 * 4, qmin, 4096)
441  : (qscale * (coeff - qbias) / 100 + qbias) * 4;
442  }
443  /* all DC coefficients use the same quant so as not to interfere
444  * with DC prediction */
445  s->qmat[qpi][inter][plane][0] = s->qmat[0][inter][plane][0];
446  }
447  }
448 }
449 
450 /*
451  * This function initializes the loop filter boundary limits if the frame's
452  * quality index is different from the previous frame's.
453  *
454  * The filter_limit_values may not be larger than 127.
455  */
457 {
459 }
460 
461 /*
462  * This function unpacks all of the superblock/macroblock/fragment coding
463  * information from the bitstream.
464  */
466 {
467  int superblock_starts[3] = {
469  };
470  int bit = 0;
471  int current_superblock = 0;
472  int current_run = 0;
473  int num_partial_superblocks = 0;
474 
475  int i, j;
476  int current_fragment;
477  int plane;
478  int plane0_num_coded_frags = 0;
479 
480  if (s->keyframe) {
482  } else {
483  /* unpack the list of partially-coded superblocks */
484  bit = get_bits1(gb) ^ 1;
485  current_run = 0;
486 
487  while (current_superblock < s->superblock_count && get_bits_left(gb) > 0) {
488  if (s->theora && current_run == MAXIMUM_LONG_BIT_RUN)
489  bit = get_bits1(gb);
490  else
491  bit ^= 1;
492 
493  current_run = get_vlc2(gb, s->superblock_run_length_vlc.table,
494  6, 2) + 1;
495  if (current_run == 34)
496  current_run += get_bits(gb, 12);
497 
498  if (current_run > s->superblock_count - current_superblock) {
500  "Invalid partially coded superblock run length\n");
501  return -1;
502  }
503 
504  memset(s->superblock_coding + current_superblock, bit, current_run);
505 
506  current_superblock += current_run;
507  if (bit)
508  num_partial_superblocks += current_run;
509  }
510 
511  /* unpack the list of fully coded superblocks if any of the blocks were
512  * not marked as partially coded in the previous step */
513  if (num_partial_superblocks < s->superblock_count) {
514  int superblocks_decoded = 0;
515 
516  current_superblock = 0;
517  bit = get_bits1(gb) ^ 1;
518  current_run = 0;
519 
520  while (superblocks_decoded < s->superblock_count - num_partial_superblocks &&
521  get_bits_left(gb) > 0) {
522  if (s->theora && current_run == MAXIMUM_LONG_BIT_RUN)
523  bit = get_bits1(gb);
524  else
525  bit ^= 1;
526 
527  current_run = get_vlc2(gb, s->superblock_run_length_vlc.table,
528  6, 2) + 1;
529  if (current_run == 34)
530  current_run += get_bits(gb, 12);
531 
532  for (j = 0; j < current_run; current_superblock++) {
533  if (current_superblock >= s->superblock_count) {
535  "Invalid fully coded superblock run length\n");
536  return -1;
537  }
538 
539  /* skip any superblocks already marked as partially coded */
540  if (s->superblock_coding[current_superblock] == SB_NOT_CODED) {
541  s->superblock_coding[current_superblock] = 2 * bit;
542  j++;
543  }
544  }
545  superblocks_decoded += current_run;
546  }
547  }
548 
549  /* if there were partial blocks, initialize bitstream for
550  * unpacking fragment codings */
551  if (num_partial_superblocks) {
552  current_run = 0;
553  bit = get_bits1(gb);
554  /* toggle the bit because as soon as the first run length is
555  * fetched the bit will be toggled again */
556  bit ^= 1;
557  }
558  }
559 
560  /* figure out which fragments are coded; iterate through each
561  * superblock (all planes) */
562  s->total_num_coded_frags = 0;
564 
567 
568  for (plane = 0; plane < 3; plane++) {
569  int sb_start = superblock_starts[plane];
570  int sb_end = sb_start + (plane ? s->c_superblock_count
571  : s->y_superblock_count);
572  int num_coded_frags = 0;
573 
574  if (s->keyframe) {
575  if (s->num_kf_coded_fragment[plane] == -1) {
576  for (i = sb_start; i < sb_end; i++) {
577  /* iterate through all 16 fragments in a superblock */
578  for (j = 0; j < 16; j++) {
579  /* if the fragment is in bounds, check its coding status */
580  current_fragment = s->superblock_fragments[i * 16 + j];
581  if (current_fragment != -1) {
582  s->coded_fragment_list[plane][num_coded_frags++] =
583  current_fragment;
584  }
585  }
586  }
587  s->num_kf_coded_fragment[plane] = num_coded_frags;
588  } else
589  num_coded_frags = s->num_kf_coded_fragment[plane];
590  } else {
591  for (i = sb_start; i < sb_end && get_bits_left(gb) > 0; i++) {
592  if (get_bits_left(gb) < plane0_num_coded_frags >> 2) {
593  return AVERROR_INVALIDDATA;
594  }
595  /* iterate through all 16 fragments in a superblock */
596  for (j = 0; j < 16; j++) {
597  /* if the fragment is in bounds, check its coding status */
598  current_fragment = s->superblock_fragments[i * 16 + j];
599  if (current_fragment != -1) {
600  int coded = s->superblock_coding[i];
601 
602  if (coded == SB_PARTIALLY_CODED) {
603  /* fragment may or may not be coded; this is the case
604  * that cares about the fragment coding runs */
605  if (current_run-- == 0) {
606  bit ^= 1;
607  current_run = get_vlc2(gb, s->fragment_run_length_vlc.table, 5, 2);
608  }
609  coded = bit;
610  }
611 
612  if (coded) {
613  /* default mode; actual mode will be decoded in
614  * the next phase */
615  s->all_fragments[current_fragment].coding_method =
617  s->coded_fragment_list[plane][num_coded_frags++] =
618  current_fragment;
619  } else {
620  /* not coded; copy this fragment from the prior frame */
621  s->all_fragments[current_fragment].coding_method =
622  MODE_COPY;
623  }
624  }
625  }
626  }
627  }
628  if (!plane)
629  plane0_num_coded_frags = num_coded_frags;
630  s->total_num_coded_frags += num_coded_frags;
631  for (i = 0; i < 64; i++)
632  s->num_coded_frags[plane][i] = num_coded_frags;
633  if (plane < 2)
634  s->coded_fragment_list[plane + 1] = s->coded_fragment_list[plane] +
635  num_coded_frags;
636  }
637  return 0;
638 }
639 
640 #define BLOCK_X (2 * mb_x + (k & 1))
641 #define BLOCK_Y (2 * mb_y + (k >> 1))
642 
643 #if CONFIG_VP4_DECODER
644 /**
645  * @return number of blocks, or > yuv_macroblock_count on error.
646  * return value is always >= 1.
647  */
648 static int vp4_get_mb_count(Vp3DecodeContext *s, GetBitContext *gb)
649 {
650  int v = 1;
651  int bits;
652  while ((bits = show_bits(gb, 9)) == 0x1ff) {
653  skip_bits(gb, 9);
654  v += 256;
655  if (v > s->yuv_macroblock_count) {
656  av_log(s->avctx, AV_LOG_ERROR, "Invalid run length\n");
657  return v;
658  }
659  }
660 #define body(n) { \
661  skip_bits(gb, 2 + n); \
662  v += (1 << n) + get_bits(gb, n); }
663 #define thresh(n) (0x200 - (0x80 >> n))
664 #define else_if(n) else if (bits < thresh(n)) body(n)
665  if (bits < 0x100) {
666  skip_bits(gb, 1);
667  } else if (bits < thresh(0)) {
668  skip_bits(gb, 2);
669  v += 1;
670  }
671  else_if(1)
672  else_if(2)
673  else_if(3)
674  else_if(4)
675  else_if(5)
676  else_if(6)
677  else body(7)
678 #undef body
679 #undef thresh
680 #undef else_if
681  return v;
682 }
683 
684 static int vp4_get_block_pattern(Vp3DecodeContext *s, GetBitContext *gb, int *next_block_pattern_table)
685 {
686  int v = get_vlc2(gb, s->block_pattern_vlc[*next_block_pattern_table].table, 3, 2);
687  if (v == -1) {
688  av_log(s->avctx, AV_LOG_ERROR, "Invalid block pattern\n");
689  *next_block_pattern_table = 0;
690  return 0;
691  }
692  *next_block_pattern_table = vp4_block_pattern_table_selector[v];
693  return v + 1;
694 }
695 
696 static int vp4_unpack_macroblocks(Vp3DecodeContext *s, GetBitContext *gb)
697 {
698  int plane, i, j, k, fragment;
699  int next_block_pattern_table;
700  int bit, current_run, has_partial;
701 
703 
704  if (s->keyframe)
705  return 0;
706 
707  has_partial = 0;
708  bit = get_bits1(gb);
709  for (i = 0; i < s->yuv_macroblock_count; i += current_run) {
710  if (get_bits_left(gb) <= 0)
711  return AVERROR_INVALIDDATA;
712  current_run = vp4_get_mb_count(s, gb);
713  if (current_run > s->yuv_macroblock_count - i)
714  return -1;
715  memset(s->superblock_coding + i, 2 * bit, current_run);
716  bit ^= 1;
717  has_partial |= bit;
718  }
719 
720  if (has_partial) {
721  if (get_bits_left(gb) <= 0)
722  return AVERROR_INVALIDDATA;
723  bit = get_bits1(gb);
724  current_run = vp4_get_mb_count(s, gb);
725  for (i = 0; i < s->yuv_macroblock_count; i++) {
726  if (!s->superblock_coding[i]) {
727  if (!current_run) {
728  bit ^= 1;
729  current_run = vp4_get_mb_count(s, gb);
730  }
731  s->superblock_coding[i] = bit;
732  current_run--;
733  }
734  }
735  if (current_run) /* handle situation when vp4_get_mb_count() fails */
736  return -1;
737  }
738 
739  next_block_pattern_table = 0;
740  i = 0;
741  for (plane = 0; plane < 3; plane++) {
742  int sb_x, sb_y;
743  int sb_width = plane ? s->c_superblock_width : s->y_superblock_width;
744  int sb_height = plane ? s->c_superblock_height : s->y_superblock_height;
745  int mb_width = plane ? s->c_macroblock_width : s->macroblock_width;
746  int mb_height = plane ? s->c_macroblock_height : s->macroblock_height;
747  int fragment_width = s->fragment_width[!!plane];
748  int fragment_height = s->fragment_height[!!plane];
749 
750  for (sb_y = 0; sb_y < sb_height; sb_y++) {
751  for (sb_x = 0; sb_x < sb_width; sb_x++) {
752  for (j = 0; j < 4; j++) {
753  int mb_x = 2 * sb_x + (j >> 1);
754  int mb_y = 2 * sb_y + (j >> 1) ^ (j & 1);
755  int mb_coded, pattern, coded;
756 
757  if (mb_x >= mb_width || mb_y >= mb_height)
758  continue;
759 
760  mb_coded = s->superblock_coding[i++];
761 
762  if (mb_coded == SB_FULLY_CODED)
763  pattern = 0xF;
764  else if (mb_coded == SB_PARTIALLY_CODED)
765  pattern = vp4_get_block_pattern(s, gb, &next_block_pattern_table);
766  else
767  pattern = 0;
768 
769  for (k = 0; k < 4; k++) {
770  if (BLOCK_X >= fragment_width || BLOCK_Y >= fragment_height)
771  continue;
772  fragment = s->fragment_start[plane] + BLOCK_Y * fragment_width + BLOCK_X;
773  coded = pattern & (8 >> k);
774  /* MODE_INTER_NO_MV is the default for coded fragments.
775  the actual method is decoded in the next phase. */
776  s->all_fragments[fragment].coding_method = coded ? MODE_INTER_NO_MV : MODE_COPY;
777  }
778  }
779  }
780  }
781  }
782  return 0;
783 }
784 #endif
785 
786 /*
787  * This function unpacks all the coding mode data for individual macroblocks
788  * from the bitstream.
789  */
791 {
792  int i, j, k, sb_x, sb_y;
793  int scheme;
794  int current_macroblock;
795  int current_fragment;
796  int coding_mode;
797  int custom_mode_alphabet[CODING_MODE_COUNT];
798  const int *alphabet;
799  Vp3Fragment *frag;
800 
801  if (s->keyframe) {
802  for (i = 0; i < s->fragment_count; i++)
804  } else {
805  /* fetch the mode coding scheme for this frame */
806  scheme = get_bits(gb, 3);
807 
808  /* is it a custom coding scheme? */
809  if (scheme == 0) {
810  for (i = 0; i < 8; i++)
811  custom_mode_alphabet[i] = MODE_INTER_NO_MV;
812  for (i = 0; i < 8; i++)
813  custom_mode_alphabet[get_bits(gb, 3)] = i;
814  alphabet = custom_mode_alphabet;
815  } else
816  alphabet = ModeAlphabet[scheme - 1];
817 
818  /* iterate through all of the macroblocks that contain 1 or more
819  * coded fragments */
820  for (sb_y = 0; sb_y < s->y_superblock_height; sb_y++) {
821  for (sb_x = 0; sb_x < s->y_superblock_width; sb_x++) {
822  if (get_bits_left(gb) <= 0)
823  return -1;
824 
825  for (j = 0; j < 4; j++) {
826  int mb_x = 2 * sb_x + (j >> 1);
827  int mb_y = 2 * sb_y + (((j >> 1) + j) & 1);
828  current_macroblock = mb_y * s->macroblock_width + mb_x;
829 
830  if (mb_x >= s->macroblock_width ||
831  mb_y >= s->macroblock_height)
832  continue;
833 
834  /* coding modes are only stored if the macroblock has
835  * at least one luma block coded, otherwise it must be
836  * INTER_NO_MV */
837  for (k = 0; k < 4; k++) {
838  current_fragment = BLOCK_Y *
839  s->fragment_width[0] + BLOCK_X;
840  if (s->all_fragments[current_fragment].coding_method != MODE_COPY)
841  break;
842  }
843  if (k == 4) {
844  s->macroblock_coding[current_macroblock] = MODE_INTER_NO_MV;
845  continue;
846  }
847 
848  /* mode 7 means get 3 bits for each coding mode */
849  if (scheme == 7)
850  coding_mode = get_bits(gb, 3);
851  else
852  coding_mode = alphabet[get_vlc2(gb, s->mode_code_vlc.table, 3, 3)];
853 
854  s->macroblock_coding[current_macroblock] = coding_mode;
855  for (k = 0; k < 4; k++) {
856  frag = s->all_fragments + BLOCK_Y * s->fragment_width[0] + BLOCK_X;
857  if (frag->coding_method != MODE_COPY)
858  frag->coding_method = coding_mode;
859  }
860 
861 #define SET_CHROMA_MODES \
862  if (frag[s->fragment_start[1]].coding_method != MODE_COPY) \
863  frag[s->fragment_start[1]].coding_method = coding_mode; \
864  if (frag[s->fragment_start[2]].coding_method != MODE_COPY) \
865  frag[s->fragment_start[2]].coding_method = coding_mode;
866 
867  if (s->chroma_y_shift) {
868  frag = s->all_fragments + mb_y *
869  s->fragment_width[1] + mb_x;
871  } else if (s->chroma_x_shift) {
872  frag = s->all_fragments +
873  2 * mb_y * s->fragment_width[1] + mb_x;
874  for (k = 0; k < 2; k++) {
876  frag += s->fragment_width[1];
877  }
878  } else {
879  for (k = 0; k < 4; k++) {
880  frag = s->all_fragments +
881  BLOCK_Y * s->fragment_width[1] + BLOCK_X;
883  }
884  }
885  }
886  }
887  }
888  }
889 
890  return 0;
891 }
892 
893 static int vp4_get_mv(Vp3DecodeContext *s, GetBitContext *gb, int axis, int last_motion)
894 {
895  int v = get_vlc2(gb, s->vp4_mv_vlc[axis][vp4_mv_table_selector[FFABS(last_motion)]].table, 6, 2) - 31;
896  return last_motion < 0 ? -v : v;
897 }
898 
899 /*
900  * This function unpacks all the motion vectors for the individual
901  * macroblocks from the bitstream.
902  */
904 {
905  int j, k, sb_x, sb_y;
906  int coding_mode;
907  int motion_x[4];
908  int motion_y[4];
909  int last_motion_x = 0;
910  int last_motion_y = 0;
911  int prior_last_motion_x = 0;
912  int prior_last_motion_y = 0;
913  int last_gold_motion_x = 0;
914  int last_gold_motion_y = 0;
915  int current_macroblock;
916  int current_fragment;
917  int frag;
918 
919  if (s->keyframe)
920  return 0;
921 
922  /* coding mode 0 is the VLC scheme; 1 is the fixed code scheme; 2 is VP4 code scheme */
923  coding_mode = s->version < 2 ? get_bits1(gb) : 2;
924 
925  /* iterate through all of the macroblocks that contain 1 or more
926  * coded fragments */
927  for (sb_y = 0; sb_y < s->y_superblock_height; sb_y++) {
928  for (sb_x = 0; sb_x < s->y_superblock_width; sb_x++) {
929  if (get_bits_left(gb) <= 0)
930  return -1;
931 
932  for (j = 0; j < 4; j++) {
933  int mb_x = 2 * sb_x + (j >> 1);
934  int mb_y = 2 * sb_y + (((j >> 1) + j) & 1);
935  current_macroblock = mb_y * s->macroblock_width + mb_x;
936 
937  if (mb_x >= s->macroblock_width ||
938  mb_y >= s->macroblock_height ||
939  s->macroblock_coding[current_macroblock] == MODE_COPY)
940  continue;
941 
942  switch (s->macroblock_coding[current_macroblock]) {
943  case MODE_GOLDEN_MV:
944  if (coding_mode == 2) { /* VP4 */
945  last_gold_motion_x = motion_x[0] = vp4_get_mv(s, gb, 0, last_gold_motion_x);
946  last_gold_motion_y = motion_y[0] = vp4_get_mv(s, gb, 1, last_gold_motion_y);
947  break;
948  } /* otherwise fall through */
949  case MODE_INTER_PLUS_MV:
950  /* all 6 fragments use the same motion vector */
951  if (coding_mode == 0) {
952  motion_x[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
953  motion_y[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
954  } else if (coding_mode == 1) {
955  motion_x[0] = fixed_motion_vector_table[get_bits(gb, 6)];
956  motion_y[0] = fixed_motion_vector_table[get_bits(gb, 6)];
957  } else { /* VP4 */
958  motion_x[0] = vp4_get_mv(s, gb, 0, last_motion_x);
959  motion_y[0] = vp4_get_mv(s, gb, 1, last_motion_y);
960  }
961 
962  /* vector maintenance, only on MODE_INTER_PLUS_MV */
963  if (s->macroblock_coding[current_macroblock] == MODE_INTER_PLUS_MV) {
964  prior_last_motion_x = last_motion_x;
965  prior_last_motion_y = last_motion_y;
966  last_motion_x = motion_x[0];
967  last_motion_y = motion_y[0];
968  }
969  break;
970 
971  case MODE_INTER_FOURMV:
972  /* vector maintenance */
973  prior_last_motion_x = last_motion_x;
974  prior_last_motion_y = last_motion_y;
975 
976  /* fetch 4 vectors from the bitstream, one for each
977  * Y fragment, then average for the C fragment vectors */
978  for (k = 0; k < 4; k++) {
979  current_fragment = BLOCK_Y * s->fragment_width[0] + BLOCK_X;
980  if (s->all_fragments[current_fragment].coding_method != MODE_COPY) {
981  if (coding_mode == 0) {
982  motion_x[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
983  motion_y[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
984  } else if (coding_mode == 1) {
985  motion_x[k] = fixed_motion_vector_table[get_bits(gb, 6)];
986  motion_y[k] = fixed_motion_vector_table[get_bits(gb, 6)];
987  } else { /* VP4 */
988  motion_x[k] = vp4_get_mv(s, gb, 0, prior_last_motion_x);
989  motion_y[k] = vp4_get_mv(s, gb, 1, prior_last_motion_y);
990  }
991  last_motion_x = motion_x[k];
992  last_motion_y = motion_y[k];
993  } else {
994  motion_x[k] = 0;
995  motion_y[k] = 0;
996  }
997  }
998  break;
999 
1000  case MODE_INTER_LAST_MV:
1001  /* all 6 fragments use the last motion vector */
1002  motion_x[0] = last_motion_x;
1003  motion_y[0] = last_motion_y;
1004 
1005  /* no vector maintenance (last vector remains the
1006  * last vector) */
1007  break;
1008 
1009  case MODE_INTER_PRIOR_LAST:
1010  /* all 6 fragments use the motion vector prior to the
1011  * last motion vector */
1012  motion_x[0] = prior_last_motion_x;
1013  motion_y[0] = prior_last_motion_y;
1014 
1015  /* vector maintenance */
1016  prior_last_motion_x = last_motion_x;
1017  prior_last_motion_y = last_motion_y;
1018  last_motion_x = motion_x[0];
1019  last_motion_y = motion_y[0];
1020  break;
1021 
1022  default:
1023  /* covers intra, inter without MV, golden without MV */
1024  motion_x[0] = 0;
1025  motion_y[0] = 0;
1026 
1027  /* no vector maintenance */
1028  break;
1029  }
1030 
1031  /* assign the motion vectors to the correct fragments */
1032  for (k = 0; k < 4; k++) {
1033  current_fragment =
1034  BLOCK_Y * s->fragment_width[0] + BLOCK_X;
1035  if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) {
1036  s->motion_val[0][current_fragment][0] = motion_x[k];
1037  s->motion_val[0][current_fragment][1] = motion_y[k];
1038  } else {
1039  s->motion_val[0][current_fragment][0] = motion_x[0];
1040  s->motion_val[0][current_fragment][1] = motion_y[0];
1041  }
1042  }
1043 
1044  if (s->chroma_y_shift) {
1045  if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) {
1046  motion_x[0] = RSHIFT(motion_x[0] + motion_x[1] +
1047  motion_x[2] + motion_x[3], 2);
1048  motion_y[0] = RSHIFT(motion_y[0] + motion_y[1] +
1049  motion_y[2] + motion_y[3], 2);
1050  }
1051  if (s->version <= 2) {
1052  motion_x[0] = (motion_x[0] >> 1) | (motion_x[0] & 1);
1053  motion_y[0] = (motion_y[0] >> 1) | (motion_y[0] & 1);
1054  }
1055  frag = mb_y * s->fragment_width[1] + mb_x;
1056  s->motion_val[1][frag][0] = motion_x[0];
1057  s->motion_val[1][frag][1] = motion_y[0];
1058  } else if (s->chroma_x_shift) {
1059  if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) {
1060  motion_x[0] = RSHIFT(motion_x[0] + motion_x[1], 1);
1061  motion_y[0] = RSHIFT(motion_y[0] + motion_y[1], 1);
1062  motion_x[1] = RSHIFT(motion_x[2] + motion_x[3], 1);
1063  motion_y[1] = RSHIFT(motion_y[2] + motion_y[3], 1);
1064  } else {
1065  motion_x[1] = motion_x[0];
1066  motion_y[1] = motion_y[0];
1067  }
1068  if (s->version <= 2) {
1069  motion_x[0] = (motion_x[0] >> 1) | (motion_x[0] & 1);
1070  motion_x[1] = (motion_x[1] >> 1) | (motion_x[1] & 1);
1071  }
1072  frag = 2 * mb_y * s->fragment_width[1] + mb_x;
1073  for (k = 0; k < 2; k++) {
1074  s->motion_val[1][frag][0] = motion_x[k];
1075  s->motion_val[1][frag][1] = motion_y[k];
1076  frag += s->fragment_width[1];
1077  }
1078  } else {
1079  for (k = 0; k < 4; k++) {
1080  frag = BLOCK_Y * s->fragment_width[1] + BLOCK_X;
1081  if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) {
1082  s->motion_val[1][frag][0] = motion_x[k];
1083  s->motion_val[1][frag][1] = motion_y[k];
1084  } else {
1085  s->motion_val[1][frag][0] = motion_x[0];
1086  s->motion_val[1][frag][1] = motion_y[0];
1087  }
1088  }
1089  }
1090  }
1091  }
1092  }
1093 
1094  return 0;
1095 }
1096 
1098 {
1099  int qpi, i, j, bit, run_length, blocks_decoded, num_blocks_at_qpi;
1100  int num_blocks = s->total_num_coded_frags;
1101 
1102  for (qpi = 0; qpi < s->nqps - 1 && num_blocks > 0; qpi++) {
1103  i = blocks_decoded = num_blocks_at_qpi = 0;
1104 
1105  bit = get_bits1(gb) ^ 1;
1106  run_length = 0;
1107 
1108  do {
1109  if (run_length == MAXIMUM_LONG_BIT_RUN)
1110  bit = get_bits1(gb);
1111  else
1112  bit ^= 1;
1113 
1114  run_length = get_vlc2(gb, s->superblock_run_length_vlc.table, 6, 2) + 1;
1115  if (run_length == 34)
1116  run_length += get_bits(gb, 12);
1117  blocks_decoded += run_length;
1118 
1119  if (!bit)
1120  num_blocks_at_qpi += run_length;
1121 
1122  for (j = 0; j < run_length; i++) {
1123  if (i >= s->total_num_coded_frags)
1124  return -1;
1125 
1126  if (s->all_fragments[s->coded_fragment_list[0][i]].qpi == qpi) {
1127  s->all_fragments[s->coded_fragment_list[0][i]].qpi += bit;
1128  j++;
1129  }
1130  }
1131  } while (blocks_decoded < num_blocks && get_bits_left(gb) > 0);
1132 
1133  num_blocks -= num_blocks_at_qpi;
1134  }
1135 
1136  return 0;
1137 }
1138 
1139 static inline int get_eob_run(GetBitContext *gb, int token)
1140 {
1141  int v = eob_run_table[token].base;
1142  if (eob_run_table[token].bits)
1143  v += get_bits(gb, eob_run_table[token].bits);
1144  return v;
1145 }
1146 
1147 static inline int get_coeff(GetBitContext *gb, int token, int16_t *coeff)
1148 {
1149  int bits_to_get, zero_run;
1150 
1151  bits_to_get = coeff_get_bits[token];
1152  if (bits_to_get)
1153  bits_to_get = get_bits(gb, bits_to_get);
1154  *coeff = coeff_tables[token][bits_to_get];
1155 
1156  zero_run = zero_run_base[token];
1157  if (zero_run_get_bits[token])
1158  zero_run += get_bits(gb, zero_run_get_bits[token]);
1159 
1160  return zero_run;
1161 }
1162 
1163 /*
1164  * This function is called by unpack_dct_coeffs() to extract the VLCs from
1165  * the bitstream. The VLCs encode tokens which are used to unpack DCT
1166  * data. This function unpacks all the VLCs for either the Y plane or both
1167  * C planes, and is called for DC coefficients or different AC coefficient
1168  * levels (since different coefficient types require different VLC tables.
1169  *
1170  * This function returns a residual eob run. E.g, if a particular token gave
1171  * instructions to EOB the next 5 fragments and there were only 2 fragments
1172  * left in the current fragment range, 3 would be returned so that it could
1173  * be passed into the next call to this same function.
1174  */
1176  VLC *table, int coeff_index,
1177  int plane,
1178  int eob_run)
1179 {
1180  int i, j = 0;
1181  int token;
1182  int zero_run = 0;
1183  int16_t coeff = 0;
1184  int blocks_ended;
1185  int coeff_i = 0;
1186  int num_coeffs = s->num_coded_frags[plane][coeff_index];
1187  int16_t *dct_tokens = s->dct_tokens[plane][coeff_index];
1188 
1189  /* local references to structure members to avoid repeated dereferences */
1190  int *coded_fragment_list = s->coded_fragment_list[plane];
1191  Vp3Fragment *all_fragments = s->all_fragments;
1192  VLC_TYPE(*vlc_table)[2] = table->table;
1193 
1194  if (num_coeffs < 0) {
1196  "Invalid number of coefficients at level %d\n", coeff_index);
1197  return AVERROR_INVALIDDATA;
1198  }
1199 
1200  if (eob_run > num_coeffs) {
1201  coeff_i =
1202  blocks_ended = num_coeffs;
1203  eob_run -= num_coeffs;
1204  } else {
1205  coeff_i =
1206  blocks_ended = eob_run;
1207  eob_run = 0;
1208  }
1209 
1210  // insert fake EOB token to cover the split between planes or zzi
1211  if (blocks_ended)
1212  dct_tokens[j++] = blocks_ended << 2;
1213 
1214  while (coeff_i < num_coeffs && get_bits_left(gb) > 0) {
1215  /* decode a VLC into a token */
1216  token = get_vlc2(gb, vlc_table, 11, 3);
1217  /* use the token to get a zero run, a coefficient, and an eob run */
1218  if ((unsigned) token <= 6U) {
1219  eob_run = get_eob_run(gb, token);
1220  if (!eob_run)
1221  eob_run = INT_MAX;
1222 
1223  // record only the number of blocks ended in this plane,
1224  // any spill will be recorded in the next plane.
1225  if (eob_run > num_coeffs - coeff_i) {
1226  dct_tokens[j++] = TOKEN_EOB(num_coeffs - coeff_i);
1227  blocks_ended += num_coeffs - coeff_i;
1228  eob_run -= num_coeffs - coeff_i;
1229  coeff_i = num_coeffs;
1230  } else {
1231  dct_tokens[j++] = TOKEN_EOB(eob_run);
1232  blocks_ended += eob_run;
1233  coeff_i += eob_run;
1234  eob_run = 0;
1235  }
1236  } else if (token >= 0) {
1237  zero_run = get_coeff(gb, token, &coeff);
1238 
1239  if (zero_run) {
1240  dct_tokens[j++] = TOKEN_ZERO_RUN(coeff, zero_run);
1241  } else {
1242  // Save DC into the fragment structure. DC prediction is
1243  // done in raster order, so the actual DC can't be in with
1244  // other tokens. We still need the token in dct_tokens[]
1245  // however, or else the structure collapses on itself.
1246  if (!coeff_index)
1247  all_fragments[coded_fragment_list[coeff_i]].dc = coeff;
1248 
1249  dct_tokens[j++] = TOKEN_COEFF(coeff);
1250  }
1251 
1252  if (coeff_index + zero_run > 64) {
1254  "Invalid zero run of %d with %d coeffs left\n",
1255  zero_run, 64 - coeff_index);
1256  zero_run = 64 - coeff_index;
1257  }
1258 
1259  // zero runs code multiple coefficients,
1260  // so don't try to decode coeffs for those higher levels
1261  for (i = coeff_index + 1; i <= coeff_index + zero_run; i++)
1262  s->num_coded_frags[plane][i]--;
1263  coeff_i++;
1264  } else {
1265  av_log(s->avctx, AV_LOG_ERROR, "Invalid token %d\n", token);
1266  return -1;
1267  }
1268  }
1269 
1270  if (blocks_ended > s->num_coded_frags[plane][coeff_index])
1271  av_log(s->avctx, AV_LOG_ERROR, "More blocks ended than coded!\n");
1272 
1273  // decrement the number of blocks that have higher coefficients for each
1274  // EOB run at this level
1275  if (blocks_ended)
1276  for (i = coeff_index + 1; i < 64; i++)
1277  s->num_coded_frags[plane][i] -= blocks_ended;
1278 
1279  // setup the next buffer
1280  if (plane < 2)
1281  s->dct_tokens[plane + 1][coeff_index] = dct_tokens + j;
1282  else if (coeff_index < 63)
1283  s->dct_tokens[0][coeff_index + 1] = dct_tokens + j;
1284 
1285  return eob_run;
1286 }
1287 
1289  int first_fragment,
1290  int fragment_width,
1291  int fragment_height);
1292 /*
1293  * This function unpacks all of the DCT coefficient data from the
1294  * bitstream.
1295  */
1297 {
1298  int i;
1299  int dc_y_table;
1300  int dc_c_table;
1301  int ac_y_table;
1302  int ac_c_table;
1303  int residual_eob_run = 0;
1304  VLC *y_tables[64];
1305  VLC *c_tables[64];
1306 
1307  s->dct_tokens[0][0] = s->dct_tokens_base;
1308 
1309  if (get_bits_left(gb) < 16)
1310  return AVERROR_INVALIDDATA;
1311 
1312  /* fetch the DC table indexes */
1313  dc_y_table = get_bits(gb, 4);
1314  dc_c_table = get_bits(gb, 4);
1315 
1316  /* unpack the Y plane DC coefficients */
1317  residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_y_table], 0,
1318  0, residual_eob_run);
1319  if (residual_eob_run < 0)
1320  return residual_eob_run;
1321  if (get_bits_left(gb) < 8)
1322  return AVERROR_INVALIDDATA;
1323 
1324  /* reverse prediction of the Y-plane DC coefficients */
1326 
1327  /* unpack the C plane DC coefficients */
1328  residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_c_table], 0,
1329  1, residual_eob_run);
1330  if (residual_eob_run < 0)
1331  return residual_eob_run;
1332  residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_c_table], 0,
1333  2, residual_eob_run);
1334  if (residual_eob_run < 0)
1335  return residual_eob_run;
1336 
1337  /* reverse prediction of the C-plane DC coefficients */
1338  if (!(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
1340  s->fragment_width[1], s->fragment_height[1]);
1342  s->fragment_width[1], s->fragment_height[1]);
1343  }
1344 
1345  if (get_bits_left(gb) < 8)
1346  return AVERROR_INVALIDDATA;
1347  /* fetch the AC table indexes */
1348  ac_y_table = get_bits(gb, 4);
1349  ac_c_table = get_bits(gb, 4);
1350 
1351  /* build tables of AC VLC tables */
1352  for (i = 1; i <= 5; i++) {
1353  y_tables[i] = &s->ac_vlc_1[ac_y_table];
1354  c_tables[i] = &s->ac_vlc_1[ac_c_table];
1355  }
1356  for (i = 6; i <= 14; i++) {
1357  y_tables[i] = &s->ac_vlc_2[ac_y_table];
1358  c_tables[i] = &s->ac_vlc_2[ac_c_table];
1359  }
1360  for (i = 15; i <= 27; i++) {
1361  y_tables[i] = &s->ac_vlc_3[ac_y_table];
1362  c_tables[i] = &s->ac_vlc_3[ac_c_table];
1363  }
1364  for (i = 28; i <= 63; i++) {
1365  y_tables[i] = &s->ac_vlc_4[ac_y_table];
1366  c_tables[i] = &s->ac_vlc_4[ac_c_table];
1367  }
1368 
1369  /* decode all AC coefficients */
1370  for (i = 1; i <= 63; i++) {
1371  residual_eob_run = unpack_vlcs(s, gb, y_tables[i], i,
1372  0, residual_eob_run);
1373  if (residual_eob_run < 0)
1374  return residual_eob_run;
1375 
1376  residual_eob_run = unpack_vlcs(s, gb, c_tables[i], i,
1377  1, residual_eob_run);
1378  if (residual_eob_run < 0)
1379  return residual_eob_run;
1380  residual_eob_run = unpack_vlcs(s, gb, c_tables[i], i,
1381  2, residual_eob_run);
1382  if (residual_eob_run < 0)
1383  return residual_eob_run;
1384  }
1385 
1386  return 0;
1387 }
1388 
1389 #if CONFIG_VP4_DECODER
1390 /**
1391  * eob_tracker[] is instead of TOKEN_EOB(value)
1392  * a dummy TOKEN_EOB(0) value is used to make vp3_dequant work
1393  *
1394  * @return < 0 on error
1395  */
1396 static int vp4_unpack_vlcs(Vp3DecodeContext *s, GetBitContext *gb,
1397  VLC *vlc_tables[64],
1398  int plane, int eob_tracker[64], int fragment)
1399 {
1400  int token;
1401  int zero_run = 0;
1402  int16_t coeff = 0;
1403  int coeff_i = 0;
1404  int eob_run;
1405 
1406  while (!eob_tracker[coeff_i]) {
1407  if (get_bits_left(gb) < 1)
1408  return AVERROR_INVALIDDATA;
1409 
1410  token = get_vlc2(gb, vlc_tables[coeff_i]->table, 11, 3);
1411 
1412  /* use the token to get a zero run, a coefficient, and an eob run */
1413  if ((unsigned) token <= 6U) {
1414  eob_run = get_eob_run(gb, token);
1415  *s->dct_tokens[plane][coeff_i]++ = TOKEN_EOB(0);
1416  eob_tracker[coeff_i] = eob_run - 1;
1417  return 0;
1418  } else if (token >= 0) {
1419  zero_run = get_coeff(gb, token, &coeff);
1420 
1421  if (zero_run) {
1422  if (coeff_i + zero_run > 64) {
1424  "Invalid zero run of %d with %d coeffs left\n",
1425  zero_run, 64 - coeff_i);
1426  zero_run = 64 - coeff_i;
1427  }
1428  *s->dct_tokens[plane][coeff_i]++ = TOKEN_ZERO_RUN(coeff, zero_run);
1429  coeff_i += zero_run;
1430  } else {
1431  if (!coeff_i)
1432  s->all_fragments[fragment].dc = coeff;
1433 
1434  *s->dct_tokens[plane][coeff_i]++ = TOKEN_COEFF(coeff);
1435  }
1436  coeff_i++;
1437  if (coeff_i >= 64) /* > 64 occurs when there is a zero_run overflow */
1438  return 0; /* stop */
1439  } else {
1440  av_log(s->avctx, AV_LOG_ERROR, "Invalid token %d\n", token);
1441  return -1;
1442  }
1443  }
1444  *s->dct_tokens[plane][coeff_i]++ = TOKEN_EOB(0);
1445  eob_tracker[coeff_i]--;
1446  return 0;
1447 }
1448 
1449 static void vp4_dc_predictor_reset(VP4Predictor *p)
1450 {
1451  p->dc = 0;
1452  p->type = VP4_DC_UNDEFINED;
1453 }
1454 
1455 static void vp4_dc_pred_before(const Vp3DecodeContext *s, VP4Predictor dc_pred[6][6], int sb_x)
1456 {
1457  int i, j;
1458 
1459  for (i = 0; i < 4; i++)
1460  dc_pred[0][i + 1] = s->dc_pred_row[sb_x * 4 + i];
1461 
1462  for (j = 1; j < 5; j++)
1463  for (i = 0; i < 4; i++)
1464  vp4_dc_predictor_reset(&dc_pred[j][i + 1]);
1465 }
1466 
1467 static void vp4_dc_pred_after(Vp3DecodeContext *s, VP4Predictor dc_pred[6][6], int sb_x)
1468 {
1469  int i;
1470 
1471  for (i = 0; i < 4; i++)
1472  s->dc_pred_row[sb_x * 4 + i] = dc_pred[4][i + 1];
1473 
1474  for (i = 1; i < 5; i++)
1475  dc_pred[i][0] = dc_pred[i][4];
1476 }
1477 
1478 /* note: dc_pred points to the current block */
1479 static int vp4_dc_pred(const Vp3DecodeContext *s, const VP4Predictor * dc_pred, const int * last_dc, int type, int plane)
1480 {
1481  int count = 0;
1482  int dc = 0;
1483 
1484  if (dc_pred[-6].type == type) {
1485  dc += dc_pred[-6].dc;
1486  count++;
1487  }
1488 
1489  if (dc_pred[6].type == type) {
1490  dc += dc_pred[6].dc;
1491  count++;
1492  }
1493 
1494  if (count != 2 && dc_pred[-1].type == type) {
1495  dc += dc_pred[-1].dc;
1496  count++;
1497  }
1498 
1499  if (count != 2 && dc_pred[1].type == type) {
1500  dc += dc_pred[1].dc;
1501  count++;
1502  }
1503 
1504  /* using division instead of shift to correctly handle negative values */
1505  return count == 2 ? dc / 2 : last_dc[type];
1506 }
1507 
1508 static void vp4_set_tokens_base(Vp3DecodeContext *s)
1509 {
1510  int plane, i;
1511  int16_t *base = s->dct_tokens_base;
1512  for (plane = 0; plane < 3; plane++) {
1513  for (i = 0; i < 64; i++) {
1514  s->dct_tokens[plane][i] = base;
1515  base += s->fragment_width[!!plane] * s->fragment_height[!!plane];
1516  }
1517  }
1518 }
1519 
1520 static int vp4_unpack_dct_coeffs(Vp3DecodeContext *s, GetBitContext *gb)
1521 {
1522  int i, j;
1523  int dc_y_table;
1524  int dc_c_table;
1525  int ac_y_table;
1526  int ac_c_table;
1527  VLC *tables[2][64];
1528  int plane, sb_y, sb_x;
1529  int eob_tracker[64];
1530  VP4Predictor dc_pred[6][6];
1531  int last_dc[NB_VP4_DC_TYPES];
1532 
1533  if (get_bits_left(gb) < 16)
1534  return AVERROR_INVALIDDATA;
1535 
1536  /* fetch the DC table indexes */
1537  dc_y_table = get_bits(gb, 4);
1538  dc_c_table = get_bits(gb, 4);
1539 
1540  ac_y_table = get_bits(gb, 4);
1541  ac_c_table = get_bits(gb, 4);
1542 
1543  /* build tables of DC/AC VLC tables */
1544 
1545  tables[0][0] = &s->dc_vlc[dc_y_table];
1546  tables[1][0] = &s->dc_vlc[dc_c_table];
1547  for (i = 1; i <= 5; i++) {
1548  tables[0][i] = &s->ac_vlc_1[ac_y_table];
1549  tables[1][i] = &s->ac_vlc_1[ac_c_table];
1550  }
1551  for (i = 6; i <= 14; i++) {
1552  tables[0][i] = &s->ac_vlc_2[ac_y_table];
1553  tables[1][i] = &s->ac_vlc_2[ac_c_table];
1554  }
1555  for (i = 15; i <= 27; i++) {
1556  tables[0][i] = &s->ac_vlc_3[ac_y_table];
1557  tables[1][i] = &s->ac_vlc_3[ac_c_table];
1558  }
1559  for (i = 28; i <= 63; i++) {
1560  tables[0][i] = &s->ac_vlc_4[ac_y_table];
1561  tables[1][i] = &s->ac_vlc_4[ac_c_table];
1562  }
1563 
1564  vp4_set_tokens_base(s);
1565 
1566  memset(last_dc, 0, sizeof(last_dc));
1567 
1568  for (plane = 0; plane < ((s->avctx->flags & AV_CODEC_FLAG_GRAY) ? 1 : 3); plane++) {
1569  memset(eob_tracker, 0, sizeof(eob_tracker));
1570 
1571  /* initialise dc prediction */
1572  for (i = 0; i < s->fragment_width[!!plane]; i++)
1573  vp4_dc_predictor_reset(&s->dc_pred_row[i]);
1574 
1575  for (j = 0; j < 6; j++)
1576  for (i = 0; i < 6; i++)
1577  vp4_dc_predictor_reset(&dc_pred[j][i]);
1578 
1579  for (sb_y = 0; sb_y * 4 < s->fragment_height[!!plane]; sb_y++) {
1580  for (sb_x = 0; sb_x *4 < s->fragment_width[!!plane]; sb_x++) {
1581  vp4_dc_pred_before(s, dc_pred, sb_x);
1582  for (j = 0; j < 16; j++) {
1583  int hx = hilbert_offset[j][0];
1584  int hy = hilbert_offset[j][1];
1585  int x = 4 * sb_x + hx;
1586  int y = 4 * sb_y + hy;
1587  VP4Predictor *this_dc_pred = &dc_pred[hy + 1][hx + 1];
1588  int fragment, dc_block_type;
1589 
1590  if (x >= s->fragment_width[!!plane] || y >= s->fragment_height[!!plane])
1591  continue;
1592 
1593  fragment = s->fragment_start[plane] + y * s->fragment_width[!!plane] + x;
1594 
1595  if (s->all_fragments[fragment].coding_method == MODE_COPY)
1596  continue;
1597 
1598  if (vp4_unpack_vlcs(s, gb, tables[!!plane], plane, eob_tracker, fragment) < 0)
1599  return -1;
1600 
1601  dc_block_type = vp4_pred_block_type_map[s->all_fragments[fragment].coding_method];
1602 
1603  s->all_fragments[fragment].dc +=
1604  vp4_dc_pred(s, this_dc_pred, last_dc, dc_block_type, plane);
1605 
1606  this_dc_pred->type = dc_block_type,
1607  this_dc_pred->dc = last_dc[dc_block_type] = s->all_fragments[fragment].dc;
1608  }
1609  vp4_dc_pred_after(s, dc_pred, sb_x);
1610  }
1611  }
1612  }
1613 
1614  vp4_set_tokens_base(s);
1615 
1616  return 0;
1617 }
1618 #endif
1619 
1620 /*
1621  * This function reverses the DC prediction for each coded fragment in
1622  * the frame. Much of this function is adapted directly from the original
1623  * VP3 source code.
1624  */
1625 #define COMPATIBLE_FRAME(x) \
1626  (compatible_frame[s->all_fragments[x].coding_method] == current_frame_type)
1627 #define DC_COEFF(u) s->all_fragments[u].dc
1628 
1630  int first_fragment,
1631  int fragment_width,
1632  int fragment_height)
1633 {
1634 #define PUL 8
1635 #define PU 4
1636 #define PUR 2
1637 #define PL 1
1638 
1639  int x, y;
1640  int i = first_fragment;
1641 
1642  int predicted_dc;
1643 
1644  /* DC values for the left, up-left, up, and up-right fragments */
1645  int vl, vul, vu, vur;
1646 
1647  /* indexes for the left, up-left, up, and up-right fragments */
1648  int l, ul, u, ur;
1649 
1650  /*
1651  * The 6 fields mean:
1652  * 0: up-left multiplier
1653  * 1: up multiplier
1654  * 2: up-right multiplier
1655  * 3: left multiplier
1656  */
1657  static const int predictor_transform[16][4] = {
1658  { 0, 0, 0, 0 },
1659  { 0, 0, 0, 128 }, // PL
1660  { 0, 0, 128, 0 }, // PUR
1661  { 0, 0, 53, 75 }, // PUR|PL
1662  { 0, 128, 0, 0 }, // PU
1663  { 0, 64, 0, 64 }, // PU |PL
1664  { 0, 128, 0, 0 }, // PU |PUR
1665  { 0, 0, 53, 75 }, // PU |PUR|PL
1666  { 128, 0, 0, 0 }, // PUL
1667  { 0, 0, 0, 128 }, // PUL|PL
1668  { 64, 0, 64, 0 }, // PUL|PUR
1669  { 0, 0, 53, 75 }, // PUL|PUR|PL
1670  { 0, 128, 0, 0 }, // PUL|PU
1671  { -104, 116, 0, 116 }, // PUL|PU |PL
1672  { 24, 80, 24, 0 }, // PUL|PU |PUR
1673  { -104, 116, 0, 116 } // PUL|PU |PUR|PL
1674  };
1675 
1676  /* This table shows which types of blocks can use other blocks for
1677  * prediction. For example, INTRA is the only mode in this table to
1678  * have a frame number of 0. That means INTRA blocks can only predict
1679  * from other INTRA blocks. There are 2 golden frame coding types;
1680  * blocks encoding in these modes can only predict from other blocks
1681  * that were encoded with these 1 of these 2 modes. */
1682  static const unsigned char compatible_frame[9] = {
1683  1, /* MODE_INTER_NO_MV */
1684  0, /* MODE_INTRA */
1685  1, /* MODE_INTER_PLUS_MV */
1686  1, /* MODE_INTER_LAST_MV */
1687  1, /* MODE_INTER_PRIOR_MV */
1688  2, /* MODE_USING_GOLDEN */
1689  2, /* MODE_GOLDEN_MV */
1690  1, /* MODE_INTER_FOUR_MV */
1691  3 /* MODE_COPY */
1692  };
1693  int current_frame_type;
1694 
1695  /* there is a last DC predictor for each of the 3 frame types */
1696  short last_dc[3];
1697 
1698  int transform = 0;
1699 
1700  vul =
1701  vu =
1702  vur =
1703  vl = 0;
1704  last_dc[0] =
1705  last_dc[1] =
1706  last_dc[2] = 0;
1707 
1708  /* for each fragment row... */
1709  for (y = 0; y < fragment_height; y++) {
1710  /* for each fragment in a row... */
1711  for (x = 0; x < fragment_width; x++, i++) {
1712 
1713  /* reverse prediction if this block was coded */
1714  if (s->all_fragments[i].coding_method != MODE_COPY) {
1715  current_frame_type =
1716  compatible_frame[s->all_fragments[i].coding_method];
1717 
1718  transform = 0;
1719  if (x) {
1720  l = i - 1;
1721  vl = DC_COEFF(l);
1722  if (COMPATIBLE_FRAME(l))
1723  transform |= PL;
1724  }
1725  if (y) {
1726  u = i - fragment_width;
1727  vu = DC_COEFF(u);
1728  if (COMPATIBLE_FRAME(u))
1729  transform |= PU;
1730  if (x) {
1731  ul = i - fragment_width - 1;
1732  vul = DC_COEFF(ul);
1733  if (COMPATIBLE_FRAME(ul))
1734  transform |= PUL;
1735  }
1736  if (x + 1 < fragment_width) {
1737  ur = i - fragment_width + 1;
1738  vur = DC_COEFF(ur);
1739  if (COMPATIBLE_FRAME(ur))
1740  transform |= PUR;
1741  }
1742  }
1743 
1744  if (transform == 0) {
1745  /* if there were no fragments to predict from, use last
1746  * DC saved */
1747  predicted_dc = last_dc[current_frame_type];
1748  } else {
1749  /* apply the appropriate predictor transform */
1750  predicted_dc =
1751  (predictor_transform[transform][0] * vul) +
1752  (predictor_transform[transform][1] * vu) +
1753  (predictor_transform[transform][2] * vur) +
1754  (predictor_transform[transform][3] * vl);
1755 
1756  predicted_dc /= 128;
1757 
1758  /* check for outranging on the [ul u l] and
1759  * [ul u ur l] predictors */
1760  if ((transform == 15) || (transform == 13)) {
1761  if (FFABS(predicted_dc - vu) > 128)
1762  predicted_dc = vu;
1763  else if (FFABS(predicted_dc - vl) > 128)
1764  predicted_dc = vl;
1765  else if (FFABS(predicted_dc - vul) > 128)
1766  predicted_dc = vul;
1767  }
1768  }
1769 
1770  /* at long last, apply the predictor */
1771  DC_COEFF(i) += predicted_dc;
1772  /* save the DC */
1773  last_dc[current_frame_type] = DC_COEFF(i);
1774  }
1775  }
1776  }
1777 }
1778 
1779 static void apply_loop_filter(Vp3DecodeContext *s, int plane,
1780  int ystart, int yend)
1781 {
1782  int x, y;
1783  int *bounding_values = s->bounding_values_array + 127;
1784 
1785  int width = s->fragment_width[!!plane];
1786  int height = s->fragment_height[!!plane];
1787  int fragment = s->fragment_start[plane] + ystart * width;
1788  ptrdiff_t stride = s->current_frame.f->linesize[plane];
1789  uint8_t *plane_data = s->current_frame.f->data[plane];
1790  if (!s->flipped_image)
1791  stride = -stride;
1792  plane_data += s->data_offset[plane] + 8 * ystart * stride;
1793 
1794  for (y = ystart; y < yend; y++) {
1795  for (x = 0; x < width; x++) {
1796  /* This code basically just deblocks on the edges of coded blocks.
1797  * However, it has to be much more complicated because of the
1798  * brain damaged deblock ordering used in VP3/Theora. Order matters
1799  * because some pixels get filtered twice. */
1800  if (s->all_fragments[fragment].coding_method != MODE_COPY) {
1801  /* do not perform left edge filter for left columns frags */
1802  if (x > 0) {
1803  s->vp3dsp.h_loop_filter(
1804  plane_data + 8 * x,
1805  stride, bounding_values);
1806  }
1807 
1808  /* do not perform top edge filter for top row fragments */
1809  if (y > 0) {
1810  s->vp3dsp.v_loop_filter(
1811  plane_data + 8 * x,
1812  stride, bounding_values);
1813  }
1814 
1815  /* do not perform right edge filter for right column
1816  * fragments or if right fragment neighbor is also coded
1817  * in this frame (it will be filtered in next iteration) */
1818  if ((x < width - 1) &&
1819  (s->all_fragments[fragment + 1].coding_method == MODE_COPY)) {
1820  s->vp3dsp.h_loop_filter(
1821  plane_data + 8 * x + 8,
1822  stride, bounding_values);
1823  }
1824 
1825  /* do not perform bottom edge filter for bottom row
1826  * fragments or if bottom fragment neighbor is also coded
1827  * in this frame (it will be filtered in the next row) */
1828  if ((y < height - 1) &&
1829  (s->all_fragments[fragment + width].coding_method == MODE_COPY)) {
1830  s->vp3dsp.v_loop_filter(
1831  plane_data + 8 * x + 8 * stride,
1832  stride, bounding_values);
1833  }
1834  }
1835 
1836  fragment++;
1837  }
1838  plane_data += 8 * stride;
1839  }
1840 }
1841 
1842 /**
1843  * Pull DCT tokens from the 64 levels to decode and dequant the coefficients
1844  * for the next block in coding order
1845  */
1846 static inline int vp3_dequant(Vp3DecodeContext *s, Vp3Fragment *frag,
1847  int plane, int inter, int16_t block[64])
1848 {
1849  int16_t *dequantizer = s->qmat[frag->qpi][inter][plane];
1850  uint8_t *perm = s->idct_scantable;
1851  int i = 0;
1852 
1853  do {
1854  int token = *s->dct_tokens[plane][i];
1855  switch (token & 3) {
1856  case 0: // EOB
1857  if (--token < 4) // 0-3 are token types so the EOB run must now be 0
1858  s->dct_tokens[plane][i]++;
1859  else
1860  *s->dct_tokens[plane][i] = token & ~3;
1861  goto end;
1862  case 1: // zero run
1863  s->dct_tokens[plane][i]++;
1864  i += (token >> 2) & 0x7f;
1865  if (i > 63) {
1866  av_log(s->avctx, AV_LOG_ERROR, "Coefficient index overflow\n");
1867  return i;
1868  }
1869  block[perm[i]] = (token >> 9) * dequantizer[perm[i]];
1870  i++;
1871  break;
1872  case 2: // coeff
1873  block[perm[i]] = (token >> 2) * dequantizer[perm[i]];
1874  s->dct_tokens[plane][i++]++;
1875  break;
1876  default: // shouldn't happen
1877  return i;
1878  }
1879  } while (i < 64);
1880  // return value is expected to be a valid level
1881  i--;
1882 end:
1883  // the actual DC+prediction is in the fragment structure
1884  block[0] = frag->dc * s->qmat[0][inter][plane][0];
1885  return i;
1886 }
1887 
1888 /**
1889  * called when all pixels up to row y are complete
1890  */
1892 {
1893  int h, cy, i;
1895 
1896  if (HAVE_THREADS && s->avctx->active_thread_type & FF_THREAD_FRAME) {
1897  int y_flipped = s->flipped_image ? s->height - y : y;
1898 
1899  /* At the end of the frame, report INT_MAX instead of the height of
1900  * the frame. This makes the other threads' ff_thread_await_progress()
1901  * calls cheaper, because they don't have to clip their values. */
1903  y_flipped == s->height ? INT_MAX
1904  : y_flipped - 1,
1905  0);
1906  }
1907 
1908  if (!s->avctx->draw_horiz_band)
1909  return;
1910 
1911  h = y - s->last_slice_end;
1912  s->last_slice_end = y;
1913  y -= h;
1914 
1915  if (!s->flipped_image)
1916  y = s->height - y - h;
1917 
1918  cy = y >> s->chroma_y_shift;
1919  offset[0] = s->current_frame.f->linesize[0] * y;
1920  offset[1] = s->current_frame.f->linesize[1] * cy;
1921  offset[2] = s->current_frame.f->linesize[2] * cy;
1922  for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
1923  offset[i] = 0;
1924 
1925  emms_c();
1926  s->avctx->draw_horiz_band(s->avctx, s->current_frame.f, offset, y, 3, h);
1927 }
1928 
1929 /**
1930  * Wait for the reference frame of the current fragment.
1931  * The progress value is in luma pixel rows.
1932  */
1934  int motion_y, int y)
1935 {
1936  ThreadFrame *ref_frame;
1937  int ref_row;
1938  int border = motion_y & 1;
1939 
1940  if (fragment->coding_method == MODE_USING_GOLDEN ||
1941  fragment->coding_method == MODE_GOLDEN_MV)
1942  ref_frame = &s->golden_frame;
1943  else
1944  ref_frame = &s->last_frame;
1945 
1946  ref_row = y + (motion_y >> 1);
1947  ref_row = FFMAX(FFABS(ref_row), ref_row + 8 + border);
1948 
1949  ff_thread_await_progress(ref_frame, ref_row, 0);
1950 }
1951 
1952 #if CONFIG_VP4_DECODER
1953 /**
1954  * @return non-zero if temp (edge_emu_buffer) was populated
1955  */
1956 static int vp4_mc_loop_filter(Vp3DecodeContext *s, int plane, int motion_x, int motion_y, int bx, int by,
1957  uint8_t * motion_source, int stride, int src_x, int src_y, uint8_t *temp)
1958 {
1959  int motion_shift = plane ? 4 : 2;
1960  int subpel_mask = plane ? 3 : 1;
1961  int *bounding_values = s->bounding_values_array + 127;
1962 
1963  int i;
1964  int x, y;
1965  int x2, y2;
1966  int x_subpel, y_subpel;
1967  int x_offset, y_offset;
1968 
1969  int block_width = plane ? 8 : 16;
1970  int plane_width = s->width >> (plane && s->chroma_x_shift);
1971  int plane_height = s->height >> (plane && s->chroma_y_shift);
1972 
1973 #define loop_stride 12
1974  uint8_t loop[12 * loop_stride];
1975 
1976  /* using division instead of shift to correctly handle negative values */
1977  x = 8 * bx + motion_x / motion_shift;
1978  y = 8 * by + motion_y / motion_shift;
1979 
1980  x_subpel = motion_x & subpel_mask;
1981  y_subpel = motion_y & subpel_mask;
1982 
1983  if (x_subpel || y_subpel) {
1984  x--;
1985  y--;
1986 
1987  if (x_subpel)
1988  x = FFMIN(x, x + FFSIGN(motion_x));
1989 
1990  if (y_subpel)
1991  y = FFMIN(y, y + FFSIGN(motion_y));
1992 
1993  x2 = x + block_width;
1994  y2 = y + block_width;
1995 
1996  if (x2 < 0 || x2 >= plane_width || y2 < 0 || y2 >= plane_height)
1997  return 0;
1998 
1999  x_offset = (-(x + 2) & 7) + 2;
2000  y_offset = (-(y + 2) & 7) + 2;
2001 
2002  if (x_offset > 8 + x_subpel && y_offset > 8 + y_subpel)
2003  return 0;
2004 
2005  s->vdsp.emulated_edge_mc(loop, motion_source - stride - 1,
2006  loop_stride, stride,
2007  12, 12, src_x - 1, src_y - 1,
2008  plane_width,
2009  plane_height);
2010 
2011  if (x_offset <= 8 + x_subpel)
2012  ff_vp3dsp_h_loop_filter_12(loop + x_offset, loop_stride, bounding_values);
2013 
2014  if (y_offset <= 8 + y_subpel)
2015  ff_vp3dsp_v_loop_filter_12(loop + y_offset*loop_stride, loop_stride, bounding_values);
2016 
2017  } else {
2018 
2019  x_offset = -x & 7;
2020  y_offset = -y & 7;
2021 
2022  if (!x_offset && !y_offset)
2023  return 0;
2024 
2025  s->vdsp.emulated_edge_mc(loop, motion_source - stride - 1,
2026  loop_stride, stride,
2027  12, 12, src_x - 1, src_y - 1,
2028  plane_width,
2029  plane_height);
2030 
2031 #define safe_loop_filter(name, ptr, stride, bounding_values) \
2032  if ((uintptr_t)(ptr) & 7) \
2033  s->vp3dsp.name##_unaligned(ptr, stride, bounding_values); \
2034  else \
2035  s->vp3dsp.name(ptr, stride, bounding_values);
2036 
2037  if (x_offset)
2038  safe_loop_filter(h_loop_filter, loop + loop_stride + x_offset + 1, loop_stride, bounding_values);
2039 
2040  if (y_offset)
2041  safe_loop_filter(v_loop_filter, loop + (y_offset + 1)*loop_stride + 1, loop_stride, bounding_values);
2042  }
2043 
2044  for (i = 0; i < 9; i++)
2045  memcpy(temp + i*stride, loop + (i + 1) * loop_stride + 1, 9);
2046 
2047  return 1;
2048 }
2049 #endif
2050 
2051 /*
2052  * Perform the final rendering for a particular slice of data.
2053  * The slice number ranges from 0..(c_superblock_height - 1).
2054  */
2055 static void render_slice(Vp3DecodeContext *s, int slice)
2056 {
2057  int x, y, i, j, fragment;
2058  int16_t *block = s->block;
2059  int motion_x = 0xdeadbeef, motion_y = 0xdeadbeef;
2060  int motion_halfpel_index;
2061  uint8_t *motion_source;
2062  int plane, first_pixel;
2063 
2064  if (slice >= s->c_superblock_height)
2065  return;
2066 
2067  for (plane = 0; plane < 3; plane++) {
2068  uint8_t *output_plane = s->current_frame.f->data[plane] +
2069  s->data_offset[plane];
2070  uint8_t *last_plane = s->last_frame.f->data[plane] +
2071  s->data_offset[plane];
2072  uint8_t *golden_plane = s->golden_frame.f->data[plane] +
2073  s->data_offset[plane];
2074  ptrdiff_t stride = s->current_frame.f->linesize[plane];
2075  int plane_width = s->width >> (plane && s->chroma_x_shift);
2076  int plane_height = s->height >> (plane && s->chroma_y_shift);
2077  int8_t(*motion_val)[2] = s->motion_val[!!plane];
2078 
2079  int sb_x, sb_y = slice << (!plane && s->chroma_y_shift);
2080  int slice_height = sb_y + 1 + (!plane && s->chroma_y_shift);
2081  int slice_width = plane ? s->c_superblock_width
2082  : s->y_superblock_width;
2083 
2084  int fragment_width = s->fragment_width[!!plane];
2085  int fragment_height = s->fragment_height[!!plane];
2086  int fragment_start = s->fragment_start[plane];
2087 
2088  int do_await = !plane && HAVE_THREADS &&
2090 
2091  if (!s->flipped_image)
2092  stride = -stride;
2093  if (CONFIG_GRAY && plane && (s->avctx->flags & AV_CODEC_FLAG_GRAY))
2094  continue;
2095 
2096  /* for each superblock row in the slice (both of them)... */
2097  for (; sb_y < slice_height; sb_y++) {
2098  /* for each superblock in a row... */
2099  for (sb_x = 0; sb_x < slice_width; sb_x++) {
2100  /* for each block in a superblock... */
2101  for (j = 0; j < 16; j++) {
2102  x = 4 * sb_x + hilbert_offset[j][0];
2103  y = 4 * sb_y + hilbert_offset[j][1];
2104  fragment = y * fragment_width + x;
2105 
2106  i = fragment_start + fragment;
2107 
2108  // bounds check
2109  if (x >= fragment_width || y >= fragment_height)
2110  continue;
2111 
2112  first_pixel = 8 * y * stride + 8 * x;
2113 
2114  if (do_await &&
2117  motion_val[fragment][1],
2118  (16 * y) >> s->chroma_y_shift);
2119 
2120  /* transform if this block was coded */
2121  if (s->all_fragments[i].coding_method != MODE_COPY) {
2124  motion_source = golden_plane;
2125  else
2126  motion_source = last_plane;
2127 
2128  motion_source += first_pixel;
2129  motion_halfpel_index = 0;
2130 
2131  /* sort out the motion vector if this fragment is coded
2132  * using a motion vector method */
2133  if ((s->all_fragments[i].coding_method > MODE_INTRA) &&
2135  int src_x, src_y;
2136  int standard_mc = 1;
2137  motion_x = motion_val[fragment][0];
2138  motion_y = motion_val[fragment][1];
2139 #if CONFIG_VP4_DECODER
2140  if (plane && s->version >= 2) {
2141  motion_x = (motion_x >> 1) | (motion_x & 1);
2142  motion_y = (motion_y >> 1) | (motion_y & 1);
2143  }
2144 #endif
2145 
2146  src_x = (motion_x >> 1) + 8 * x;
2147  src_y = (motion_y >> 1) + 8 * y;
2148 
2149  motion_halfpel_index = motion_x & 0x01;
2150  motion_source += (motion_x >> 1);
2151 
2152  motion_halfpel_index |= (motion_y & 0x01) << 1;
2153  motion_source += ((motion_y >> 1) * stride);
2154 
2155 #if CONFIG_VP4_DECODER
2156  if (s->version >= 2) {
2158  if (stride < 0)
2159  temp -= 8 * stride;
2160  if (vp4_mc_loop_filter(s, plane, motion_val[fragment][0], motion_val[fragment][1], x, y, motion_source, stride, src_x, src_y, temp)) {
2161  motion_source = temp;
2162  standard_mc = 0;
2163  }
2164  }
2165 #endif
2166 
2167  if (standard_mc && (
2168  src_x < 0 || src_y < 0 ||
2169  src_x + 9 >= plane_width ||
2170  src_y + 9 >= plane_height)) {
2172  if (stride < 0)
2173  temp -= 8 * stride;
2174 
2175  s->vdsp.emulated_edge_mc(temp, motion_source,
2176  stride, stride,
2177  9, 9, src_x, src_y,
2178  plane_width,
2179  plane_height);
2180  motion_source = temp;
2181  }
2182  }
2183 
2184  /* first, take care of copying a block from either the
2185  * previous or the golden frame */
2186  if (s->all_fragments[i].coding_method != MODE_INTRA) {
2187  /* Note, it is possible to implement all MC cases
2188  * with put_no_rnd_pixels_l2 which would look more
2189  * like the VP3 source but this would be slower as
2190  * put_no_rnd_pixels_tab is better optimized */
2191  if (motion_halfpel_index != 3) {
2192  s->hdsp.put_no_rnd_pixels_tab[1][motion_halfpel_index](
2193  output_plane + first_pixel,
2194  motion_source, stride, 8);
2195  } else {
2196  /* d is 0 if motion_x and _y have the same sign,
2197  * else -1 */
2198  int d = (motion_x ^ motion_y) >> 31;
2199  s->vp3dsp.put_no_rnd_pixels_l2(output_plane + first_pixel,
2200  motion_source - d,
2201  motion_source + stride + 1 + d,
2202  stride, 8);
2203  }
2204  }
2205 
2206  /* invert DCT and place (or add) in final output */
2207 
2208  if (s->all_fragments[i].coding_method == MODE_INTRA) {
2209  vp3_dequant(s, s->all_fragments + i,
2210  plane, 0, block);
2211  s->vp3dsp.idct_put(output_plane + first_pixel,
2212  stride,
2213  block);
2214  } else {
2215  if (vp3_dequant(s, s->all_fragments + i,
2216  plane, 1, block)) {
2217  s->vp3dsp.idct_add(output_plane + first_pixel,
2218  stride,
2219  block);
2220  } else {
2221  s->vp3dsp.idct_dc_add(output_plane + first_pixel,
2222  stride, block);
2223  }
2224  }
2225  } else {
2226  /* copy directly from the previous frame */
2227  s->hdsp.put_pixels_tab[1][0](
2228  output_plane + first_pixel,
2229  last_plane + first_pixel,
2230  stride, 8);
2231  }
2232  }
2233  }
2234 
2235  // Filter up to the last row in the superblock row
2236  if (s->version < 2 && !s->skip_loop_filter)
2237  apply_loop_filter(s, plane, 4 * sb_y - !!sb_y,
2238  FFMIN(4 * sb_y + 3, fragment_height - 1));
2239  }
2240  }
2241 
2242  /* this looks like a good place for slice dispatch... */
2243  /* algorithm:
2244  * if (slice == s->macroblock_height - 1)
2245  * dispatch (both last slice & 2nd-to-last slice);
2246  * else if (slice > 0)
2247  * dispatch (slice - 1);
2248  */
2249 
2250  vp3_draw_horiz_band(s, FFMIN((32 << s->chroma_y_shift) * (slice + 1) - 16,
2251  s->height - 16));
2252 }
2253 
2254 /// Allocate tables for per-frame data in Vp3DecodeContext
2256 {
2257  Vp3DecodeContext *s = avctx->priv_data;
2258  int y_fragment_count, c_fragment_count;
2259 
2260  free_tables(avctx);
2261 
2262  y_fragment_count = s->fragment_width[0] * s->fragment_height[0];
2263  c_fragment_count = s->fragment_width[1] * s->fragment_height[1];
2264 
2265  /* superblock_coding is used by unpack_superblocks (VP3/Theora) and vp4_unpack_macroblocks (VP4) */
2268 
2269  s-> kf_coded_fragment_list = av_mallocz_array(s->fragment_count, sizeof(int));
2271  memset(s-> num_kf_coded_fragment, -1, sizeof(s-> num_kf_coded_fragment));
2272 
2274  64 * sizeof(*s->dct_tokens_base));
2275  s->motion_val[0] = av_mallocz_array(y_fragment_count, sizeof(*s->motion_val[0]));
2276  s->motion_val[1] = av_mallocz_array(c_fragment_count, sizeof(*s->motion_val[1]));
2277 
2278  /* work out the block mapping tables */
2279  s->superblock_fragments = av_mallocz_array(s->superblock_count, 16 * sizeof(int));
2281 
2282  s->dc_pred_row = av_malloc_array(s->y_superblock_width * 4, sizeof(*s->dc_pred_row));
2283 
2284  if (!s->superblock_coding || !s->all_fragments ||
2288  !s->dc_pred_row ||
2289  !s->motion_val[0] || !s->motion_val[1]) {
2290  vp3_decode_end(avctx);
2291  return -1;
2292  }
2293 
2294  init_block_mapping(s);
2295 
2296  return 0;
2297 }
2298 
2300 {
2302  s->last_frame.f = av_frame_alloc();
2303  s->golden_frame.f = av_frame_alloc();
2304 
2305  if (!s->current_frame.f || !s->last_frame.f || !s->golden_frame.f) {
2307  av_frame_free(&s->last_frame.f);
2309  return AVERROR(ENOMEM);
2310  }
2311 
2312  return 0;
2313 }
2314 
2316 {
2317  Vp3DecodeContext *s = avctx->priv_data;
2318  int i, inter, plane, ret;
2319  int c_width;
2320  int c_height;
2321  int y_fragment_count, c_fragment_count;
2322 #if CONFIG_VP4_DECODER
2323  int j;
2324 #endif
2325 
2326  ret = init_frames(s);
2327  if (ret < 0)
2328  return ret;
2329 
2330  if (avctx->codec_tag == MKTAG('V', 'P', '4', '0'))
2331  s->version = 3;
2332  else if (avctx->codec_tag == MKTAG('V', 'P', '3', '0'))
2333  s->version = 0;
2334  else
2335  s->version = 1;
2336 
2337  s->avctx = avctx;
2338  s->width = FFALIGN(avctx->coded_width, 16);
2339  s->height = FFALIGN(avctx->coded_height, 16);
2340  if (avctx->codec_id != AV_CODEC_ID_THEORA)
2341  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
2344  ff_videodsp_init(&s->vdsp, 8);
2345  ff_vp3dsp_init(&s->vp3dsp, avctx->flags);
2346 
2347  for (i = 0; i < 64; i++) {
2348 #define TRANSPOSE(x) (((x) >> 3) | (((x) & 7) << 3))
2349  s->idct_permutation[i] = TRANSPOSE(i);
2351 #undef TRANSPOSE
2352  }
2353 
2354  /* initialize to an impossible value which will force a recalculation
2355  * in the first frame decode */
2356  for (i = 0; i < 3; i++)
2357  s->qps[i] = -1;
2358 
2360  if (ret)
2361  return ret;
2362 
2363  s->y_superblock_width = (s->width + 31) / 32;
2364  s->y_superblock_height = (s->height + 31) / 32;
2366 
2367  /* work out the dimensions for the C planes */
2368  c_width = s->width >> s->chroma_x_shift;
2369  c_height = s->height >> s->chroma_y_shift;
2370  s->c_superblock_width = (c_width + 31) / 32;
2371  s->c_superblock_height = (c_height + 31) / 32;
2373 
2377 
2378  s->macroblock_width = (s->width + 15) / 16;
2379  s->macroblock_height = (s->height + 15) / 16;
2381  s->c_macroblock_width = (c_width + 15) / 16;
2382  s->c_macroblock_height = (c_height + 15) / 16;
2385 
2386  s->fragment_width[0] = s->width / FRAGMENT_PIXELS;
2387  s->fragment_height[0] = s->height / FRAGMENT_PIXELS;
2388  s->fragment_width[1] = s->fragment_width[0] >> s->chroma_x_shift;
2389  s->fragment_height[1] = s->fragment_height[0] >> s->chroma_y_shift;
2390 
2391  /* fragment count covers all 8x8 blocks for all 3 planes */
2392  y_fragment_count = s->fragment_width[0] * s->fragment_height[0];
2393  c_fragment_count = s->fragment_width[1] * s->fragment_height[1];
2394  s->fragment_count = y_fragment_count + 2 * c_fragment_count;
2395  s->fragment_start[1] = y_fragment_count;
2396  s->fragment_start[2] = y_fragment_count + c_fragment_count;
2397 
2398  if (!s->theora_tables) {
2399  for (i = 0; i < 64; i++) {
2407  }
2408 
2409  for (inter = 0; inter < 2; inter++) {
2410  for (plane = 0; plane < 3; plane++) {
2411  s->qr_count[inter][plane] = 1;
2412  s->qr_size[inter][plane][0] = 63;
2413  s->qr_base[inter][plane][0] =
2414  s->qr_base[inter][plane][1] = 2 * inter + (!!plane) * !inter;
2415  }
2416  }
2417 
2418  /* init VLC tables */
2419  if (s->version < 2) {
2420  for (i = 0; i < 16; i++) {
2421  /* DC histograms */
2422  init_vlc(&s->dc_vlc[i], 11, 32,
2423  &dc_bias[i][0][1], 4, 2,
2424  &dc_bias[i][0][0], 4, 2, 0);
2425 
2426  /* group 1 AC histograms */
2427  init_vlc(&s->ac_vlc_1[i], 11, 32,
2428  &ac_bias_0[i][0][1], 4, 2,
2429  &ac_bias_0[i][0][0], 4, 2, 0);
2430 
2431  /* group 2 AC histograms */
2432  init_vlc(&s->ac_vlc_2[i], 11, 32,
2433  &ac_bias_1[i][0][1], 4, 2,
2434  &ac_bias_1[i][0][0], 4, 2, 0);
2435 
2436  /* group 3 AC histograms */
2437  init_vlc(&s->ac_vlc_3[i], 11, 32,
2438  &ac_bias_2[i][0][1], 4, 2,
2439  &ac_bias_2[i][0][0], 4, 2, 0);
2440 
2441  /* group 4 AC histograms */
2442  init_vlc(&s->ac_vlc_4[i], 11, 32,
2443  &ac_bias_3[i][0][1], 4, 2,
2444  &ac_bias_3[i][0][0], 4, 2, 0);
2445  }
2446 #if CONFIG_VP4_DECODER
2447  } else { /* version >= 2 */
2448  for (i = 0; i < 16; i++) {
2449  /* DC histograms */
2450  init_vlc(&s->dc_vlc[i], 11, 32,
2451  &vp4_dc_bias[i][0][1], 4, 2,
2452  &vp4_dc_bias[i][0][0], 4, 2, 0);
2453 
2454  /* group 1 AC histograms */
2455  init_vlc(&s->ac_vlc_1[i], 11, 32,
2456  &vp4_ac_bias_0[i][0][1], 4, 2,
2457  &vp4_ac_bias_0[i][0][0], 4, 2, 0);
2458 
2459  /* group 2 AC histograms */
2460  init_vlc(&s->ac_vlc_2[i], 11, 32,
2461  &vp4_ac_bias_1[i][0][1], 4, 2,
2462  &vp4_ac_bias_1[i][0][0], 4, 2, 0);
2463 
2464  /* group 3 AC histograms */
2465  init_vlc(&s->ac_vlc_3[i], 11, 32,
2466  &vp4_ac_bias_2[i][0][1], 4, 2,
2467  &vp4_ac_bias_2[i][0][0], 4, 2, 0);
2468 
2469  /* group 4 AC histograms */
2470  init_vlc(&s->ac_vlc_4[i], 11, 32,
2471  &vp4_ac_bias_3[i][0][1], 4, 2,
2472  &vp4_ac_bias_3[i][0][0], 4, 2, 0);
2473  }
2474 #endif
2475  }
2476  } else {
2477  for (i = 0; i < 16; i++) {
2478  /* DC histograms */
2479  if (init_vlc(&s->dc_vlc[i], 11, 32,
2480  &s->huffman_table[i][0][1], 8, 4,
2481  &s->huffman_table[i][0][0], 8, 4, 0) < 0)
2482  goto vlc_fail;
2483 
2484  /* group 1 AC histograms */
2485  if (init_vlc(&s->ac_vlc_1[i], 11, 32,
2486  &s->huffman_table[i + 16][0][1], 8, 4,
2487  &s->huffman_table[i + 16][0][0], 8, 4, 0) < 0)
2488  goto vlc_fail;
2489 
2490  /* group 2 AC histograms */
2491  if (init_vlc(&s->ac_vlc_2[i], 11, 32,
2492  &s->huffman_table[i + 16 * 2][0][1], 8, 4,
2493  &s->huffman_table[i + 16 * 2][0][0], 8, 4, 0) < 0)
2494  goto vlc_fail;
2495 
2496  /* group 3 AC histograms */
2497  if (init_vlc(&s->ac_vlc_3[i], 11, 32,
2498  &s->huffman_table[i + 16 * 3][0][1], 8, 4,
2499  &s->huffman_table[i + 16 * 3][0][0], 8, 4, 0) < 0)
2500  goto vlc_fail;
2501 
2502  /* group 4 AC histograms */
2503  if (init_vlc(&s->ac_vlc_4[i], 11, 32,
2504  &s->huffman_table[i + 16 * 4][0][1], 8, 4,
2505  &s->huffman_table[i + 16 * 4][0][0], 8, 4, 0) < 0)
2506  goto vlc_fail;
2507  }
2508  }
2509 
2511  &superblock_run_length_vlc_table[0][1], 4, 2,
2512  &superblock_run_length_vlc_table[0][0], 4, 2, 0);
2513 
2514  init_vlc(&s->fragment_run_length_vlc, 5, 30,
2515  &fragment_run_length_vlc_table[0][1], 4, 2,
2516  &fragment_run_length_vlc_table[0][0], 4, 2, 0);
2517 
2518  init_vlc(&s->mode_code_vlc, 3, 8,
2519  &mode_code_vlc_table[0][1], 2, 1,
2520  &mode_code_vlc_table[0][0], 2, 1, 0);
2521 
2522  init_vlc(&s->motion_vector_vlc, 6, 63,
2523  &motion_vector_vlc_table[0][1], 2, 1,
2524  &motion_vector_vlc_table[0][0], 2, 1, 0);
2525 
2526 #if CONFIG_VP4_DECODER
2527  for (j = 0; j < 2; j++)
2528  for (i = 0; i < 7; i++)
2529  init_vlc(&s->vp4_mv_vlc[j][i], 6, 63,
2530  &vp4_mv_vlc[j][i][0][1], 4, 2,
2531  &vp4_mv_vlc[j][i][0][0], 4, 2, 0);
2532 
2533  /* version >= 2 */
2534  for (i = 0; i < 2; i++)
2535  init_vlc(&s->block_pattern_vlc[i], 3, 14,
2536  &vp4_block_pattern_vlc[i][0][1], 2, 1,
2537  &vp4_block_pattern_vlc[i][0][0], 2, 1, 0);
2538 #endif
2539 
2540  return allocate_tables(avctx);
2541 
2542 vlc_fail:
2543  av_log(avctx, AV_LOG_FATAL, "Invalid huffman table\n");
2544  return -1;
2545 }
2546 
2547 /// Release and shuffle frames after decode finishes
2548 static int update_frames(AVCodecContext *avctx)
2549 {
2550  Vp3DecodeContext *s = avctx->priv_data;
2551  int ret = 0;
2552 
2553  /* shuffle frames (last = current) */
2556  if (ret < 0)
2557  goto fail;
2558 
2559  if (s->keyframe) {
2562  }
2563 
2564 fail:
2566  return ret;
2567 }
2568 
2569 #if HAVE_THREADS
2570 static int ref_frame(Vp3DecodeContext *s, ThreadFrame *dst, ThreadFrame *src)
2571 {
2573  if (src->f->data[0])
2574  return ff_thread_ref_frame(dst, src);
2575  return 0;
2576 }
2577 
2578 static int ref_frames(Vp3DecodeContext *dst, Vp3DecodeContext *src)
2579 {
2580  int ret;
2581  if ((ret = ref_frame(dst, &dst->current_frame, &src->current_frame)) < 0 ||
2582  (ret = ref_frame(dst, &dst->golden_frame, &src->golden_frame)) < 0 ||
2583  (ret = ref_frame(dst, &dst->last_frame, &src->last_frame)) < 0)
2584  return ret;
2585  return 0;
2586 }
2587 
2588 static int vp3_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
2589 {
2590  Vp3DecodeContext *s = dst->priv_data, *s1 = src->priv_data;
2591  int qps_changed = 0, i, err;
2592 
2593  if (!s1->current_frame.f->data[0] ||
2594  s->width != s1->width || s->height != s1->height) {
2595  if (s != s1)
2596  ref_frames(s, s1);
2597  return -1;
2598  }
2599 
2600  if (s != s1) {
2601  // copy previous frame data
2602  if ((err = ref_frames(s, s1)) < 0)
2603  return err;
2604 
2605  s->keyframe = s1->keyframe;
2606 
2607  // copy qscale data if necessary
2608  for (i = 0; i < 3; i++) {
2609  if (s->qps[i] != s1->qps[1]) {
2610  qps_changed = 1;
2611  memcpy(&s->qmat[i], &s1->qmat[i], sizeof(s->qmat[i]));
2612  }
2613  }
2614 
2615  if (s->qps[0] != s1->qps[0])
2616  memcpy(&s->bounding_values_array, &s1->bounding_values_array,
2617  sizeof(s->bounding_values_array));
2618 
2619  if (qps_changed) {
2620  memcpy(s->qps, s1->qps, sizeof(s->qps));
2621  memcpy(s->last_qps, s1->last_qps, sizeof(s->last_qps));
2622  s->nqps = s1->nqps;
2623  }
2624  }
2625 
2626  return update_frames(dst);
2627 }
2628 #endif
2629 
2631  void *data, int *got_frame,
2632  AVPacket *avpkt)
2633 {
2634  AVFrame *frame = data;
2635  const uint8_t *buf = avpkt->data;
2636  int buf_size = avpkt->size;
2637  Vp3DecodeContext *s = avctx->priv_data;
2638  GetBitContext gb;
2639  int i, ret;
2640 
2641  if ((ret = init_get_bits8(&gb, buf, buf_size)) < 0)
2642  return ret;
2643 
2644 #if CONFIG_THEORA_DECODER
2645  if (s->theora && get_bits1(&gb)) {
2646  int type = get_bits(&gb, 7);
2647  skip_bits_long(&gb, 6*8); /* "theora" */
2648 
2650  av_log(avctx, AV_LOG_ERROR, "midstream reconfiguration with multithreading is unsupported, try -threads 1\n");
2651  return AVERROR_PATCHWELCOME;
2652  }
2653  if (type == 0) {
2654  vp3_decode_end(avctx);
2655  ret = theora_decode_header(avctx, &gb);
2656 
2657  if (ret >= 0)
2658  ret = vp3_decode_init(avctx);
2659  if (ret < 0) {
2660  vp3_decode_end(avctx);
2661  return ret;
2662  }
2663  return buf_size;
2664  } else if (type == 2) {
2665  vp3_decode_end(avctx);
2666  ret = theora_decode_tables(avctx, &gb);
2667  if (ret >= 0)
2668  ret = vp3_decode_init(avctx);
2669  if (ret < 0) {
2670  vp3_decode_end(avctx);
2671  return ret;
2672  }
2673  return buf_size;
2674  }
2675 
2676  av_log(avctx, AV_LOG_ERROR,
2677  "Header packet passed to frame decoder, skipping\n");
2678  return -1;
2679  }
2680 #endif
2681 
2682  s->keyframe = !get_bits1(&gb);
2683  if (!s->all_fragments) {
2684  av_log(avctx, AV_LOG_ERROR, "Data packet without prior valid headers\n");
2685  return -1;
2686  }
2687  if (!s->theora)
2688  skip_bits(&gb, 1);
2689  for (i = 0; i < 3; i++)
2690  s->last_qps[i] = s->qps[i];
2691 
2692  s->nqps = 0;
2693  do {
2694  s->qps[s->nqps++] = get_bits(&gb, 6);
2695  } while (s->theora >= 0x030200 && s->nqps < 3 && get_bits1(&gb));
2696  for (i = s->nqps; i < 3; i++)
2697  s->qps[i] = -1;
2698 
2699  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2700  av_log(s->avctx, AV_LOG_INFO, " VP3 %sframe #%d: Q index = %d\n",
2701  s->keyframe ? "key" : "", avctx->frame_number + 1, s->qps[0]);
2702 
2703  s->skip_loop_filter = !s->filter_limit_values[s->qps[0]] ||
2704  avctx->skip_loop_filter >= (s->keyframe ? AVDISCARD_ALL
2705  : AVDISCARD_NONKEY);
2706 
2707  if (s->qps[0] != s->last_qps[0])
2708  init_loop_filter(s);
2709 
2710  for (i = 0; i < s->nqps; i++)
2711  // reinit all dequantizers if the first one changed, because
2712  // the DC of the first quantizer must be used for all matrices
2713  if (s->qps[i] != s->last_qps[i] || s->qps[0] != s->last_qps[0])
2714  init_dequantizer(s, i);
2715 
2716  if (avctx->skip_frame >= AVDISCARD_NONKEY && !s->keyframe)
2717  return buf_size;
2718 
2721  s->current_frame.f->key_frame = s->keyframe;
2723  goto error;
2724 
2725  if (!s->edge_emu_buffer)
2727 
2728  if (s->keyframe) {
2729  if (!s->theora) {
2730  skip_bits(&gb, 4); /* width code */
2731  skip_bits(&gb, 4); /* height code */
2732  if (s->version) {
2733  s->version = get_bits(&gb, 5);
2734  if (avctx->frame_number == 0)
2736  "VP version: %d\n", s->version);
2737  }
2738  }
2739  if (s->version || s->theora) {
2740  if (get_bits1(&gb))
2742  "Warning, unsupported keyframe coding type?!\n");
2743  skip_bits(&gb, 2); /* reserved? */
2744 
2745 #if CONFIG_VP4_DECODER
2746  if (s->version >= 2) {
2747  int mb_height, mb_width;
2748  int mb_width_mul, mb_width_div, mb_height_mul, mb_height_div;
2749 
2750  mb_height = get_bits(&gb, 8);
2751  mb_width = get_bits(&gb, 8);
2752  if (mb_height != s->macroblock_height ||
2753  mb_width != s->macroblock_width)
2754  avpriv_request_sample(s->avctx, "macroblock dimension mismatch");
2755 
2756  mb_width_mul = get_bits(&gb, 5);
2757  mb_width_div = get_bits(&gb, 3);
2758  mb_height_mul = get_bits(&gb, 5);
2759  mb_height_div = get_bits(&gb, 3);
2760  if (mb_width_mul != 1 || mb_width_div != 1 || mb_height_mul != 1 || mb_height_div != 1)
2761  avpriv_request_sample(s->avctx, "unexpected macroblock dimension multipler/divider");
2762 
2763  if (get_bits(&gb, 2))
2764  avpriv_request_sample(s->avctx, "unknown bits");
2765  }
2766 #endif
2767  }
2768  } else {
2769  if (!s->golden_frame.f->data[0]) {
2771  "vp3: first frame not a keyframe\n");
2772 
2774  if ((ret = ff_thread_get_buffer(avctx, &s->golden_frame,
2775  AV_GET_BUFFER_FLAG_REF)) < 0)
2776  goto error;
2778  if ((ret = ff_thread_ref_frame(&s->last_frame,
2779  &s->golden_frame)) < 0)
2780  goto error;
2781  ff_thread_report_progress(&s->last_frame, INT_MAX, 0);
2782  }
2783  }
2784 
2785  memset(s->all_fragments, 0, s->fragment_count * sizeof(Vp3Fragment));
2786  ff_thread_finish_setup(avctx);
2787 
2788  if (s->version < 2) {
2789  if ((ret = unpack_superblocks(s, &gb)) < 0) {
2790  av_log(s->avctx, AV_LOG_ERROR, "error in unpack_superblocks\n");
2791  goto error;
2792  }
2793 #if CONFIG_VP4_DECODER
2794  } else {
2795  if ((ret = vp4_unpack_macroblocks(s, &gb)) < 0) {
2796  av_log(s->avctx, AV_LOG_ERROR, "error in vp4_unpack_macroblocks\n");
2797  goto error;
2798  }
2799 #endif
2800  }
2801  if ((ret = unpack_modes(s, &gb)) < 0) {
2802  av_log(s->avctx, AV_LOG_ERROR, "error in unpack_modes\n");
2803  goto error;
2804  }
2805  if (ret = unpack_vectors(s, &gb)) {
2806  av_log(s->avctx, AV_LOG_ERROR, "error in unpack_vectors\n");
2807  goto error;
2808  }
2809  if ((ret = unpack_block_qpis(s, &gb)) < 0) {
2810  av_log(s->avctx, AV_LOG_ERROR, "error in unpack_block_qpis\n");
2811  goto error;
2812  }
2813 
2814  if (s->version < 2) {
2815  if ((ret = unpack_dct_coeffs(s, &gb)) < 0) {
2816  av_log(s->avctx, AV_LOG_ERROR, "error in unpack_dct_coeffs\n");
2817  goto error;
2818  }
2819 #if CONFIG_VP4_DECODER
2820  } else {
2821  if ((ret = vp4_unpack_dct_coeffs(s, &gb)) < 0) {
2822  av_log(s->avctx, AV_LOG_ERROR, "error in vp4_unpack_dct_coeffs\n");
2823  goto error;
2824  }
2825 #endif
2826  }
2827 
2828  for (i = 0; i < 3; i++) {
2829  int height = s->height >> (i && s->chroma_y_shift);
2830  if (s->flipped_image)
2831  s->data_offset[i] = 0;
2832  else
2833  s->data_offset[i] = (height - 1) * s->current_frame.f->linesize[i];
2834  }
2835 
2836  s->last_slice_end = 0;
2837  for (i = 0; i < s->c_superblock_height; i++)
2838  render_slice(s, i);
2839 
2840  // filter the last row
2841  if (s->version < 2)
2842  for (i = 0; i < 3; i++) {
2843  int row = (s->height >> (3 + (i && s->chroma_y_shift))) - 1;
2844  apply_loop_filter(s, i, row, row + 1);
2845  }
2846  vp3_draw_horiz_band(s, s->height);
2847 
2848  /* output frame, offset as needed */
2849  if ((ret = av_frame_ref(data, s->current_frame.f)) < 0)
2850  return ret;
2851 
2852  frame->crop_left = s->offset_x;
2853  frame->crop_right = avctx->coded_width - avctx->width - s->offset_x;
2854  frame->crop_top = s->offset_y;
2855  frame->crop_bottom = avctx->coded_height - avctx->height - s->offset_y;
2856 
2857  *got_frame = 1;
2858 
2859  if (!HAVE_THREADS || !(s->avctx->active_thread_type & FF_THREAD_FRAME)) {
2860  ret = update_frames(avctx);
2861  if (ret < 0)
2862  return ret;
2863  }
2864 
2865  return buf_size;
2866 
2867 error:
2868  ff_thread_report_progress(&s->current_frame, INT_MAX, 0);
2869 
2870  if (!HAVE_THREADS || !(s->avctx->active_thread_type & FF_THREAD_FRAME))
2872 
2873  return ret;
2874 }
2875 
2877 {
2878  Vp3DecodeContext *s = avctx->priv_data;
2879 
2880  if (get_bits1(gb)) {
2881  int token;
2882  if (s->entries >= 32) { /* overflow */
2883  av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n");
2884  return -1;
2885  }
2886  token = get_bits(gb, 5);
2887  ff_dlog(avctx, "hti %d hbits %x token %d entry : %d size %d\n",
2888  s->hti, s->hbits, token, s->entries, s->huff_code_size);
2889  s->huffman_table[s->hti][token][0] = s->hbits;
2890  s->huffman_table[s->hti][token][1] = s->huff_code_size;
2891  s->entries++;
2892  } else {
2893  if (s->huff_code_size >= 32) { /* overflow */
2894  av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n");
2895  return -1;
2896  }
2897  s->huff_code_size++;
2898  s->hbits <<= 1;
2899  if (read_huffman_tree(avctx, gb))
2900  return -1;
2901  s->hbits |= 1;
2902  if (read_huffman_tree(avctx, gb))
2903  return -1;
2904  s->hbits >>= 1;
2905  s->huff_code_size--;
2906  }
2907  return 0;
2908 }
2909 
2910 #if CONFIG_THEORA_DECODER
2911 static const enum AVPixelFormat theora_pix_fmts[4] = {
2913 };
2914 
2915 static int theora_decode_header(AVCodecContext *avctx, GetBitContext *gb)
2916 {
2917  Vp3DecodeContext *s = avctx->priv_data;
2918  int visible_width, visible_height, colorspace;
2919  uint8_t offset_x = 0, offset_y = 0;
2920  int ret;
2921  AVRational fps, aspect;
2922 
2923  s->theora_header = 0;
2924  s->theora = get_bits(gb, 24);
2925  av_log(avctx, AV_LOG_DEBUG, "Theora bitstream version %X\n", s->theora);
2926  if (!s->theora) {
2927  s->theora = 1;
2928  avpriv_request_sample(s->avctx, "theora 0");
2929  }
2930 
2931  /* 3.2.0 aka alpha3 has the same frame orientation as original vp3
2932  * but previous versions have the image flipped relative to vp3 */
2933  if (s->theora < 0x030200) {
2934  s->flipped_image = 1;
2935  av_log(avctx, AV_LOG_DEBUG,
2936  "Old (<alpha3) Theora bitstream, flipped image\n");
2937  }
2938 
2939  visible_width =
2940  s->width = get_bits(gb, 16) << 4;
2941  visible_height =
2942  s->height = get_bits(gb, 16) << 4;
2943 
2944  if (s->theora >= 0x030200) {
2945  visible_width = get_bits(gb, 24);
2946  visible_height = get_bits(gb, 24);
2947 
2948  offset_x = get_bits(gb, 8); /* offset x */
2949  offset_y = get_bits(gb, 8); /* offset y, from bottom */
2950  }
2951 
2952  /* sanity check */
2953  if (av_image_check_size(visible_width, visible_height, 0, avctx) < 0 ||
2954  visible_width + offset_x > s->width ||
2955  visible_height + offset_y > s->height) {
2956  av_log(avctx, AV_LOG_ERROR,
2957  "Invalid frame dimensions - w:%d h:%d x:%d y:%d (%dx%d).\n",
2958  visible_width, visible_height, offset_x, offset_y,
2959  s->width, s->height);
2960  return AVERROR_INVALIDDATA;
2961  }
2962 
2963  fps.num = get_bits_long(gb, 32);
2964  fps.den = get_bits_long(gb, 32);
2965  if (fps.num && fps.den) {
2966  if (fps.num < 0 || fps.den < 0) {
2967  av_log(avctx, AV_LOG_ERROR, "Invalid framerate\n");
2968  return AVERROR_INVALIDDATA;
2969  }
2970  av_reduce(&avctx->framerate.den, &avctx->framerate.num,
2971  fps.den, fps.num, 1 << 30);
2972  }
2973 
2974  aspect.num = get_bits(gb, 24);
2975  aspect.den = get_bits(gb, 24);
2976  if (aspect.num && aspect.den) {
2978  &avctx->sample_aspect_ratio.den,
2979  aspect.num, aspect.den, 1 << 30);
2980  ff_set_sar(avctx, avctx->sample_aspect_ratio);
2981  }
2982 
2983  if (s->theora < 0x030200)
2984  skip_bits(gb, 5); /* keyframe frequency force */
2985  colorspace = get_bits(gb, 8);
2986  skip_bits(gb, 24); /* bitrate */
2987 
2988  skip_bits(gb, 6); /* quality hint */
2989 
2990  if (s->theora >= 0x030200) {
2991  skip_bits(gb, 5); /* keyframe frequency force */
2992  avctx->pix_fmt = theora_pix_fmts[get_bits(gb, 2)];
2993  if (avctx->pix_fmt == AV_PIX_FMT_NONE) {
2994  av_log(avctx, AV_LOG_ERROR, "Invalid pixel format\n");
2995  return AVERROR_INVALIDDATA;
2996  }
2997  skip_bits(gb, 3); /* reserved */
2998  } else
2999  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
3000 
3001  ret = ff_set_dimensions(avctx, s->width, s->height);
3002  if (ret < 0)
3003  return ret;
3004  if (!(avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP)) {
3005  avctx->width = visible_width;
3006  avctx->height = visible_height;
3007  // translate offsets from theora axis ([0,0] lower left)
3008  // to normal axis ([0,0] upper left)
3009  s->offset_x = offset_x;
3010  s->offset_y = s->height - visible_height - offset_y;
3011  }
3012 
3013  if (colorspace == 1)
3015  else if (colorspace == 2)
3017 
3018  if (colorspace == 1 || colorspace == 2) {
3019  avctx->colorspace = AVCOL_SPC_BT470BG;
3020  avctx->color_trc = AVCOL_TRC_BT709;
3021  }
3022 
3023  s->theora_header = 1;
3024  return 0;
3025 }
3026 
3027 static int theora_decode_tables(AVCodecContext *avctx, GetBitContext *gb)
3028 {
3029  Vp3DecodeContext *s = avctx->priv_data;
3030  int i, n, matrices, inter, plane;
3031 
3032  if (!s->theora_header)
3033  return AVERROR_INVALIDDATA;
3034 
3035  if (s->theora >= 0x030200) {
3036  n = get_bits(gb, 3);
3037  /* loop filter limit values table */
3038  if (n)
3039  for (i = 0; i < 64; i++)
3040  s->filter_limit_values[i] = get_bits(gb, n);
3041  }
3042 
3043  if (s->theora >= 0x030200)
3044  n = get_bits(gb, 4) + 1;
3045  else
3046  n = 16;
3047  /* quality threshold table */
3048  for (i = 0; i < 64; i++)
3049  s->coded_ac_scale_factor[i] = get_bits(gb, n);
3050 
3051  if (s->theora >= 0x030200)
3052  n = get_bits(gb, 4) + 1;
3053  else
3054  n = 16;
3055  /* dc scale factor table */
3056  for (i = 0; i < 64; i++)
3057  s->coded_dc_scale_factor[0][i] =
3058  s->coded_dc_scale_factor[1][i] = get_bits(gb, n);
3059 
3060  if (s->theora >= 0x030200)
3061  matrices = get_bits(gb, 9) + 1;
3062  else
3063  matrices = 3;
3064 
3065  if (matrices > 384) {
3066  av_log(avctx, AV_LOG_ERROR, "invalid number of base matrixes\n");
3067  return -1;
3068  }
3069 
3070  for (n = 0; n < matrices; n++)
3071  for (i = 0; i < 64; i++)
3072  s->base_matrix[n][i] = get_bits(gb, 8);
3073 
3074  for (inter = 0; inter <= 1; inter++) {
3075  for (plane = 0; plane <= 2; plane++) {
3076  int newqr = 1;
3077  if (inter || plane > 0)
3078  newqr = get_bits1(gb);
3079  if (!newqr) {
3080  int qtj, plj;
3081  if (inter && get_bits1(gb)) {
3082  qtj = 0;
3083  plj = plane;
3084  } else {
3085  qtj = (3 * inter + plane - 1) / 3;
3086  plj = (plane + 2) % 3;
3087  }
3088  s->qr_count[inter][plane] = s->qr_count[qtj][plj];
3089  memcpy(s->qr_size[inter][plane], s->qr_size[qtj][plj],
3090  sizeof(s->qr_size[0][0]));
3091  memcpy(s->qr_base[inter][plane], s->qr_base[qtj][plj],
3092  sizeof(s->qr_base[0][0]));
3093  } else {
3094  int qri = 0;
3095  int qi = 0;
3096 
3097  for (;;) {
3098  i = get_bits(gb, av_log2(matrices - 1) + 1);
3099  if (i >= matrices) {
3100  av_log(avctx, AV_LOG_ERROR,
3101  "invalid base matrix index\n");
3102  return -1;
3103  }
3104  s->qr_base[inter][plane][qri] = i;
3105  if (qi >= 63)
3106  break;
3107  i = get_bits(gb, av_log2(63 - qi) + 1) + 1;
3108  s->qr_size[inter][plane][qri++] = i;
3109  qi += i;
3110  }
3111 
3112  if (qi > 63) {
3113  av_log(avctx, AV_LOG_ERROR, "invalid qi %d > 63\n", qi);
3114  return -1;
3115  }
3116  s->qr_count[inter][plane] = qri;
3117  }
3118  }
3119  }
3120 
3121  /* Huffman tables */
3122  for (s->hti = 0; s->hti < 80; s->hti++) {
3123  s->entries = 0;
3124  s->huff_code_size = 1;
3125  if (!get_bits1(gb)) {
3126  s->hbits = 0;
3127  if (read_huffman_tree(avctx, gb))
3128  return -1;
3129  s->hbits = 1;
3130  if (read_huffman_tree(avctx, gb))
3131  return -1;
3132  }
3133  }
3134 
3135  s->theora_tables = 1;
3136 
3137  return 0;
3138 }
3139 
3140 static av_cold int theora_decode_init(AVCodecContext *avctx)
3141 {
3142  Vp3DecodeContext *s = avctx->priv_data;
3143  GetBitContext gb;
3144  int ptype;
3145  const uint8_t *header_start[3];
3146  int header_len[3];
3147  int i;
3148  int ret;
3149 
3150  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
3151 
3152  s->theora = 1;
3153 
3154  if (!avctx->extradata_size) {
3155  av_log(avctx, AV_LOG_ERROR, "Missing extradata!\n");
3156  return -1;
3157  }
3158 
3160  42, header_start, header_len) < 0) {
3161  av_log(avctx, AV_LOG_ERROR, "Corrupt extradata\n");
3162  return -1;
3163  }
3164 
3165  for (i = 0; i < 3; i++) {
3166  if (header_len[i] <= 0)
3167  continue;
3168  ret = init_get_bits8(&gb, header_start[i], header_len[i]);
3169  if (ret < 0)
3170  return ret;
3171 
3172  ptype = get_bits(&gb, 8);
3173 
3174  if (!(ptype & 0x80)) {
3175  av_log(avctx, AV_LOG_ERROR, "Invalid extradata!\n");
3176 // return -1;
3177  }
3178 
3179  // FIXME: Check for this as well.
3180  skip_bits_long(&gb, 6 * 8); /* "theora" */
3181 
3182  switch (ptype) {
3183  case 0x80:
3184  if (theora_decode_header(avctx, &gb) < 0)
3185  return -1;
3186  break;
3187  case 0x81:
3188 // FIXME: is this needed? it breaks sometimes
3189 // theora_decode_comments(avctx, gb);
3190  break;
3191  case 0x82:
3192  if (theora_decode_tables(avctx, &gb))
3193  return -1;
3194  break;
3195  default:
3196  av_log(avctx, AV_LOG_ERROR,
3197  "Unknown Theora config packet: %d\n", ptype & ~0x80);
3198  break;
3199  }
3200  if (ptype != 0x81 && 8 * header_len[i] != get_bits_count(&gb))
3201  av_log(avctx, AV_LOG_WARNING,
3202  "%d bits left in packet %X\n",
3203  8 * header_len[i] - get_bits_count(&gb), ptype);
3204  if (s->theora < 0x030200)
3205  break;
3206  }
3207 
3208  return vp3_decode_init(avctx);
3209 }
3210 
3212  .name = "theora",
3213  .long_name = NULL_IF_CONFIG_SMALL("Theora"),
3214  .type = AVMEDIA_TYPE_VIDEO,
3215  .id = AV_CODEC_ID_THEORA,
3216  .priv_data_size = sizeof(Vp3DecodeContext),
3217  .init = theora_decode_init,
3218  .close = vp3_decode_end,
3223  .update_thread_context = ONLY_IF_THREADS_ENABLED(vp3_update_thread_context),
3225 };
3226 #endif
3227 
3229  .name = "vp3",
3230  .long_name = NULL_IF_CONFIG_SMALL("On2 VP3"),
3231  .type = AVMEDIA_TYPE_VIDEO,
3232  .id = AV_CODEC_ID_VP3,
3233  .priv_data_size = sizeof(Vp3DecodeContext),
3234  .init = vp3_decode_init,
3235  .close = vp3_decode_end,
3240  .update_thread_context = ONLY_IF_THREADS_ENABLED(vp3_update_thread_context),
3241  .caps_internal = FF_CODEC_CAP_ALLOCATE_PROGRESS,
3242 };
3243 
3244 #if CONFIG_VP4_DECODER
3246  .name = "vp4",
3247  .long_name = NULL_IF_CONFIG_SMALL("On2 VP4"),
3248  .type = AVMEDIA_TYPE_VIDEO,
3249  .id = AV_CODEC_ID_VP4,
3250  .priv_data_size = sizeof(Vp3DecodeContext),
3251  .init = vp3_decode_init,
3252  .close = vp3_decode_end,
3257  .update_thread_context = ONLY_IF_THREADS_ENABLED(vp3_update_thread_context),
3258  .caps_internal = FF_CODEC_CAP_ALLOCATE_PROGRESS,
3259 };
3260 #endif
#define BLOCK_Y
Definition: vp3.c:641
AVCodec ff_vp4_decoder
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:38
int last_slice_end
Definition: vp3.c:175
uint8_t idct_scantable[64]
Definition: vp3.c:169
AVRational framerate
Definition: avcodec.h:2069
discard all frames except keyframes
Definition: avcodec.h:235
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AV_NUM_DATA_POINTERS
Definition: frame.h:309
int16_t qmat[3][2][3][64]
qmat[qpi][is_inter][plane]
Definition: vp3.c:275
static int init_block_mapping(Vp3DecodeContext *s)
This function sets up all of the various blocks mappings: superblocks <-> fragments, macroblocks <-> fragments, superblocks <-> macroblocks.
Definition: vp3.c:379
#define SB_NOT_CODED
Definition: vp3.c:60
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
#define TOKEN_EOB(eob_run)
Definition: vp3.c:241
static void render_slice(Vp3DecodeContext *s, int slice)
Definition: vp3.c:2055
static const uint16_t vp4_dc_bias[16][32][2]
Definition: vp4data.h:371
#define PUR
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
int y_superblock_count
Definition: vp3.c:185
static void flush(AVCodecContext *avctx)
int bounding_values_array[256+2]
Definition: vp3.c:297
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:714
void(* put_no_rnd_pixels_l2)(uint8_t *dst, const uint8_t *a, const uint8_t *b, ptrdiff_t stride, int h)
Copy 8xH pixels from source to destination buffer using a bilinear filter with no rounding (i...
Definition: vp3dsp.h:36
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
misc image utilities
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
static int get_coeff(GetBitContext *gb, int token, int16_t *coeff)
Definition: vp3.c:1147
uint16_t qr_base[2][3][64]
Definition: vp3.c:220
AVFrame * f
Definition: thread.h:35
else temp
Definition: vf_mcdeint.c:256
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:105
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
VLC mode_code_vlc
Definition: vp3.c:269
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
static int theora_decode_tables(AVCodecContext *avctx, GetBitContext *gb)
int y_superblock_width
Definition: vp3.c:183
static const uint16_t fragment_run_length_vlc_table[30][2]
Definition: vp3data.h:119
HpelDSPContext hdsp
Definition: vp3.c:170
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601 ...
Definition: pixfmt.h:518
#define avpriv_request_sample(...)
#define MODE_INTER_PLUS_MV
Definition: vp3.c:71
int num
Numerator.
Definition: rational.h:59
int size
Definition: packet.h:356
static av_cold int init_frames(Vp3DecodeContext *s)
Definition: vp3.c:2299
int u_superblock_start
Definition: vp3.c:189
#define BLOCK_X
Definition: vp3.c:640
int av_log2(unsigned v)
Definition: intmath.c:26
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:905
static int unpack_modes(Vp3DecodeContext *s, GetBitContext *gb)
Definition: vp3.c:790
static const uint8_t zero_run_base[32]
Definition: vp3data.h:207
void(* v_loop_filter)(uint8_t *src, ptrdiff_t stride, int *bounding_values)
Definition: vp3dsp.h:44
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
uint8_t coding_method
Definition: vp3.c:56
static av_cold int vp3_decode_init(AVCodecContext *avctx)
Definition: vp3.c:2315
GLint GLenum type
Definition: opengl_enc.c:104
static const uint8_t coeff_get_bits[32]
Definition: vp3data.h:222
int num_kf_coded_fragment[3]
Definition: vp3.c:258
static int theora_decode_header(AVCodecContext *avctx, GetBitContext *gb)
static int unpack_superblocks(Vp3DecodeContext *s, GetBitContext *gb)
Definition: vp3.c:465
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
static const uint16_t vp4_ac_scale_factor[64]
Definition: vp4data.h:64
static void reverse_dc_prediction(Vp3DecodeContext *s, int first_fragment, int fragment_width, int fragment_height)
Definition: vp3.c:1629
discard all
Definition: avcodec.h:236
VLC ac_vlc_4[16]
Definition: vp3.c:264
VLC motion_vector_vlc
Definition: vp3.c:270
static av_cold int vp3_decode_end(AVCodecContext *avctx)
Definition: vp3.c:334
static void error(const char *err)
int huff_code_size
Definition: vp3.c:293
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before ff_thread_await_progress() has been called on them.reget_buffer() and buffer age optimizations no longer work.*The contents of buffers must not be written to after ff_thread_report_progress() has been called on them.This includes draw_edges().Porting codecs to frame threading
static const uint16_t vp4_ac_bias_0[16][32][2]
Definition: vp4data.h:534
int * superblock_fragments
Definition: vp3.c:281
VLC superblock_run_length_vlc
Definition: vp3.c:266
AVCodec.
Definition: codec.h:190
#define MAXIMUM_LONG_BIT_RUN
Definition: vp3.c:67
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
static const uint16_t ac_bias_3[16][32][2]
Definition: vp3data.h:2633
void(* draw_horiz_band)(struct AVCodecContext *s, const AVFrame *src, int offset[AV_NUM_DATA_POINTERS], int y, int type, int height)
If non NULL, &#39;draw_horiz_band&#39; is called by the libavcodec decoder to draw a horizontal band...
Definition: avcodec.h:761
static const uint16_t dc_bias[16][32][2]
Definition: vp3data.h:445
Vp3Fragment * all_fragments
Definition: vp3.c:205
static void init_loop_filter(Vp3DecodeContext *s)
Definition: vp3.c:456
uint8_t base
Definition: vp3data.h:202
#define COMPATIBLE_FRAME(x)
Definition: vp3.c:1625
int dc
Definition: vp3.c:152
void(* emulated_edge_mc)(uint8_t *dst, const uint8_t *src, ptrdiff_t dst_linesize, ptrdiff_t src_linesize, int block_w, int block_h, int src_x, int src_y, int w, int h)
Copy a rectangular area of samples to a temporary buffer and replicate the border samples...
Definition: videodsp.h:63
uint8_t offset_y
Definition: vp3.c:209
int y_superblock_height
Definition: vp3.c:184
#define TRANSPOSE(x)
The exact code depends on how similar the blocks are and how related they are to the block
uint8_t
#define av_cold
Definition: attributes.h:88
#define av_malloc(s)
static int unpack_vectors(Vp3DecodeContext *s, GetBitContext *gb)
Definition: vp3.c:903
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
VLC ac_vlc_1[16]
Definition: vp3.c:261
#define TOKEN_ZERO_RUN(coeff, zero_run)
Definition: vp3.c:242
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1612
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
static int vp3_dequant(Vp3DecodeContext *s, Vp3Fragment *frag, int plane, int inter, int16_t block[64])
Pull DCT tokens from the 64 levels to decode and dequant the coefficients for the next block in codin...
Definition: vp3.c:1846
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
static int FUNC() huffman_table(CodedBitstreamContext *ctx, RWContext *rw, JPEGRawHuffmanTable *current)
unsigned int hbits
Definition: vp3.c:291
Multithreading support functions.
int macroblock_width
Definition: vp3.c:194
uint8_t idct_permutation[64]
Definition: vp3.c:168
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:444
static void init_dequantizer(Vp3DecodeContext *s, int qpi)
Definition: vp3.c:413
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:627
static void output_plane(const Plane *plane, int buf_sel, uint8_t *dst, ptrdiff_t dst_pitch, int dst_height)
Convert and output the current plane.
Definition: indeo3.c:1027
uint8_t qpi
Definition: vp3.c:57
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:262
static void vp3_decode_flush(AVCodecContext *avctx)
Definition: vp3.c:322
#define DC_COEFF(u)
Definition: vp3.c:1627
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:112
#define height
uint8_t * data
Definition: packet.h:355
uint8_t filter_limit_values[64]
Definition: vp3.c:296
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
Definition: utils.c:1849
int ff_set_sar(AVCodecContext *avctx, AVRational sar)
Check that the provided sample aspect ratio is valid and set it on the codec context.
Definition: utils.c:120
#define ff_dlog(a,...)
bitstream reader API header.
VLC ac_vlc_2[16]
Definition: vp3.c:262
static const uint8_t vp31_intra_c_dequant[64]
Definition: vp3data.h:42
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:308
static const uint8_t mode_code_vlc_table[8][2]
Definition: vp3data.h:144
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:1168
#define FFALIGN(x, a)
Definition: macros.h:48
#define MODE_INTRA
Definition: vp3.c:70
#define av_log(a,...)
static int unpack_dct_coeffs(Vp3DecodeContext *s, GetBitContext *gb)
Definition: vp3.c:1296
static const uint16_t table[]
Definition: prosumer.c:206
#define FF_CODEC_CAP_ALLOCATE_PROGRESS
Definition: internal.h:75
static void body(uint32_t ABCD[4], const uint8_t *src, int nblocks)
Definition: md5.c:101
static const uint16_t ac_bias_1[16][32][2]
Definition: vp3data.h:1539
int height
Definition: vp3.c:162
static const uint8_t vp4_pred_block_type_map[8]
Definition: vp3.c:140
#define U(x)
Definition: vp56_arith.h:37
#define src
Definition: vp8dsp.c:254
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
static int vp3_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: vp3.c:2630
static const uint8_t motion_vector_vlc_table[63][2]
Definition: vp3data.h:151
also FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
Definition: pixfmt.h:463
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
#define AV_CODEC_FLAG2_IGNORE_CROP
Discard cropping information from SPS.
Definition: avcodec.h:371
VP3DSPContext vp3dsp
Definition: vp3.c:172
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
int c_superblock_width
Definition: vp3.c:186
uint8_t qr_count[2][3]
Definition: vp3.c:218
int fragment_height[2]
Definition: vp3.c:203
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: vlc.h:38
VLC ac_vlc_3[16]
Definition: vp3.c:263
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
#define CODING_MODE_COUNT
Definition: vp3.c:77
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: pixdesc.c:2601
void(* idct_add)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition: vp3dsp.h:42
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1804
static const int8_t fixed_motion_vector_table[64]
Definition: vp3data.h:189
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:606
void(* h_loop_filter)(uint8_t *src, ptrdiff_t stride, int *bounding_values)
Definition: vp3dsp.h:45
AVCodec ff_theora_decoder
int theora
Definition: vp3.c:160
static av_cold void free_tables(AVCodecContext *avctx)
Definition: vp3.c:306
const char * name
Name of the codec implementation.
Definition: codec.h:197
uint8_t bits
Definition: vp3data.h:202
int theora_header
Definition: vp3.c:160
GLsizei count
Definition: opengl_enc.c:108
#define FFMAX(a, b)
Definition: common.h:94
uint16_t coded_dc_scale_factor[2][64]
Definition: vp3.c:215
int qps[3]
Definition: vp3.c:178
#define fail()
Definition: checkasm.h:123
static const int ModeAlphabet[6][CODING_MODE_COUNT]
Definition: vp3.c:87
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:106
#define FF_CODEC_CAP_EXPORTS_CROPPING
The decoder sets the cropping fields in the output frames manually.
Definition: internal.h:66
Definition: vlc.h:26
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:192
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:338
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames.The frames must then be freed with ff_thread_release_buffer().Otherwise decode directly into the user-supplied frames.Call ff_thread_report_progress() after some part of the current picture has decoded.A good place to put this is where draw_horiz_band() is called-add this if it isn't called anywhere
static const int16_t *const coeff_tables[32]
Definition: vp3data.h:407
int chroma_y_shift
Definition: vp3.c:163
int flipped_image
Definition: vp3.c:174
unsigned char * macroblock_coding
Definition: vp3.c:285
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:282
Half-pel DSP context.
Definition: hpeldsp.h:45
int fragment_width[2]
Definition: vp3.c:202
#define AV_CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
Definition: codec.h:44
int type
Definition: vp3.c:153
#define SET_CHROMA_MODES
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:391
static const uint8_t vp31_intra_y_dequant[64]
Definition: vp3data.h:29
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:333
VLC block_pattern_vlc[2]
Definition: vp3.c:268
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1796
#define FFMIN(a, b)
Definition: common.h:96
VLC fragment_run_length_vlc
Definition: vp3.c:267
VLC vp4_mv_vlc[2][7]
Definition: vp3.c:271
#define PU
#define width
#define FFSIGN(a)
Definition: common.h:73
int macroblock_height
Definition: vp3.c:195
int width
picture width / height.
Definition: avcodec.h:699
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call ff_thread_finish_setup() afterwards.If some code can't be moved
#define SB_PARTIALLY_CODED
Definition: vp3.c:61
static int unpack_vlcs(Vp3DecodeContext *s, GetBitContext *gb, VLC *table, int coeff_index, int plane, int eob_run)
Definition: vp3.c:1175
int yuv_macroblock_count
Definition: vp3.c:199
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
Definition: pixfmt.h:465
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
uint8_t * edge_emu_buffer
Definition: vp3.c:287
static const uint8_t vp4_mv_table_selector[32]
Definition: vp4data.h:105
static const uint16_t vp4_ac_bias_3[16][32][2]
Definition: vp4data.h:1023
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1140
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:446
static const uint16_t vp31_ac_scale_factor[64]
Definition: vp3data.h:76
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
perm
Definition: f_perms.c:74
static const int8_t motion_vector_table[63]
Definition: vp3data.h:179
#define MODE_COPY
Definition: vp3.c:80
#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
int avpriv_split_xiph_headers(const uint8_t *extradata, int extradata_size, int first_header_size, const uint8_t *header_start[3], int header_len[3])
Split a single extradata buffer into the three headers that most Xiph codecs use. ...
Definition: xiph.c:24
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 const uint16_t ac_bias_2[16][32][2]
Definition: vp3data.h:2086
static const uint8_t hilbert_offset[16][2]
Definition: vp3.c:125
static const uint8_t vp4_y_dc_scale_factor[64]
Definition: vp4data.h:42
int macroblock_count
Definition: vp3.c:193
int c_superblock_height
Definition: vp3.c:187
void ff_vp3dsp_h_loop_filter_12(uint8_t *first_pixel, ptrdiff_t stride, int *bounding_values)
int offset_x_warned
Definition: vp3.c:210
int total_num_coded_frags
Definition: vp3.c:250
void(* idct_dc_add)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition: vp3dsp.h:43
int c_superblock_count
Definition: vp3.c:188
if(ret)
AVCodec ff_vp3_decoder
Definition: vp3.c:3228
VP4 video decoder.
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
static void apply_loop_filter(Vp3DecodeContext *s, int plane, int ystart, int yend)
Definition: vp3.c:1779
static const int8_t transform[32][32]
Definition: hevcdsp.c:27
also ITU-R BT1361
Definition: pixfmt.h:485
static const uint8_t vp4_filter_limit_values[64]
Definition: vp4data.h:75
Half-pel DSP functions.
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
int superblock_count
Definition: vp3.c:182
static const uint8_t vp4_block_pattern_table_selector[14]
Definition: vp4data.h:86
Libavcodec external API header.
int entries
Definition: vp3.c:292
static const uint16_t ac_bias_0[16][32][2]
Definition: vp3data.h:992
enum AVCodecID codec_id
Definition: avcodec.h:536
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:339
int16_t * dct_tokens[3][64]
This is a list of all tokens in bitstream order.
Definition: vp3.c:239
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
int skip_loop_filter
Definition: vp3.c:176
static int loop
Definition: ffplay.c:341
int debug
debug
Definition: avcodec.h:1611
ThreadFrame current_frame
Definition: vp3.c:166
main external API structure.
Definition: avcodec.h:526
#define RSHIFT(a, b)
Definition: common.h:54
int last_qps[3]
Definition: vp3.c:180
static const uint8_t vp4_generic_dequant[64]
Definition: vp4data.h:31
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> (&#39;D&#39;<<24) + (&#39;C&#39;<<16) + (&#39;B&#39;<<8) + &#39;A&#39;).
Definition: avcodec.h:551
uint8_t qr_size[2][3][64]
Definition: vp3.c:219
op_pixels_func put_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
Definition: hpeldsp.h:56
#define PUL
static av_cold int allocate_tables(AVCodecContext *avctx)
Allocate tables for per-frame data in Vp3DecodeContext.
Definition: vp3.c:2255
int data_offset[3]
Definition: vp3.c:207
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have update_thread_context() run it in the next thread.Add AV_CODEC_CAP_FRAME_THREADS to the codec capabilities.There will be very little speed gain at this point but it should work.If there are inter-frame dependencies
int extradata_size
Definition: avcodec.h:628
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
int coded_height
Definition: avcodec.h:714
op_pixels_func put_no_rnd_pixels_tab[4][4]
Halfpel motion compensation with no rounding (a+b)>>1.
Definition: hpeldsp.h:82
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
#define SB_FULLY_CODED
Definition: vp3.c:62
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1154
Rational number (pair of numerator and denominator).
Definition: rational.h:58
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1147
int * nkf_coded_fragment_list
Definition: vp3.c:257
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
int num_coded_frags[3][64]
number of blocks that contain DCT coefficients at the given level or higher
Definition: vp3.c:249
int keyframe
Definition: vp3.c:167
#define TOKEN_COEFF(coeff)
Definition: vp3.c:243
#define s1
Definition: regdef.h:38
static int vp4_get_mv(Vp3DecodeContext *s, GetBitContext *gb, int axis, int last_motion)
Definition: vp3.c:893
static VLC_TYPE vlc_tables[VLC_TABLES_SIZE][2]
Definition: imc.c:120
#define MODE_GOLDEN_MV
Definition: vp3.c:75
static const uint8_t vp31_dc_scale_factor[64]
Definition: vp3data.h:65
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
#define FRAGMENT_PIXELS
Definition: vp3.c:51
static int read_huffman_tree(AVCodecContext *avctx, GetBitContext *gb)
Definition: vp3.c:2876
static int update_frames(AVCodecContext *avctx)
Release and shuffle frames after decode finishes.
Definition: vp3.c:2548
Writing a table generator This documentation is preliminary Parts of the API are not good and should be changed Basic concepts A table generator consists of two *_tablegen c and *_tablegen h The h file will provide the variable declarations and initialization code for the tables
Definition: tablegen.txt:8
static const uint16_t superblock_run_length_vlc_table[34][2]
Definition: vp3data.h:98
#define MODE_USING_GOLDEN
Definition: vp3.c:74
uint32_t huffman_table[80][32][2]
Definition: vp3.c:294
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:554
#define MODE_INTER_FOURMV
Definition: vp3.c:76
static const uint8_t vp4_uv_dc_scale_factor[64]
Definition: vp4data.h:53
int16_t block[64]
Definition: vp3.c:173
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:322
static const struct @167 eob_run_table[7]
int v_superblock_start
Definition: vp3.c:190
static const uint8_t vp4_block_pattern_vlc[2][14][2]
Definition: vp4data.h:90
static int theora_header(AVFormatContext *s, int idx)
int version
Definition: vp3.c:161
static const uint16_t vp4_ac_bias_2[16][32][2]
Definition: vp4data.h:860
void ff_vp3dsp_v_loop_filter_12(uint8_t *first_pixel, ptrdiff_t stride, int *bounding_values)
int * coded_fragment_list[3]
Definition: vp3.c:254
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
static const uint8_t vp31_inter_dequant[64]
Definition: vp3data.h:54
unsigned char * superblock_coding
Definition: vp3.c:191
common internal api header.
ThreadFrame last_frame
Definition: vp3.c:165
int16_t * dct_tokens_base
Definition: vp3.c:240
AVCodecContext * avctx
Definition: vp3.c:159
#define bit(string, value)
Definition: cbs_mpeg2.c:58
static int get_eob_run(GetBitContext *gb, int token)
Definition: vp3.c:1139
VideoDSPContext vdsp
Definition: vp3.c:171
int c_macroblock_width
Definition: vp3.c:197
static const uint16_t vp4_ac_bias_1[16][32][2]
Definition: vp4data.h:697
int den
Denominator.
Definition: rational.h:60
int c_macroblock_count
Definition: vp3.c:196
Core video DSP helper functions.
uint8_t base_matrix[384][64]
Definition: vp3.c:217
void ff_vp3dsp_set_bounding_values(int *bounding_values_array, int filter_limit)
Definition: vp3dsp.c:473
int fragment_count
Definition: vp3.c:201
void * priv_data
Definition: avcodec.h:553
static int unpack_block_qpis(Vp3DecodeContext *s, GetBitContext *gb)
Definition: vp3.c:1097
int * kf_coded_fragment_list
Definition: vp3.c:256
static void await_reference_row(Vp3DecodeContext *s, Vp3Fragment *fragment, int motion_y, int y)
Wait for the reference frame of the current fragment.
Definition: vp3.c:1933
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:386
static const double coeff[2][5]
Definition: vf_owdenoise.c:72
int c_macroblock_height
Definition: vp3.c:198
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:613
#define MODE_INTER_PRIOR_LAST
Definition: vp3.c:73
#define MODE_INTER_NO_MV
Definition: vp3.c:69
VP4Predictor * dc_pred_row
Definition: vp3.c:299
int fragment_start[3]
Definition: vp3.c:206
int theora_tables
Definition: vp3.c:160
#define av_freep(p)
static const uint16_t vp4_mv_vlc[2][7][63][2]
Definition: vp4data.h:112
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:188
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
Definition: pixfmt.h:560
#define VLC_TYPE
Definition: vlc.h:24
#define MODE_INTER_LAST_MV
Definition: vp3.c:72
#define av_malloc_array(a, b)
ThreadFrame golden_frame
Definition: vp3.c:164
int chroma_x_shift
Definition: vp3.c:163
void(* idct_put)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition: vp3dsp.h:41
#define stride
av_cold void ff_vp3dsp_init(VP3DSPContext *c, int flags)
Definition: vp3dsp.c:445
static const uint8_t vp31_filter_limit_values[64]
Definition: vp3data.h:87
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
#define MKTAG(a, b, c, d)
Definition: common.h:406
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: packet.h:332
static void vp3_draw_horiz_band(Vp3DecodeContext *s, int y)
called when all pixels up to row y are complete
Definition: vp3.c:1891
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:361
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:509
int16_t dc
Definition: vp3.c:55
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
uint8_t offset_x
Definition: vp3.c:208
for(j=16;j >0;--j)
uint32_t coded_ac_scale_factor[64]
Definition: vp3.c:216
static const uint8_t zero_run_get_bits[32]
Definition: vp3data.h:214
int i
Definition: input.c:406
Predicted.
Definition: avutil.h:275
VLC dc_vlc[16]
Definition: vp3.c:260
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
#define PL
int8_t(*[2] motion_val)[2]
Definition: vp3.c:212