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