2 * Copyright (C) 2003-2004 the ffmpeg project
4 * This file is part of Libav.
6 * Libav is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * Libav is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with Libav; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 * On2 VP3 Video Decoder
25 * VP3 Video Decoder by Mike Melanson (mike at multimedia.cx)
26 * For more information about the VP3 coding process, visit:
27 * http://wiki.multimedia.cx/index.php?title=On2_VP3
29 * Theora decoder by Alex Beregszaszi
36 #include "libavutil/imgutils.h"
47 #define FRAGMENT_PIXELS 8
49 //FIXME split things out into their own arrays
50 typedef struct Vp3Fragment
{
52 uint8_t coding_method
;
56 #define SB_NOT_CODED 0
57 #define SB_PARTIALLY_CODED 1
58 #define SB_FULLY_CODED 2
60 // This is the maximum length of a single long bit run that can be encoded
61 // for superblock coding or block qps. Theora special-cases this to read a
62 // bit instead of flipping the current bit to allow for runs longer than 4129.
63 #define MAXIMUM_LONG_BIT_RUN 4129
65 #define MODE_INTER_NO_MV 0
67 #define MODE_INTER_PLUS_MV 2
68 #define MODE_INTER_LAST_MV 3
69 #define MODE_INTER_PRIOR_LAST 4
70 #define MODE_USING_GOLDEN 5
71 #define MODE_GOLDEN_MV 6
72 #define MODE_INTER_FOURMV 7
73 #define CODING_MODE_COUNT 8
75 /* special internal mode */
78 /* There are 6 preset schemes, plus a free-form scheme */
79 static const int ModeAlphabet
[6][CODING_MODE_COUNT
] =
81 /* scheme 1: Last motion vector dominates */
82 { MODE_INTER_LAST_MV
, MODE_INTER_PRIOR_LAST
,
83 MODE_INTER_PLUS_MV
, MODE_INTER_NO_MV
,
84 MODE_INTRA
, MODE_USING_GOLDEN
,
85 MODE_GOLDEN_MV
, MODE_INTER_FOURMV
},
88 { MODE_INTER_LAST_MV
, MODE_INTER_PRIOR_LAST
,
89 MODE_INTER_NO_MV
, MODE_INTER_PLUS_MV
,
90 MODE_INTRA
, MODE_USING_GOLDEN
,
91 MODE_GOLDEN_MV
, MODE_INTER_FOURMV
},
94 { MODE_INTER_LAST_MV
, MODE_INTER_PLUS_MV
,
95 MODE_INTER_PRIOR_LAST
, MODE_INTER_NO_MV
,
96 MODE_INTRA
, MODE_USING_GOLDEN
,
97 MODE_GOLDEN_MV
, MODE_INTER_FOURMV
},
100 { MODE_INTER_LAST_MV
, MODE_INTER_PLUS_MV
,
101 MODE_INTER_NO_MV
, MODE_INTER_PRIOR_LAST
,
102 MODE_INTRA
, MODE_USING_GOLDEN
,
103 MODE_GOLDEN_MV
, MODE_INTER_FOURMV
},
105 /* scheme 5: No motion vector dominates */
106 { MODE_INTER_NO_MV
, MODE_INTER_LAST_MV
,
107 MODE_INTER_PRIOR_LAST
, MODE_INTER_PLUS_MV
,
108 MODE_INTRA
, MODE_USING_GOLDEN
,
109 MODE_GOLDEN_MV
, MODE_INTER_FOURMV
},
112 { MODE_INTER_NO_MV
, MODE_USING_GOLDEN
,
113 MODE_INTER_LAST_MV
, MODE_INTER_PRIOR_LAST
,
114 MODE_INTER_PLUS_MV
, MODE_INTRA
,
115 MODE_GOLDEN_MV
, MODE_INTER_FOURMV
},
119 static const uint8_t hilbert_offset
[16][2] = {
120 {0,0}, {1,0}, {1,1}, {0,1},
121 {0,2}, {0,3}, {1,3}, {1,2},
122 {2,2}, {2,3}, {3,3}, {3,2},
123 {3,1}, {2,1}, {2,0}, {3,0}
126 #define MIN_DEQUANT_VAL 2
128 typedef struct Vp3DecodeContext
{
129 AVCodecContext
*avctx
;
130 int theora
, theora_tables
;
133 int chroma_x_shift
, chroma_y_shift
;
134 AVFrame golden_frame
;
136 AVFrame current_frame
;
139 VideoDSPContext vdsp
;
140 VP3DSPContext vp3dsp
;
141 DECLARE_ALIGNED(16, int16_t, block
)[64];
144 int skip_loop_filter
;
150 int superblock_count
;
151 int y_superblock_width
;
152 int y_superblock_height
;
153 int y_superblock_count
;
154 int c_superblock_width
;
155 int c_superblock_height
;
156 int c_superblock_count
;
157 int u_superblock_start
;
158 int v_superblock_start
;
159 unsigned char *superblock_coding
;
161 int macroblock_count
;
162 int macroblock_width
;
163 int macroblock_height
;
166 int fragment_width
[2];
167 int fragment_height
[2];
169 Vp3Fragment
*all_fragments
;
170 int fragment_start
[3];
173 int8_t (*motion_val
[2])[2];
178 uint16_t coded_dc_scale_factor
[64];
179 uint32_t coded_ac_scale_factor
[64];
180 uint8_t base_matrix
[384][64];
181 uint8_t qr_count
[2][3];
182 uint8_t qr_size
[2][3][64];
183 uint16_t qr_base
[2][3][64];
186 * This is a list of all tokens in bitstream order. Reordering takes place
187 * by pulling from each level during IDCT. As a consequence, IDCT must be
188 * in Hilbert order, making the minimum slice height 64 for 4:2:0 and 32
189 * otherwise. The 32 different tokens with up to 12 bits of extradata are
190 * collapsed into 3 types, packed as follows:
191 * (from the low to high bits)
193 * 2 bits: type (0,1,2)
194 * 0: EOB run, 14 bits for run length (12 needed)
195 * 1: zero run, 7 bits for run length
196 * 7 bits for the next coefficient (3 needed)
197 * 2: coefficient, 14 bits (11 needed)
199 * Coefficients are signed, so are packed in the highest bits for automatic
202 int16_t *dct_tokens
[3][64];
203 int16_t *dct_tokens_base
;
204 #define TOKEN_EOB(eob_run) ((eob_run) << 2)
205 #define TOKEN_ZERO_RUN(coeff, zero_run) (((coeff) << 9) + ((zero_run) << 2) + 1)
206 #define TOKEN_COEFF(coeff) (((coeff) << 2) + 2)
209 * number of blocks that contain DCT coefficients at the given level or higher
211 int num_coded_frags
[3][64];
212 int total_num_coded_frags
;
214 /* this is a list of indexes into the all_fragments array indicating
215 * which of the fragments are coded */
216 int *coded_fragment_list
[3];
224 VLC superblock_run_length_vlc
;
225 VLC fragment_run_length_vlc
;
227 VLC motion_vector_vlc
;
229 /* these arrays need to be on 16-byte boundaries since SSE2 operations
231 DECLARE_ALIGNED(16, int16_t, qmat
)[3][2][3][64]; ///< qmat[qpi][is_inter][plane]
233 /* This table contains superblock_count * 16 entries. Each set of 16
234 * numbers corresponds to the fragment indexes 0..15 of the superblock.
235 * An entry will be -1 to indicate that no entry corresponds to that
237 int *superblock_fragments
;
239 /* This is an array that indicates how a particular macroblock
241 unsigned char *macroblock_coding
;
243 uint8_t *edge_emu_buffer
;
250 uint32_t huffman_table
[80][32][2];
252 uint8_t filter_limit_values
[64];
253 DECLARE_ALIGNED(8, int, bounding_values_array
)[256+2];
256 /************************************************************************
257 * VP3 specific functions
258 ************************************************************************/
260 static void vp3_decode_flush(AVCodecContext
*avctx
)
262 Vp3DecodeContext
*s
= avctx
->priv_data
;
264 if (s
->golden_frame
.data
[0]) {
265 if (s
->golden_frame
.data
[0] == s
->last_frame
.data
[0])
266 memset(&s
->last_frame
, 0, sizeof(AVFrame
));
267 if (s
->current_frame
.data
[0] == s
->golden_frame
.data
[0])
268 memset(&s
->current_frame
, 0, sizeof(AVFrame
));
269 ff_thread_release_buffer(avctx
, &s
->golden_frame
);
271 if (s
->last_frame
.data
[0]) {
272 if (s
->current_frame
.data
[0] == s
->last_frame
.data
[0])
273 memset(&s
->current_frame
, 0, sizeof(AVFrame
));
274 ff_thread_release_buffer(avctx
, &s
->last_frame
);
276 if (s
->current_frame
.data
[0])
277 ff_thread_release_buffer(avctx
, &s
->current_frame
);
280 static av_cold
int vp3_decode_end(AVCodecContext
*avctx
)
282 Vp3DecodeContext
*s
= avctx
->priv_data
;
285 av_freep(&s
->superblock_coding
);
286 av_freep(&s
->all_fragments
);
287 av_freep(&s
->coded_fragment_list
[0]);
288 av_freep(&s
->dct_tokens_base
);
289 av_freep(&s
->superblock_fragments
);
290 av_freep(&s
->macroblock_coding
);
291 av_freep(&s
->motion_val
[0]);
292 av_freep(&s
->motion_val
[1]);
293 av_freep(&s
->edge_emu_buffer
);
295 if (avctx
->internal
->is_copy
)
298 for (i
= 0; i
< 16; i
++) {
299 ff_free_vlc(&s
->dc_vlc
[i
]);
300 ff_free_vlc(&s
->ac_vlc_1
[i
]);
301 ff_free_vlc(&s
->ac_vlc_2
[i
]);
302 ff_free_vlc(&s
->ac_vlc_3
[i
]);
303 ff_free_vlc(&s
->ac_vlc_4
[i
]);
306 ff_free_vlc(&s
->superblock_run_length_vlc
);
307 ff_free_vlc(&s
->fragment_run_length_vlc
);
308 ff_free_vlc(&s
->mode_code_vlc
);
309 ff_free_vlc(&s
->motion_vector_vlc
);
311 /* release all frames */
312 vp3_decode_flush(avctx
);
318 * This function sets up all of the various blocks mappings:
319 * superblocks <-> fragments, macroblocks <-> fragments,
320 * superblocks <-> macroblocks
322 * @return 0 is successful; returns 1 if *anything* went wrong.
324 static int init_block_mapping(Vp3DecodeContext
*s
)
326 int sb_x
, sb_y
, plane
;
329 for (plane
= 0; plane
< 3; plane
++) {
330 int sb_width
= plane
? s
->c_superblock_width
: s
->y_superblock_width
;
331 int sb_height
= plane
? s
->c_superblock_height
: s
->y_superblock_height
;
332 int frag_width
= s
->fragment_width
[!!plane
];
333 int frag_height
= s
->fragment_height
[!!plane
];
335 for (sb_y
= 0; sb_y
< sb_height
; sb_y
++)
336 for (sb_x
= 0; sb_x
< sb_width
; sb_x
++)
337 for (i
= 0; i
< 16; i
++) {
338 x
= 4*sb_x
+ hilbert_offset
[i
][0];
339 y
= 4*sb_y
+ hilbert_offset
[i
][1];
341 if (x
< frag_width
&& y
< frag_height
)
342 s
->superblock_fragments
[j
++] = s
->fragment_start
[plane
] + y
*frag_width
+ x
;
344 s
->superblock_fragments
[j
++] = -1;
348 return 0; /* successful path out */
352 * This function sets up the dequantization tables used for a particular
355 static void init_dequantizer(Vp3DecodeContext
*s
, int qpi
)
357 int ac_scale_factor
= s
->coded_ac_scale_factor
[s
->qps
[qpi
]];
358 int dc_scale_factor
= s
->coded_dc_scale_factor
[s
->qps
[qpi
]];
359 int i
, plane
, inter
, qri
, bmi
, bmj
, qistart
;
361 for(inter
=0; inter
<2; inter
++){
362 for(plane
=0; plane
<3; plane
++){
364 for(qri
=0; qri
<s
->qr_count
[inter
][plane
]; qri
++){
365 sum
+= s
->qr_size
[inter
][plane
][qri
];
366 if(s
->qps
[qpi
] <= sum
)
369 qistart
= sum
- s
->qr_size
[inter
][plane
][qri
];
370 bmi
= s
->qr_base
[inter
][plane
][qri
];
371 bmj
= s
->qr_base
[inter
][plane
][qri
+1];
373 int coeff
= ( 2*(sum
-s
->qps
[qpi
])*s
->base_matrix
[bmi
][i
]
374 - 2*(qistart
-s
->qps
[qpi
])*s
->base_matrix
[bmj
][i
]
375 + s
->qr_size
[inter
][plane
][qri
])
376 / (2*s
->qr_size
[inter
][plane
][qri
]);
378 int qmin
= 8<<(inter
+ !i
);
379 int qscale
= i
? ac_scale_factor
: dc_scale_factor
;
381 s
->qmat
[qpi
][inter
][plane
][s
->dsp
.idct_permutation
[i
]]= av_clip((qscale
* coeff
)/100 * 4, qmin
, 4096);
383 // all DC coefficients use the same quant so as not to interfere with DC prediction
384 s
->qmat
[qpi
][inter
][plane
][0] = s
->qmat
[0][inter
][plane
][0];
390 * This function initializes the loop filter boundary limits if the frame's
391 * quality index is different from the previous frame's.
393 * The filter_limit_values may not be larger than 127.
395 static void init_loop_filter(Vp3DecodeContext
*s
)
397 int *bounding_values
= s
->bounding_values_array
+127;
402 filter_limit
= s
->filter_limit_values
[s
->qps
[0]];
403 assert(filter_limit
< 128);
405 /* set up the bounding values */
406 memset(s
->bounding_values_array
, 0, 256 * sizeof(int));
407 for (x
= 0; x
< filter_limit
; x
++) {
408 bounding_values
[-x
] = -x
;
409 bounding_values
[x
] = x
;
411 for (x
= value
= filter_limit
; x
< 128 && value
; x
++, value
--) {
412 bounding_values
[ x
] = value
;
413 bounding_values
[-x
] = -value
;
416 bounding_values
[128] = value
;
417 bounding_values
[129] = bounding_values
[130] = filter_limit
* 0x02020202;
421 * This function unpacks all of the superblock/macroblock/fragment coding
422 * information from the bitstream.
424 static int unpack_superblocks(Vp3DecodeContext
*s
, GetBitContext
*gb
)
426 int superblock_starts
[3] = { 0, s
->u_superblock_start
, s
->v_superblock_start
};
428 int current_superblock
= 0;
430 int num_partial_superblocks
= 0;
433 int current_fragment
;
437 memset(s
->superblock_coding
, SB_FULLY_CODED
, s
->superblock_count
);
441 /* unpack the list of partially-coded superblocks */
442 bit
= get_bits1(gb
) ^ 1;
445 while (current_superblock
< s
->superblock_count
&& get_bits_left(gb
) > 0) {
446 if (s
->theora
&& current_run
== MAXIMUM_LONG_BIT_RUN
)
451 current_run
= get_vlc2(gb
,
452 s
->superblock_run_length_vlc
.table
, 6, 2) + 1;
453 if (current_run
== 34)
454 current_run
+= get_bits(gb
, 12);
456 if (current_superblock
+ current_run
> s
->superblock_count
) {
457 av_log(s
->avctx
, AV_LOG_ERROR
, "Invalid partially coded superblock run length\n");
461 memset(s
->superblock_coding
+ current_superblock
, bit
, current_run
);
463 current_superblock
+= current_run
;
465 num_partial_superblocks
+= current_run
;
468 /* unpack the list of fully coded superblocks if any of the blocks were
469 * not marked as partially coded in the previous step */
470 if (num_partial_superblocks
< s
->superblock_count
) {
471 int superblocks_decoded
= 0;
473 current_superblock
= 0;
474 bit
= get_bits1(gb
) ^ 1;
477 while (superblocks_decoded
< s
->superblock_count
- num_partial_superblocks
478 && get_bits_left(gb
) > 0) {
480 if (s
->theora
&& current_run
== MAXIMUM_LONG_BIT_RUN
)
485 current_run
= get_vlc2(gb
,
486 s
->superblock_run_length_vlc
.table
, 6, 2) + 1;
487 if (current_run
== 34)
488 current_run
+= get_bits(gb
, 12);
490 for (j
= 0; j
< current_run
; current_superblock
++) {
491 if (current_superblock
>= s
->superblock_count
) {
492 av_log(s
->avctx
, AV_LOG_ERROR
, "Invalid fully coded superblock run length\n");
496 /* skip any superblocks already marked as partially coded */
497 if (s
->superblock_coding
[current_superblock
] == SB_NOT_CODED
) {
498 s
->superblock_coding
[current_superblock
] = 2*bit
;
502 superblocks_decoded
+= current_run
;
506 /* if there were partial blocks, initialize bitstream for
507 * unpacking fragment codings */
508 if (num_partial_superblocks
) {
512 /* toggle the bit because as soon as the first run length is
513 * fetched the bit will be toggled again */
518 /* figure out which fragments are coded; iterate through each
519 * superblock (all planes) */
520 s
->total_num_coded_frags
= 0;
521 memset(s
->macroblock_coding
, MODE_COPY
, s
->macroblock_count
);
523 for (plane
= 0; plane
< 3; plane
++) {
524 int sb_start
= superblock_starts
[plane
];
525 int sb_end
= sb_start
+ (plane
? s
->c_superblock_count
: s
->y_superblock_count
);
526 int num_coded_frags
= 0;
528 for (i
= sb_start
; i
< sb_end
&& get_bits_left(gb
) > 0; i
++) {
530 /* iterate through all 16 fragments in a superblock */
531 for (j
= 0; j
< 16; j
++) {
533 /* if the fragment is in bounds, check its coding status */
534 current_fragment
= s
->superblock_fragments
[i
* 16 + j
];
535 if (current_fragment
!= -1) {
536 int coded
= s
->superblock_coding
[i
];
538 if (s
->superblock_coding
[i
] == SB_PARTIALLY_CODED
) {
540 /* fragment may or may not be coded; this is the case
541 * that cares about the fragment coding runs */
542 if (current_run
-- == 0) {
544 current_run
= get_vlc2(gb
,
545 s
->fragment_run_length_vlc
.table
, 5, 2);
551 /* default mode; actual mode will be decoded in
553 s
->all_fragments
[current_fragment
].coding_method
=
555 s
->coded_fragment_list
[plane
][num_coded_frags
++] =
558 /* not coded; copy this fragment from the prior frame */
559 s
->all_fragments
[current_fragment
].coding_method
=
565 s
->total_num_coded_frags
+= num_coded_frags
;
566 for (i
= 0; i
< 64; i
++)
567 s
->num_coded_frags
[plane
][i
] = num_coded_frags
;
569 s
->coded_fragment_list
[plane
+1] = s
->coded_fragment_list
[plane
] + num_coded_frags
;
575 * This function unpacks all the coding mode data for individual macroblocks
576 * from the bitstream.
578 static int unpack_modes(Vp3DecodeContext
*s
, GetBitContext
*gb
)
580 int i
, j
, k
, sb_x
, sb_y
;
582 int current_macroblock
;
583 int current_fragment
;
585 int custom_mode_alphabet
[CODING_MODE_COUNT
];
590 for (i
= 0; i
< s
->fragment_count
; i
++)
591 s
->all_fragments
[i
].coding_method
= MODE_INTRA
;
595 /* fetch the mode coding scheme for this frame */
596 scheme
= get_bits(gb
, 3);
598 /* is it a custom coding scheme? */
600 for (i
= 0; i
< 8; i
++)
601 custom_mode_alphabet
[i
] = MODE_INTER_NO_MV
;
602 for (i
= 0; i
< 8; i
++)
603 custom_mode_alphabet
[get_bits(gb
, 3)] = i
;
604 alphabet
= custom_mode_alphabet
;
606 alphabet
= ModeAlphabet
[scheme
-1];
608 /* iterate through all of the macroblocks that contain 1 or more
610 for (sb_y
= 0; sb_y
< s
->y_superblock_height
; sb_y
++) {
611 for (sb_x
= 0; sb_x
< s
->y_superblock_width
; sb_x
++) {
612 if (get_bits_left(gb
) <= 0)
615 for (j
= 0; j
< 4; j
++) {
616 int mb_x
= 2*sb_x
+ (j
>>1);
617 int mb_y
= 2*sb_y
+ (((j
>>1)+j
)&1);
618 current_macroblock
= mb_y
* s
->macroblock_width
+ mb_x
;
620 if (mb_x
>= s
->macroblock_width
|| mb_y
>= s
->macroblock_height
)
623 #define BLOCK_X (2*mb_x + (k&1))
624 #define BLOCK_Y (2*mb_y + (k>>1))
625 /* coding modes are only stored if the macroblock has at least one
626 * luma block coded, otherwise it must be INTER_NO_MV */
627 for (k
= 0; k
< 4; k
++) {
628 current_fragment
= BLOCK_Y
*s
->fragment_width
[0] + BLOCK_X
;
629 if (s
->all_fragments
[current_fragment
].coding_method
!= MODE_COPY
)
633 s
->macroblock_coding
[current_macroblock
] = MODE_INTER_NO_MV
;
637 /* mode 7 means get 3 bits for each coding mode */
639 coding_mode
= get_bits(gb
, 3);
641 coding_mode
= alphabet
642 [get_vlc2(gb
, s
->mode_code_vlc
.table
, 3, 3)];
644 s
->macroblock_coding
[current_macroblock
] = coding_mode
;
645 for (k
= 0; k
< 4; k
++) {
646 frag
= s
->all_fragments
+ BLOCK_Y
*s
->fragment_width
[0] + BLOCK_X
;
647 if (frag
->coding_method
!= MODE_COPY
)
648 frag
->coding_method
= coding_mode
;
651 #define SET_CHROMA_MODES \
652 if (frag[s->fragment_start[1]].coding_method != MODE_COPY) \
653 frag[s->fragment_start[1]].coding_method = coding_mode;\
654 if (frag[s->fragment_start[2]].coding_method != MODE_COPY) \
655 frag[s->fragment_start[2]].coding_method = coding_mode;
657 if (s
->chroma_y_shift
) {
658 frag
= s
->all_fragments
+ mb_y
*s
->fragment_width
[1] + mb_x
;
660 } else if (s
->chroma_x_shift
) {
661 frag
= s
->all_fragments
+ 2*mb_y
*s
->fragment_width
[1] + mb_x
;
662 for (k
= 0; k
< 2; k
++) {
664 frag
+= s
->fragment_width
[1];
667 for (k
= 0; k
< 4; k
++) {
668 frag
= s
->all_fragments
+ BLOCK_Y
*s
->fragment_width
[1] + BLOCK_X
;
681 * This function unpacks all the motion vectors for the individual
682 * macroblocks from the bitstream.
684 static int unpack_vectors(Vp3DecodeContext
*s
, GetBitContext
*gb
)
686 int j
, k
, sb_x
, sb_y
;
690 int last_motion_x
= 0;
691 int last_motion_y
= 0;
692 int prior_last_motion_x
= 0;
693 int prior_last_motion_y
= 0;
694 int current_macroblock
;
695 int current_fragment
;
701 /* coding mode 0 is the VLC scheme; 1 is the fixed code scheme */
702 coding_mode
= get_bits1(gb
);
704 /* iterate through all of the macroblocks that contain 1 or more
706 for (sb_y
= 0; sb_y
< s
->y_superblock_height
; sb_y
++) {
707 for (sb_x
= 0; sb_x
< s
->y_superblock_width
; sb_x
++) {
708 if (get_bits_left(gb
) <= 0)
711 for (j
= 0; j
< 4; j
++) {
712 int mb_x
= 2*sb_x
+ (j
>>1);
713 int mb_y
= 2*sb_y
+ (((j
>>1)+j
)&1);
714 current_macroblock
= mb_y
* s
->macroblock_width
+ mb_x
;
716 if (mb_x
>= s
->macroblock_width
|| mb_y
>= s
->macroblock_height
||
717 (s
->macroblock_coding
[current_macroblock
] == MODE_COPY
))
720 switch (s
->macroblock_coding
[current_macroblock
]) {
722 case MODE_INTER_PLUS_MV
:
724 /* all 6 fragments use the same motion vector */
725 if (coding_mode
== 0) {
726 motion_x
[0] = motion_vector_table
[get_vlc2(gb
, s
->motion_vector_vlc
.table
, 6, 2)];
727 motion_y
[0] = motion_vector_table
[get_vlc2(gb
, s
->motion_vector_vlc
.table
, 6, 2)];
729 motion_x
[0] = fixed_motion_vector_table
[get_bits(gb
, 6)];
730 motion_y
[0] = fixed_motion_vector_table
[get_bits(gb
, 6)];
733 /* vector maintenance, only on MODE_INTER_PLUS_MV */
734 if (s
->macroblock_coding
[current_macroblock
] ==
735 MODE_INTER_PLUS_MV
) {
736 prior_last_motion_x
= last_motion_x
;
737 prior_last_motion_y
= last_motion_y
;
738 last_motion_x
= motion_x
[0];
739 last_motion_y
= motion_y
[0];
743 case MODE_INTER_FOURMV
:
744 /* vector maintenance */
745 prior_last_motion_x
= last_motion_x
;
746 prior_last_motion_y
= last_motion_y
;
748 /* fetch 4 vectors from the bitstream, one for each
749 * Y fragment, then average for the C fragment vectors */
750 for (k
= 0; k
< 4; k
++) {
751 current_fragment
= BLOCK_Y
*s
->fragment_width
[0] + BLOCK_X
;
752 if (s
->all_fragments
[current_fragment
].coding_method
!= MODE_COPY
) {
753 if (coding_mode
== 0) {
754 motion_x
[k
] = motion_vector_table
[get_vlc2(gb
, s
->motion_vector_vlc
.table
, 6, 2)];
755 motion_y
[k
] = motion_vector_table
[get_vlc2(gb
, s
->motion_vector_vlc
.table
, 6, 2)];
757 motion_x
[k
] = fixed_motion_vector_table
[get_bits(gb
, 6)];
758 motion_y
[k
] = fixed_motion_vector_table
[get_bits(gb
, 6)];
760 last_motion_x
= motion_x
[k
];
761 last_motion_y
= motion_y
[k
];
769 case MODE_INTER_LAST_MV
:
770 /* all 6 fragments use the last motion vector */
771 motion_x
[0] = last_motion_x
;
772 motion_y
[0] = last_motion_y
;
774 /* no vector maintenance (last vector remains the
778 case MODE_INTER_PRIOR_LAST
:
779 /* all 6 fragments use the motion vector prior to the
780 * last motion vector */
781 motion_x
[0] = prior_last_motion_x
;
782 motion_y
[0] = prior_last_motion_y
;
784 /* vector maintenance */
785 prior_last_motion_x
= last_motion_x
;
786 prior_last_motion_y
= last_motion_y
;
787 last_motion_x
= motion_x
[0];
788 last_motion_y
= motion_y
[0];
792 /* covers intra, inter without MV, golden without MV */
796 /* no vector maintenance */
800 /* assign the motion vectors to the correct fragments */
801 for (k
= 0; k
< 4; k
++) {
803 BLOCK_Y
*s
->fragment_width
[0] + BLOCK_X
;
804 if (s
->macroblock_coding
[current_macroblock
] == MODE_INTER_FOURMV
) {
805 s
->motion_val
[0][current_fragment
][0] = motion_x
[k
];
806 s
->motion_val
[0][current_fragment
][1] = motion_y
[k
];
808 s
->motion_val
[0][current_fragment
][0] = motion_x
[0];
809 s
->motion_val
[0][current_fragment
][1] = motion_y
[0];
813 if (s
->chroma_y_shift
) {
814 if (s
->macroblock_coding
[current_macroblock
] == MODE_INTER_FOURMV
) {
815 motion_x
[0] = RSHIFT(motion_x
[0] + motion_x
[1] + motion_x
[2] + motion_x
[3], 2);
816 motion_y
[0] = RSHIFT(motion_y
[0] + motion_y
[1] + motion_y
[2] + motion_y
[3], 2);
818 motion_x
[0] = (motion_x
[0]>>1) | (motion_x
[0]&1);
819 motion_y
[0] = (motion_y
[0]>>1) | (motion_y
[0]&1);
820 frag
= mb_y
*s
->fragment_width
[1] + mb_x
;
821 s
->motion_val
[1][frag
][0] = motion_x
[0];
822 s
->motion_val
[1][frag
][1] = motion_y
[0];
823 } else if (s
->chroma_x_shift
) {
824 if (s
->macroblock_coding
[current_macroblock
] == MODE_INTER_FOURMV
) {
825 motion_x
[0] = RSHIFT(motion_x
[0] + motion_x
[1], 1);
826 motion_y
[0] = RSHIFT(motion_y
[0] + motion_y
[1], 1);
827 motion_x
[1] = RSHIFT(motion_x
[2] + motion_x
[3], 1);
828 motion_y
[1] = RSHIFT(motion_y
[2] + motion_y
[3], 1);
830 motion_x
[1] = motion_x
[0];
831 motion_y
[1] = motion_y
[0];
833 motion_x
[0] = (motion_x
[0]>>1) | (motion_x
[0]&1);
834 motion_x
[1] = (motion_x
[1]>>1) | (motion_x
[1]&1);
836 frag
= 2*mb_y
*s
->fragment_width
[1] + mb_x
;
837 for (k
= 0; k
< 2; k
++) {
838 s
->motion_val
[1][frag
][0] = motion_x
[k
];
839 s
->motion_val
[1][frag
][1] = motion_y
[k
];
840 frag
+= s
->fragment_width
[1];
843 for (k
= 0; k
< 4; k
++) {
844 frag
= BLOCK_Y
*s
->fragment_width
[1] + BLOCK_X
;
845 if (s
->macroblock_coding
[current_macroblock
] == MODE_INTER_FOURMV
) {
846 s
->motion_val
[1][frag
][0] = motion_x
[k
];
847 s
->motion_val
[1][frag
][1] = motion_y
[k
];
849 s
->motion_val
[1][frag
][0] = motion_x
[0];
850 s
->motion_val
[1][frag
][1] = motion_y
[0];
861 static int unpack_block_qpis(Vp3DecodeContext
*s
, GetBitContext
*gb
)
863 int qpi
, i
, j
, bit
, run_length
, blocks_decoded
, num_blocks_at_qpi
;
864 int num_blocks
= s
->total_num_coded_frags
;
866 for (qpi
= 0; qpi
< s
->nqps
-1 && num_blocks
> 0; qpi
++) {
867 i
= blocks_decoded
= num_blocks_at_qpi
= 0;
869 bit
= get_bits1(gb
) ^ 1;
873 if (run_length
== MAXIMUM_LONG_BIT_RUN
)
878 run_length
= get_vlc2(gb
, s
->superblock_run_length_vlc
.table
, 6, 2) + 1;
879 if (run_length
== 34)
880 run_length
+= get_bits(gb
, 12);
881 blocks_decoded
+= run_length
;
884 num_blocks_at_qpi
+= run_length
;
886 for (j
= 0; j
< run_length
; i
++) {
887 if (i
>= s
->total_num_coded_frags
)
890 if (s
->all_fragments
[s
->coded_fragment_list
[0][i
]].qpi
== qpi
) {
891 s
->all_fragments
[s
->coded_fragment_list
[0][i
]].qpi
+= bit
;
895 } while (blocks_decoded
< num_blocks
&& get_bits_left(gb
) > 0);
897 num_blocks
-= num_blocks_at_qpi
;
904 * This function is called by unpack_dct_coeffs() to extract the VLCs from
905 * the bitstream. The VLCs encode tokens which are used to unpack DCT
906 * data. This function unpacks all the VLCs for either the Y plane or both
907 * C planes, and is called for DC coefficients or different AC coefficient
908 * levels (since different coefficient types require different VLC tables.
910 * This function returns a residual eob run. E.g, if a particular token gave
911 * instructions to EOB the next 5 fragments and there were only 2 fragments
912 * left in the current fragment range, 3 would be returned so that it could
913 * be passed into the next call to this same function.
915 static int unpack_vlcs(Vp3DecodeContext
*s
, GetBitContext
*gb
,
916 VLC
*table
, int coeff_index
,
927 int num_coeffs
= s
->num_coded_frags
[plane
][coeff_index
];
928 int16_t *dct_tokens
= s
->dct_tokens
[plane
][coeff_index
];
930 /* local references to structure members to avoid repeated deferences */
931 int *coded_fragment_list
= s
->coded_fragment_list
[plane
];
932 Vp3Fragment
*all_fragments
= s
->all_fragments
;
933 VLC_TYPE (*vlc_table
)[2] = table
->table
;
936 av_log(s
->avctx
, AV_LOG_ERROR
, "Invalid number of coefficents at level %d\n", coeff_index
);
938 if (eob_run
> num_coeffs
) {
939 coeff_i
= blocks_ended
= num_coeffs
;
940 eob_run
-= num_coeffs
;
942 coeff_i
= blocks_ended
= eob_run
;
946 // insert fake EOB token to cover the split between planes or zzi
948 dct_tokens
[j
++] = blocks_ended
<< 2;
950 while (coeff_i
< num_coeffs
&& get_bits_left(gb
) > 0) {
951 /* decode a VLC into a token */
952 token
= get_vlc2(gb
, vlc_table
, 11, 3);
953 /* use the token to get a zero run, a coefficient, and an eob run */
954 if ((unsigned) token
<= 6U) {
955 eob_run
= eob_run_base
[token
];
956 if (eob_run_get_bits
[token
])
957 eob_run
+= get_bits(gb
, eob_run_get_bits
[token
]);
959 // record only the number of blocks ended in this plane,
960 // any spill will be recorded in the next plane.
961 if (eob_run
> num_coeffs
- coeff_i
) {
962 dct_tokens
[j
++] = TOKEN_EOB(num_coeffs
- coeff_i
);
963 blocks_ended
+= num_coeffs
- coeff_i
;
964 eob_run
-= num_coeffs
- coeff_i
;
965 coeff_i
= num_coeffs
;
967 dct_tokens
[j
++] = TOKEN_EOB(eob_run
);
968 blocks_ended
+= eob_run
;
972 } else if (token
>= 0) {
973 bits_to_get
= coeff_get_bits
[token
];
975 bits_to_get
= get_bits(gb
, bits_to_get
);
976 coeff
= coeff_tables
[token
][bits_to_get
];
978 zero_run
= zero_run_base
[token
];
979 if (zero_run_get_bits
[token
])
980 zero_run
+= get_bits(gb
, zero_run_get_bits
[token
]);
983 dct_tokens
[j
++] = TOKEN_ZERO_RUN(coeff
, zero_run
);
985 // Save DC into the fragment structure. DC prediction is
986 // done in raster order, so the actual DC can't be in with
987 // other tokens. We still need the token in dct_tokens[]
988 // however, or else the structure collapses on itself.
990 all_fragments
[coded_fragment_list
[coeff_i
]].dc
= coeff
;
992 dct_tokens
[j
++] = TOKEN_COEFF(coeff
);
995 if (coeff_index
+ zero_run
> 64) {
996 av_log(s
->avctx
, AV_LOG_DEBUG
, "Invalid zero run of %d with"
997 " %d coeffs left\n", zero_run
, 64-coeff_index
);
998 zero_run
= 64 - coeff_index
;
1001 // zero runs code multiple coefficients,
1002 // so don't try to decode coeffs for those higher levels
1003 for (i
= coeff_index
+1; i
<= coeff_index
+zero_run
; i
++)
1004 s
->num_coded_frags
[plane
][i
]--;
1007 av_log(s
->avctx
, AV_LOG_ERROR
,
1008 "Invalid token %d\n", token
);
1013 if (blocks_ended
> s
->num_coded_frags
[plane
][coeff_index
])
1014 av_log(s
->avctx
, AV_LOG_ERROR
, "More blocks ended than coded!\n");
1016 // decrement the number of blocks that have higher coeffecients for each
1017 // EOB run at this level
1019 for (i
= coeff_index
+1; i
< 64; i
++)
1020 s
->num_coded_frags
[plane
][i
] -= blocks_ended
;
1022 // setup the next buffer
1024 s
->dct_tokens
[plane
+1][coeff_index
] = dct_tokens
+ j
;
1025 else if (coeff_index
< 63)
1026 s
->dct_tokens
[0][coeff_index
+1] = dct_tokens
+ j
;
1031 static void reverse_dc_prediction(Vp3DecodeContext
*s
,
1034 int fragment_height
);
1036 * This function unpacks all of the DCT coefficient data from the
1039 static int unpack_dct_coeffs(Vp3DecodeContext
*s
, GetBitContext
*gb
)
1046 int residual_eob_run
= 0;
1050 s
->dct_tokens
[0][0] = s
->dct_tokens_base
;
1052 /* fetch the DC table indexes */
1053 dc_y_table
= get_bits(gb
, 4);
1054 dc_c_table
= get_bits(gb
, 4);
1056 /* unpack the Y plane DC coefficients */
1057 residual_eob_run
= unpack_vlcs(s
, gb
, &s
->dc_vlc
[dc_y_table
], 0,
1058 0, residual_eob_run
);
1059 if (residual_eob_run
< 0)
1060 return residual_eob_run
;
1062 /* reverse prediction of the Y-plane DC coefficients */
1063 reverse_dc_prediction(s
, 0, s
->fragment_width
[0], s
->fragment_height
[0]);
1065 /* unpack the C plane DC coefficients */
1066 residual_eob_run
= unpack_vlcs(s
, gb
, &s
->dc_vlc
[dc_c_table
], 0,
1067 1, residual_eob_run
);
1068 if (residual_eob_run
< 0)
1069 return residual_eob_run
;
1070 residual_eob_run
= unpack_vlcs(s
, gb
, &s
->dc_vlc
[dc_c_table
], 0,
1071 2, residual_eob_run
);
1072 if (residual_eob_run
< 0)
1073 return residual_eob_run
;
1075 /* reverse prediction of the C-plane DC coefficients */
1076 if (!(s
->avctx
->flags
& CODEC_FLAG_GRAY
))
1078 reverse_dc_prediction(s
, s
->fragment_start
[1],
1079 s
->fragment_width
[1], s
->fragment_height
[1]);
1080 reverse_dc_prediction(s
, s
->fragment_start
[2],
1081 s
->fragment_width
[1], s
->fragment_height
[1]);
1084 /* fetch the AC table indexes */
1085 ac_y_table
= get_bits(gb
, 4);
1086 ac_c_table
= get_bits(gb
, 4);
1088 /* build tables of AC VLC tables */
1089 for (i
= 1; i
<= 5; i
++) {
1090 y_tables
[i
] = &s
->ac_vlc_1
[ac_y_table
];
1091 c_tables
[i
] = &s
->ac_vlc_1
[ac_c_table
];
1093 for (i
= 6; i
<= 14; i
++) {
1094 y_tables
[i
] = &s
->ac_vlc_2
[ac_y_table
];
1095 c_tables
[i
] = &s
->ac_vlc_2
[ac_c_table
];
1097 for (i
= 15; i
<= 27; i
++) {
1098 y_tables
[i
] = &s
->ac_vlc_3
[ac_y_table
];
1099 c_tables
[i
] = &s
->ac_vlc_3
[ac_c_table
];
1101 for (i
= 28; i
<= 63; i
++) {
1102 y_tables
[i
] = &s
->ac_vlc_4
[ac_y_table
];
1103 c_tables
[i
] = &s
->ac_vlc_4
[ac_c_table
];
1106 /* decode all AC coefficents */
1107 for (i
= 1; i
<= 63; i
++) {
1108 residual_eob_run
= unpack_vlcs(s
, gb
, y_tables
[i
], i
,
1109 0, residual_eob_run
);
1110 if (residual_eob_run
< 0)
1111 return residual_eob_run
;
1113 residual_eob_run
= unpack_vlcs(s
, gb
, c_tables
[i
], i
,
1114 1, residual_eob_run
);
1115 if (residual_eob_run
< 0)
1116 return residual_eob_run
;
1117 residual_eob_run
= unpack_vlcs(s
, gb
, c_tables
[i
], i
,
1118 2, residual_eob_run
);
1119 if (residual_eob_run
< 0)
1120 return residual_eob_run
;
1127 * This function reverses the DC prediction for each coded fragment in
1128 * the frame. Much of this function is adapted directly from the original
1131 #define COMPATIBLE_FRAME(x) \
1132 (compatible_frame[s->all_fragments[x].coding_method] == current_frame_type)
1133 #define DC_COEFF(u) s->all_fragments[u].dc
1135 static void reverse_dc_prediction(Vp3DecodeContext
*s
,
1138 int fragment_height
)
1147 int i
= first_fragment
;
1151 /* DC values for the left, up-left, up, and up-right fragments */
1152 int vl
, vul
, vu
, vur
;
1154 /* indexes for the left, up-left, up, and up-right fragments */
1158 * The 6 fields mean:
1159 * 0: up-left multiplier
1161 * 2: up-right multiplier
1162 * 3: left multiplier
1164 static const int predictor_transform
[16][4] = {
1166 { 0, 0, 0,128}, // PL
1167 { 0, 0,128, 0}, // PUR
1168 { 0, 0, 53, 75}, // PUR|PL
1169 { 0,128, 0, 0}, // PU
1170 { 0, 64, 0, 64}, // PU|PL
1171 { 0,128, 0, 0}, // PU|PUR
1172 { 0, 0, 53, 75}, // PU|PUR|PL
1173 {128, 0, 0, 0}, // PUL
1174 { 0, 0, 0,128}, // PUL|PL
1175 { 64, 0, 64, 0}, // PUL|PUR
1176 { 0, 0, 53, 75}, // PUL|PUR|PL
1177 { 0,128, 0, 0}, // PUL|PU
1178 {-104,116, 0,116}, // PUL|PU|PL
1179 { 24, 80, 24, 0}, // PUL|PU|PUR
1180 {-104,116, 0,116} // PUL|PU|PUR|PL
1183 /* This table shows which types of blocks can use other blocks for
1184 * prediction. For example, INTRA is the only mode in this table to
1185 * have a frame number of 0. That means INTRA blocks can only predict
1186 * from other INTRA blocks. There are 2 golden frame coding types;
1187 * blocks encoding in these modes can only predict from other blocks
1188 * that were encoded with these 1 of these 2 modes. */
1189 static const unsigned char compatible_frame
[9] = {
1190 1, /* MODE_INTER_NO_MV */
1192 1, /* MODE_INTER_PLUS_MV */
1193 1, /* MODE_INTER_LAST_MV */
1194 1, /* MODE_INTER_PRIOR_MV */
1195 2, /* MODE_USING_GOLDEN */
1196 2, /* MODE_GOLDEN_MV */
1197 1, /* MODE_INTER_FOUR_MV */
1200 int current_frame_type
;
1202 /* there is a last DC predictor for each of the 3 frame types */
1207 vul
= vu
= vur
= vl
= 0;
1208 last_dc
[0] = last_dc
[1] = last_dc
[2] = 0;
1210 /* for each fragment row... */
1211 for (y
= 0; y
< fragment_height
; y
++) {
1213 /* for each fragment in a row... */
1214 for (x
= 0; x
< fragment_width
; x
++, i
++) {
1216 /* reverse prediction if this block was coded */
1217 if (s
->all_fragments
[i
].coding_method
!= MODE_COPY
) {
1219 current_frame_type
=
1220 compatible_frame
[s
->all_fragments
[i
].coding_method
];
1226 if(COMPATIBLE_FRAME(l
))
1230 u
= i
-fragment_width
;
1232 if(COMPATIBLE_FRAME(u
))
1235 ul
= i
-fragment_width
-1;
1237 if(COMPATIBLE_FRAME(ul
))
1240 if(x
+ 1 < fragment_width
){
1241 ur
= i
-fragment_width
+1;
1243 if(COMPATIBLE_FRAME(ur
))
1248 if (transform
== 0) {
1250 /* if there were no fragments to predict from, use last
1252 predicted_dc
= last_dc
[current_frame_type
];
1255 /* apply the appropriate predictor transform */
1257 (predictor_transform
[transform
][0] * vul
) +
1258 (predictor_transform
[transform
][1] * vu
) +
1259 (predictor_transform
[transform
][2] * vur
) +
1260 (predictor_transform
[transform
][3] * vl
);
1262 predicted_dc
/= 128;
1264 /* check for outranging on the [ul u l] and
1265 * [ul u ur l] predictors */
1266 if ((transform
== 15) || (transform
== 13)) {
1267 if (FFABS(predicted_dc
- vu
) > 128)
1269 else if (FFABS(predicted_dc
- vl
) > 128)
1271 else if (FFABS(predicted_dc
- vul
) > 128)
1276 /* at long last, apply the predictor */
1277 DC_COEFF(i
) += predicted_dc
;
1279 last_dc
[current_frame_type
] = DC_COEFF(i
);
1285 static void apply_loop_filter(Vp3DecodeContext
*s
, int plane
, int ystart
, int yend
)
1288 int *bounding_values
= s
->bounding_values_array
+127;
1290 int width
= s
->fragment_width
[!!plane
];
1291 int height
= s
->fragment_height
[!!plane
];
1292 int fragment
= s
->fragment_start
[plane
] + ystart
* width
;
1293 int stride
= s
->current_frame
.linesize
[plane
];
1294 uint8_t *plane_data
= s
->current_frame
.data
[plane
];
1295 if (!s
->flipped_image
) stride
= -stride
;
1296 plane_data
+= s
->data_offset
[plane
] + 8*ystart
*stride
;
1298 for (y
= ystart
; y
< yend
; y
++) {
1300 for (x
= 0; x
< width
; x
++) {
1301 /* This code basically just deblocks on the edges of coded blocks.
1302 * However, it has to be much more complicated because of the
1303 * braindamaged deblock ordering used in VP3/Theora. Order matters
1304 * because some pixels get filtered twice. */
1305 if( s
->all_fragments
[fragment
].coding_method
!= MODE_COPY
)
1307 /* do not perform left edge filter for left columns frags */
1309 s
->vp3dsp
.h_loop_filter(
1311 stride
, bounding_values
);
1314 /* do not perform top edge filter for top row fragments */
1316 s
->vp3dsp
.v_loop_filter(
1318 stride
, bounding_values
);
1321 /* do not perform right edge filter for right column
1322 * fragments or if right fragment neighbor is also coded
1323 * in this frame (it will be filtered in next iteration) */
1324 if ((x
< width
- 1) &&
1325 (s
->all_fragments
[fragment
+ 1].coding_method
== MODE_COPY
)) {
1326 s
->vp3dsp
.h_loop_filter(
1327 plane_data
+ 8*x
+ 8,
1328 stride
, bounding_values
);
1331 /* do not perform bottom edge filter for bottom row
1332 * fragments or if bottom fragment neighbor is also coded
1333 * in this frame (it will be filtered in the next row) */
1334 if ((y
< height
- 1) &&
1335 (s
->all_fragments
[fragment
+ width
].coding_method
== MODE_COPY
)) {
1336 s
->vp3dsp
.v_loop_filter(
1337 plane_data
+ 8*x
+ 8*stride
,
1338 stride
, bounding_values
);
1344 plane_data
+= 8*stride
;
1349 * Pull DCT tokens from the 64 levels to decode and dequant the coefficients
1350 * for the next block in coding order
1352 static inline int vp3_dequant(Vp3DecodeContext
*s
, Vp3Fragment
*frag
,
1353 int plane
, int inter
, int16_t block
[64])
1355 int16_t *dequantizer
= s
->qmat
[frag
->qpi
][inter
][plane
];
1356 uint8_t *perm
= s
->scantable
.permutated
;
1360 int token
= *s
->dct_tokens
[plane
][i
];
1361 switch (token
& 3) {
1363 if (--token
< 4) // 0-3 are token types, so the EOB run must now be 0
1364 s
->dct_tokens
[plane
][i
]++;
1366 *s
->dct_tokens
[plane
][i
] = token
& ~3;
1369 s
->dct_tokens
[plane
][i
]++;
1370 i
+= (token
>> 2) & 0x7f;
1372 av_log(s
->avctx
, AV_LOG_ERROR
, "Coefficient index overflow\n");
1375 block
[perm
[i
]] = (token
>> 9) * dequantizer
[perm
[i
]];
1379 block
[perm
[i
]] = (token
>> 2) * dequantizer
[perm
[i
]];
1380 s
->dct_tokens
[plane
][i
++]++;
1382 default: // shouldn't happen
1386 // return value is expected to be a valid level
1389 // the actual DC+prediction is in the fragment structure
1390 block
[0] = frag
->dc
* s
->qmat
[0][inter
][plane
][0];
1395 * called when all pixels up to row y are complete
1397 static void vp3_draw_horiz_band(Vp3DecodeContext
*s
, int y
)
1400 int offset
[AV_NUM_DATA_POINTERS
];
1402 if (HAVE_THREADS
&& s
->avctx
->active_thread_type
&FF_THREAD_FRAME
) {
1403 int y_flipped
= s
->flipped_image
? s
->avctx
->height
-y
: y
;
1405 // At the end of the frame, report INT_MAX instead of the height of the frame.
1406 // This makes the other threads' ff_thread_await_progress() calls cheaper, because
1407 // they don't have to clip their values.
1408 ff_thread_report_progress(&s
->current_frame
, y_flipped
==s
->avctx
->height
? INT_MAX
: y_flipped
-1, 0);
1411 if(s
->avctx
->draw_horiz_band
==NULL
)
1414 h
= y
- s
->last_slice_end
;
1415 s
->last_slice_end
= y
;
1418 if (!s
->flipped_image
) {
1419 y
= s
->avctx
->height
- y
- h
;
1422 cy
= y
>> s
->chroma_y_shift
;
1423 offset
[0] = s
->current_frame
.linesize
[0]*y
;
1424 offset
[1] = s
->current_frame
.linesize
[1]*cy
;
1425 offset
[2] = s
->current_frame
.linesize
[2]*cy
;
1426 for (i
= 3; i
< AV_NUM_DATA_POINTERS
; i
++)
1430 s
->avctx
->draw_horiz_band(s
->avctx
, &s
->current_frame
, offset
, y
, 3, h
);
1434 * Wait for the reference frame of the current fragment.
1435 * The progress value is in luma pixel rows.
1437 static void await_reference_row(Vp3DecodeContext
*s
, Vp3Fragment
*fragment
, int motion_y
, int y
)
1441 int border
= motion_y
&1;
1443 if (fragment
->coding_method
== MODE_USING_GOLDEN
||
1444 fragment
->coding_method
== MODE_GOLDEN_MV
)
1445 ref_frame
= &s
->golden_frame
;
1447 ref_frame
= &s
->last_frame
;
1449 ref_row
= y
+ (motion_y
>>1);
1450 ref_row
= FFMAX(FFABS(ref_row
), ref_row
+ 8 + border
);
1452 ff_thread_await_progress(ref_frame
, ref_row
, 0);
1456 * Perform the final rendering for a particular slice of data.
1457 * The slice number ranges from 0..(c_superblock_height - 1).
1459 static void render_slice(Vp3DecodeContext
*s
, int slice
)
1461 int x
, y
, i
, j
, fragment
;
1462 int16_t *block
= s
->block
;
1463 int motion_x
= 0xdeadbeef, motion_y
= 0xdeadbeef;
1464 int motion_halfpel_index
;
1465 uint8_t *motion_source
;
1466 int plane
, first_pixel
;
1468 if (slice
>= s
->c_superblock_height
)
1471 for (plane
= 0; plane
< 3; plane
++) {
1472 uint8_t *output_plane
= s
->current_frame
.data
[plane
] + s
->data_offset
[plane
];
1473 uint8_t * last_plane
= s
-> last_frame
.data
[plane
] + s
->data_offset
[plane
];
1474 uint8_t *golden_plane
= s
-> golden_frame
.data
[plane
] + s
->data_offset
[plane
];
1475 int stride
= s
->current_frame
.linesize
[plane
];
1476 int plane_width
= s
->width
>> (plane
&& s
->chroma_x_shift
);
1477 int plane_height
= s
->height
>> (plane
&& s
->chroma_y_shift
);
1478 int8_t (*motion_val
)[2] = s
->motion_val
[!!plane
];
1480 int sb_x
, sb_y
= slice
<< (!plane
&& s
->chroma_y_shift
);
1481 int slice_height
= sb_y
+ 1 + (!plane
&& s
->chroma_y_shift
);
1482 int slice_width
= plane
? s
->c_superblock_width
: s
->y_superblock_width
;
1484 int fragment_width
= s
->fragment_width
[!!plane
];
1485 int fragment_height
= s
->fragment_height
[!!plane
];
1486 int fragment_start
= s
->fragment_start
[plane
];
1487 int do_await
= !plane
&& HAVE_THREADS
&& (s
->avctx
->active_thread_type
&FF_THREAD_FRAME
);
1489 if (!s
->flipped_image
) stride
= -stride
;
1490 if (CONFIG_GRAY
&& plane
&& (s
->avctx
->flags
& CODEC_FLAG_GRAY
))
1493 /* for each superblock row in the slice (both of them)... */
1494 for (; sb_y
< slice_height
; sb_y
++) {
1496 /* for each superblock in a row... */
1497 for (sb_x
= 0; sb_x
< slice_width
; sb_x
++) {
1499 /* for each block in a superblock... */
1500 for (j
= 0; j
< 16; j
++) {
1501 x
= 4*sb_x
+ hilbert_offset
[j
][0];
1502 y
= 4*sb_y
+ hilbert_offset
[j
][1];
1503 fragment
= y
*fragment_width
+ x
;
1505 i
= fragment_start
+ fragment
;
1508 if (x
>= fragment_width
|| y
>= fragment_height
)
1511 first_pixel
= 8*y
*stride
+ 8*x
;
1513 if (do_await
&& s
->all_fragments
[i
].coding_method
!= MODE_INTRA
)
1514 await_reference_row(s
, &s
->all_fragments
[i
], motion_val
[fragment
][1], (16*y
) >> s
->chroma_y_shift
);
1516 /* transform if this block was coded */
1517 if (s
->all_fragments
[i
].coding_method
!= MODE_COPY
) {
1518 if ((s
->all_fragments
[i
].coding_method
== MODE_USING_GOLDEN
) ||
1519 (s
->all_fragments
[i
].coding_method
== MODE_GOLDEN_MV
))
1520 motion_source
= golden_plane
;
1522 motion_source
= last_plane
;
1524 motion_source
+= first_pixel
;
1525 motion_halfpel_index
= 0;
1527 /* sort out the motion vector if this fragment is coded
1528 * using a motion vector method */
1529 if ((s
->all_fragments
[i
].coding_method
> MODE_INTRA
) &&
1530 (s
->all_fragments
[i
].coding_method
!= MODE_USING_GOLDEN
)) {
1532 motion_x
= motion_val
[fragment
][0];
1533 motion_y
= motion_val
[fragment
][1];
1535 src_x
= (motion_x
>>1) + 8*x
;
1536 src_y
= (motion_y
>>1) + 8*y
;
1538 motion_halfpel_index
= motion_x
& 0x01;
1539 motion_source
+= (motion_x
>> 1);
1541 motion_halfpel_index
|= (motion_y
& 0x01) << 1;
1542 motion_source
+= ((motion_y
>> 1) * stride
);
1544 if(src_x
<0 || src_y
<0 || src_x
+ 9 >= plane_width
|| src_y
+ 9 >= plane_height
){
1545 uint8_t *temp
= s
->edge_emu_buffer
;
1546 if(stride
<0) temp
-= 8*stride
;
1548 s
->vdsp
.emulated_edge_mc(temp
, motion_source
, stride
, 9, 9, src_x
, src_y
, plane_width
, plane_height
);
1549 motion_source
= temp
;
1554 /* first, take care of copying a block from either the
1555 * previous or the golden frame */
1556 if (s
->all_fragments
[i
].coding_method
!= MODE_INTRA
) {
1557 /* Note, it is possible to implement all MC cases with
1558 put_no_rnd_pixels_l2 which would look more like the
1559 VP3 source but this would be slower as
1560 put_no_rnd_pixels_tab is better optimzed */
1561 if(motion_halfpel_index
!= 3){
1562 s
->dsp
.put_no_rnd_pixels_tab
[1][motion_halfpel_index
](
1563 output_plane
+ first_pixel
,
1564 motion_source
, stride
, 8);
1566 int d
= (motion_x
^ motion_y
)>>31; // d is 0 if motion_x and _y have the same sign, else -1
1567 s
->vp3dsp
.put_no_rnd_pixels_l2(
1568 output_plane
+ first_pixel
,
1570 motion_source
+ stride
+ 1 + d
,
1575 /* invert DCT and place (or add) in final output */
1577 if (s
->all_fragments
[i
].coding_method
== MODE_INTRA
) {
1579 index
= vp3_dequant(s
, s
->all_fragments
+ i
, plane
, 0, block
);
1583 output_plane
+ first_pixel
,
1587 int index
= vp3_dequant(s
, s
->all_fragments
+ i
, plane
, 1, block
);
1592 output_plane
+ first_pixel
,
1596 s
->vp3dsp
.idct_dc_add(output_plane
+ first_pixel
, stride
, block
);
1601 /* copy directly from the previous frame */
1602 s
->dsp
.put_pixels_tab
[1][0](
1603 output_plane
+ first_pixel
,
1604 last_plane
+ first_pixel
,
1611 // Filter up to the last row in the superblock row
1612 if (!s
->skip_loop_filter
)
1613 apply_loop_filter(s
, plane
, 4*sb_y
- !!sb_y
, FFMIN(4*sb_y
+3, fragment_height
-1));
1617 /* this looks like a good place for slice dispatch... */
1619 * if (slice == s->macroblock_height - 1)
1620 * dispatch (both last slice & 2nd-to-last slice);
1621 * else if (slice > 0)
1622 * dispatch (slice - 1);
1625 vp3_draw_horiz_band(s
, FFMIN((32 << s
->chroma_y_shift
) * (slice
+ 1) -16, s
->height
-16));
1628 /// Allocate tables for per-frame data in Vp3DecodeContext
1629 static av_cold
int allocate_tables(AVCodecContext
*avctx
)
1631 Vp3DecodeContext
*s
= avctx
->priv_data
;
1632 int y_fragment_count
, c_fragment_count
;
1634 y_fragment_count
= s
->fragment_width
[0] * s
->fragment_height
[0];
1635 c_fragment_count
= s
->fragment_width
[1] * s
->fragment_height
[1];
1637 s
->superblock_coding
= av_malloc(s
->superblock_count
);
1638 s
->all_fragments
= av_malloc(s
->fragment_count
* sizeof(Vp3Fragment
));
1639 s
->coded_fragment_list
[0] = av_malloc(s
->fragment_count
* sizeof(int));
1640 s
->dct_tokens_base
= av_malloc(64*s
->fragment_count
* sizeof(*s
->dct_tokens_base
));
1641 s
->motion_val
[0] = av_malloc(y_fragment_count
* sizeof(*s
->motion_val
[0]));
1642 s
->motion_val
[1] = av_malloc(c_fragment_count
* sizeof(*s
->motion_val
[1]));
1644 /* work out the block mapping tables */
1645 s
->superblock_fragments
= av_malloc(s
->superblock_count
* 16 * sizeof(int));
1646 s
->macroblock_coding
= av_malloc(s
->macroblock_count
+ 1);
1648 if (!s
->superblock_coding
|| !s
->all_fragments
|| !s
->dct_tokens_base
||
1649 !s
->coded_fragment_list
[0] || !s
->superblock_fragments
|| !s
->macroblock_coding
||
1650 !s
->motion_val
[0] || !s
->motion_val
[1]) {
1651 vp3_decode_end(avctx
);
1655 init_block_mapping(s
);
1660 static av_cold
int vp3_decode_init(AVCodecContext
*avctx
)
1662 Vp3DecodeContext
*s
= avctx
->priv_data
;
1663 int i
, inter
, plane
;
1666 int y_fragment_count
, c_fragment_count
;
1668 if (avctx
->codec_tag
== MKTAG('V','P','3','0'))
1674 s
->width
= FFALIGN(avctx
->width
, 16);
1675 s
->height
= FFALIGN(avctx
->height
, 16);
1676 if (avctx
->pix_fmt
== AV_PIX_FMT_NONE
)
1677 avctx
->pix_fmt
= AV_PIX_FMT_YUV420P
;
1678 avctx
->chroma_sample_location
= AVCHROMA_LOC_CENTER
;
1679 ff_dsputil_init(&s
->dsp
, avctx
);
1680 ff_videodsp_init(&s
->vdsp
, 8);
1681 ff_vp3dsp_init(&s
->vp3dsp
, avctx
->flags
);
1683 ff_init_scantable_permutation(s
->dsp
.idct_permutation
, s
->vp3dsp
.idct_perm
);
1684 ff_init_scantable(s
->dsp
.idct_permutation
, &s
->scantable
, ff_zigzag_direct
);
1686 /* initialize to an impossible value which will force a recalculation
1687 * in the first frame decode */
1688 for (i
= 0; i
< 3; i
++)
1691 av_pix_fmt_get_chroma_sub_sample(avctx
->pix_fmt
, &s
->chroma_x_shift
,
1692 &s
->chroma_y_shift
);
1694 s
->y_superblock_width
= (s
->width
+ 31) / 32;
1695 s
->y_superblock_height
= (s
->height
+ 31) / 32;
1696 s
->y_superblock_count
= s
->y_superblock_width
* s
->y_superblock_height
;
1698 /* work out the dimensions for the C planes */
1699 c_width
= s
->width
>> s
->chroma_x_shift
;
1700 c_height
= s
->height
>> s
->chroma_y_shift
;
1701 s
->c_superblock_width
= (c_width
+ 31) / 32;
1702 s
->c_superblock_height
= (c_height
+ 31) / 32;
1703 s
->c_superblock_count
= s
->c_superblock_width
* s
->c_superblock_height
;
1705 s
->superblock_count
= s
->y_superblock_count
+ (s
->c_superblock_count
* 2);
1706 s
->u_superblock_start
= s
->y_superblock_count
;
1707 s
->v_superblock_start
= s
->u_superblock_start
+ s
->c_superblock_count
;
1709 s
->macroblock_width
= (s
->width
+ 15) / 16;
1710 s
->macroblock_height
= (s
->height
+ 15) / 16;
1711 s
->macroblock_count
= s
->macroblock_width
* s
->macroblock_height
;
1713 s
->fragment_width
[0] = s
->width
/ FRAGMENT_PIXELS
;
1714 s
->fragment_height
[0] = s
->height
/ FRAGMENT_PIXELS
;
1715 s
->fragment_width
[1] = s
->fragment_width
[0] >> s
->chroma_x_shift
;
1716 s
->fragment_height
[1] = s
->fragment_height
[0] >> s
->chroma_y_shift
;
1718 /* fragment count covers all 8x8 blocks for all 3 planes */
1719 y_fragment_count
= s
->fragment_width
[0] * s
->fragment_height
[0];
1720 c_fragment_count
= s
->fragment_width
[1] * s
->fragment_height
[1];
1721 s
->fragment_count
= y_fragment_count
+ 2*c_fragment_count
;
1722 s
->fragment_start
[1] = y_fragment_count
;
1723 s
->fragment_start
[2] = y_fragment_count
+ c_fragment_count
;
1725 if (!s
->theora_tables
)
1727 for (i
= 0; i
< 64; i
++) {
1728 s
->coded_dc_scale_factor
[i
] = vp31_dc_scale_factor
[i
];
1729 s
->coded_ac_scale_factor
[i
] = vp31_ac_scale_factor
[i
];
1730 s
->base_matrix
[0][i
] = vp31_intra_y_dequant
[i
];
1731 s
->base_matrix
[1][i
] = vp31_intra_c_dequant
[i
];
1732 s
->base_matrix
[2][i
] = vp31_inter_dequant
[i
];
1733 s
->filter_limit_values
[i
] = vp31_filter_limit_values
[i
];
1736 for(inter
=0; inter
<2; inter
++){
1737 for(plane
=0; plane
<3; plane
++){
1738 s
->qr_count
[inter
][plane
]= 1;
1739 s
->qr_size
[inter
][plane
][0]= 63;
1740 s
->qr_base
[inter
][plane
][0]=
1741 s
->qr_base
[inter
][plane
][1]= 2*inter
+ (!!plane
)*!inter
;
1745 /* init VLC tables */
1746 for (i
= 0; i
< 16; i
++) {
1749 init_vlc(&s
->dc_vlc
[i
], 11, 32,
1750 &dc_bias
[i
][0][1], 4, 2,
1751 &dc_bias
[i
][0][0], 4, 2, 0);
1753 /* group 1 AC histograms */
1754 init_vlc(&s
->ac_vlc_1
[i
], 11, 32,
1755 &ac_bias_0
[i
][0][1], 4, 2,
1756 &ac_bias_0
[i
][0][0], 4, 2, 0);
1758 /* group 2 AC histograms */
1759 init_vlc(&s
->ac_vlc_2
[i
], 11, 32,
1760 &ac_bias_1
[i
][0][1], 4, 2,
1761 &ac_bias_1
[i
][0][0], 4, 2, 0);
1763 /* group 3 AC histograms */
1764 init_vlc(&s
->ac_vlc_3
[i
], 11, 32,
1765 &ac_bias_2
[i
][0][1], 4, 2,
1766 &ac_bias_2
[i
][0][0], 4, 2, 0);
1768 /* group 4 AC histograms */
1769 init_vlc(&s
->ac_vlc_4
[i
], 11, 32,
1770 &ac_bias_3
[i
][0][1], 4, 2,
1771 &ac_bias_3
[i
][0][0], 4, 2, 0);
1775 for (i
= 0; i
< 16; i
++) {
1777 if (init_vlc(&s
->dc_vlc
[i
], 11, 32,
1778 &s
->huffman_table
[i
][0][1], 8, 4,
1779 &s
->huffman_table
[i
][0][0], 8, 4, 0) < 0)
1782 /* group 1 AC histograms */
1783 if (init_vlc(&s
->ac_vlc_1
[i
], 11, 32,
1784 &s
->huffman_table
[i
+16][0][1], 8, 4,
1785 &s
->huffman_table
[i
+16][0][0], 8, 4, 0) < 0)
1788 /* group 2 AC histograms */
1789 if (init_vlc(&s
->ac_vlc_2
[i
], 11, 32,
1790 &s
->huffman_table
[i
+16*2][0][1], 8, 4,
1791 &s
->huffman_table
[i
+16*2][0][0], 8, 4, 0) < 0)
1794 /* group 3 AC histograms */
1795 if (init_vlc(&s
->ac_vlc_3
[i
], 11, 32,
1796 &s
->huffman_table
[i
+16*3][0][1], 8, 4,
1797 &s
->huffman_table
[i
+16*3][0][0], 8, 4, 0) < 0)
1800 /* group 4 AC histograms */
1801 if (init_vlc(&s
->ac_vlc_4
[i
], 11, 32,
1802 &s
->huffman_table
[i
+16*4][0][1], 8, 4,
1803 &s
->huffman_table
[i
+16*4][0][0], 8, 4, 0) < 0)
1808 init_vlc(&s
->superblock_run_length_vlc
, 6, 34,
1809 &superblock_run_length_vlc_table
[0][1], 4, 2,
1810 &superblock_run_length_vlc_table
[0][0], 4, 2, 0);
1812 init_vlc(&s
->fragment_run_length_vlc
, 5, 30,
1813 &fragment_run_length_vlc_table
[0][1], 4, 2,
1814 &fragment_run_length_vlc_table
[0][0], 4, 2, 0);
1816 init_vlc(&s
->mode_code_vlc
, 3, 8,
1817 &mode_code_vlc_table
[0][1], 2, 1,
1818 &mode_code_vlc_table
[0][0], 2, 1, 0);
1820 init_vlc(&s
->motion_vector_vlc
, 6, 63,
1821 &motion_vector_vlc_table
[0][1], 2, 1,
1822 &motion_vector_vlc_table
[0][0], 2, 1, 0);
1824 for (i
= 0; i
< 3; i
++) {
1825 s
->current_frame
.data
[i
] = NULL
;
1826 s
->last_frame
.data
[i
] = NULL
;
1827 s
->golden_frame
.data
[i
] = NULL
;
1830 return allocate_tables(avctx
);
1833 av_log(avctx
, AV_LOG_FATAL
, "Invalid huffman table\n");
1837 /// Release and shuffle frames after decode finishes
1838 static void update_frames(AVCodecContext
*avctx
)
1840 Vp3DecodeContext
*s
= avctx
->priv_data
;
1842 /* release the last frame, if it is allocated and if it is not the
1844 if (s
->last_frame
.data
[0] && s
->last_frame
.type
!= FF_BUFFER_TYPE_COPY
)
1845 ff_thread_release_buffer(avctx
, &s
->last_frame
);
1847 /* shuffle frames (last = current) */
1848 s
->last_frame
= s
->current_frame
;
1851 if (s
->golden_frame
.data
[0])
1852 ff_thread_release_buffer(avctx
, &s
->golden_frame
);
1853 s
->golden_frame
= s
->current_frame
;
1854 s
->last_frame
.type
= FF_BUFFER_TYPE_COPY
;
1857 s
->current_frame
.data
[0]= NULL
; /* ensure that we catch any access to this released frame */
1860 static int vp3_update_thread_context(AVCodecContext
*dst
, const AVCodecContext
*src
)
1862 Vp3DecodeContext
*s
= dst
->priv_data
, *s1
= src
->priv_data
;
1863 int qps_changed
= 0, i
, err
;
1865 #define copy_fields(to, from, start_field, end_field) memcpy(&to->start_field, &from->start_field, (char*)&to->end_field - (char*)&to->start_field)
1867 if (!s1
->current_frame
.data
[0]
1868 ||s
->width
!= s1
->width
1869 ||s
->height
!= s1
->height
) {
1871 copy_fields(s
, s1
, golden_frame
, current_frame
);
1876 // init tables if the first frame hasn't been decoded
1877 if (!s
->current_frame
.data
[0]) {
1878 int y_fragment_count
, c_fragment_count
;
1880 err
= allocate_tables(dst
);
1883 y_fragment_count
= s
->fragment_width
[0] * s
->fragment_height
[0];
1884 c_fragment_count
= s
->fragment_width
[1] * s
->fragment_height
[1];
1885 memcpy(s
->motion_val
[0], s1
->motion_val
[0], y_fragment_count
* sizeof(*s
->motion_val
[0]));
1886 memcpy(s
->motion_val
[1], s1
->motion_val
[1], c_fragment_count
* sizeof(*s
->motion_val
[1]));
1889 // copy previous frame data
1890 copy_fields(s
, s1
, golden_frame
, dsp
);
1892 // copy qscale data if necessary
1893 for (i
= 0; i
< 3; i
++) {
1894 if (s
->qps
[i
] != s1
->qps
[1]) {
1896 memcpy(&s
->qmat
[i
], &s1
->qmat
[i
], sizeof(s
->qmat
[i
]));
1900 if (s
->qps
[0] != s1
->qps
[0])
1901 memcpy(&s
->bounding_values_array
, &s1
->bounding_values_array
, sizeof(s
->bounding_values_array
));
1904 copy_fields(s
, s1
, qps
, superblock_count
);
1913 static int vp3_decode_frame(AVCodecContext
*avctx
,
1914 void *data
, int *got_frame
,
1917 const uint8_t *buf
= avpkt
->data
;
1918 int buf_size
= avpkt
->size
;
1919 Vp3DecodeContext
*s
= avctx
->priv_data
;
1923 init_get_bits(&gb
, buf
, buf_size
* 8);
1925 if (s
->theora
&& get_bits1(&gb
))
1927 av_log(avctx
, AV_LOG_ERROR
, "Header packet passed to frame decoder, skipping\n");
1931 s
->keyframe
= !get_bits1(&gb
);
1934 for (i
= 0; i
< 3; i
++)
1935 s
->last_qps
[i
] = s
->qps
[i
];
1939 s
->qps
[s
->nqps
++]= get_bits(&gb
, 6);
1940 } while(s
->theora
>= 0x030200 && s
->nqps
<3 && get_bits1(&gb
));
1941 for (i
= s
->nqps
; i
< 3; i
++)
1944 if (s
->avctx
->debug
& FF_DEBUG_PICT_INFO
)
1945 av_log(s
->avctx
, AV_LOG_INFO
, " VP3 %sframe #%d: Q index = %d\n",
1946 s
->keyframe
?"key":"", avctx
->frame_number
+1, s
->qps
[0]);
1948 s
->skip_loop_filter
= !s
->filter_limit_values
[s
->qps
[0]] ||
1949 avctx
->skip_loop_filter
>= (s
->keyframe
? AVDISCARD_ALL
: AVDISCARD_NONKEY
);
1951 if (s
->qps
[0] != s
->last_qps
[0])
1952 init_loop_filter(s
);
1954 for (i
= 0; i
< s
->nqps
; i
++)
1955 // reinit all dequantizers if the first one changed, because
1956 // the DC of the first quantizer must be used for all matrices
1957 if (s
->qps
[i
] != s
->last_qps
[i
] || s
->qps
[0] != s
->last_qps
[0])
1958 init_dequantizer(s
, i
);
1960 if (avctx
->skip_frame
>= AVDISCARD_NONKEY
&& !s
->keyframe
)
1963 s
->current_frame
.reference
= 3;
1964 s
->current_frame
.pict_type
= s
->keyframe
? AV_PICTURE_TYPE_I
: AV_PICTURE_TYPE_P
;
1965 if (ff_thread_get_buffer(avctx
, &s
->current_frame
) < 0) {
1966 av_log(s
->avctx
, AV_LOG_ERROR
, "get_buffer() failed\n");
1970 if (!s
->edge_emu_buffer
)
1971 s
->edge_emu_buffer
= av_malloc(9*FFABS(s
->current_frame
.linesize
[0]));
1976 skip_bits(&gb
, 4); /* width code */
1977 skip_bits(&gb
, 4); /* height code */
1980 s
->version
= get_bits(&gb
, 5);
1981 if (avctx
->frame_number
== 0)
1982 av_log(s
->avctx
, AV_LOG_DEBUG
, "VP version: %d\n", s
->version
);
1985 if (s
->version
|| s
->theora
)
1988 av_log(s
->avctx
, AV_LOG_ERROR
, "Warning, unsupported keyframe coding type?!\n");
1989 skip_bits(&gb
, 2); /* reserved? */
1992 if (!s
->golden_frame
.data
[0]) {
1993 av_log(s
->avctx
, AV_LOG_WARNING
, "vp3: first frame not a keyframe\n");
1995 s
->golden_frame
.reference
= 3;
1996 s
->golden_frame
.pict_type
= AV_PICTURE_TYPE_I
;
1997 if (ff_thread_get_buffer(avctx
, &s
->golden_frame
) < 0) {
1998 av_log(s
->avctx
, AV_LOG_ERROR
, "get_buffer() failed\n");
2001 s
->last_frame
= s
->golden_frame
;
2002 s
->last_frame
.type
= FF_BUFFER_TYPE_COPY
;
2003 ff_thread_report_progress(&s
->last_frame
, INT_MAX
, 0);
2007 memset(s
->all_fragments
, 0, s
->fragment_count
* sizeof(Vp3Fragment
));
2008 ff_thread_finish_setup(avctx
);
2010 if (unpack_superblocks(s
, &gb
)){
2011 av_log(s
->avctx
, AV_LOG_ERROR
, "error in unpack_superblocks\n");
2014 if (unpack_modes(s
, &gb
)){
2015 av_log(s
->avctx
, AV_LOG_ERROR
, "error in unpack_modes\n");
2018 if (unpack_vectors(s
, &gb
)){
2019 av_log(s
->avctx
, AV_LOG_ERROR
, "error in unpack_vectors\n");
2022 if (unpack_block_qpis(s
, &gb
)){
2023 av_log(s
->avctx
, AV_LOG_ERROR
, "error in unpack_block_qpis\n");
2026 if (unpack_dct_coeffs(s
, &gb
)){
2027 av_log(s
->avctx
, AV_LOG_ERROR
, "error in unpack_dct_coeffs\n");
2031 for (i
= 0; i
< 3; i
++) {
2032 int height
= s
->height
>> (i
&& s
->chroma_y_shift
);
2033 if (s
->flipped_image
)
2034 s
->data_offset
[i
] = 0;
2036 s
->data_offset
[i
] = (height
-1) * s
->current_frame
.linesize
[i
];
2039 s
->last_slice_end
= 0;
2040 for (i
= 0; i
< s
->c_superblock_height
; i
++)
2043 // filter the last row
2044 for (i
= 0; i
< 3; i
++) {
2045 int row
= (s
->height
>> (3+(i
&& s
->chroma_y_shift
))) - 1;
2046 apply_loop_filter(s
, i
, row
, row
+1);
2048 vp3_draw_horiz_band(s
, s
->avctx
->height
);
2051 *(AVFrame
*)data
= s
->current_frame
;
2053 if (!HAVE_THREADS
|| !(s
->avctx
->active_thread_type
&FF_THREAD_FRAME
))
2054 update_frames(avctx
);
2059 ff_thread_report_progress(&s
->current_frame
, INT_MAX
, 0);
2061 if (!HAVE_THREADS
|| !(s
->avctx
->active_thread_type
&FF_THREAD_FRAME
))
2062 avctx
->release_buffer(avctx
, &s
->current_frame
);
2067 static int read_huffman_tree(AVCodecContext
*avctx
, GetBitContext
*gb
)
2069 Vp3DecodeContext
*s
= avctx
->priv_data
;
2071 if (get_bits1(gb
)) {
2073 if (s
->entries
>= 32) { /* overflow */
2074 av_log(avctx
, AV_LOG_ERROR
, "huffman tree overflow\n");
2077 token
= get_bits(gb
, 5);
2078 av_dlog(avctx
, "hti %d hbits %x token %d entry : %d size %d\n",
2079 s
->hti
, s
->hbits
, token
, s
->entries
, s
->huff_code_size
);
2080 s
->huffman_table
[s
->hti
][token
][0] = s
->hbits
;
2081 s
->huffman_table
[s
->hti
][token
][1] = s
->huff_code_size
;
2085 if (s
->huff_code_size
>= 32) {/* overflow */
2086 av_log(avctx
, AV_LOG_ERROR
, "huffman tree overflow\n");
2089 s
->huff_code_size
++;
2091 if (read_huffman_tree(avctx
, gb
))
2094 if (read_huffman_tree(avctx
, gb
))
2097 s
->huff_code_size
--;
2102 static int vp3_init_thread_copy(AVCodecContext
*avctx
)
2104 Vp3DecodeContext
*s
= avctx
->priv_data
;
2106 s
->superblock_coding
= NULL
;
2107 s
->all_fragments
= NULL
;
2108 s
->coded_fragment_list
[0] = NULL
;
2109 s
->dct_tokens_base
= NULL
;
2110 s
->superblock_fragments
= NULL
;
2111 s
->macroblock_coding
= NULL
;
2112 s
->motion_val
[0] = NULL
;
2113 s
->motion_val
[1] = NULL
;
2114 s
->edge_emu_buffer
= NULL
;
2119 #if CONFIG_THEORA_DECODER
2120 static const enum AVPixelFormat theora_pix_fmts
[4] = {
2121 AV_PIX_FMT_YUV420P
, AV_PIX_FMT_NONE
, AV_PIX_FMT_YUV422P
, AV_PIX_FMT_YUV444P
2124 static int theora_decode_header(AVCodecContext
*avctx
, GetBitContext
*gb
)
2126 Vp3DecodeContext
*s
= avctx
->priv_data
;
2127 int visible_width
, visible_height
, colorspace
;
2128 int offset_x
= 0, offset_y
= 0;
2129 AVRational fps
, aspect
;
2131 s
->theora
= get_bits_long(gb
, 24);
2132 av_log(avctx
, AV_LOG_DEBUG
, "Theora bitstream version %X\n", s
->theora
);
2134 /* 3.2.0 aka alpha3 has the same frame orientation as original vp3 */
2135 /* but previous versions have the image flipped relative to vp3 */
2136 if (s
->theora
< 0x030200)
2138 s
->flipped_image
= 1;
2139 av_log(avctx
, AV_LOG_DEBUG
, "Old (<alpha3) Theora bitstream, flipped image\n");
2142 visible_width
= s
->width
= get_bits(gb
, 16) << 4;
2143 visible_height
= s
->height
= get_bits(gb
, 16) << 4;
2145 if(av_image_check_size(s
->width
, s
->height
, 0, avctx
)){
2146 av_log(avctx
, AV_LOG_ERROR
, "Invalid dimensions (%dx%d)\n", s
->width
, s
->height
);
2147 s
->width
= s
->height
= 0;
2151 if (s
->theora
>= 0x030200) {
2152 visible_width
= get_bits_long(gb
, 24);
2153 visible_height
= get_bits_long(gb
, 24);
2155 offset_x
= get_bits(gb
, 8); /* offset x */
2156 offset_y
= get_bits(gb
, 8); /* offset y, from bottom */
2159 fps
.num
= get_bits_long(gb
, 32);
2160 fps
.den
= get_bits_long(gb
, 32);
2161 if (fps
.num
&& fps
.den
) {
2162 av_reduce(&avctx
->time_base
.num
, &avctx
->time_base
.den
,
2163 fps
.den
, fps
.num
, 1<<30);
2166 aspect
.num
= get_bits_long(gb
, 24);
2167 aspect
.den
= get_bits_long(gb
, 24);
2168 if (aspect
.num
&& aspect
.den
) {
2169 av_reduce(&avctx
->sample_aspect_ratio
.num
,
2170 &avctx
->sample_aspect_ratio
.den
,
2171 aspect
.num
, aspect
.den
, 1<<30);
2174 if (s
->theora
< 0x030200)
2175 skip_bits(gb
, 5); /* keyframe frequency force */
2176 colorspace
= get_bits(gb
, 8);
2177 skip_bits(gb
, 24); /* bitrate */
2179 skip_bits(gb
, 6); /* quality hint */
2181 if (s
->theora
>= 0x030200)
2183 skip_bits(gb
, 5); /* keyframe frequency force */
2184 avctx
->pix_fmt
= theora_pix_fmts
[get_bits(gb
, 2)];
2185 skip_bits(gb
, 3); /* reserved */
2188 // align_get_bits(gb);
2190 if ( visible_width
<= s
->width
&& visible_width
> s
->width
-16
2191 && visible_height
<= s
->height
&& visible_height
> s
->height
-16
2192 && !offset_x
&& (offset_y
== s
->height
- visible_height
))
2193 avcodec_set_dimensions(avctx
, visible_width
, visible_height
);
2195 avcodec_set_dimensions(avctx
, s
->width
, s
->height
);
2197 if (colorspace
== 1) {
2198 avctx
->color_primaries
= AVCOL_PRI_BT470M
;
2199 } else if (colorspace
== 2) {
2200 avctx
->color_primaries
= AVCOL_PRI_BT470BG
;
2202 if (colorspace
== 1 || colorspace
== 2) {
2203 avctx
->colorspace
= AVCOL_SPC_BT470BG
;
2204 avctx
->color_trc
= AVCOL_TRC_BT709
;
2210 static int theora_decode_tables(AVCodecContext
*avctx
, GetBitContext
*gb
)
2212 Vp3DecodeContext
*s
= avctx
->priv_data
;
2213 int i
, n
, matrices
, inter
, plane
;
2215 if (s
->theora
>= 0x030200) {
2216 n
= get_bits(gb
, 3);
2217 /* loop filter limit values table */
2219 for (i
= 0; i
< 64; i
++)
2220 s
->filter_limit_values
[i
] = get_bits(gb
, n
);
2223 if (s
->theora
>= 0x030200)
2224 n
= get_bits(gb
, 4) + 1;
2227 /* quality threshold table */
2228 for (i
= 0; i
< 64; i
++)
2229 s
->coded_ac_scale_factor
[i
] = get_bits(gb
, n
);
2231 if (s
->theora
>= 0x030200)
2232 n
= get_bits(gb
, 4) + 1;
2235 /* dc scale factor table */
2236 for (i
= 0; i
< 64; i
++)
2237 s
->coded_dc_scale_factor
[i
] = get_bits(gb
, n
);
2239 if (s
->theora
>= 0x030200)
2240 matrices
= get_bits(gb
, 9) + 1;
2245 av_log(avctx
, AV_LOG_ERROR
, "invalid number of base matrixes\n");
2249 for(n
=0; n
<matrices
; n
++){
2250 for (i
= 0; i
< 64; i
++)
2251 s
->base_matrix
[n
][i
]= get_bits(gb
, 8);
2254 for (inter
= 0; inter
<= 1; inter
++) {
2255 for (plane
= 0; plane
<= 2; plane
++) {
2257 if (inter
|| plane
> 0)
2258 newqr
= get_bits1(gb
);
2261 if(inter
&& get_bits1(gb
)){
2265 qtj
= (3*inter
+ plane
- 1) / 3;
2266 plj
= (plane
+ 2) % 3;
2268 s
->qr_count
[inter
][plane
]= s
->qr_count
[qtj
][plj
];
2269 memcpy(s
->qr_size
[inter
][plane
], s
->qr_size
[qtj
][plj
], sizeof(s
->qr_size
[0][0]));
2270 memcpy(s
->qr_base
[inter
][plane
], s
->qr_base
[qtj
][plj
], sizeof(s
->qr_base
[0][0]));
2276 i
= get_bits(gb
, av_log2(matrices
-1)+1);
2278 av_log(avctx
, AV_LOG_ERROR
, "invalid base matrix index\n");
2281 s
->qr_base
[inter
][plane
][qri
]= i
;
2284 i
= get_bits(gb
, av_log2(63-qi
)+1) + 1;
2285 s
->qr_size
[inter
][plane
][qri
++]= i
;
2290 av_log(avctx
, AV_LOG_ERROR
, "invalid qi %d > 63\n", qi
);
2293 s
->qr_count
[inter
][plane
]= qri
;
2298 /* Huffman tables */
2299 for (s
->hti
= 0; s
->hti
< 80; s
->hti
++) {
2301 s
->huff_code_size
= 1;
2302 if (!get_bits1(gb
)) {
2304 if(read_huffman_tree(avctx
, gb
))
2307 if(read_huffman_tree(avctx
, gb
))
2312 s
->theora_tables
= 1;
2317 static av_cold
int theora_decode_init(AVCodecContext
*avctx
)
2319 Vp3DecodeContext
*s
= avctx
->priv_data
;
2322 uint8_t *header_start
[3];
2328 if (!avctx
->extradata_size
)
2330 av_log(avctx
, AV_LOG_ERROR
, "Missing extradata!\n");
2334 if (avpriv_split_xiph_headers(avctx
->extradata
, avctx
->extradata_size
,
2335 42, header_start
, header_len
) < 0) {
2336 av_log(avctx
, AV_LOG_ERROR
, "Corrupt extradata\n");
2341 if (header_len
[i
] <= 0)
2343 init_get_bits(&gb
, header_start
[i
], header_len
[i
] * 8);
2345 ptype
= get_bits(&gb
, 8);
2347 if (!(ptype
& 0x80))
2349 av_log(avctx
, AV_LOG_ERROR
, "Invalid extradata!\n");
2353 // FIXME: Check for this as well.
2354 skip_bits_long(&gb
, 6*8); /* "theora" */
2359 theora_decode_header(avctx
, &gb
);
2362 // FIXME: is this needed? it breaks sometimes
2363 // theora_decode_comments(avctx, gb);
2366 if (theora_decode_tables(avctx
, &gb
))
2370 av_log(avctx
, AV_LOG_ERROR
, "Unknown Theora config packet: %d\n", ptype
&~0x80);
2373 if(ptype
!= 0x81 && 8*header_len
[i
] != get_bits_count(&gb
))
2374 av_log(avctx
, AV_LOG_WARNING
, "%d bits left in packet %X\n", 8*header_len
[i
] - get_bits_count(&gb
), ptype
);
2375 if (s
->theora
< 0x030200)
2379 return vp3_decode_init(avctx
);
2382 AVCodec ff_theora_decoder
= {
2384 .type
= AVMEDIA_TYPE_VIDEO
,
2385 .id
= AV_CODEC_ID_THEORA
,
2386 .priv_data_size
= sizeof(Vp3DecodeContext
),
2387 .init
= theora_decode_init
,
2388 .close
= vp3_decode_end
,
2389 .decode
= vp3_decode_frame
,
2390 .capabilities
= CODEC_CAP_DR1
| CODEC_CAP_DRAW_HORIZ_BAND
|
2391 CODEC_CAP_FRAME_THREADS
,
2392 .flush
= vp3_decode_flush
,
2393 .long_name
= NULL_IF_CONFIG_SMALL("Theora"),
2394 .init_thread_copy
= ONLY_IF_THREADS_ENABLED(vp3_init_thread_copy
),
2395 .update_thread_context
= ONLY_IF_THREADS_ENABLED(vp3_update_thread_context
)
2399 AVCodec ff_vp3_decoder
= {
2401 .type
= AVMEDIA_TYPE_VIDEO
,
2402 .id
= AV_CODEC_ID_VP3
,
2403 .priv_data_size
= sizeof(Vp3DecodeContext
),
2404 .init
= vp3_decode_init
,
2405 .close
= vp3_decode_end
,
2406 .decode
= vp3_decode_frame
,
2407 .capabilities
= CODEC_CAP_DR1
| CODEC_CAP_DRAW_HORIZ_BAND
|
2408 CODEC_CAP_FRAME_THREADS
,
2409 .flush
= vp3_decode_flush
,
2410 .long_name
= NULL_IF_CONFIG_SMALL("On2 VP3"),
2411 .init_thread_copy
= ONLY_IF_THREADS_ENABLED(vp3_init_thread_copy
),
2412 .update_thread_context
= ONLY_IF_THREADS_ENABLED(vp3_update_thread_context
),