Mercurial > libavcodec.hg
annotate vp3.c @ 12197:fbf4d5b1b664 libavcodec
Remove FF_MM_SSE2/3 flags for CPUs where this is generally not faster than
regular MMX code. Examples of this are the Core1 CPU. Instead, set a new flag,
FF_MM_SSE2/3SLOW, which can be checked for particular SSE2/3 functions that
have been checked specifically on such CPUs and are actually faster than
their MMX counterparts.
In addition, use this flag to enable particular VP8 and LPC SSE2 functions
that are faster than their MMX counterparts.
Based on a patch by Loren Merritt <lorenm AT u washington edu>.
author | rbultje |
---|---|
date | Mon, 19 Jul 2010 22:38:23 +0000 |
parents | fdafbcef52f5 |
children | 914f484bb476 |
rev | line source |
---|---|
1224 | 1 /* |
1867
7f7aa6ac3723
cut over to using new VP3 DSP functions and remove the old ones; bring
melanson
parents:
1864
diff
changeset
|
2 * Copyright (C) 2003-2004 the ffmpeg project |
1224 | 3 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3940
diff
changeset
|
4 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3940
diff
changeset
|
5 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3940
diff
changeset
|
6 * FFmpeg is free software; you can redistribute it and/or |
1224 | 7 * modify it under the terms of the GNU Lesser General Public |
8 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3940
diff
changeset
|
9 * version 2.1 of the License, or (at your option) any later version. |
1224 | 10 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3940
diff
changeset
|
11 * FFmpeg is distributed in the hope that it will be useful, |
1224 | 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
14 * Lesser General Public License for more details. | |
15 * | |
16 * You should have received a copy of the GNU Lesser General Public | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3940
diff
changeset
|
17 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
2979
diff
changeset
|
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
1224 | 19 */ |
20 | |
21 /** | |
11644
7dd2a45249a9
Remove explicit filename from Doxygen @file commands.
diego
parents:
11640
diff
changeset
|
22 * @file |
1224 | 23 * On2 VP3 Video Decoder |
2702
5a4e5225cbb6
use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents:
2699
diff
changeset
|
24 * |
5a4e5225cbb6
use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents:
2699
diff
changeset
|
25 * VP3 Video Decoder by Mike Melanson (mike at multimedia.cx) |
5a4e5225cbb6
use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents:
2699
diff
changeset
|
26 * For more information about the VP3 coding process, visit: |
6747
b9a57d71425d
Add complete multimedia Wiki URL, patch by Sisir Koppaka.
diego
parents:
6710
diff
changeset
|
27 * http://wiki.multimedia.cx/index.php?title=On2_VP3 |
2702
5a4e5225cbb6
use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents:
2699
diff
changeset
|
28 * |
5a4e5225cbb6
use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents:
2699
diff
changeset
|
29 * Theora decoder by Alex Beregszaszi |
1224 | 30 */ |
31 | |
32 #include <stdio.h> | |
33 #include <stdlib.h> | |
34 #include <string.h> | |
35 | |
36 #include "avcodec.h" | |
37 #include "dsputil.h" | |
9428 | 38 #include "get_bits.h" |
1224 | 39 |
40 #include "vp3data.h" | |
4723
b62a3a46856c
use generic xiph header spliting func to split theora headers
aurel
parents:
4594
diff
changeset
|
41 #include "xiph.h" |
1224 | 42 |
43 #define FRAGMENT_PIXELS 8 | |
44 | |
10258 | 45 static av_cold int vp3_decode_end(AVCodecContext *avctx); |
46 | |
2714
b008c78467e6
use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents:
2712
diff
changeset
|
47 //FIXME split things out into their own arrays |
1224 | 48 typedef struct Vp3Fragment { |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
49 int16_t dc; |
2706 | 50 uint8_t coding_method; |
9731 | 51 uint8_t qpi; |
1224 | 52 } Vp3Fragment; |
53 | |
54 #define SB_NOT_CODED 0 | |
55 #define SB_PARTIALLY_CODED 1 | |
56 #define SB_FULLY_CODED 2 | |
57 | |
11226
386c361bf136
Make the special 4129 case for long-run bit strings a #define and explain it
conrad
parents:
11225
diff
changeset
|
58 // This is the maximum length of a single long bit run that can be encoded |
386c361bf136
Make the special 4129 case for long-run bit strings a #define and explain it
conrad
parents:
11225
diff
changeset
|
59 // for superblock coding or block qps. Theora special-cases this to read a |
386c361bf136
Make the special 4129 case for long-run bit strings a #define and explain it
conrad
parents:
11225
diff
changeset
|
60 // bit instead of flipping the current bit to allow for runs longer than 4129. |
386c361bf136
Make the special 4129 case for long-run bit strings a #define and explain it
conrad
parents:
11225
diff
changeset
|
61 #define MAXIMUM_LONG_BIT_RUN 4129 |
386c361bf136
Make the special 4129 case for long-run bit strings a #define and explain it
conrad
parents:
11225
diff
changeset
|
62 |
1224 | 63 #define MODE_INTER_NO_MV 0 |
64 #define MODE_INTRA 1 | |
65 #define MODE_INTER_PLUS_MV 2 | |
66 #define MODE_INTER_LAST_MV 3 | |
67 #define MODE_INTER_PRIOR_LAST 4 | |
68 #define MODE_USING_GOLDEN 5 | |
69 #define MODE_GOLDEN_MV 6 | |
70 #define MODE_INTER_FOURMV 7 | |
71 #define CODING_MODE_COUNT 8 | |
72 | |
73 /* special internal mode */ | |
74 #define MODE_COPY 8 | |
75 | |
76 /* There are 6 preset schemes, plus a free-form scheme */ | |
7139
03fe3194eff7
make ModeAlphabet read-only and use a custom mode alphabet
stefang
parents:
7040
diff
changeset
|
77 static const int ModeAlphabet[6][CODING_MODE_COUNT] = |
1224 | 78 { |
79 /* scheme 1: Last motion vector dominates */ | |
2967 | 80 { MODE_INTER_LAST_MV, MODE_INTER_PRIOR_LAST, |
1224 | 81 MODE_INTER_PLUS_MV, MODE_INTER_NO_MV, |
2967 | 82 MODE_INTRA, MODE_USING_GOLDEN, |
1224 | 83 MODE_GOLDEN_MV, MODE_INTER_FOURMV }, |
84 | |
85 /* scheme 2 */ | |
2967 | 86 { MODE_INTER_LAST_MV, MODE_INTER_PRIOR_LAST, |
1224 | 87 MODE_INTER_NO_MV, MODE_INTER_PLUS_MV, |
2967 | 88 MODE_INTRA, MODE_USING_GOLDEN, |
1224 | 89 MODE_GOLDEN_MV, MODE_INTER_FOURMV }, |
90 | |
91 /* scheme 3 */ | |
2967 | 92 { MODE_INTER_LAST_MV, MODE_INTER_PLUS_MV, |
1224 | 93 MODE_INTER_PRIOR_LAST, MODE_INTER_NO_MV, |
2967 | 94 MODE_INTRA, MODE_USING_GOLDEN, |
1224 | 95 MODE_GOLDEN_MV, MODE_INTER_FOURMV }, |
96 | |
97 /* scheme 4 */ | |
2967 | 98 { MODE_INTER_LAST_MV, MODE_INTER_PLUS_MV, |
1224 | 99 MODE_INTER_NO_MV, MODE_INTER_PRIOR_LAST, |
2967 | 100 MODE_INTRA, MODE_USING_GOLDEN, |
1224 | 101 MODE_GOLDEN_MV, MODE_INTER_FOURMV }, |
102 | |
103 /* scheme 5: No motion vector dominates */ | |
2967 | 104 { MODE_INTER_NO_MV, MODE_INTER_LAST_MV, |
1224 | 105 MODE_INTER_PRIOR_LAST, MODE_INTER_PLUS_MV, |
2967 | 106 MODE_INTRA, MODE_USING_GOLDEN, |
1224 | 107 MODE_GOLDEN_MV, MODE_INTER_FOURMV }, |
108 | |
109 /* scheme 6 */ | |
2967 | 110 { MODE_INTER_NO_MV, MODE_USING_GOLDEN, |
1224 | 111 MODE_INTER_LAST_MV, MODE_INTER_PRIOR_LAST, |
2967 | 112 MODE_INTER_PLUS_MV, MODE_INTRA, |
1224 | 113 MODE_GOLDEN_MV, MODE_INTER_FOURMV }, |
114 | |
115 }; | |
116 | |
11352 | 117 static const uint8_t hilbert_offset[16][2] = { |
118 {0,0}, {1,0}, {1,1}, {0,1}, | |
119 {0,2}, {0,3}, {1,3}, {1,2}, | |
120 {2,2}, {2,3}, {3,3}, {3,2}, | |
121 {3,1}, {2,1}, {2,0}, {3,0} | |
122 }; | |
123 | |
1224 | 124 #define MIN_DEQUANT_VAL 2 |
125 | |
126 typedef struct Vp3DecodeContext { | |
127 AVCodecContext *avctx; | |
1516
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
128 int theora, theora_tables; |
1664 | 129 int version; |
1224 | 130 int width, height; |
11475
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
131 int chroma_x_shift, chroma_y_shift; |
1224 | 132 AVFrame golden_frame; |
133 AVFrame last_frame; | |
134 AVFrame current_frame; | |
135 int keyframe; | |
136 DSPContext dsp; | |
1626
f74ae637ffa9
finally working with old theora bitstream (flipped image), the only sample I have is decoded successfully (theora.ogg)
alex
parents:
1598
diff
changeset
|
137 int flipped_image; |
11132
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
138 int last_slice_end; |
11782
a617365c7c6f
vp3: Skip the loop filter when strength is 0 or when requested
conrad
parents:
11757
diff
changeset
|
139 int skip_loop_filter; |
1224 | 140 |
9731 | 141 int qps[3]; |
142 int nqps; | |
143 int last_qps[3]; | |
1224 | 144 |
145 int superblock_count; | |
1238
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
146 int y_superblock_width; |
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
147 int y_superblock_height; |
11351
0f55f380a1b2
Explictly separate decoding whether fragments are coded by plane
conrad
parents:
11314
diff
changeset
|
148 int y_superblock_count; |
1238
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
149 int c_superblock_width; |
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
150 int c_superblock_height; |
11351
0f55f380a1b2
Explictly separate decoding whether fragments are coded by plane
conrad
parents:
11314
diff
changeset
|
151 int c_superblock_count; |
1224 | 152 int u_superblock_start; |
153 int v_superblock_start; | |
154 unsigned char *superblock_coding; | |
155 | |
156 int macroblock_count; | |
157 int macroblock_width; | |
158 int macroblock_height; | |
159 | |
160 int fragment_count; | |
11473 | 161 int fragment_width[2]; |
162 int fragment_height[2]; | |
1224 | 163 |
164 Vp3Fragment *all_fragments; | |
3498 | 165 int fragment_start[3]; |
11133 | 166 int data_offset[3]; |
2967 | 167 |
11477 | 168 int8_t (*motion_val[2])[2]; |
169 | |
2694 | 170 ScanTable scantable; |
2967 | 171 |
1516
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
172 /* tables */ |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
173 uint16_t coded_dc_scale_factor[64]; |
1867
7f7aa6ac3723
cut over to using new VP3 DSP functions and remove the old ones; bring
melanson
parents:
1864
diff
changeset
|
174 uint32_t coded_ac_scale_factor[64]; |
3489
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
175 uint8_t base_matrix[384][64]; |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
176 uint8_t qr_count[2][3]; |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
177 uint8_t qr_size [2][3][64]; |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
178 uint16_t qr_base[2][3][64]; |
1224 | 179 |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
180 /** |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
181 * This is a list of all tokens in bitstream order. Reordering takes place |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
182 * by pulling from each level during IDCT. As a consequence, IDCT must be |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
183 * in Hilbert order, making the minimum slice height 64 for 4:2:0 and 32 |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
184 * otherwise. The 32 different tokens with up to 12 bits of extradata are |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
185 * collapsed into 3 types, packed as follows: |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
186 * (from the low to high bits) |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
187 * |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
188 * 2 bits: type (0,1,2) |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
189 * 0: EOB run, 14 bits for run length (12 needed) |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
190 * 1: zero run, 7 bits for run length |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
191 * 7 bits for the next coefficient (3 needed) |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
192 * 2: coefficient, 14 bits (11 needed) |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
193 * |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
194 * Coefficients are signed, so are packed in the highest bits for automatic |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
195 * sign extension. |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
196 */ |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
197 int16_t *dct_tokens[3][64]; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
198 int16_t *dct_tokens_base; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
199 #define TOKEN_EOB(eob_run) ((eob_run) << 2) |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
200 #define TOKEN_ZERO_RUN(coeff, zero_run) (((coeff) << 9) + ((zero_run) << 2) + 1) |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
201 #define TOKEN_COEFF(coeff) (((coeff) << 2) + 2) |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
202 |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
203 /** |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
204 * number of blocks that contain DCT coefficients at the given level or higher |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
205 */ |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
206 int num_coded_frags[3][64]; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
207 int total_num_coded_frags; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
208 |
6903 | 209 /* this is a list of indexes into the all_fragments array indicating |
1224 | 210 * which of the fragments are coded */ |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
211 int *coded_fragment_list[3]; |
10619
d930f99edbf9
Use a list to track which fragments coded in this frame still have
melanson
parents:
10258
diff
changeset
|
212 |
1224 | 213 VLC dc_vlc[16]; |
214 VLC ac_vlc_1[16]; | |
215 VLC ac_vlc_2[16]; | |
216 VLC ac_vlc_3[16]; | |
217 VLC ac_vlc_4[16]; | |
218 | |
2702
5a4e5225cbb6
use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents:
2699
diff
changeset
|
219 VLC superblock_run_length_vlc; |
5a4e5225cbb6
use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents:
2699
diff
changeset
|
220 VLC fragment_run_length_vlc; |
5a4e5225cbb6
use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents:
2699
diff
changeset
|
221 VLC mode_code_vlc; |
5a4e5225cbb6
use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents:
2699
diff
changeset
|
222 VLC motion_vector_vlc; |
5a4e5225cbb6
use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents:
2699
diff
changeset
|
223 |
1972 | 224 /* these arrays need to be on 16-byte boundaries since SSE2 operations |
225 * index into them */ | |
11369 | 226 DECLARE_ALIGNED(16, int16_t, qmat)[3][2][3][64]; //<qmat[qpi][is_inter][plane] |
1224 | 227 |
228 /* This table contains superblock_count * 16 entries. Each set of 16 | |
6903 | 229 * numbers corresponds to the fragment indexes 0..15 of the superblock. |
1224 | 230 * An entry will be -1 to indicate that no entry corresponds to that |
231 * index. */ | |
232 int *superblock_fragments; | |
233 | |
2967 | 234 /* This is an array that indicates how a particular macroblock |
1244
a02df1ba6c7f
fix image buffer leak on keyframes, add more error condition checks
tmmm
parents:
1240
diff
changeset
|
235 * is coded. */ |
1240
c95ff60bc1a1
fix motion vector decoding bug and reinstate interframes
tmmm
parents:
1239
diff
changeset
|
236 unsigned char *macroblock_coding; |
1224 | 237 |
1406 | 238 uint8_t edge_emu_buffer[9*2048]; //FIXME dynamic alloc |
3776 | 239 int8_t qscale_table[2048]; //FIXME dynamic alloc (width+15)/16 |
2718
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
240 |
2723
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
241 /* Huffman decode */ |
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
242 int hti; |
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
243 unsigned int hbits; |
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
244 int entries; |
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
245 int huff_code_size; |
11646
a69e24b73f3c
theora: coeff huffman codes are allowed to be up to 32 bits long (for 32 tokens)
conrad
parents:
11644
diff
changeset
|
246 uint32_t huffman_table[80][32][2]; |
2723
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
247 |
7966
14a49e087126
filter_limit_values only needs 7 bits, make its tables smaller
conrad
parents:
7961
diff
changeset
|
248 uint8_t filter_limit_values[64]; |
11369 | 249 DECLARE_ALIGNED(8, int, bounding_values_array)[256+2]; |
1224 | 250 } Vp3DecodeContext; |
251 | |
252 /************************************************************************ | |
253 * VP3 specific functions | |
254 ************************************************************************/ | |
255 | |
256 /* | |
257 * This function sets up all of the various blocks mappings: | |
258 * superblocks <-> fragments, macroblocks <-> fragments, | |
259 * superblocks <-> macroblocks | |
1238
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
260 * |
12024 | 261 * @return 0 is successful; returns 1 if *anything* went wrong. |
1224 | 262 */ |
2967 | 263 static int init_block_mapping(Vp3DecodeContext *s) |
1224 | 264 { |
11469 | 265 int sb_x, sb_y, plane; |
266 int x, y, i, j = 0; | |
1224 | 267 |
11469 | 268 for (plane = 0; plane < 3; plane++) { |
269 int sb_width = plane ? s->c_superblock_width : s->y_superblock_width; | |
270 int sb_height = plane ? s->c_superblock_height : s->y_superblock_height; | |
11473 | 271 int frag_width = s->fragment_width[!!plane]; |
272 int frag_height = s->fragment_height[!!plane]; | |
1224 | 273 |
11469 | 274 for (sb_y = 0; sb_y < sb_height; sb_y++) |
275 for (sb_x = 0; sb_x < sb_width; sb_x++) | |
276 for (i = 0; i < 16; i++) { | |
277 x = 4*sb_x + hilbert_offset[i][0]; | |
278 y = 4*sb_y + hilbert_offset[i][1]; | |
1224 | 279 |
11469 | 280 if (x < frag_width && y < frag_height) |
281 s->superblock_fragments[j++] = s->fragment_start[plane] + y*frag_width + x; | |
282 else | |
283 s->superblock_fragments[j++] = -1; | |
284 } | |
1224 | 285 } |
286 | |
1238
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
287 return 0; /* successful path out */ |
1224 | 288 } |
289 | |
290 /* | |
2723
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
291 * This function sets up the dequantization tables used for a particular |
1224 | 292 * frame. |
293 */ | |
9731 | 294 static void init_dequantizer(Vp3DecodeContext *s, int qpi) |
1224 | 295 { |
9731 | 296 int ac_scale_factor = s->coded_ac_scale_factor[s->qps[qpi]]; |
297 int dc_scale_factor = s->coded_dc_scale_factor[s->qps[qpi]]; | |
3920
3a151ccc6ed7
Remove unused variables and the corresponding warnings along with them.
diego
parents:
3776
diff
changeset
|
298 int i, plane, inter, qri, bmi, bmj, qistart; |
1224 | 299 |
3489
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
300 for(inter=0; inter<2; inter++){ |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
301 for(plane=0; plane<3; plane++){ |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
302 int sum=0; |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
303 for(qri=0; qri<s->qr_count[inter][plane]; qri++){ |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
304 sum+= s->qr_size[inter][plane][qri]; |
9731 | 305 if(s->qps[qpi] <= sum) |
3489
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
306 break; |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
307 } |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
308 qistart= sum - s->qr_size[inter][plane][qri]; |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
309 bmi= s->qr_base[inter][plane][qri ]; |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
310 bmj= s->qr_base[inter][plane][qri+1]; |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
311 for(i=0; i<64; i++){ |
9731 | 312 int coeff= ( 2*(sum -s->qps[qpi])*s->base_matrix[bmi][i] |
313 - 2*(qistart-s->qps[qpi])*s->base_matrix[bmj][i] | |
3489
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
314 + s->qr_size[inter][plane][qri]) |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
315 / (2*s->qr_size[inter][plane][qri]); |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
316 |
3491 | 317 int qmin= 8<<(inter + !i); |
3489
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
318 int qscale= i ? ac_scale_factor : dc_scale_factor; |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
319 |
9731 | 320 s->qmat[qpi][inter][plane][s->dsp.idct_permutation[i]]= av_clip((qscale * coeff)/100 * 4, qmin, 4096); |
3489
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
321 } |
9731 | 322 // all DC coefficients use the same quant so as not to interfere with DC prediction |
323 s->qmat[qpi][inter][plane][0] = s->qmat[0][inter][plane][0]; | |
3489
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
324 } |
1224 | 325 } |
2967 | 326 |
9731 | 327 memset(s->qscale_table, (FFMAX(s->qmat[0][0][0][1], s->qmat[0][0][1][1])+8)/16, 512); //FIXME finetune |
1224 | 328 } |
329 | |
330 /* | |
2723
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
331 * This function initializes the loop filter boundary limits if the frame's |
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
332 * quality index is different from the previous frame's. |
9921
f42402d1778b
Extend init_loop_filter to work for filter limit values up to 127 instead
reimar
parents:
9811
diff
changeset
|
333 * |
f42402d1778b
Extend init_loop_filter to work for filter limit values up to 127 instead
reimar
parents:
9811
diff
changeset
|
334 * The filter_limit_values may not be larger than 127. |
2723
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
335 */ |
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
336 static void init_loop_filter(Vp3DecodeContext *s) |
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
337 { |
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
338 int *bounding_values= s->bounding_values_array+127; |
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
339 int filter_limit; |
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
340 int x; |
9921
f42402d1778b
Extend init_loop_filter to work for filter limit values up to 127 instead
reimar
parents:
9811
diff
changeset
|
341 int value; |
2723
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
342 |
9731 | 343 filter_limit = s->filter_limit_values[s->qps[0]]; |
2723
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
344 |
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
345 /* set up the bounding values */ |
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
346 memset(s->bounding_values_array, 0, 256 * sizeof(int)); |
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
347 for (x = 0; x < filter_limit; x++) { |
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
348 bounding_values[-x] = -x; |
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
349 bounding_values[x] = x; |
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
350 } |
9921
f42402d1778b
Extend init_loop_filter to work for filter limit values up to 127 instead
reimar
parents:
9811
diff
changeset
|
351 for (x = value = filter_limit; x < 128 && value; x++, value--) { |
f42402d1778b
Extend init_loop_filter to work for filter limit values up to 127 instead
reimar
parents:
9811
diff
changeset
|
352 bounding_values[ x] = value; |
f42402d1778b
Extend init_loop_filter to work for filter limit values up to 127 instead
reimar
parents:
9811
diff
changeset
|
353 bounding_values[-x] = -value; |
f42402d1778b
Extend init_loop_filter to work for filter limit values up to 127 instead
reimar
parents:
9811
diff
changeset
|
354 } |
f42402d1778b
Extend init_loop_filter to work for filter limit values up to 127 instead
reimar
parents:
9811
diff
changeset
|
355 if (value) |
f42402d1778b
Extend init_loop_filter to work for filter limit values up to 127 instead
reimar
parents:
9811
diff
changeset
|
356 bounding_values[128] = value; |
8032 | 357 bounding_values[129] = bounding_values[130] = filter_limit * 0x02020202; |
2723
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
358 } |
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
359 |
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
360 /* |
2967 | 361 * This function unpacks all of the superblock/macroblock/fragment coding |
1224 | 362 * information from the bitstream. |
363 */ | |
1238
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
364 static int unpack_superblocks(Vp3DecodeContext *s, GetBitContext *gb) |
1224 | 365 { |
11361 | 366 int superblock_starts[3] = { 0, s->u_superblock_start, s->v_superblock_start }; |
1224 | 367 int bit = 0; |
368 int current_superblock = 0; | |
369 int current_run = 0; | |
11227
9aea1eaefe16
Decode fully coded superblocks in the same manner as partial superblocks and qpi
conrad
parents:
11226
diff
changeset
|
370 int num_partial_superblocks = 0; |
1224 | 371 |
372 int i, j; | |
373 int current_fragment; | |
11351
0f55f380a1b2
Explictly separate decoding whether fragments are coded by plane
conrad
parents:
11314
diff
changeset
|
374 int plane; |
1224 | 375 |
376 if (s->keyframe) { | |
377 memset(s->superblock_coding, SB_FULLY_CODED, s->superblock_count); | |
378 | |
379 } else { | |
380 | |
381 /* unpack the list of partially-coded superblocks */ | |
11757
7dff9c1061e1
theora: Don't read an excess bit for maximum length long bit runs if the run
conrad
parents:
11646
diff
changeset
|
382 bit = get_bits1(gb) ^ 1; |
7dff9c1061e1
theora: Don't read an excess bit for maximum length long bit runs if the run
conrad
parents:
11646
diff
changeset
|
383 current_run = 0; |
7dff9c1061e1
theora: Don't read an excess bit for maximum length long bit runs if the run
conrad
parents:
11646
diff
changeset
|
384 |
11636 | 385 while (current_superblock < s->superblock_count && get_bits_left(gb) > 0) { |
11757
7dff9c1061e1
theora: Don't read an excess bit for maximum length long bit runs if the run
conrad
parents:
11646
diff
changeset
|
386 if (s->theora && current_run == MAXIMUM_LONG_BIT_RUN) |
7dff9c1061e1
theora: Don't read an excess bit for maximum length long bit runs if the run
conrad
parents:
11646
diff
changeset
|
387 bit = get_bits1(gb); |
7dff9c1061e1
theora: Don't read an excess bit for maximum length long bit runs if the run
conrad
parents:
11646
diff
changeset
|
388 else |
7dff9c1061e1
theora: Don't read an excess bit for maximum length long bit runs if the run
conrad
parents:
11646
diff
changeset
|
389 bit ^= 1; |
7dff9c1061e1
theora: Don't read an excess bit for maximum length long bit runs if the run
conrad
parents:
11646
diff
changeset
|
390 |
2967 | 391 current_run = get_vlc2(gb, |
11225
5811a86f55f1
Use memset to set the runs partially coded superblocks
conrad
parents:
11195
diff
changeset
|
392 s->superblock_run_length_vlc.table, 6, 2) + 1; |
5811a86f55f1
Use memset to set the runs partially coded superblocks
conrad
parents:
11195
diff
changeset
|
393 if (current_run == 34) |
2703
3817945001ce
replace get_superblock_run_length() with a VLC table
melanson
parents:
2702
diff
changeset
|
394 current_run += get_bits(gb, 12); |
1224 | 395 |
11225
5811a86f55f1
Use memset to set the runs partially coded superblocks
conrad
parents:
11195
diff
changeset
|
396 if (current_superblock + current_run > s->superblock_count) { |
5811a86f55f1
Use memset to set the runs partially coded superblocks
conrad
parents:
11195
diff
changeset
|
397 av_log(s->avctx, AV_LOG_ERROR, "Invalid partially coded superblock run length\n"); |
5811a86f55f1
Use memset to set the runs partially coded superblocks
conrad
parents:
11195
diff
changeset
|
398 return -1; |
5811a86f55f1
Use memset to set the runs partially coded superblocks
conrad
parents:
11195
diff
changeset
|
399 } |
5811a86f55f1
Use memset to set the runs partially coded superblocks
conrad
parents:
11195
diff
changeset
|
400 |
5811a86f55f1
Use memset to set the runs partially coded superblocks
conrad
parents:
11195
diff
changeset
|
401 memset(s->superblock_coding + current_superblock, bit, current_run); |
5811a86f55f1
Use memset to set the runs partially coded superblocks
conrad
parents:
11195
diff
changeset
|
402 |
5811a86f55f1
Use memset to set the runs partially coded superblocks
conrad
parents:
11195
diff
changeset
|
403 current_superblock += current_run; |
11227
9aea1eaefe16
Decode fully coded superblocks in the same manner as partial superblocks and qpi
conrad
parents:
11226
diff
changeset
|
404 if (bit) |
9aea1eaefe16
Decode fully coded superblocks in the same manner as partial superblocks and qpi
conrad
parents:
11226
diff
changeset
|
405 num_partial_superblocks += current_run; |
1224 | 406 } |
407 | |
408 /* unpack the list of fully coded superblocks if any of the blocks were | |
409 * not marked as partially coded in the previous step */ | |
11227
9aea1eaefe16
Decode fully coded superblocks in the same manner as partial superblocks and qpi
conrad
parents:
11226
diff
changeset
|
410 if (num_partial_superblocks < s->superblock_count) { |
9aea1eaefe16
Decode fully coded superblocks in the same manner as partial superblocks and qpi
conrad
parents:
11226
diff
changeset
|
411 int superblocks_decoded = 0; |
1224 | 412 |
413 current_superblock = 0; | |
11757
7dff9c1061e1
theora: Don't read an excess bit for maximum length long bit runs if the run
conrad
parents:
11646
diff
changeset
|
414 bit = get_bits1(gb) ^ 1; |
7dff9c1061e1
theora: Don't read an excess bit for maximum length long bit runs if the run
conrad
parents:
11646
diff
changeset
|
415 current_run = 0; |
7dff9c1061e1
theora: Don't read an excess bit for maximum length long bit runs if the run
conrad
parents:
11646
diff
changeset
|
416 |
11636 | 417 while (superblocks_decoded < s->superblock_count - num_partial_superblocks |
418 && get_bits_left(gb) > 0) { | |
11757
7dff9c1061e1
theora: Don't read an excess bit for maximum length long bit runs if the run
conrad
parents:
11646
diff
changeset
|
419 |
7dff9c1061e1
theora: Don't read an excess bit for maximum length long bit runs if the run
conrad
parents:
11646
diff
changeset
|
420 if (s->theora && current_run == MAXIMUM_LONG_BIT_RUN) |
7dff9c1061e1
theora: Don't read an excess bit for maximum length long bit runs if the run
conrad
parents:
11646
diff
changeset
|
421 bit = get_bits1(gb); |
7dff9c1061e1
theora: Don't read an excess bit for maximum length long bit runs if the run
conrad
parents:
11646
diff
changeset
|
422 else |
7dff9c1061e1
theora: Don't read an excess bit for maximum length long bit runs if the run
conrad
parents:
11646
diff
changeset
|
423 bit ^= 1; |
7dff9c1061e1
theora: Don't read an excess bit for maximum length long bit runs if the run
conrad
parents:
11646
diff
changeset
|
424 |
11227
9aea1eaefe16
Decode fully coded superblocks in the same manner as partial superblocks and qpi
conrad
parents:
11226
diff
changeset
|
425 current_run = get_vlc2(gb, |
9aea1eaefe16
Decode fully coded superblocks in the same manner as partial superblocks and qpi
conrad
parents:
11226
diff
changeset
|
426 s->superblock_run_length_vlc.table, 6, 2) + 1; |
9aea1eaefe16
Decode fully coded superblocks in the same manner as partial superblocks and qpi
conrad
parents:
11226
diff
changeset
|
427 if (current_run == 34) |
9aea1eaefe16
Decode fully coded superblocks in the same manner as partial superblocks and qpi
conrad
parents:
11226
diff
changeset
|
428 current_run += get_bits(gb, 12); |
9aea1eaefe16
Decode fully coded superblocks in the same manner as partial superblocks and qpi
conrad
parents:
11226
diff
changeset
|
429 |
9aea1eaefe16
Decode fully coded superblocks in the same manner as partial superblocks and qpi
conrad
parents:
11226
diff
changeset
|
430 for (j = 0; j < current_run; current_superblock++) { |
9aea1eaefe16
Decode fully coded superblocks in the same manner as partial superblocks and qpi
conrad
parents:
11226
diff
changeset
|
431 if (current_superblock >= s->superblock_count) { |
9aea1eaefe16
Decode fully coded superblocks in the same manner as partial superblocks and qpi
conrad
parents:
11226
diff
changeset
|
432 av_log(s->avctx, AV_LOG_ERROR, "Invalid fully coded superblock run length\n"); |
9aea1eaefe16
Decode fully coded superblocks in the same manner as partial superblocks and qpi
conrad
parents:
11226
diff
changeset
|
433 return -1; |
9aea1eaefe16
Decode fully coded superblocks in the same manner as partial superblocks and qpi
conrad
parents:
11226
diff
changeset
|
434 } |
1224 | 435 |
436 /* skip any superblocks already marked as partially coded */ | |
437 if (s->superblock_coding[current_superblock] == SB_NOT_CODED) { | |
11227
9aea1eaefe16
Decode fully coded superblocks in the same manner as partial superblocks and qpi
conrad
parents:
11226
diff
changeset
|
438 s->superblock_coding[current_superblock] = 2*bit; |
9aea1eaefe16
Decode fully coded superblocks in the same manner as partial superblocks and qpi
conrad
parents:
11226
diff
changeset
|
439 j++; |
9aea1eaefe16
Decode fully coded superblocks in the same manner as partial superblocks and qpi
conrad
parents:
11226
diff
changeset
|
440 } |
9aea1eaefe16
Decode fully coded superblocks in the same manner as partial superblocks and qpi
conrad
parents:
11226
diff
changeset
|
441 } |
9aea1eaefe16
Decode fully coded superblocks in the same manner as partial superblocks and qpi
conrad
parents:
11226
diff
changeset
|
442 superblocks_decoded += current_run; |
1224 | 443 } |
444 } | |
445 | |
446 /* if there were partial blocks, initialize bitstream for | |
447 * unpacking fragment codings */ | |
11227
9aea1eaefe16
Decode fully coded superblocks in the same manner as partial superblocks and qpi
conrad
parents:
11226
diff
changeset
|
448 if (num_partial_superblocks) { |
1224 | 449 |
450 current_run = 0; | |
5513 | 451 bit = get_bits1(gb); |
2967 | 452 /* toggle the bit because as soon as the first run length is |
1224 | 453 * fetched the bit will be toggled again */ |
454 bit ^= 1; | |
455 } | |
456 } | |
457 | |
458 /* figure out which fragments are coded; iterate through each | |
459 * superblock (all planes) */ | |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
460 s->total_num_coded_frags = 0; |
1240
c95ff60bc1a1
fix motion vector decoding bug and reinstate interframes
tmmm
parents:
1239
diff
changeset
|
461 memset(s->macroblock_coding, MODE_COPY, s->macroblock_count); |
11351
0f55f380a1b2
Explictly separate decoding whether fragments are coded by plane
conrad
parents:
11314
diff
changeset
|
462 |
0f55f380a1b2
Explictly separate decoding whether fragments are coded by plane
conrad
parents:
11314
diff
changeset
|
463 for (plane = 0; plane < 3; plane++) { |
11361 | 464 int sb_start = superblock_starts[plane]; |
11351
0f55f380a1b2
Explictly separate decoding whether fragments are coded by plane
conrad
parents:
11314
diff
changeset
|
465 int sb_end = sb_start + (plane ? s->c_superblock_count : s->y_superblock_count); |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
466 int num_coded_frags = 0; |
11351
0f55f380a1b2
Explictly separate decoding whether fragments are coded by plane
conrad
parents:
11314
diff
changeset
|
467 |
11636 | 468 for (i = sb_start; i < sb_end && get_bits_left(gb) > 0; i++) { |
1224 | 469 |
470 /* iterate through all 16 fragments in a superblock */ | |
471 for (j = 0; j < 16; j++) { | |
472 | |
473 /* if the fragment is in bounds, check its coding status */ | |
474 current_fragment = s->superblock_fragments[i * 16 + j]; | |
475 if (current_fragment != -1) { | |
11229 | 476 int coded = s->superblock_coding[i]; |
1224 | 477 |
11229 | 478 if (s->superblock_coding[i] == SB_PARTIALLY_CODED) { |
1224 | 479 |
480 /* fragment may or may not be coded; this is the case | |
481 * that cares about the fragment coding runs */ | |
2705 | 482 if (current_run-- == 0) { |
1224 | 483 bit ^= 1; |
2967 | 484 current_run = get_vlc2(gb, |
2705 | 485 s->fragment_run_length_vlc.table, 5, 2); |
1224 | 486 } |
11229 | 487 coded = bit; |
488 } | |
1224 | 489 |
11229 | 490 if (coded) { |
2967 | 491 /* default mode; actual mode will be decoded in |
1272
777d4145cdfb
fix subtle logic problem in block unpacker that leads to incorrect token
tmmm
parents:
1244
diff
changeset
|
492 * the next phase */ |
2967 | 493 s->all_fragments[current_fragment].coding_method = |
1224 | 494 MODE_INTER_NO_MV; |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
495 s->coded_fragment_list[plane][num_coded_frags++] = |
1224 | 496 current_fragment; |
497 } else { | |
498 /* not coded; copy this fragment from the prior frame */ | |
499 s->all_fragments[current_fragment].coding_method = | |
500 MODE_COPY; | |
501 } | |
502 } | |
503 } | |
504 } | |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
505 s->total_num_coded_frags += num_coded_frags; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
506 for (i = 0; i < 64; i++) |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
507 s->num_coded_frags[plane][i] = num_coded_frags; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
508 if (plane < 2) |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
509 s->coded_fragment_list[plane+1] = s->coded_fragment_list[plane] + num_coded_frags; |
10619
d930f99edbf9
Use a list to track which fragments coded in this frame still have
melanson
parents:
10258
diff
changeset
|
510 } |
1238
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
511 return 0; |
1224 | 512 } |
513 | |
514 /* | |
515 * This function unpacks all the coding mode data for individual macroblocks | |
516 * from the bitstream. | |
517 */ | |
1238
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
518 static int unpack_modes(Vp3DecodeContext *s, GetBitContext *gb) |
1224 | 519 { |
11149 | 520 int i, j, k, sb_x, sb_y; |
1224 | 521 int scheme; |
522 int current_macroblock; | |
523 int current_fragment; | |
524 int coding_mode; | |
7139
03fe3194eff7
make ModeAlphabet read-only and use a custom mode alphabet
stefang
parents:
7040
diff
changeset
|
525 int custom_mode_alphabet[CODING_MODE_COUNT]; |
11153 | 526 const int *alphabet; |
11475
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
527 Vp3Fragment *frag; |
1224 | 528 |
529 if (s->keyframe) { | |
530 for (i = 0; i < s->fragment_count; i++) | |
531 s->all_fragments[i].coding_method = MODE_INTRA; | |
532 | |
533 } else { | |
534 | |
535 /* fetch the mode coding scheme for this frame */ | |
536 scheme = get_bits(gb, 3); | |
537 | |
538 /* is it a custom coding scheme? */ | |
539 if (scheme == 0) { | |
540 for (i = 0; i < 8; i++) | |
8736
f973fff63599
VP3: Prevent stack corruption from an unset custom coding method.
alexc
parents:
8718
diff
changeset
|
541 custom_mode_alphabet[i] = MODE_INTER_NO_MV; |
f973fff63599
VP3: Prevent stack corruption from an unset custom coding method.
alexc
parents:
8718
diff
changeset
|
542 for (i = 0; i < 8; i++) |
7139
03fe3194eff7
make ModeAlphabet read-only and use a custom mode alphabet
stefang
parents:
7040
diff
changeset
|
543 custom_mode_alphabet[get_bits(gb, 3)] = i; |
11153 | 544 alphabet = custom_mode_alphabet; |
545 } else | |
546 alphabet = ModeAlphabet[scheme-1]; | |
1224 | 547 |
548 /* iterate through all of the macroblocks that contain 1 or more | |
549 * coded fragments */ | |
11149 | 550 for (sb_y = 0; sb_y < s->y_superblock_height; sb_y++) { |
551 for (sb_x = 0; sb_x < s->y_superblock_width; sb_x++) { | |
11636 | 552 if (get_bits_left(gb) <= 0) |
553 return -1; | |
1224 | 554 |
555 for (j = 0; j < 4; j++) { | |
11149 | 556 int mb_x = 2*sb_x + (j>>1); |
557 int mb_y = 2*sb_y + (((j>>1)+j)&1); | |
558 current_macroblock = mb_y * s->macroblock_width + mb_x; | |
559 | |
11151 | 560 if (mb_x >= s->macroblock_width || mb_y >= s->macroblock_height) |
1224 | 561 continue; |
562 | |
11150 | 563 #define BLOCK_X (2*mb_x + (k&1)) |
564 #define BLOCK_Y (2*mb_y + (k>>1)) | |
11151 | 565 /* coding modes are only stored if the macroblock has at least one |
566 * luma block coded, otherwise it must be INTER_NO_MV */ | |
567 for (k = 0; k < 4; k++) { | |
11473 | 568 current_fragment = BLOCK_Y*s->fragment_width[0] + BLOCK_X; |
11151 | 569 if (s->all_fragments[current_fragment].coding_method != MODE_COPY) |
570 break; | |
571 } | |
572 if (k == 4) { | |
573 s->macroblock_coding[current_macroblock] = MODE_INTER_NO_MV; | |
574 continue; | |
575 } | |
11150 | 576 |
1224 | 577 /* mode 7 means get 3 bits for each coding mode */ |
578 if (scheme == 7) | |
579 coding_mode = get_bits(gb, 3); | |
580 else | |
11153 | 581 coding_mode = alphabet |
2702
5a4e5225cbb6
use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents:
2699
diff
changeset
|
582 [get_vlc2(gb, s->mode_code_vlc.table, 3, 3)]; |
1224 | 583 |
1240
c95ff60bc1a1
fix motion vector decoding bug and reinstate interframes
tmmm
parents:
1239
diff
changeset
|
584 s->macroblock_coding[current_macroblock] = coding_mode; |
11150 | 585 for (k = 0; k < 4; k++) { |
11475
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
586 frag = s->all_fragments + BLOCK_Y*s->fragment_width[0] + BLOCK_X; |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
587 if (frag->coding_method != MODE_COPY) |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
588 frag->coding_method = coding_mode; |
11150 | 589 } |
11475
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
590 |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
591 #define SET_CHROMA_MODES \ |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
592 if (frag[s->fragment_start[1]].coding_method != MODE_COPY) \ |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
593 frag[s->fragment_start[1]].coding_method = coding_mode;\ |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
594 if (frag[s->fragment_start[2]].coding_method != MODE_COPY) \ |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
595 frag[s->fragment_start[2]].coding_method = coding_mode; |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
596 |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
597 if (s->chroma_y_shift) { |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
598 frag = s->all_fragments + mb_y*s->fragment_width[1] + mb_x; |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
599 SET_CHROMA_MODES |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
600 } else if (s->chroma_x_shift) { |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
601 frag = s->all_fragments + 2*mb_y*s->fragment_width[1] + mb_x; |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
602 for (k = 0; k < 2; k++) { |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
603 SET_CHROMA_MODES |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
604 frag += s->fragment_width[1]; |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
605 } |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
606 } else { |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
607 for (k = 0; k < 4; k++) { |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
608 frag = s->all_fragments + BLOCK_Y*s->fragment_width[1] + BLOCK_X; |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
609 SET_CHROMA_MODES |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
610 } |
1224 | 611 } |
612 } | |
11149 | 613 } |
1224 | 614 } |
615 } | |
1238
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
616 |
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
617 return 0; |
1229
cefec170ee46
fixed buffer allocation logic (hopefully) so that decoder does not crash
tmmm
parents:
1227
diff
changeset
|
618 } |
cefec170ee46
fixed buffer allocation logic (hopefully) so that decoder does not crash
tmmm
parents:
1227
diff
changeset
|
619 |
cefec170ee46
fixed buffer allocation logic (hopefully) so that decoder does not crash
tmmm
parents:
1227
diff
changeset
|
620 /* |
1224 | 621 * This function unpacks all the motion vectors for the individual |
622 * macroblocks from the bitstream. | |
623 */ | |
1238
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
624 static int unpack_vectors(Vp3DecodeContext *s, GetBitContext *gb) |
1224 | 625 { |
11152
b3ff7fcfffc4
Directly check whether a fragment is coded for 4MV mode instead of iterating
conrad
parents:
11151
diff
changeset
|
626 int j, k, sb_x, sb_y; |
1224 | 627 int coding_mode; |
11472 | 628 int motion_x[4]; |
629 int motion_y[4]; | |
1224 | 630 int last_motion_x = 0; |
631 int last_motion_y = 0; | |
632 int prior_last_motion_x = 0; | |
633 int prior_last_motion_y = 0; | |
634 int current_macroblock; | |
635 int current_fragment; | |
11477 | 636 int frag; |
1224 | 637 |
7970 | 638 if (s->keyframe) |
7969 | 639 return 0; |
7971 | 640 |
7972 | 641 /* coding mode 0 is the VLC scheme; 1 is the fixed code scheme */ |
642 coding_mode = get_bits1(gb); | |
1224 | 643 |
7972 | 644 /* iterate through all of the macroblocks that contain 1 or more |
645 * coded fragments */ | |
11149 | 646 for (sb_y = 0; sb_y < s->y_superblock_height; sb_y++) { |
647 for (sb_x = 0; sb_x < s->y_superblock_width; sb_x++) { | |
11636 | 648 if (get_bits_left(gb) <= 0) |
649 return -1; | |
1224 | 650 |
7972 | 651 for (j = 0; j < 4; j++) { |
11149 | 652 int mb_x = 2*sb_x + (j>>1); |
653 int mb_y = 2*sb_y + (((j>>1)+j)&1); | |
654 current_macroblock = mb_y * s->macroblock_width + mb_x; | |
655 | |
656 if (mb_x >= s->macroblock_width || mb_y >= s->macroblock_height || | |
7972 | 657 (s->macroblock_coding[current_macroblock] == MODE_COPY)) |
658 continue; | |
659 | |
660 switch (s->macroblock_coding[current_macroblock]) { | |
661 | |
662 case MODE_INTER_PLUS_MV: | |
663 case MODE_GOLDEN_MV: | |
664 /* all 6 fragments use the same motion vector */ | |
665 if (coding_mode == 0) { | |
666 motion_x[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)]; | |
667 motion_y[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)]; | |
668 } else { | |
669 motion_x[0] = fixed_motion_vector_table[get_bits(gb, 6)]; | |
670 motion_y[0] = fixed_motion_vector_table[get_bits(gb, 6)]; | |
1238
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
671 } |
1224 | 672 |
7972 | 673 /* vector maintenance, only on MODE_INTER_PLUS_MV */ |
674 if (s->macroblock_coding[current_macroblock] == | |
675 MODE_INTER_PLUS_MV) { | |
1224 | 676 prior_last_motion_x = last_motion_x; |
677 prior_last_motion_y = last_motion_y; | |
678 last_motion_x = motion_x[0]; | |
679 last_motion_y = motion_y[0]; | |
7972 | 680 } |
681 break; | |
682 | |
683 case MODE_INTER_FOURMV: | |
684 /* vector maintenance */ | |
685 prior_last_motion_x = last_motion_x; | |
686 prior_last_motion_y = last_motion_y; | |
1229
cefec170ee46
fixed buffer allocation logic (hopefully) so that decoder does not crash
tmmm
parents:
1227
diff
changeset
|
687 |
7972 | 688 /* fetch 4 vectors from the bitstream, one for each |
689 * Y fragment, then average for the C fragment vectors */ | |
690 for (k = 0; k < 4; k++) { | |
11473 | 691 current_fragment = BLOCK_Y*s->fragment_width[0] + BLOCK_X; |
11152
b3ff7fcfffc4
Directly check whether a fragment is coded for 4MV mode instead of iterating
conrad
parents:
11151
diff
changeset
|
692 if (s->all_fragments[current_fragment].coding_method != MODE_COPY) { |
7972 | 693 if (coding_mode == 0) { |
694 motion_x[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)]; | |
695 motion_y[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)]; | |
696 } else { | |
697 motion_x[k] = fixed_motion_vector_table[get_bits(gb, 6)]; | |
698 motion_y[k] = fixed_motion_vector_table[get_bits(gb, 6)]; | |
699 } | |
700 last_motion_x = motion_x[k]; | |
701 last_motion_y = motion_y[k]; | |
702 } else { | |
703 motion_x[k] = 0; | |
704 motion_y[k] = 0; | |
705 } | |
1224 | 706 } |
7972 | 707 break; |
708 | |
709 case MODE_INTER_LAST_MV: | |
710 /* all 6 fragments use the last motion vector */ | |
711 motion_x[0] = last_motion_x; | |
712 motion_y[0] = last_motion_y; | |
713 | |
714 /* no vector maintenance (last vector remains the | |
715 * last vector) */ | |
716 break; | |
717 | |
718 case MODE_INTER_PRIOR_LAST: | |
719 /* all 6 fragments use the motion vector prior to the | |
720 * last motion vector */ | |
721 motion_x[0] = prior_last_motion_x; | |
722 motion_y[0] = prior_last_motion_y; | |
723 | |
724 /* vector maintenance */ | |
725 prior_last_motion_x = last_motion_x; | |
726 prior_last_motion_y = last_motion_y; | |
727 last_motion_x = motion_x[0]; | |
728 last_motion_y = motion_y[0]; | |
729 break; | |
730 | |
731 default: | |
732 /* covers intra, inter without MV, golden without MV */ | |
10696
a80851eebd2e
Optimize unpack_vectors() by not shuffling around redundant vectors.
melanson
parents:
10652
diff
changeset
|
733 motion_x[0] = 0; |
a80851eebd2e
Optimize unpack_vectors() by not shuffling around redundant vectors.
melanson
parents:
10652
diff
changeset
|
734 motion_y[0] = 0; |
7972 | 735 |
736 /* no vector maintenance */ | |
737 break; | |
738 } | |
739 | |
740 /* assign the motion vectors to the correct fragments */ | |
11150 | 741 for (k = 0; k < 4; k++) { |
7972 | 742 current_fragment = |
11473 | 743 BLOCK_Y*s->fragment_width[0] + BLOCK_X; |
10696
a80851eebd2e
Optimize unpack_vectors() by not shuffling around redundant vectors.
melanson
parents:
10652
diff
changeset
|
744 if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) { |
11477 | 745 s->motion_val[0][current_fragment][0] = motion_x[k]; |
746 s->motion_val[0][current_fragment][1] = motion_y[k]; | |
10696
a80851eebd2e
Optimize unpack_vectors() by not shuffling around redundant vectors.
melanson
parents:
10652
diff
changeset
|
747 } else { |
11477 | 748 s->motion_val[0][current_fragment][0] = motion_x[0]; |
749 s->motion_val[0][current_fragment][1] = motion_y[0]; | |
10696
a80851eebd2e
Optimize unpack_vectors() by not shuffling around redundant vectors.
melanson
parents:
10652
diff
changeset
|
750 } |
1224 | 751 } |
11475
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
752 |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
753 if (s->chroma_y_shift) { |
11472 | 754 if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) { |
755 motion_x[0] = RSHIFT(motion_x[0] + motion_x[1] + motion_x[2] + motion_x[3], 2); | |
756 motion_y[0] = RSHIFT(motion_y[0] + motion_y[1] + motion_y[2] + motion_y[3], 2); | |
757 } | |
11475
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
758 motion_x[0] = (motion_x[0]>>1) | (motion_x[0]&1); |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
759 motion_y[0] = (motion_y[0]>>1) | (motion_y[0]&1); |
11477 | 760 frag = mb_y*s->fragment_width[1] + mb_x; |
761 s->motion_val[1][frag][0] = motion_x[0]; | |
762 s->motion_val[1][frag][1] = motion_y[0]; | |
11475
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
763 } else if (s->chroma_x_shift) { |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
764 if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) { |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
765 motion_x[0] = RSHIFT(motion_x[0] + motion_x[1], 1); |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
766 motion_y[0] = RSHIFT(motion_y[0] + motion_y[1], 1); |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
767 motion_x[1] = RSHIFT(motion_x[2] + motion_x[3], 1); |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
768 motion_y[1] = RSHIFT(motion_y[2] + motion_y[3], 1); |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
769 } else { |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
770 motion_x[1] = motion_x[0]; |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
771 motion_y[1] = motion_y[0]; |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
772 } |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
773 motion_x[0] = (motion_x[0]>>1) | (motion_x[0]&1); |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
774 motion_x[1] = (motion_x[1]>>1) | (motion_x[1]&1); |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
775 |
11477 | 776 frag = 2*mb_y*s->fragment_width[1] + mb_x; |
11475
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
777 for (k = 0; k < 2; k++) { |
11477 | 778 s->motion_val[1][frag][0] = motion_x[k]; |
779 s->motion_val[1][frag][1] = motion_y[k]; | |
11475
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
780 frag += s->fragment_width[1]; |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
781 } |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
782 } else { |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
783 for (k = 0; k < 4; k++) { |
11477 | 784 frag = BLOCK_Y*s->fragment_width[1] + BLOCK_X; |
11475
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
785 if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) { |
11477 | 786 s->motion_val[1][frag][0] = motion_x[k]; |
787 s->motion_val[1][frag][1] = motion_y[k]; | |
11475
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
788 } else { |
11477 | 789 s->motion_val[1][frag][0] = motion_x[0]; |
790 s->motion_val[1][frag][1] = motion_y[0]; | |
11475
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
791 } |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
792 } |
11150 | 793 } |
1224 | 794 } |
11149 | 795 } |
7972 | 796 } |
1238
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
797 |
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
798 return 0; |
1224 | 799 } |
800 | |
9731 | 801 static int unpack_block_qpis(Vp3DecodeContext *s, GetBitContext *gb) |
802 { | |
803 int qpi, i, j, bit, run_length, blocks_decoded, num_blocks_at_qpi; | |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
804 int num_blocks = s->total_num_coded_frags; |
9731 | 805 |
806 for (qpi = 0; qpi < s->nqps-1 && num_blocks > 0; qpi++) { | |
807 i = blocks_decoded = num_blocks_at_qpi = 0; | |
808 | |
11757
7dff9c1061e1
theora: Don't read an excess bit for maximum length long bit runs if the run
conrad
parents:
11646
diff
changeset
|
809 bit = get_bits1(gb) ^ 1; |
7dff9c1061e1
theora: Don't read an excess bit for maximum length long bit runs if the run
conrad
parents:
11646
diff
changeset
|
810 run_length = 0; |
9731 | 811 |
812 do { | |
11757
7dff9c1061e1
theora: Don't read an excess bit for maximum length long bit runs if the run
conrad
parents:
11646
diff
changeset
|
813 if (run_length == MAXIMUM_LONG_BIT_RUN) |
7dff9c1061e1
theora: Don't read an excess bit for maximum length long bit runs if the run
conrad
parents:
11646
diff
changeset
|
814 bit = get_bits1(gb); |
7dff9c1061e1
theora: Don't read an excess bit for maximum length long bit runs if the run
conrad
parents:
11646
diff
changeset
|
815 else |
7dff9c1061e1
theora: Don't read an excess bit for maximum length long bit runs if the run
conrad
parents:
11646
diff
changeset
|
816 bit ^= 1; |
7dff9c1061e1
theora: Don't read an excess bit for maximum length long bit runs if the run
conrad
parents:
11646
diff
changeset
|
817 |
9731 | 818 run_length = get_vlc2(gb, s->superblock_run_length_vlc.table, 6, 2) + 1; |
819 if (run_length == 34) | |
820 run_length += get_bits(gb, 12); | |
821 blocks_decoded += run_length; | |
822 | |
823 if (!bit) | |
824 num_blocks_at_qpi += run_length; | |
825 | |
826 for (j = 0; j < run_length; i++) { | |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
827 if (i >= s->total_num_coded_frags) |
9731 | 828 return -1; |
829 | |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
830 if (s->all_fragments[s->coded_fragment_list[0][i]].qpi == qpi) { |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
831 s->all_fragments[s->coded_fragment_list[0][i]].qpi += bit; |
9731 | 832 j++; |
833 } | |
834 } | |
11636 | 835 } while (blocks_decoded < num_blocks && get_bits_left(gb) > 0); |
9731 | 836 |
837 num_blocks -= num_blocks_at_qpi; | |
838 } | |
839 | |
840 return 0; | |
841 } | |
842 | |
2967 | 843 /* |
1224 | 844 * This function is called by unpack_dct_coeffs() to extract the VLCs from |
845 * the bitstream. The VLCs encode tokens which are used to unpack DCT | |
846 * data. This function unpacks all the VLCs for either the Y plane or both | |
847 * C planes, and is called for DC coefficients or different AC coefficient | |
848 * levels (since different coefficient types require different VLC tables. | |
849 * | |
850 * This function returns a residual eob run. E.g, if a particular token gave | |
851 * instructions to EOB the next 5 fragments and there were only 2 fragments | |
852 * left in the current fragment range, 3 would be returned so that it could | |
853 * be passed into the next call to this same function. | |
854 */ | |
855 static int unpack_vlcs(Vp3DecodeContext *s, GetBitContext *gb, | |
856 VLC *table, int coeff_index, | |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
857 int plane, |
1224 | 858 int eob_run) |
859 { | |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
860 int i, j = 0; |
1224 | 861 int token; |
2712
9c1a436dac6b
replace unpack_token() with a series of lookup tables
melanson
parents:
2709
diff
changeset
|
862 int zero_run = 0; |
9c1a436dac6b
replace unpack_token() with a series of lookup tables
melanson
parents:
2709
diff
changeset
|
863 DCTELEM coeff = 0; |
10202
d0456fd306d2
Modify unpack_vlcs() so that there are fewer dereferences through the
melanson
parents:
10140
diff
changeset
|
864 int bits_to_get; |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
865 int blocks_ended; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
866 int coeff_i = 0; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
867 int num_coeffs = s->num_coded_frags[plane][coeff_index]; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
868 int16_t *dct_tokens = s->dct_tokens[plane][coeff_index]; |
10202
d0456fd306d2
Modify unpack_vlcs() so that there are fewer dereferences through the
melanson
parents:
10140
diff
changeset
|
869 |
d0456fd306d2
Modify unpack_vlcs() so that there are fewer dereferences through the
melanson
parents:
10140
diff
changeset
|
870 /* local references to structure members to avoid repeated deferences */ |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
871 int *coded_fragment_list = s->coded_fragment_list[plane]; |
10202
d0456fd306d2
Modify unpack_vlcs() so that there are fewer dereferences through the
melanson
parents:
10140
diff
changeset
|
872 Vp3Fragment *all_fragments = s->all_fragments; |
d0456fd306d2
Modify unpack_vlcs() so that there are fewer dereferences through the
melanson
parents:
10140
diff
changeset
|
873 VLC_TYPE (*vlc_table)[2] = table->table; |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
874 |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
875 if (num_coeffs < 0) |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
876 av_log(s->avctx, AV_LOG_ERROR, "Invalid number of coefficents at level %d\n", coeff_index); |
1244
a02df1ba6c7f
fix image buffer leak on keyframes, add more error condition checks
tmmm
parents:
1240
diff
changeset
|
877 |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
878 if (eob_run > num_coeffs) { |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
879 coeff_i = blocks_ended = num_coeffs; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
880 eob_run -= num_coeffs; |
10619
d930f99edbf9
Use a list to track which fragments coded in this frame still have
melanson
parents:
10258
diff
changeset
|
881 } else { |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
882 coeff_i = blocks_ended = eob_run; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
883 eob_run = 0; |
1244
a02df1ba6c7f
fix image buffer leak on keyframes, add more error condition checks
tmmm
parents:
1240
diff
changeset
|
884 } |
a02df1ba6c7f
fix image buffer leak on keyframes, add more error condition checks
tmmm
parents:
1240
diff
changeset
|
885 |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
886 // insert fake EOB token to cover the split between planes or zzi |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
887 if (blocks_ended) |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
888 dct_tokens[j++] = blocks_ended << 2; |
7037
480faa9f79dd
Almost-cosmetics: split out coeff_count from all_fragments struct into
reimar
parents:
6903
diff
changeset
|
889 |
11453 | 890 while (coeff_i < num_coeffs && get_bits_left(gb) > 0) { |
1224 | 891 /* decode a VLC into a token */ |
11646
a69e24b73f3c
theora: coeff huffman codes are allowed to be up to 32 bits long (for 32 tokens)
conrad
parents:
11644
diff
changeset
|
892 token = get_vlc2(gb, vlc_table, 11, 3); |
1224 | 893 /* use the token to get a zero run, a coefficient, and an eob run */ |
2712
9c1a436dac6b
replace unpack_token() with a series of lookup tables
melanson
parents:
2709
diff
changeset
|
894 if (token <= 6) { |
9c1a436dac6b
replace unpack_token() with a series of lookup tables
melanson
parents:
2709
diff
changeset
|
895 eob_run = eob_run_base[token]; |
9c1a436dac6b
replace unpack_token() with a series of lookup tables
melanson
parents:
2709
diff
changeset
|
896 if (eob_run_get_bits[token]) |
9c1a436dac6b
replace unpack_token() with a series of lookup tables
melanson
parents:
2709
diff
changeset
|
897 eob_run += get_bits(gb, eob_run_get_bits[token]); |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
898 |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
899 // record only the number of blocks ended in this plane, |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
900 // any spill will be recorded in the next plane. |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
901 if (eob_run > num_coeffs - coeff_i) { |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
902 dct_tokens[j++] = TOKEN_EOB(num_coeffs - coeff_i); |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
903 blocks_ended += num_coeffs - coeff_i; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
904 eob_run -= num_coeffs - coeff_i; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
905 coeff_i = num_coeffs; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
906 } else { |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
907 dct_tokens[j++] = TOKEN_EOB(eob_run); |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
908 blocks_ended += eob_run; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
909 coeff_i += eob_run; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
910 eob_run = 0; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
911 } |
2712
9c1a436dac6b
replace unpack_token() with a series of lookup tables
melanson
parents:
2709
diff
changeset
|
912 } else { |
9c1a436dac6b
replace unpack_token() with a series of lookup tables
melanson
parents:
2709
diff
changeset
|
913 bits_to_get = coeff_get_bits[token]; |
10230
afaf58d1e894
Another micro-optimization for unpack_vlcs(): Eliminate a possible
melanson
parents:
10223
diff
changeset
|
914 if (bits_to_get) |
afaf58d1e894
Another micro-optimization for unpack_vlcs(): Eliminate a possible
melanson
parents:
10223
diff
changeset
|
915 bits_to_get = get_bits(gb, bits_to_get); |
afaf58d1e894
Another micro-optimization for unpack_vlcs(): Eliminate a possible
melanson
parents:
10223
diff
changeset
|
916 coeff = coeff_tables[token][bits_to_get]; |
2712
9c1a436dac6b
replace unpack_token() with a series of lookup tables
melanson
parents:
2709
diff
changeset
|
917 |
9c1a436dac6b
replace unpack_token() with a series of lookup tables
melanson
parents:
2709
diff
changeset
|
918 zero_run = zero_run_base[token]; |
9c1a436dac6b
replace unpack_token() with a series of lookup tables
melanson
parents:
2709
diff
changeset
|
919 if (zero_run_get_bits[token]) |
9c1a436dac6b
replace unpack_token() with a series of lookup tables
melanson
parents:
2709
diff
changeset
|
920 zero_run += get_bits(gb, zero_run_get_bits[token]); |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
921 |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
922 if (zero_run) { |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
923 dct_tokens[j++] = TOKEN_ZERO_RUN(coeff, zero_run); |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
924 } else { |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
925 // Save DC into the fragment structure. DC prediction is |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
926 // done in raster order, so the actual DC can't be in with |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
927 // other tokens. We still need the token in dct_tokens[] |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
928 // however, or else the structure collapses on itself. |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
929 if (!coeff_index) |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
930 all_fragments[coded_fragment_list[coeff_i]].dc = coeff; |
1224 | 931 |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
932 dct_tokens[j++] = TOKEN_COEFF(coeff); |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
933 } |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
934 |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
935 if (coeff_index + zero_run > 64) { |
11418 | 936 av_log(s->avctx, AV_LOG_DEBUG, "Invalid zero run of %d with" |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
937 " %d coeffs left\n", zero_run, 64-coeff_index); |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
938 zero_run = 64 - coeff_index; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
939 } |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
940 |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
941 // zero runs code multiple coefficients, |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
942 // so don't try to decode coeffs for those higher levels |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
943 for (i = coeff_index+1; i <= coeff_index+zero_run; i++) |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
944 s->num_coded_frags[plane][i]--; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
945 coeff_i++; |
2714
b008c78467e6
use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents:
2712
diff
changeset
|
946 } |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
947 } |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
948 |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
949 if (blocks_ended > s->num_coded_frags[plane][coeff_index]) |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
950 av_log(s->avctx, AV_LOG_ERROR, "More blocks ended than coded!\n"); |
10619
d930f99edbf9
Use a list to track which fragments coded in this frame still have
melanson
parents:
10258
diff
changeset
|
951 |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
952 // decrement the number of blocks that have higher coeffecients for each |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
953 // EOB run at this level |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
954 if (blocks_ended) |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
955 for (i = coeff_index+1; i < 64; i++) |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
956 s->num_coded_frags[plane][i] -= blocks_ended; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
957 |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
958 // setup the next buffer |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
959 if (plane < 2) |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
960 s->dct_tokens[plane+1][coeff_index] = dct_tokens + j; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
961 else if (coeff_index < 63) |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
962 s->dct_tokens[0][coeff_index+1] = dct_tokens + j; |
1224 | 963 |
964 return eob_run; | |
965 } | |
966 | |
10223
b08865f6d4e3
Perform the DC prediction reversal immediately after decoding all of
melanson
parents:
10202
diff
changeset
|
967 static void reverse_dc_prediction(Vp3DecodeContext *s, |
b08865f6d4e3
Perform the DC prediction reversal immediately after decoding all of
melanson
parents:
10202
diff
changeset
|
968 int first_fragment, |
b08865f6d4e3
Perform the DC prediction reversal immediately after decoding all of
melanson
parents:
10202
diff
changeset
|
969 int fragment_width, |
b08865f6d4e3
Perform the DC prediction reversal immediately after decoding all of
melanson
parents:
10202
diff
changeset
|
970 int fragment_height); |
1224 | 971 /* |
972 * This function unpacks all of the DCT coefficient data from the | |
973 * bitstream. | |
974 */ | |
1238
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
975 static int unpack_dct_coeffs(Vp3DecodeContext *s, GetBitContext *gb) |
1224 | 976 { |
977 int i; | |
978 int dc_y_table; | |
979 int dc_c_table; | |
980 int ac_y_table; | |
981 int ac_c_table; | |
982 int residual_eob_run = 0; | |
10620
972b17631531
Small refactoring: Instead of 4 loops for decoding AC coefficients based
melanson
parents:
10619
diff
changeset
|
983 VLC *y_tables[64]; |
972b17631531
Small refactoring: Instead of 4 loops for decoding AC coefficients based
melanson
parents:
10619
diff
changeset
|
984 VLC *c_tables[64]; |
1224 | 985 |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
986 s->dct_tokens[0][0] = s->dct_tokens_base; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
987 |
6903 | 988 /* fetch the DC table indexes */ |
1224 | 989 dc_y_table = get_bits(gb, 4); |
990 dc_c_table = get_bits(gb, 4); | |
991 | |
992 /* unpack the Y plane DC coefficients */ | |
2967 | 993 residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_y_table], 0, |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
994 0, residual_eob_run); |
1224 | 995 |
10223
b08865f6d4e3
Perform the DC prediction reversal immediately after decoding all of
melanson
parents:
10202
diff
changeset
|
996 /* reverse prediction of the Y-plane DC coefficients */ |
11473 | 997 reverse_dc_prediction(s, 0, s->fragment_width[0], s->fragment_height[0]); |
10223
b08865f6d4e3
Perform the DC prediction reversal immediately after decoding all of
melanson
parents:
10202
diff
changeset
|
998 |
1224 | 999 /* unpack the C plane DC coefficients */ |
1000 residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_c_table], 0, | |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1001 1, residual_eob_run); |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1002 residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_c_table], 0, |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1003 2, residual_eob_run); |
1224 | 1004 |
10223
b08865f6d4e3
Perform the DC prediction reversal immediately after decoding all of
melanson
parents:
10202
diff
changeset
|
1005 /* reverse prediction of the C-plane DC coefficients */ |
b08865f6d4e3
Perform the DC prediction reversal immediately after decoding all of
melanson
parents:
10202
diff
changeset
|
1006 if (!(s->avctx->flags & CODEC_FLAG_GRAY)) |
b08865f6d4e3
Perform the DC prediction reversal immediately after decoding all of
melanson
parents:
10202
diff
changeset
|
1007 { |
b08865f6d4e3
Perform the DC prediction reversal immediately after decoding all of
melanson
parents:
10202
diff
changeset
|
1008 reverse_dc_prediction(s, s->fragment_start[1], |
11473 | 1009 s->fragment_width[1], s->fragment_height[1]); |
10223
b08865f6d4e3
Perform the DC prediction reversal immediately after decoding all of
melanson
parents:
10202
diff
changeset
|
1010 reverse_dc_prediction(s, s->fragment_start[2], |
11473 | 1011 s->fragment_width[1], s->fragment_height[1]); |
10223
b08865f6d4e3
Perform the DC prediction reversal immediately after decoding all of
melanson
parents:
10202
diff
changeset
|
1012 } |
b08865f6d4e3
Perform the DC prediction reversal immediately after decoding all of
melanson
parents:
10202
diff
changeset
|
1013 |
6903 | 1014 /* fetch the AC table indexes */ |
1224 | 1015 ac_y_table = get_bits(gb, 4); |
1016 ac_c_table = get_bits(gb, 4); | |
1017 | |
10620
972b17631531
Small refactoring: Instead of 4 loops for decoding AC coefficients based
melanson
parents:
10619
diff
changeset
|
1018 /* build tables of AC VLC tables */ |
1224 | 1019 for (i = 1; i <= 5; i++) { |
10620
972b17631531
Small refactoring: Instead of 4 loops for decoding AC coefficients based
melanson
parents:
10619
diff
changeset
|
1020 y_tables[i] = &s->ac_vlc_1[ac_y_table]; |
972b17631531
Small refactoring: Instead of 4 loops for decoding AC coefficients based
melanson
parents:
10619
diff
changeset
|
1021 c_tables[i] = &s->ac_vlc_1[ac_c_table]; |
972b17631531
Small refactoring: Instead of 4 loops for decoding AC coefficients based
melanson
parents:
10619
diff
changeset
|
1022 } |
972b17631531
Small refactoring: Instead of 4 loops for decoding AC coefficients based
melanson
parents:
10619
diff
changeset
|
1023 for (i = 6; i <= 14; i++) { |
972b17631531
Small refactoring: Instead of 4 loops for decoding AC coefficients based
melanson
parents:
10619
diff
changeset
|
1024 y_tables[i] = &s->ac_vlc_2[ac_y_table]; |
972b17631531
Small refactoring: Instead of 4 loops for decoding AC coefficients based
melanson
parents:
10619
diff
changeset
|
1025 c_tables[i] = &s->ac_vlc_2[ac_c_table]; |
972b17631531
Small refactoring: Instead of 4 loops for decoding AC coefficients based
melanson
parents:
10619
diff
changeset
|
1026 } |
972b17631531
Small refactoring: Instead of 4 loops for decoding AC coefficients based
melanson
parents:
10619
diff
changeset
|
1027 for (i = 15; i <= 27; i++) { |
972b17631531
Small refactoring: Instead of 4 loops for decoding AC coefficients based
melanson
parents:
10619
diff
changeset
|
1028 y_tables[i] = &s->ac_vlc_3[ac_y_table]; |
972b17631531
Small refactoring: Instead of 4 loops for decoding AC coefficients based
melanson
parents:
10619
diff
changeset
|
1029 c_tables[i] = &s->ac_vlc_3[ac_c_table]; |
972b17631531
Small refactoring: Instead of 4 loops for decoding AC coefficients based
melanson
parents:
10619
diff
changeset
|
1030 } |
972b17631531
Small refactoring: Instead of 4 loops for decoding AC coefficients based
melanson
parents:
10619
diff
changeset
|
1031 for (i = 28; i <= 63; i++) { |
972b17631531
Small refactoring: Instead of 4 loops for decoding AC coefficients based
melanson
parents:
10619
diff
changeset
|
1032 y_tables[i] = &s->ac_vlc_4[ac_y_table]; |
972b17631531
Small refactoring: Instead of 4 loops for decoding AC coefficients based
melanson
parents:
10619
diff
changeset
|
1033 c_tables[i] = &s->ac_vlc_4[ac_c_table]; |
1224 | 1034 } |
1035 | |
10620
972b17631531
Small refactoring: Instead of 4 loops for decoding AC coefficients based
melanson
parents:
10619
diff
changeset
|
1036 /* decode all AC coefficents */ |
972b17631531
Small refactoring: Instead of 4 loops for decoding AC coefficients based
melanson
parents:
10619
diff
changeset
|
1037 for (i = 1; i <= 63; i++) { |
972b17631531
Small refactoring: Instead of 4 loops for decoding AC coefficients based
melanson
parents:
10619
diff
changeset
|
1038 residual_eob_run = unpack_vlcs(s, gb, y_tables[i], i, |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1039 0, residual_eob_run); |
1224 | 1040 |
10620
972b17631531
Small refactoring: Instead of 4 loops for decoding AC coefficients based
melanson
parents:
10619
diff
changeset
|
1041 residual_eob_run = unpack_vlcs(s, gb, c_tables[i], i, |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1042 1, residual_eob_run); |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1043 residual_eob_run = unpack_vlcs(s, gb, c_tables[i], i, |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1044 2, residual_eob_run); |
1224 | 1045 } |
1238
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
1046 |
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
1047 return 0; |
1224 | 1048 } |
1049 | |
1050 /* | |
1051 * This function reverses the DC prediction for each coded fragment in | |
2967 | 1052 * the frame. Much of this function is adapted directly from the original |
1224 | 1053 * VP3 source code. |
1054 */ | |
1055 #define COMPATIBLE_FRAME(x) \ | |
1056 (compatible_frame[s->all_fragments[x].coding_method] == current_frame_type) | |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1057 #define DC_COEFF(u) s->all_fragments[u].dc |
1224 | 1058 |
1059 static void reverse_dc_prediction(Vp3DecodeContext *s, | |
1060 int first_fragment, | |
1061 int fragment_width, | |
2967 | 1062 int fragment_height) |
1224 | 1063 { |
1064 | |
1065 #define PUL 8 | |
1066 #define PU 4 | |
1067 #define PUR 2 | |
1068 #define PL 1 | |
1069 | |
1070 int x, y; | |
1071 int i = first_fragment; | |
1072 | |
3940 | 1073 int predicted_dc; |
1224 | 1074 |
1075 /* DC values for the left, up-left, up, and up-right fragments */ | |
1076 int vl, vul, vu, vur; | |
1077 | |
6903 | 1078 /* indexes for the left, up-left, up, and up-right fragments */ |
1224 | 1079 int l, ul, u, ur; |
1080 | |
2967 | 1081 /* |
1224 | 1082 * The 6 fields mean: |
1083 * 0: up-left multiplier | |
1084 * 1: up multiplier | |
1085 * 2: up-right multiplier | |
1086 * 3: left multiplier | |
1087 */ | |
10133 | 1088 static const int predictor_transform[16][4] = { |
3501 | 1089 { 0, 0, 0, 0}, |
1090 { 0, 0, 0,128}, // PL | |
1091 { 0, 0,128, 0}, // PUR | |
1092 { 0, 0, 53, 75}, // PUR|PL | |
1093 { 0,128, 0, 0}, // PU | |
1094 { 0, 64, 0, 64}, // PU|PL | |
1095 { 0,128, 0, 0}, // PU|PUR | |
1096 { 0, 0, 53, 75}, // PU|PUR|PL | |
1097 {128, 0, 0, 0}, // PUL | |
1098 { 0, 0, 0,128}, // PUL|PL | |
1099 { 64, 0, 64, 0}, // PUL|PUR | |
1100 { 0, 0, 53, 75}, // PUL|PUR|PL | |
1101 { 0,128, 0, 0}, // PUL|PU | |
1102 {-104,116, 0,116}, // PUL|PU|PL | |
1103 { 24, 80, 24, 0}, // PUL|PU|PUR | |
1104 {-104,116, 0,116} // PUL|PU|PUR|PL | |
1224 | 1105 }; |
1106 | |
1107 /* This table shows which types of blocks can use other blocks for | |
1108 * prediction. For example, INTRA is the only mode in this table to | |
1109 * have a frame number of 0. That means INTRA blocks can only predict | |
2967 | 1110 * from other INTRA blocks. There are 2 golden frame coding types; |
1224 | 1111 * blocks encoding in these modes can only predict from other blocks |
1112 * that were encoded with these 1 of these 2 modes. */ | |
10650 | 1113 static const unsigned char compatible_frame[9] = { |
1224 | 1114 1, /* MODE_INTER_NO_MV */ |
1115 0, /* MODE_INTRA */ | |
1116 1, /* MODE_INTER_PLUS_MV */ | |
1117 1, /* MODE_INTER_LAST_MV */ | |
1118 1, /* MODE_INTER_PRIOR_MV */ | |
1119 2, /* MODE_USING_GOLDEN */ | |
1120 2, /* MODE_GOLDEN_MV */ | |
10650 | 1121 1, /* MODE_INTER_FOUR_MV */ |
1122 3 /* MODE_COPY */ | |
1224 | 1123 }; |
1124 int current_frame_type; | |
1125 | |
1126 /* there is a last DC predictor for each of the 3 frame types */ | |
1127 short last_dc[3]; | |
1128 | |
1129 int transform = 0; | |
1130 | |
1131 vul = vu = vur = vl = 0; | |
1132 last_dc[0] = last_dc[1] = last_dc[2] = 0; | |
1133 | |
1134 /* for each fragment row... */ | |
1135 for (y = 0; y < fragment_height; y++) { | |
1136 | |
1137 /* for each fragment in a row... */ | |
1138 for (x = 0; x < fragment_width; x++, i++) { | |
1139 | |
1140 /* reverse prediction if this block was coded */ | |
1141 if (s->all_fragments[i].coding_method != MODE_COPY) { | |
1142 | |
2967 | 1143 current_frame_type = |
1224 | 1144 compatible_frame[s->all_fragments[i].coding_method]; |
3500 | 1145 |
1146 transform= 0; | |
1147 if(x){ | |
1148 l= i-1; | |
2714
b008c78467e6
use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents:
2712
diff
changeset
|
1149 vl = DC_COEFF(l); |
10650 | 1150 if(COMPATIBLE_FRAME(l)) |
3501 | 1151 transform |= PL; |
3500 | 1152 } |
1153 if(y){ | |
1154 u= i-fragment_width; | |
2714
b008c78467e6
use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents:
2712
diff
changeset
|
1155 vu = DC_COEFF(u); |
10650 | 1156 if(COMPATIBLE_FRAME(u)) |
3501 | 1157 transform |= PU; |
3500 | 1158 if(x){ |
1159 ul= i-fragment_width-1; | |
1160 vul = DC_COEFF(ul); | |
10650 | 1161 if(COMPATIBLE_FRAME(ul)) |
3501 | 1162 transform |= PUL; |
3500 | 1163 } |
1164 if(x + 1 < fragment_width){ | |
1165 ur= i-fragment_width+1; | |
1166 vur = DC_COEFF(ur); | |
10650 | 1167 if(COMPATIBLE_FRAME(ur)) |
3501 | 1168 transform |= PUR; |
3500 | 1169 } |
1224 | 1170 } |
1171 | |
1172 if (transform == 0) { | |
1173 | |
1174 /* if there were no fragments to predict from, use last | |
1175 * DC saved */ | |
2714
b008c78467e6
use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents:
2712
diff
changeset
|
1176 predicted_dc = last_dc[current_frame_type]; |
1224 | 1177 } else { |
1178 | |
1179 /* apply the appropriate predictor transform */ | |
1180 predicted_dc = | |
1181 (predictor_transform[transform][0] * vul) + | |
1182 (predictor_transform[transform][1] * vu) + | |
1183 (predictor_transform[transform][2] * vur) + | |
1184 (predictor_transform[transform][3] * vl); | |
1185 | |
3502 | 1186 predicted_dc /= 128; |
1224 | 1187 |
1188 /* check for outranging on the [ul u l] and | |
1189 * [ul u ur l] predictors */ | |
10649
a34d38ec5a0b
Check transform==15 first, since it's more common than 13.
cehoyos
parents:
10648
diff
changeset
|
1190 if ((transform == 15) || (transform == 13)) { |
4001 | 1191 if (FFABS(predicted_dc - vu) > 128) |
1224 | 1192 predicted_dc = vu; |
4001 | 1193 else if (FFABS(predicted_dc - vl) > 128) |
1224 | 1194 predicted_dc = vl; |
4001 | 1195 else if (FFABS(predicted_dc - vul) > 128) |
1224 | 1196 predicted_dc = vul; |
1197 } | |
1198 } | |
1199 | |
2714
b008c78467e6
use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents:
2712
diff
changeset
|
1200 /* at long last, apply the predictor */ |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1201 DC_COEFF(i) += predicted_dc; |
1224 | 1202 /* save the DC */ |
2714
b008c78467e6
use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents:
2712
diff
changeset
|
1203 last_dc[current_frame_type] = DC_COEFF(i); |
1224 | 1204 } |
1205 } | |
1206 } | |
1207 } | |
1208 | |
11130 | 1209 static void apply_loop_filter(Vp3DecodeContext *s, int plane, int ystart, int yend) |
11129
0bca1b2ac58d
Move apply_loop_filter above render_slice, it'll be used by the latter soon
conrad
parents:
11128
diff
changeset
|
1210 { |
0bca1b2ac58d
Move apply_loop_filter above render_slice, it'll be used by the latter soon
conrad
parents:
11128
diff
changeset
|
1211 int x, y; |
0bca1b2ac58d
Move apply_loop_filter above render_slice, it'll be used by the latter soon
conrad
parents:
11128
diff
changeset
|
1212 int *bounding_values= s->bounding_values_array+127; |
0bca1b2ac58d
Move apply_loop_filter above render_slice, it'll be used by the latter soon
conrad
parents:
11128
diff
changeset
|
1213 |
11473 | 1214 int width = s->fragment_width[!!plane]; |
1215 int height = s->fragment_height[!!plane]; | |
11131 | 1216 int fragment = s->fragment_start [plane] + ystart * width; |
1217 int stride = s->current_frame.linesize[plane]; | |
1218 uint8_t *plane_data = s->current_frame.data [plane]; | |
1219 if (!s->flipped_image) stride = -stride; | |
11133 | 1220 plane_data += s->data_offset[plane] + 8*ystart*stride; |
11129
0bca1b2ac58d
Move apply_loop_filter above render_slice, it'll be used by the latter soon
conrad
parents:
11128
diff
changeset
|
1221 |
11131 | 1222 for (y = ystart; y < yend; y++) { |
11129
0bca1b2ac58d
Move apply_loop_filter above render_slice, it'll be used by the latter soon
conrad
parents:
11128
diff
changeset
|
1223 |
11131 | 1224 for (x = 0; x < width; x++) { |
1225 /* This code basically just deblocks on the edges of coded blocks. | |
1226 * However, it has to be much more complicated because of the | |
1227 * braindamaged deblock ordering used in VP3/Theora. Order matters | |
1228 * because some pixels get filtered twice. */ | |
1229 if( s->all_fragments[fragment].coding_method != MODE_COPY ) | |
1230 { | |
1231 /* do not perform left edge filter for left columns frags */ | |
1232 if (x > 0) { | |
1233 s->dsp.vp3_h_loop_filter( | |
11133 | 1234 plane_data + 8*x, |
11131 | 1235 stride, bounding_values); |
11129
0bca1b2ac58d
Move apply_loop_filter above render_slice, it'll be used by the latter soon
conrad
parents:
11128
diff
changeset
|
1236 } |
0bca1b2ac58d
Move apply_loop_filter above render_slice, it'll be used by the latter soon
conrad
parents:
11128
diff
changeset
|
1237 |
11131 | 1238 /* do not perform top edge filter for top row fragments */ |
1239 if (y > 0) { | |
1240 s->dsp.vp3_v_loop_filter( | |
11133 | 1241 plane_data + 8*x, |
11131 | 1242 stride, bounding_values); |
1243 } | |
1244 | |
1245 /* do not perform right edge filter for right column | |
1246 * fragments or if right fragment neighbor is also coded | |
1247 * in this frame (it will be filtered in next iteration) */ | |
1248 if ((x < width - 1) && | |
1249 (s->all_fragments[fragment + 1].coding_method == MODE_COPY)) { | |
1250 s->dsp.vp3_h_loop_filter( | |
11133 | 1251 plane_data + 8*x + 8, |
11131 | 1252 stride, bounding_values); |
1253 } | |
1254 | |
1255 /* do not perform bottom edge filter for bottom row | |
1256 * fragments or if bottom fragment neighbor is also coded | |
1257 * in this frame (it will be filtered in the next row) */ | |
1258 if ((y < height - 1) && | |
1259 (s->all_fragments[fragment + width].coding_method == MODE_COPY)) { | |
1260 s->dsp.vp3_v_loop_filter( | |
11133 | 1261 plane_data + 8*x + 8*stride, |
11131 | 1262 stride, bounding_values); |
1263 } | |
11129
0bca1b2ac58d
Move apply_loop_filter above render_slice, it'll be used by the latter soon
conrad
parents:
11128
diff
changeset
|
1264 } |
11131 | 1265 |
1266 fragment++; | |
11129
0bca1b2ac58d
Move apply_loop_filter above render_slice, it'll be used by the latter soon
conrad
parents:
11128
diff
changeset
|
1267 } |
11133 | 1268 plane_data += 8*stride; |
11131 | 1269 } |
11129
0bca1b2ac58d
Move apply_loop_filter above render_slice, it'll be used by the latter soon
conrad
parents:
11128
diff
changeset
|
1270 } |
0bca1b2ac58d
Move apply_loop_filter above render_slice, it'll be used by the latter soon
conrad
parents:
11128
diff
changeset
|
1271 |
11132
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1272 /** |
12024 | 1273 * Pull DCT tokens from the 64 levels to decode and dequant the coefficients |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1274 * for the next block in coding order |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1275 */ |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1276 static inline int vp3_dequant(Vp3DecodeContext *s, Vp3Fragment *frag, |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1277 int plane, int inter, DCTELEM block[64]) |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1278 { |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1279 int16_t *dequantizer = s->qmat[frag->qpi][inter][plane]; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1280 uint8_t *perm = s->scantable.permutated; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1281 int i = 0; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1282 |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1283 do { |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1284 int token = *s->dct_tokens[plane][i]; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1285 switch (token & 3) { |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1286 case 0: // EOB |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1287 if (--token < 4) // 0-3 are token types, so the EOB run must now be 0 |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1288 s->dct_tokens[plane][i]++; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1289 else |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1290 *s->dct_tokens[plane][i] = token & ~3; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1291 goto end; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1292 case 1: // zero run |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1293 s->dct_tokens[plane][i]++; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1294 i += (token >> 2) & 0x7f; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1295 block[perm[i]] = (token >> 9) * dequantizer[perm[i]]; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1296 i++; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1297 break; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1298 case 2: // coeff |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1299 block[perm[i]] = (token >> 2) * dequantizer[perm[i]]; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1300 s->dct_tokens[plane][i++]++; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1301 break; |
11635 | 1302 default: // shouldn't happen |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1303 return i; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1304 } |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1305 } while (i < 64); |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1306 end: |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1307 // the actual DC+prediction is in the fragment structure |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1308 block[0] = frag->dc * s->qmat[0][inter][plane][0]; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1309 return i; |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1310 } |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1311 |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1312 /** |
11132
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1313 * called when all pixels up to row y are complete |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1314 */ |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1315 static void vp3_draw_horiz_band(Vp3DecodeContext *s, int y) |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1316 { |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1317 int h, cy; |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1318 int offset[4]; |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1319 |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1320 if(s->avctx->draw_horiz_band==NULL) |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1321 return; |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1322 |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1323 h= y - s->last_slice_end; |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1324 y -= h; |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1325 |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1326 if (!s->flipped_image) { |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1327 if (y == 0) |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1328 h -= s->height - s->avctx->height; // account for non-mod16 |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1329 y = s->height - y - h; |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1330 } |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1331 |
11856
9d81bd6f2a81
Fix vp3_draw_horiz_band to calculate chroma offsets correctly
reimar
parents:
11782
diff
changeset
|
1332 cy = y >> s->chroma_y_shift; |
11132
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1333 offset[0] = s->current_frame.linesize[0]*y; |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1334 offset[1] = s->current_frame.linesize[1]*cy; |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1335 offset[2] = s->current_frame.linesize[2]*cy; |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1336 offset[3] = 0; |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1337 |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1338 emms_c(); |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1339 s->avctx->draw_horiz_band(s->avctx, &s->current_frame, offset, y, 3, h); |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1340 s->last_slice_end= y + h; |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1341 } |
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1342 |
1224 | 1343 /* |
2722 | 1344 * Perform the final rendering for a particular slice of data. |
11352 | 1345 * The slice number ranges from 0..(c_superblock_height - 1). |
2722 | 1346 */ |
1347 static void render_slice(Vp3DecodeContext *s, int slice) | |
1348 { | |
11352 | 1349 int x, y, i, j; |
11195 | 1350 LOCAL_ALIGNED_16(DCTELEM, block, [64]); |
2722 | 1351 int motion_x = 0xdeadbeef, motion_y = 0xdeadbeef; |
1352 int motion_halfpel_index; | |
1353 uint8_t *motion_source; | |
11352 | 1354 int plane, first_pixel; |
2722 | 1355 |
11352 | 1356 if (slice >= s->c_superblock_height) |
2722 | 1357 return; |
1358 | |
1359 for (plane = 0; plane < 3; plane++) { | |
11133 | 1360 uint8_t *output_plane = s->current_frame.data [plane] + s->data_offset[plane]; |
1361 uint8_t * last_plane = s-> last_frame.data [plane] + s->data_offset[plane]; | |
1362 uint8_t *golden_plane = s-> golden_frame.data [plane] + s->data_offset[plane]; | |
3498 | 1363 int stride = s->current_frame.linesize[plane]; |
11475
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
1364 int plane_width = s->width >> (plane && s->chroma_x_shift); |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
1365 int plane_height = s->height >> (plane && s->chroma_y_shift); |
11477 | 1366 int8_t (*motion_val)[2] = s->motion_val[!!plane]; |
11352 | 1367 |
11475
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
1368 int sb_x, sb_y = slice << (!plane && s->chroma_y_shift); |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
1369 int slice_height = sb_y + 1 + (!plane && s->chroma_y_shift); |
11352 | 1370 int slice_width = plane ? s->c_superblock_width : s->y_superblock_width; |
1371 | |
11473 | 1372 int fragment_width = s->fragment_width[!!plane]; |
1373 int fragment_height = s->fragment_height[!!plane]; | |
11352 | 1374 int fragment_start = s->fragment_start[plane]; |
3498 | 1375 |
1376 if (!s->flipped_image) stride = -stride; | |
11154 | 1377 if (CONFIG_GRAY && plane && (s->avctx->flags & CODEC_FLAG_GRAY)) |
1378 continue; | |
3498 | 1379 |
2967 | 1380 |
4001 | 1381 if(FFABS(stride) > 2048) |
2722 | 1382 return; //various tables are fixed size |
1383 | |
11352 | 1384 /* for each superblock row in the slice (both of them)... */ |
1385 for (; sb_y < slice_height; sb_y++) { | |
1386 | |
1387 /* for each superblock in a row... */ | |
1388 for (sb_x = 0; sb_x < slice_width; sb_x++) { | |
2722 | 1389 |
11352 | 1390 /* for each block in a superblock... */ |
1391 for (j = 0; j < 16; j++) { | |
1392 x = 4*sb_x + hilbert_offset[j][0]; | |
1393 y = 4*sb_y + hilbert_offset[j][1]; | |
2722 | 1394 |
11352 | 1395 i = fragment_start + y*fragment_width + x; |
1396 | |
1397 // bounds check | |
1398 if (x >= fragment_width || y >= fragment_height) | |
1399 continue; | |
1400 | |
1401 first_pixel = 8*y*stride + 8*x; | |
2722 | 1402 |
1403 /* transform if this block was coded */ | |
11154 | 1404 if (s->all_fragments[i].coding_method != MODE_COPY) { |
2722 | 1405 if ((s->all_fragments[i].coding_method == MODE_USING_GOLDEN) || |
1406 (s->all_fragments[i].coding_method == MODE_GOLDEN_MV)) | |
1407 motion_source= golden_plane; | |
2967 | 1408 else |
2722 | 1409 motion_source= last_plane; |
1410 | |
11133 | 1411 motion_source += first_pixel; |
2722 | 1412 motion_halfpel_index = 0; |
1413 | |
1414 /* sort out the motion vector if this fragment is coded | |
1415 * using a motion vector method */ | |
1416 if ((s->all_fragments[i].coding_method > MODE_INTRA) && | |
1417 (s->all_fragments[i].coding_method != MODE_USING_GOLDEN)) { | |
1418 int src_x, src_y; | |
11477 | 1419 motion_x = motion_val[y*fragment_width + x][0]; |
1420 motion_y = motion_val[y*fragment_width + x][1]; | |
2722 | 1421 |
11352 | 1422 src_x= (motion_x>>1) + 8*x; |
1423 src_y= (motion_y>>1) + 8*y; | |
2722 | 1424 |
1425 motion_halfpel_index = motion_x & 0x01; | |
1426 motion_source += (motion_x >> 1); | |
1427 | |
1428 motion_halfpel_index |= (motion_y & 0x01) << 1; | |
1429 motion_source += ((motion_y >> 1) * stride); | |
1430 | |
1431 if(src_x<0 || src_y<0 || src_x + 9 >= plane_width || src_y + 9 >= plane_height){ | |
1432 uint8_t *temp= s->edge_emu_buffer; | |
1433 if(stride<0) temp -= 9*stride; | |
1434 else temp += 9*stride; | |
1435 | |
1436 ff_emulated_edge_mc(temp, motion_source, stride, 9, 9, src_x, src_y, plane_width, plane_height); | |
1437 motion_source= temp; | |
1438 } | |
1439 } | |
2967 | 1440 |
2722 | 1441 |
1442 /* first, take care of copying a block from either the | |
1443 * previous or the golden frame */ | |
1444 if (s->all_fragments[i].coding_method != MODE_INTRA) { | |
2967 | 1445 /* Note, it is possible to implement all MC cases with |
1446 put_no_rnd_pixels_l2 which would look more like the | |
1447 VP3 source but this would be slower as | |
2722 | 1448 put_no_rnd_pixels_tab is better optimzed */ |
1449 if(motion_halfpel_index != 3){ | |
1450 s->dsp.put_no_rnd_pixels_tab[1][motion_halfpel_index]( | |
11133 | 1451 output_plane + first_pixel, |
2722 | 1452 motion_source, stride, 8); |
1453 }else{ | |
1454 int d= (motion_x ^ motion_y)>>31; // d is 0 if motion_x and _y have the same sign, else -1 | |
1455 s->dsp.put_no_rnd_pixels_l2[1]( | |
11133 | 1456 output_plane + first_pixel, |
2967 | 1457 motion_source - d, |
1458 motion_source + stride + 1 + d, | |
2722 | 1459 stride, 8); |
1460 } | |
1461 } | |
1462 | |
8288 | 1463 s->dsp.clear_block(block); |
2722 | 1464 |
1465 /* invert DCT and place (or add) in final output */ | |
2967 | 1466 |
2722 | 1467 if (s->all_fragments[i].coding_method == MODE_INTRA) { |
11637 | 1468 vp3_dequant(s, s->all_fragments + i, plane, 0, block); |
2722 | 1469 if(s->avctx->idct_algo!=FF_IDCT_VP3) |
1470 block[0] += 128<<3; | |
1471 s->dsp.idct_put( | |
11133 | 1472 output_plane + first_pixel, |
2722 | 1473 stride, |
1474 block); | |
1475 } else { | |
11637 | 1476 if (vp3_dequant(s, s->all_fragments + i, plane, 1, block)) { |
2722 | 1477 s->dsp.idct_add( |
11133 | 1478 output_plane + first_pixel, |
2722 | 1479 stride, |
1480 block); | |
11637 | 1481 } else { |
1482 s->dsp.vp3_idct_dc_add(output_plane + first_pixel, stride, block); | |
1483 } | |
2722 | 1484 } |
1485 } else { | |
1486 | |
1487 /* copy directly from the previous frame */ | |
1488 s->dsp.put_pixels_tab[1][0]( | |
11133 | 1489 output_plane + first_pixel, |
1490 last_plane + first_pixel, | |
2722 | 1491 stride, 8); |
1492 | |
1493 } | |
11352 | 1494 } |
2722 | 1495 } |
11352 | 1496 |
1497 // Filter up to the last row in the superblock row | |
11782
a617365c7c6f
vp3: Skip the loop filter when strength is 0 or when requested
conrad
parents:
11757
diff
changeset
|
1498 if (!s->skip_loop_filter) |
a617365c7c6f
vp3: Skip the loop filter when strength is 0 or when requested
conrad
parents:
11757
diff
changeset
|
1499 apply_loop_filter(s, plane, 4*sb_y - !!sb_y, FFMIN(4*sb_y+3, fragment_height-1)); |
2722 | 1500 } |
1501 } | |
1502 | |
1503 /* this looks like a good place for slice dispatch... */ | |
1504 /* algorithm: | |
2723
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
1505 * if (slice == s->macroblock_height - 1) |
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
1506 * dispatch (both last slice & 2nd-to-last slice); |
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
1507 * else if (slice > 0) |
2722 | 1508 * dispatch (slice - 1); |
1509 */ | |
1510 | |
11430 | 1511 vp3_draw_horiz_band(s, FFMIN(64*slice + 64-16, s->height-16)); |
2722 | 1512 } |
1513 | |
2967 | 1514 /* |
1224 | 1515 * This is the ffmpeg/libavcodec API init function. |
1516 */ | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6448
diff
changeset
|
1517 static av_cold int vp3_decode_init(AVCodecContext *avctx) |
1224 | 1518 { |
1519 Vp3DecodeContext *s = avctx->priv_data; | |
3489
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
1520 int i, inter, plane; |
1238
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
1521 int c_width; |
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
1522 int c_height; |
11475
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
1523 int y_fragment_count, c_fragment_count; |
1224 | 1524 |
1664 | 1525 if (avctx->codec_tag == MKTAG('V','P','3','0')) |
2979 | 1526 s->version = 0; |
1664 | 1527 else |
2979 | 1528 s->version = 1; |
1664 | 1529 |
1224 | 1530 s->avctx = avctx; |
9686
bc32976d6d9d
Move ALIGN macro to libavutil/common.h and use it in various places
conrad
parents:
9637
diff
changeset
|
1531 s->width = FFALIGN(avctx->width, 16); |
bc32976d6d9d
Move ALIGN macro to libavutil/common.h and use it in various places
conrad
parents:
9637
diff
changeset
|
1532 s->height = FFALIGN(avctx->height, 16); |
11475
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
1533 if (avctx->pix_fmt == PIX_FMT_NONE) |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
1534 avctx->pix_fmt = PIX_FMT_YUV420P; |
9626
bd3e11b60ccd
Add a chroma_sample_location field to define positioning of chroma samples
conrad
parents:
9591
diff
changeset
|
1535 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER; |
2693 | 1536 if(avctx->idct_algo==FF_IDCT_AUTO) |
1537 avctx->idct_algo=FF_IDCT_VP3; | |
1224 | 1538 dsputil_init(&s->dsp, avctx); |
2967 | 1539 |
2694 | 1540 ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct); |
1224 | 1541 |
1542 /* initialize to an impossible value which will force a recalculation | |
1543 * in the first frame decode */ | |
9731 | 1544 for (i = 0; i < 3; i++) |
1545 s->qps[i] = -1; | |
1224 | 1546 |
11475
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
1547 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_x_shift, &s->chroma_y_shift); |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
1548 |
1238
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
1549 s->y_superblock_width = (s->width + 31) / 32; |
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
1550 s->y_superblock_height = (s->height + 31) / 32; |
11351
0f55f380a1b2
Explictly separate decoding whether fragments are coded by plane
conrad
parents:
11314
diff
changeset
|
1551 s->y_superblock_count = s->y_superblock_width * s->y_superblock_height; |
1238
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
1552 |
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
1553 /* work out the dimensions for the C planes */ |
11475
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
1554 c_width = s->width >> s->chroma_x_shift; |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
1555 c_height = s->height >> s->chroma_y_shift; |
1238
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
1556 s->c_superblock_width = (c_width + 31) / 32; |
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
1557 s->c_superblock_height = (c_height + 31) / 32; |
11351
0f55f380a1b2
Explictly separate decoding whether fragments are coded by plane
conrad
parents:
11314
diff
changeset
|
1558 s->c_superblock_count = s->c_superblock_width * s->c_superblock_height; |
1238
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
1559 |
11351
0f55f380a1b2
Explictly separate decoding whether fragments are coded by plane
conrad
parents:
11314
diff
changeset
|
1560 s->superblock_count = s->y_superblock_count + (s->c_superblock_count * 2); |
0f55f380a1b2
Explictly separate decoding whether fragments are coded by plane
conrad
parents:
11314
diff
changeset
|
1561 s->u_superblock_start = s->y_superblock_count; |
0f55f380a1b2
Explictly separate decoding whether fragments are coded by plane
conrad
parents:
11314
diff
changeset
|
1562 s->v_superblock_start = s->u_superblock_start + s->c_superblock_count; |
1224 | 1563 s->superblock_coding = av_malloc(s->superblock_count); |
1564 | |
1565 s->macroblock_width = (s->width + 15) / 16; | |
1566 s->macroblock_height = (s->height + 15) / 16; | |
1567 s->macroblock_count = s->macroblock_width * s->macroblock_height; | |
1568 | |
11473 | 1569 s->fragment_width[0] = s->width / FRAGMENT_PIXELS; |
1570 s->fragment_height[0] = s->height / FRAGMENT_PIXELS; | |
11475
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
1571 s->fragment_width[1] = s->fragment_width[0] >> s->chroma_x_shift; |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
1572 s->fragment_height[1] = s->fragment_height[0] >> s->chroma_y_shift; |
1224 | 1573 |
1574 /* fragment count covers all 8x8 blocks for all 3 planes */ | |
11475
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
1575 y_fragment_count = s->fragment_width[0] * s->fragment_height[0]; |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
1576 c_fragment_count = s->fragment_width[1] * s->fragment_height[1]; |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
1577 s->fragment_count = y_fragment_count + 2*c_fragment_count; |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
1578 s->fragment_start[1] = y_fragment_count; |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
1579 s->fragment_start[2] = y_fragment_count + c_fragment_count; |
1224 | 1580 |
1581 s->all_fragments = av_malloc(s->fragment_count * sizeof(Vp3Fragment)); | |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1582 s->coded_fragment_list[0] = av_malloc(s->fragment_count * sizeof(int)); |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1583 s->dct_tokens_base = av_malloc(64*s->fragment_count * sizeof(*s->dct_tokens_base)); |
11477 | 1584 s->motion_val[0] = av_malloc(y_fragment_count * sizeof(*s->motion_val[0])); |
1585 s->motion_val[1] = av_malloc(c_fragment_count * sizeof(*s->motion_val[1])); | |
1586 | |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1587 if (!s->superblock_coding || !s->all_fragments || !s->dct_tokens_base || |
11477 | 1588 !s->coded_fragment_list[0] || !s->motion_val[0] || !s->motion_val[1]) { |
10258 | 1589 vp3_decode_end(avctx); |
1590 return -1; | |
1591 } | |
1224 | 1592 |
1516
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
1593 if (!s->theora_tables) |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
1594 { |
3585 | 1595 for (i = 0; i < 64; i++) { |
2979 | 1596 s->coded_dc_scale_factor[i] = vp31_dc_scale_factor[i]; |
1597 s->coded_ac_scale_factor[i] = vp31_ac_scale_factor[i]; | |
3489
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
1598 s->base_matrix[0][i] = vp31_intra_y_dequant[i]; |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
1599 s->base_matrix[1][i] = vp31_intra_c_dequant[i]; |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
1600 s->base_matrix[2][i] = vp31_inter_dequant[i]; |
2979 | 1601 s->filter_limit_values[i] = vp31_filter_limit_values[i]; |
3585 | 1602 } |
2718
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1603 |
3489
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
1604 for(inter=0; inter<2; inter++){ |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
1605 for(plane=0; plane<3; plane++){ |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
1606 s->qr_count[inter][plane]= 1; |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
1607 s->qr_size [inter][plane][0]= 63; |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
1608 s->qr_base [inter][plane][0]= |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
1609 s->qr_base [inter][plane][1]= 2*inter + (!!plane)*!inter; |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
1610 } |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
1611 } |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
1612 |
2718
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1613 /* init VLC tables */ |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1614 for (i = 0; i < 16; i++) { |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1615 |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1616 /* DC histograms */ |
11646
a69e24b73f3c
theora: coeff huffman codes are allowed to be up to 32 bits long (for 32 tokens)
conrad
parents:
11644
diff
changeset
|
1617 init_vlc(&s->dc_vlc[i], 11, 32, |
2718
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1618 &dc_bias[i][0][1], 4, 2, |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1619 &dc_bias[i][0][0], 4, 2, 0); |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1620 |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1621 /* group 1 AC histograms */ |
11646
a69e24b73f3c
theora: coeff huffman codes are allowed to be up to 32 bits long (for 32 tokens)
conrad
parents:
11644
diff
changeset
|
1622 init_vlc(&s->ac_vlc_1[i], 11, 32, |
2718
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1623 &ac_bias_0[i][0][1], 4, 2, |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1624 &ac_bias_0[i][0][0], 4, 2, 0); |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1625 |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1626 /* group 2 AC histograms */ |
11646
a69e24b73f3c
theora: coeff huffman codes are allowed to be up to 32 bits long (for 32 tokens)
conrad
parents:
11644
diff
changeset
|
1627 init_vlc(&s->ac_vlc_2[i], 11, 32, |
2718
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1628 &ac_bias_1[i][0][1], 4, 2, |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1629 &ac_bias_1[i][0][0], 4, 2, 0); |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1630 |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1631 /* group 3 AC histograms */ |
11646
a69e24b73f3c
theora: coeff huffman codes are allowed to be up to 32 bits long (for 32 tokens)
conrad
parents:
11644
diff
changeset
|
1632 init_vlc(&s->ac_vlc_3[i], 11, 32, |
2718
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1633 &ac_bias_2[i][0][1], 4, 2, |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1634 &ac_bias_2[i][0][0], 4, 2, 0); |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1635 |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1636 /* group 4 AC histograms */ |
11646
a69e24b73f3c
theora: coeff huffman codes are allowed to be up to 32 bits long (for 32 tokens)
conrad
parents:
11644
diff
changeset
|
1637 init_vlc(&s->ac_vlc_4[i], 11, 32, |
2718
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1638 &ac_bias_3[i][0][1], 4, 2, |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1639 &ac_bias_3[i][0][0], 4, 2, 0); |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1640 } |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1641 } else { |
11646
a69e24b73f3c
theora: coeff huffman codes are allowed to be up to 32 bits long (for 32 tokens)
conrad
parents:
11644
diff
changeset
|
1642 |
2718
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1643 for (i = 0; i < 16; i++) { |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1644 /* DC histograms */ |
11646
a69e24b73f3c
theora: coeff huffman codes are allowed to be up to 32 bits long (for 32 tokens)
conrad
parents:
11644
diff
changeset
|
1645 if (init_vlc(&s->dc_vlc[i], 11, 32, |
a69e24b73f3c
theora: coeff huffman codes are allowed to be up to 32 bits long (for 32 tokens)
conrad
parents:
11644
diff
changeset
|
1646 &s->huffman_table[i][0][1], 8, 4, |
a69e24b73f3c
theora: coeff huffman codes are allowed to be up to 32 bits long (for 32 tokens)
conrad
parents:
11644
diff
changeset
|
1647 &s->huffman_table[i][0][0], 8, 4, 0) < 0) |
9923
ba58c3abf832
Make decode_init fail if the huffman tables are invalid and thus init_vlc fails.
reimar
parents:
9922
diff
changeset
|
1648 goto vlc_fail; |
2718
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1649 |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1650 /* group 1 AC histograms */ |
11646
a69e24b73f3c
theora: coeff huffman codes are allowed to be up to 32 bits long (for 32 tokens)
conrad
parents:
11644
diff
changeset
|
1651 if (init_vlc(&s->ac_vlc_1[i], 11, 32, |
a69e24b73f3c
theora: coeff huffman codes are allowed to be up to 32 bits long (for 32 tokens)
conrad
parents:
11644
diff
changeset
|
1652 &s->huffman_table[i+16][0][1], 8, 4, |
a69e24b73f3c
theora: coeff huffman codes are allowed to be up to 32 bits long (for 32 tokens)
conrad
parents:
11644
diff
changeset
|
1653 &s->huffman_table[i+16][0][0], 8, 4, 0) < 0) |
9923
ba58c3abf832
Make decode_init fail if the huffman tables are invalid and thus init_vlc fails.
reimar
parents:
9922
diff
changeset
|
1654 goto vlc_fail; |
2718
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1655 |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1656 /* group 2 AC histograms */ |
11646
a69e24b73f3c
theora: coeff huffman codes are allowed to be up to 32 bits long (for 32 tokens)
conrad
parents:
11644
diff
changeset
|
1657 if (init_vlc(&s->ac_vlc_2[i], 11, 32, |
a69e24b73f3c
theora: coeff huffman codes are allowed to be up to 32 bits long (for 32 tokens)
conrad
parents:
11644
diff
changeset
|
1658 &s->huffman_table[i+16*2][0][1], 8, 4, |
a69e24b73f3c
theora: coeff huffman codes are allowed to be up to 32 bits long (for 32 tokens)
conrad
parents:
11644
diff
changeset
|
1659 &s->huffman_table[i+16*2][0][0], 8, 4, 0) < 0) |
9923
ba58c3abf832
Make decode_init fail if the huffman tables are invalid and thus init_vlc fails.
reimar
parents:
9922
diff
changeset
|
1660 goto vlc_fail; |
2718
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1661 |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1662 /* group 3 AC histograms */ |
11646
a69e24b73f3c
theora: coeff huffman codes are allowed to be up to 32 bits long (for 32 tokens)
conrad
parents:
11644
diff
changeset
|
1663 if (init_vlc(&s->ac_vlc_3[i], 11, 32, |
a69e24b73f3c
theora: coeff huffman codes are allowed to be up to 32 bits long (for 32 tokens)
conrad
parents:
11644
diff
changeset
|
1664 &s->huffman_table[i+16*3][0][1], 8, 4, |
a69e24b73f3c
theora: coeff huffman codes are allowed to be up to 32 bits long (for 32 tokens)
conrad
parents:
11644
diff
changeset
|
1665 &s->huffman_table[i+16*3][0][0], 8, 4, 0) < 0) |
9923
ba58c3abf832
Make decode_init fail if the huffman tables are invalid and thus init_vlc fails.
reimar
parents:
9922
diff
changeset
|
1666 goto vlc_fail; |
2718
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1667 |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1668 /* group 4 AC histograms */ |
11646
a69e24b73f3c
theora: coeff huffman codes are allowed to be up to 32 bits long (for 32 tokens)
conrad
parents:
11644
diff
changeset
|
1669 if (init_vlc(&s->ac_vlc_4[i], 11, 32, |
a69e24b73f3c
theora: coeff huffman codes are allowed to be up to 32 bits long (for 32 tokens)
conrad
parents:
11644
diff
changeset
|
1670 &s->huffman_table[i+16*4][0][1], 8, 4, |
a69e24b73f3c
theora: coeff huffman codes are allowed to be up to 32 bits long (for 32 tokens)
conrad
parents:
11644
diff
changeset
|
1671 &s->huffman_table[i+16*4][0][0], 8, 4, 0) < 0) |
9923
ba58c3abf832
Make decode_init fail if the huffman tables are invalid and thus init_vlc fails.
reimar
parents:
9922
diff
changeset
|
1672 goto vlc_fail; |
2718
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1673 } |
1224 | 1674 } |
1675 | |
2703
3817945001ce
replace get_superblock_run_length() with a VLC table
melanson
parents:
2702
diff
changeset
|
1676 init_vlc(&s->superblock_run_length_vlc, 6, 34, |
3817945001ce
replace get_superblock_run_length() with a VLC table
melanson
parents:
2702
diff
changeset
|
1677 &superblock_run_length_vlc_table[0][1], 4, 2, |
3817945001ce
replace get_superblock_run_length() with a VLC table
melanson
parents:
2702
diff
changeset
|
1678 &superblock_run_length_vlc_table[0][0], 4, 2, 0); |
3817945001ce
replace get_superblock_run_length() with a VLC table
melanson
parents:
2702
diff
changeset
|
1679 |
2942
868c48736d1c
fixed long standing off-by-one bug (fixes playback on ppc)
alex
parents:
2866
diff
changeset
|
1680 init_vlc(&s->fragment_run_length_vlc, 5, 30, |
2702
5a4e5225cbb6
use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents:
2699
diff
changeset
|
1681 &fragment_run_length_vlc_table[0][1], 4, 2, |
5a4e5225cbb6
use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents:
2699
diff
changeset
|
1682 &fragment_run_length_vlc_table[0][0], 4, 2, 0); |
5a4e5225cbb6
use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents:
2699
diff
changeset
|
1683 |
5a4e5225cbb6
use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents:
2699
diff
changeset
|
1684 init_vlc(&s->mode_code_vlc, 3, 8, |
5a4e5225cbb6
use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents:
2699
diff
changeset
|
1685 &mode_code_vlc_table[0][1], 2, 1, |
5a4e5225cbb6
use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents:
2699
diff
changeset
|
1686 &mode_code_vlc_table[0][0], 2, 1, 0); |
5a4e5225cbb6
use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents:
2699
diff
changeset
|
1687 |
5a4e5225cbb6
use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents:
2699
diff
changeset
|
1688 init_vlc(&s->motion_vector_vlc, 6, 63, |
5a4e5225cbb6
use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents:
2699
diff
changeset
|
1689 &motion_vector_vlc_table[0][1], 2, 1, |
5a4e5225cbb6
use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents:
2699
diff
changeset
|
1690 &motion_vector_vlc_table[0][0], 2, 1, 0); |
5a4e5225cbb6
use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents:
2699
diff
changeset
|
1691 |
1224 | 1692 /* work out the block mapping tables */ |
1693 s->superblock_fragments = av_malloc(s->superblock_count * 16 * sizeof(int)); | |
1240
c95ff60bc1a1
fix motion vector decoding bug and reinstate interframes
tmmm
parents:
1239
diff
changeset
|
1694 s->macroblock_coding = av_malloc(s->macroblock_count + 1); |
11150 | 1695 if (!s->superblock_fragments || !s->macroblock_coding) { |
10258 | 1696 vp3_decode_end(avctx); |
1697 return -1; | |
1698 } | |
1224 | 1699 init_block_mapping(s); |
1700 | |
1229
cefec170ee46
fixed buffer allocation logic (hopefully) so that decoder does not crash
tmmm
parents:
1227
diff
changeset
|
1701 for (i = 0; i < 3; i++) { |
cefec170ee46
fixed buffer allocation logic (hopefully) so that decoder does not crash
tmmm
parents:
1227
diff
changeset
|
1702 s->current_frame.data[i] = NULL; |
cefec170ee46
fixed buffer allocation logic (hopefully) so that decoder does not crash
tmmm
parents:
1227
diff
changeset
|
1703 s->last_frame.data[i] = NULL; |
cefec170ee46
fixed buffer allocation logic (hopefully) so that decoder does not crash
tmmm
parents:
1227
diff
changeset
|
1704 s->golden_frame.data[i] = NULL; |
1227
184c480cefc3
fix decoder so that ffmpeg does not crash, at least not right away
tmmm
parents:
1224
diff
changeset
|
1705 } |
184c480cefc3
fix decoder so that ffmpeg does not crash, at least not right away
tmmm
parents:
1224
diff
changeset
|
1706 |
1224 | 1707 return 0; |
9923
ba58c3abf832
Make decode_init fail if the huffman tables are invalid and thus init_vlc fails.
reimar
parents:
9922
diff
changeset
|
1708 |
ba58c3abf832
Make decode_init fail if the huffman tables are invalid and thus init_vlc fails.
reimar
parents:
9922
diff
changeset
|
1709 vlc_fail: |
ba58c3abf832
Make decode_init fail if the huffman tables are invalid and thus init_vlc fails.
reimar
parents:
9922
diff
changeset
|
1710 av_log(avctx, AV_LOG_FATAL, "Invalid huffman table\n"); |
ba58c3abf832
Make decode_init fail if the huffman tables are invalid and thus init_vlc fails.
reimar
parents:
9922
diff
changeset
|
1711 return -1; |
1224 | 1712 } |
1713 | |
1714 /* | |
1715 * This is the ffmpeg/libavcodec API frame decode function. | |
1716 */ | |
2967 | 1717 static int vp3_decode_frame(AVCodecContext *avctx, |
1224 | 1718 void *data, int *data_size, |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
9007
diff
changeset
|
1719 AVPacket *avpkt) |
1224 | 1720 { |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
9007
diff
changeset
|
1721 const uint8_t *buf = avpkt->data; |
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
9007
diff
changeset
|
1722 int buf_size = avpkt->size; |
1224 | 1723 Vp3DecodeContext *s = avctx->priv_data; |
1724 GetBitContext gb; | |
1725 static int counter = 0; | |
2722 | 1726 int i; |
1224 | 1727 |
1728 init_get_bits(&gb, buf, buf_size * 8); | |
2967 | 1729 |
1516
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
1730 if (s->theora && get_bits1(&gb)) |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
1731 { |
2979 | 1732 av_log(avctx, AV_LOG_ERROR, "Header packet passed to frame decoder, skipping\n"); |
1733 return -1; | |
1516
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
1734 } |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
1735 |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
1736 s->keyframe = !get_bits1(&gb); |
1664 | 1737 if (!s->theora) |
2979 | 1738 skip_bits(&gb, 1); |
9731 | 1739 for (i = 0; i < 3; i++) |
1740 s->last_qps[i] = s->qps[i]; | |
3492
fa3794c46f21
parse all QIS values (we still ignore them though ...)
michael
parents:
3491
diff
changeset
|
1741 |
9731 | 1742 s->nqps=0; |
3492
fa3794c46f21
parse all QIS values (we still ignore them though ...)
michael
parents:
3491
diff
changeset
|
1743 do{ |
9731 | 1744 s->qps[s->nqps++]= get_bits(&gb, 6); |
1745 } while(s->theora >= 0x030200 && s->nqps<3 && get_bits1(&gb)); | |
1746 for (i = s->nqps; i < 3; i++) | |
1747 s->qps[i] = -1; | |
1224 | 1748 |
1667 | 1749 if (s->avctx->debug & FF_DEBUG_PICT_INFO) |
2979 | 1750 av_log(s->avctx, AV_LOG_INFO, " VP3 %sframe #%d: Q index = %d\n", |
9731 | 1751 s->keyframe?"key":"", counter, s->qps[0]); |
1224 | 1752 counter++; |
1753 | |
11782
a617365c7c6f
vp3: Skip the loop filter when strength is 0 or when requested
conrad
parents:
11757
diff
changeset
|
1754 s->skip_loop_filter = !s->filter_limit_values[s->qps[0]] || |
a617365c7c6f
vp3: Skip the loop filter when strength is 0 or when requested
conrad
parents:
11757
diff
changeset
|
1755 avctx->skip_loop_filter >= (s->keyframe ? AVDISCARD_ALL : AVDISCARD_NONKEY); |
a617365c7c6f
vp3: Skip the loop filter when strength is 0 or when requested
conrad
parents:
11757
diff
changeset
|
1756 |
9731 | 1757 if (s->qps[0] != s->last_qps[0]) |
2723
5ae980827158
apply the loop filter to fragments as they are rendered into the final
melanson
parents:
2722
diff
changeset
|
1758 init_loop_filter(s); |
9731 | 1759 |
1760 for (i = 0; i < s->nqps; i++) | |
1761 // reinit all dequantizers if the first one changed, because | |
1762 // the DC of the first quantizer must be used for all matrices | |
1763 if (s->qps[i] != s->last_qps[i] || s->qps[0] != s->last_qps[0]) | |
1764 init_dequantizer(s, i); | |
1292
f7b3fa4bb7ae
revising and fixing motion vectors, squished block unpacking bug that
tmmm
parents:
1282
diff
changeset
|
1765 |
7938
66226ee647a4
Use skip_frame for keyframe-only decoding rather than #ifdef
conrad
parents:
7875
diff
changeset
|
1766 if (avctx->skip_frame >= AVDISCARD_NONKEY && !s->keyframe) |
66226ee647a4
Use skip_frame for keyframe-only decoding rather than #ifdef
conrad
parents:
7875
diff
changeset
|
1767 return buf_size; |
66226ee647a4
Use skip_frame for keyframe-only decoding rather than #ifdef
conrad
parents:
7875
diff
changeset
|
1768 |
11419 | 1769 s->current_frame.reference = 3; |
11423 | 1770 s->current_frame.pict_type = s->keyframe ? FF_I_TYPE : FF_P_TYPE; |
11419 | 1771 if (avctx->get_buffer(avctx, &s->current_frame) < 0) { |
1772 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n"); | |
11420 | 1773 goto error; |
11419 | 1774 } |
1775 | |
1224 | 1776 if (s->keyframe) { |
2979 | 1777 if (!s->theora) |
1778 { | |
1779 skip_bits(&gb, 4); /* width code */ | |
1780 skip_bits(&gb, 4); /* height code */ | |
1781 if (s->version) | |
1782 { | |
1783 s->version = get_bits(&gb, 5); | |
1784 if (counter == 1) | |
1785 av_log(s->avctx, AV_LOG_DEBUG, "VP version: %d\n", s->version); | |
1786 } | |
1787 } | |
1788 if (s->version || s->theora) | |
1789 { | |
1790 if (get_bits1(&gb)) | |
1791 av_log(s->avctx, AV_LOG_ERROR, "Warning, unsupported keyframe coding type?!\n"); | |
1792 skip_bits(&gb, 2); /* reserved? */ | |
1793 } | |
1224 | 1794 } else { |
11133 | 1795 if (!s->golden_frame.data[0]) { |
11422
56266eb23fb7
vp3: Allocate a dummy reference frame if we have no keyframe
conrad
parents:
11421
diff
changeset
|
1796 av_log(s->avctx, AV_LOG_WARNING, "vp3: first frame not a keyframe\n"); |
11423 | 1797 |
11422
56266eb23fb7
vp3: Allocate a dummy reference frame if we have no keyframe
conrad
parents:
11421
diff
changeset
|
1798 s->golden_frame.reference = 3; |
11423 | 1799 s->golden_frame.pict_type = FF_I_TYPE; |
11422
56266eb23fb7
vp3: Allocate a dummy reference frame if we have no keyframe
conrad
parents:
11421
diff
changeset
|
1800 if (avctx->get_buffer(avctx, &s->golden_frame) < 0) { |
56266eb23fb7
vp3: Allocate a dummy reference frame if we have no keyframe
conrad
parents:
11421
diff
changeset
|
1801 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n"); |
56266eb23fb7
vp3: Allocate a dummy reference frame if we have no keyframe
conrad
parents:
11421
diff
changeset
|
1802 goto error; |
56266eb23fb7
vp3: Allocate a dummy reference frame if we have no keyframe
conrad
parents:
11421
diff
changeset
|
1803 } |
56266eb23fb7
vp3: Allocate a dummy reference frame if we have no keyframe
conrad
parents:
11421
diff
changeset
|
1804 s->last_frame = s->golden_frame; |
56266eb23fb7
vp3: Allocate a dummy reference frame if we have no keyframe
conrad
parents:
11421
diff
changeset
|
1805 s->last_frame.type = FF_BUFFER_TYPE_COPY; |
1224 | 1806 } |
1807 } | |
1808 | |
1407 | 1809 s->current_frame.qscale_table= s->qscale_table; //FIXME allocate individual tables per AVFrame |
1810 s->current_frame.qstride= 0; | |
1811 | |
11471 | 1812 memset(s->all_fragments, 0, s->fragment_count * sizeof(Vp3Fragment)); |
1224 | 1813 |
2687 | 1814 if (unpack_superblocks(s, &gb)){ |
1815 av_log(s->avctx, AV_LOG_ERROR, "error in unpack_superblocks\n"); | |
11420 | 1816 goto error; |
2687 | 1817 } |
1818 if (unpack_modes(s, &gb)){ | |
1819 av_log(s->avctx, AV_LOG_ERROR, "error in unpack_modes\n"); | |
11420 | 1820 goto error; |
1238
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
1821 } |
2687 | 1822 if (unpack_vectors(s, &gb)){ |
1823 av_log(s->avctx, AV_LOG_ERROR, "error in unpack_vectors\n"); | |
11420 | 1824 goto error; |
2687 | 1825 } |
9731 | 1826 if (unpack_block_qpis(s, &gb)){ |
1827 av_log(s->avctx, AV_LOG_ERROR, "error in unpack_block_qpis\n"); | |
11420 | 1828 goto error; |
9731 | 1829 } |
2687 | 1830 if (unpack_dct_coeffs(s, &gb)){ |
1831 av_log(s->avctx, AV_LOG_ERROR, "error in unpack_dct_coeffs\n"); | |
11420 | 1832 goto error; |
2687 | 1833 } |
1224 | 1834 |
11133 | 1835 for (i = 0; i < 3; i++) { |
11475
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
1836 int height = s->height >> (i && s->chroma_y_shift); |
11133 | 1837 if (s->flipped_image) |
1838 s->data_offset[i] = 0; | |
1839 else | |
11475
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
1840 s->data_offset[i] = (height-1) * s->current_frame.linesize[i]; |
11133 | 1841 } |
1842 | |
11132
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1843 s->last_slice_end = 0; |
11352 | 1844 for (i = 0; i < s->c_superblock_height; i++) |
2722 | 1845 render_slice(s, i); |
7038
110080ab2391
Remove the START_TIMER/STOP_TIMER from vp3.c, they clutter the output and
reimar
parents:
7037
diff
changeset
|
1846 |
11130 | 1847 // filter the last row |
1848 for (i = 0; i < 3; i++) { | |
11475
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
1849 int row = (s->height >> (3+(i && s->chroma_y_shift))) - 1; |
11130 | 1850 apply_loop_filter(s, i, row, row+1); |
1851 } | |
11132
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
1852 vp3_draw_horiz_band(s, s->height); |
1238
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
1853 |
1224 | 1854 *data_size=sizeof(AVFrame); |
1855 *(AVFrame*)data= s->current_frame; | |
1856 | |
1229
cefec170ee46
fixed buffer allocation logic (hopefully) so that decoder does not crash
tmmm
parents:
1227
diff
changeset
|
1857 /* release the last frame, if it is allocated and if it is not the |
cefec170ee46
fixed buffer allocation logic (hopefully) so that decoder does not crash
tmmm
parents:
1227
diff
changeset
|
1858 * golden frame */ |
11421 | 1859 if (s->last_frame.data[0] && s->last_frame.type != FF_BUFFER_TYPE_COPY) |
1229
cefec170ee46
fixed buffer allocation logic (hopefully) so that decoder does not crash
tmmm
parents:
1227
diff
changeset
|
1860 avctx->release_buffer(avctx, &s->last_frame); |
1224 | 1861 |
1227
184c480cefc3
fix decoder so that ffmpeg does not crash, at least not right away
tmmm
parents:
1224
diff
changeset
|
1862 /* shuffle frames (last = current) */ |
3486 | 1863 s->last_frame= s->current_frame; |
11419 | 1864 |
1865 if (s->keyframe) { | |
1866 if (s->golden_frame.data[0]) | |
1867 avctx->release_buffer(avctx, &s->golden_frame); | |
1868 s->golden_frame = s->current_frame; | |
11421 | 1869 s->last_frame.type = FF_BUFFER_TYPE_COPY; |
11419 | 1870 } |
1871 | |
1405
e69f99ade5b0
fix AVFrame.reference (the frames are used for decoding future frames so it should be !=0)
michaelni
parents:
1355
diff
changeset
|
1872 s->current_frame.data[0]= NULL; /* ensure that we catch any access to this released frame */ |
1224 | 1873 |
1874 return buf_size; | |
11420 | 1875 |
1876 error: | |
1877 if (s->current_frame.data[0]) | |
1878 avctx->release_buffer(avctx, &s->current_frame); | |
1879 return -1; | |
1224 | 1880 } |
1881 | |
1882 /* | |
1883 * This is the ffmpeg/libavcodec API module cleanup function. | |
1884 */ | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6448
diff
changeset
|
1885 static av_cold int vp3_decode_end(AVCodecContext *avctx) |
1224 | 1886 { |
1887 Vp3DecodeContext *s = avctx->priv_data; | |
6393 | 1888 int i; |
1889 | |
1890 av_free(s->superblock_coding); | |
1224 | 1891 av_free(s->all_fragments); |
11353
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1892 av_free(s->coded_fragment_list[0]); |
1ea249b4c6e7
Delay translating DCT tokens into coefficients until immediately before IDCT
conrad
parents:
11352
diff
changeset
|
1893 av_free(s->dct_tokens_base); |
1224 | 1894 av_free(s->superblock_fragments); |
1240
c95ff60bc1a1
fix motion vector decoding bug and reinstate interframes
tmmm
parents:
1239
diff
changeset
|
1895 av_free(s->macroblock_coding); |
11477 | 1896 av_free(s->motion_val[0]); |
1897 av_free(s->motion_val[1]); | |
2967 | 1898 |
6393 | 1899 for (i = 0; i < 16; i++) { |
1900 free_vlc(&s->dc_vlc[i]); | |
1901 free_vlc(&s->ac_vlc_1[i]); | |
1902 free_vlc(&s->ac_vlc_2[i]); | |
1903 free_vlc(&s->ac_vlc_3[i]); | |
1904 free_vlc(&s->ac_vlc_4[i]); | |
1905 } | |
1906 | |
1907 free_vlc(&s->superblock_run_length_vlc); | |
1908 free_vlc(&s->fragment_run_length_vlc); | |
1909 free_vlc(&s->mode_code_vlc); | |
1910 free_vlc(&s->motion_vector_vlc); | |
1911 | |
1224 | 1912 /* release all frames */ |
11421 | 1913 if (s->golden_frame.data[0]) |
1238
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
1914 avctx->release_buffer(avctx, &s->golden_frame); |
11421 | 1915 if (s->last_frame.data[0] && s->last_frame.type != FF_BUFFER_TYPE_COPY) |
1238
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
1916 avctx->release_buffer(avctx, &s->last_frame); |
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
1917 /* no need to release the current_frame since it will always be pointing |
6eab0df78d47
squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents:
1236
diff
changeset
|
1918 * to the same frame as either the golden or last frame */ |
1224 | 1919 |
1920 return 0; | |
1921 } | |
1922 | |
2718
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1923 static int read_huffman_tree(AVCodecContext *avctx, GetBitContext *gb) |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1924 { |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1925 Vp3DecodeContext *s = avctx->priv_data; |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1926 |
5513 | 1927 if (get_bits1(gb)) { |
2718
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1928 int token; |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1929 if (s->entries >= 32) { /* overflow */ |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1930 av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n"); |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1931 return -1; |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1932 } |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1933 token = get_bits(gb, 5); |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1934 //av_log(avctx, AV_LOG_DEBUG, "hti %d hbits %x token %d entry : %d size %d\n", s->hti, s->hbits, token, s->entries, s->huff_code_size); |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1935 s->huffman_table[s->hti][token][0] = s->hbits; |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1936 s->huffman_table[s->hti][token][1] = s->huff_code_size; |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1937 s->entries++; |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1938 } |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1939 else { |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1940 if (s->huff_code_size >= 32) {/* overflow */ |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1941 av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n"); |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1942 return -1; |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1943 } |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1944 s->huff_code_size++; |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1945 s->hbits <<= 1; |
8770 | 1946 if (read_huffman_tree(avctx, gb)) |
1947 return -1; | |
2718
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1948 s->hbits |= 1; |
8770 | 1949 if (read_huffman_tree(avctx, gb)) |
1950 return -1; | |
2718
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1951 s->hbits >>= 1; |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1952 s->huff_code_size--; |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1953 } |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1954 return 0; |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1955 } |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
1956 |
8590 | 1957 #if CONFIG_THEORA_DECODER |
11475
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
1958 static const enum PixelFormat theora_pix_fmts[4] = { |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
1959 PIX_FMT_YUV420P, PIX_FMT_NONE, PIX_FMT_YUV422P, PIX_FMT_YUV444P |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
1960 }; |
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
1961 |
3484
9a70c6d3c653
check how many bits are left after decoding extradata
michael
parents:
3483
diff
changeset
|
1962 static int theora_decode_header(AVCodecContext *avctx, GetBitContext *gb) |
1516
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
1963 { |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
1964 Vp3DecodeContext *s = avctx->priv_data; |
11128 | 1965 int visible_width, visible_height, colorspace; |
11638
fb475c791336
vp3: Don't crop if there's a left/top offset, it's wrong
conrad
parents:
11637
diff
changeset
|
1966 int offset_x = 0, offset_y = 0; |
11639 | 1967 AVRational fps; |
3483 | 1968 |
3484
9a70c6d3c653
check how many bits are left after decoding extradata
michael
parents:
3483
diff
changeset
|
1969 s->theora = get_bits_long(gb, 24); |
6349
aed237dd11d8
Print Theora bitstream version at DEBUG, not at VERBOSE level.
diego
parents:
6282
diff
changeset
|
1970 av_log(avctx, AV_LOG_DEBUG, "Theora bitstream version %X\n", s->theora); |
1627
a80b15c0b9d5
theora alpha3 support (with maintaining backward compatibility, maybe we should remove all backward compatibility codes after final theora release?)
alex
parents:
1626
diff
changeset
|
1971 |
2678 | 1972 /* 3.2.0 aka alpha3 has the same frame orientation as original vp3 */ |
1626
f74ae637ffa9
finally working with old theora bitstream (flipped image), the only sample I have is decoded successfully (theora.ogg)
alex
parents:
1598
diff
changeset
|
1973 /* but previous versions have the image flipped relative to vp3 */ |
2678 | 1974 if (s->theora < 0x030200) |
1626
f74ae637ffa9
finally working with old theora bitstream (flipped image), the only sample I have is decoded successfully (theora.ogg)
alex
parents:
1598
diff
changeset
|
1975 { |
2979 | 1976 s->flipped_image = 1; |
1626
f74ae637ffa9
finally working with old theora bitstream (flipped image), the only sample I have is decoded successfully (theora.ogg)
alex
parents:
1598
diff
changeset
|
1977 av_log(avctx, AV_LOG_DEBUG, "Old (<alpha3) Theora bitstream, flipped image\n"); |
f74ae637ffa9
finally working with old theora bitstream (flipped image), the only sample I have is decoded successfully (theora.ogg)
alex
parents:
1598
diff
changeset
|
1978 } |
f74ae637ffa9
finally working with old theora bitstream (flipped image), the only sample I have is decoded successfully (theora.ogg)
alex
parents:
1598
diff
changeset
|
1979 |
7967
6ac2c8312a2b
Visible width/height fields were added in Theora 3.2
conrad
parents:
7966
diff
changeset
|
1980 visible_width = s->width = get_bits(gb, 16) << 4; |
6ac2c8312a2b
Visible width/height fields were added in Theora 3.2
conrad
parents:
7966
diff
changeset
|
1981 visible_height = s->height = get_bits(gb, 16) << 4; |
2967 | 1982 |
2422 | 1983 if(avcodec_check_dimensions(avctx, s->width, s->height)){ |
2943
6bf62c1cf1b6
Fixing theora _again_. DONT BOTHER BREAKING THIS AGAIN. Added support for Theora 3.4 and stream created by Elphel cameras are decodable.
alex
parents:
2942
diff
changeset
|
1984 av_log(avctx, AV_LOG_ERROR, "Invalid dimensions (%dx%d)\n", s->width, s->height); |
2422 | 1985 s->width= s->height= 0; |
1986 return -1; | |
1987 } | |
2943
6bf62c1cf1b6
Fixing theora _again_. DONT BOTHER BREAKING THIS AGAIN. Added support for Theora 3.4 and stream created by Elphel cameras are decodable.
alex
parents:
2942
diff
changeset
|
1988 |
7967
6ac2c8312a2b
Visible width/height fields were added in Theora 3.2
conrad
parents:
7966
diff
changeset
|
1989 if (s->theora >= 0x030200) { |
7968 | 1990 visible_width = get_bits_long(gb, 24); |
1991 visible_height = get_bits_long(gb, 24); | |
1516
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
1992 |
11638
fb475c791336
vp3: Don't crop if there's a left/top offset, it's wrong
conrad
parents:
11637
diff
changeset
|
1993 offset_x = get_bits(gb, 8); /* offset x */ |
fb475c791336
vp3: Don't crop if there's a left/top offset, it's wrong
conrad
parents:
11637
diff
changeset
|
1994 offset_y = get_bits(gb, 8); /* offset y, from bottom */ |
4936 | 1995 } |
3484
9a70c6d3c653
check how many bits are left after decoding extradata
michael
parents:
3483
diff
changeset
|
1996 |
11639 | 1997 fps.num = get_bits_long(gb, 32); |
1998 fps.den = get_bits_long(gb, 32); | |
1999 if (fps.num && fps.den) { | |
11640 | 2000 av_reduce(&avctx->time_base.num, &avctx->time_base.den, |
2001 fps.den, fps.num, 1<<30); | |
11639 | 2002 } |
2003 | |
2004 avctx->sample_aspect_ratio.num = get_bits_long(gb, 24); | |
2005 avctx->sample_aspect_ratio.den = get_bits_long(gb, 24); | |
2967 | 2006 |
2678 | 2007 if (s->theora < 0x030200) |
3484
9a70c6d3c653
check how many bits are left after decoding extradata
michael
parents:
3483
diff
changeset
|
2008 skip_bits(gb, 5); /* keyframe frequency force */ |
11128 | 2009 colorspace = get_bits(gb, 8); |
3484
9a70c6d3c653
check how many bits are left after decoding extradata
michael
parents:
3483
diff
changeset
|
2010 skip_bits(gb, 24); /* bitrate */ |
9a70c6d3c653
check how many bits are left after decoding extradata
michael
parents:
3483
diff
changeset
|
2011 |
9a70c6d3c653
check how many bits are left after decoding extradata
michael
parents:
3483
diff
changeset
|
2012 skip_bits(gb, 6); /* quality hint */ |
2967 | 2013 |
2678 | 2014 if (s->theora >= 0x030200) |
1627
a80b15c0b9d5
theora alpha3 support (with maintaining backward compatibility, maybe we should remove all backward compatibility codes after final theora release?)
alex
parents:
1626
diff
changeset
|
2015 { |
3484
9a70c6d3c653
check how many bits are left after decoding extradata
michael
parents:
3483
diff
changeset
|
2016 skip_bits(gb, 5); /* keyframe frequency force */ |
11475
b7744b7bee4b
theora: Add support for 4:2:2 and 4:4:4 subsampling
conrad
parents:
11474
diff
changeset
|
2017 avctx->pix_fmt = theora_pix_fmts[get_bits(gb, 2)]; |
11127
2f7baf2042a3
Theora 3.4 doesn't exist; these fields were misunderstandings of the spec
conrad
parents:
11126
diff
changeset
|
2018 skip_bits(gb, 3); /* reserved */ |
1627
a80b15c0b9d5
theora alpha3 support (with maintaining backward compatibility, maybe we should remove all backward compatibility codes after final theora release?)
alex
parents:
1626
diff
changeset
|
2019 } |
2967 | 2020 |
3484
9a70c6d3c653
check how many bits are left after decoding extradata
michael
parents:
3483
diff
changeset
|
2021 // align_get_bits(gb); |
2967 | 2022 |
4935
b34f448e1a12
fix display of theora videos with visible size smaller than encoded size
aurel
parents:
4826
diff
changeset
|
2023 if ( visible_width <= s->width && visible_width > s->width-16 |
11638
fb475c791336
vp3: Don't crop if there's a left/top offset, it's wrong
conrad
parents:
11637
diff
changeset
|
2024 && visible_height <= s->height && visible_height > s->height-16 |
fb475c791336
vp3: Don't crop if there's a left/top offset, it's wrong
conrad
parents:
11637
diff
changeset
|
2025 && !offset_x && (offset_y == s->height - visible_height)) |
4935
b34f448e1a12
fix display of theora videos with visible size smaller than encoded size
aurel
parents:
4826
diff
changeset
|
2026 avcodec_set_dimensions(avctx, visible_width, visible_height); |
b34f448e1a12
fix display of theora videos with visible size smaller than encoded size
aurel
parents:
4826
diff
changeset
|
2027 else |
b34f448e1a12
fix display of theora videos with visible size smaller than encoded size
aurel
parents:
4826
diff
changeset
|
2028 avcodec_set_dimensions(avctx, s->width, s->height); |
1516
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2029 |
11128 | 2030 if (colorspace == 1) { |
2031 avctx->color_primaries = AVCOL_PRI_BT470M; | |
2032 } else if (colorspace == 2) { | |
2033 avctx->color_primaries = AVCOL_PRI_BT470BG; | |
2034 } | |
2035 if (colorspace == 1 || colorspace == 2) { | |
2036 avctx->colorspace = AVCOL_SPC_BT470BG; | |
2037 avctx->color_trc = AVCOL_TRC_BT709; | |
2038 } | |
2039 | |
1516
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2040 return 0; |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2041 } |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2042 |
3484
9a70c6d3c653
check how many bits are left after decoding extradata
michael
parents:
3483
diff
changeset
|
2043 static int theora_decode_tables(AVCodecContext *avctx, GetBitContext *gb) |
1516
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2044 { |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2045 Vp3DecodeContext *s = avctx->priv_data; |
3489
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2046 int i, n, matrices, inter, plane; |
2678 | 2047 |
2048 if (s->theora >= 0x030200) { | |
3484
9a70c6d3c653
check how many bits are left after decoding extradata
michael
parents:
3483
diff
changeset
|
2049 n = get_bits(gb, 3); |
2731
0b4b57c4a8f5
read loop filter limit values from Theora header, courtesy of Matthieu
melanson
parents:
2726
diff
changeset
|
2050 /* loop filter limit values table */ |
9922
ffdd1d32c40c
Ensure that the filter limit values do not exceed the maximum allowed value of 127.
reimar
parents:
9921
diff
changeset
|
2051 for (i = 0; i < 64; i++) { |
3484
9a70c6d3c653
check how many bits are left after decoding extradata
michael
parents:
3483
diff
changeset
|
2052 s->filter_limit_values[i] = get_bits(gb, n); |
9922
ffdd1d32c40c
Ensure that the filter limit values do not exceed the maximum allowed value of 127.
reimar
parents:
9921
diff
changeset
|
2053 if (s->filter_limit_values[i] > 127) { |
ffdd1d32c40c
Ensure that the filter limit values do not exceed the maximum allowed value of 127.
reimar
parents:
9921
diff
changeset
|
2054 av_log(avctx, AV_LOG_ERROR, "filter limit value too large (%i > 127), clamping\n", s->filter_limit_values[i]); |
ffdd1d32c40c
Ensure that the filter limit values do not exceed the maximum allowed value of 127.
reimar
parents:
9921
diff
changeset
|
2055 s->filter_limit_values[i] = 127; |
ffdd1d32c40c
Ensure that the filter limit values do not exceed the maximum allowed value of 127.
reimar
parents:
9921
diff
changeset
|
2056 } |
ffdd1d32c40c
Ensure that the filter limit values do not exceed the maximum allowed value of 127.
reimar
parents:
9921
diff
changeset
|
2057 } |
2678 | 2058 } |
2967 | 2059 |
2678 | 2060 if (s->theora >= 0x030200) |
3484
9a70c6d3c653
check how many bits are left after decoding extradata
michael
parents:
3483
diff
changeset
|
2061 n = get_bits(gb, 4) + 1; |
2678 | 2062 else |
2063 n = 16; | |
1516
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2064 /* quality threshold table */ |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2065 for (i = 0; i < 64; i++) |
3484
9a70c6d3c653
check how many bits are left after decoding extradata
michael
parents:
3483
diff
changeset
|
2066 s->coded_ac_scale_factor[i] = get_bits(gb, n); |
2678 | 2067 |
2068 if (s->theora >= 0x030200) | |
3484
9a70c6d3c653
check how many bits are left after decoding extradata
michael
parents:
3483
diff
changeset
|
2069 n = get_bits(gb, 4) + 1; |
2678 | 2070 else |
2071 n = 16; | |
1516
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2072 /* dc scale factor table */ |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2073 for (i = 0; i < 64; i++) |
3484
9a70c6d3c653
check how many bits are left after decoding extradata
michael
parents:
3483
diff
changeset
|
2074 s->coded_dc_scale_factor[i] = get_bits(gb, n); |
2678 | 2075 |
2076 if (s->theora >= 0x030200) | |
3484
9a70c6d3c653
check how many bits are left after decoding extradata
michael
parents:
3483
diff
changeset
|
2077 matrices = get_bits(gb, 9) + 1; |
2678 | 2078 else |
2944
3785497656c9
Correctly skip unknown matrices (patch by Matthieu Castet) and disable comment reading
alex
parents:
2943
diff
changeset
|
2079 matrices = 3; |
3489
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2080 |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2081 if(matrices > 384){ |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2082 av_log(avctx, AV_LOG_ERROR, "invalid number of base matrixes\n"); |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2083 return -1; |
2678 | 2084 } |
3489
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2085 |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2086 for(n=0; n<matrices; n++){ |
2979 | 2087 for (i = 0; i < 64; i++) |
3489
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2088 s->base_matrix[n][i]= get_bits(gb, 8); |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2089 } |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2090 |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2091 for (inter = 0; inter <= 1; inter++) { |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2092 for (plane = 0; plane <= 2; plane++) { |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2093 int newqr= 1; |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2094 if (inter || plane > 0) |
5513 | 2095 newqr = get_bits1(gb); |
2718
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
2096 if (!newqr) { |
3489
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2097 int qtj, plj; |
5513 | 2098 if(inter && get_bits1(gb)){ |
3489
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2099 qtj = 0; |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2100 plj = plane; |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2101 }else{ |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2102 qtj= (3*inter + plane - 1) / 3; |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2103 plj= (plane + 2) % 3; |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2104 } |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2105 s->qr_count[inter][plane]= s->qr_count[qtj][plj]; |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2106 memcpy(s->qr_size[inter][plane], s->qr_size[qtj][plj], sizeof(s->qr_size[0][0])); |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2107 memcpy(s->qr_base[inter][plane], s->qr_base[qtj][plj], sizeof(s->qr_base[0][0])); |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2108 } else { |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2109 int qri= 0; |
2718
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
2110 int qi = 0; |
3489
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2111 |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2112 for(;;){ |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2113 i= get_bits(gb, av_log2(matrices-1)+1); |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2114 if(i>= matrices){ |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2115 av_log(avctx, AV_LOG_ERROR, "invalid base matrix index\n"); |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2116 return -1; |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2117 } |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2118 s->qr_base[inter][plane][qri]= i; |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2119 if(qi >= 63) |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2120 break; |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2121 i = get_bits(gb, av_log2(63-qi)+1) + 1; |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2122 s->qr_size[inter][plane][qri++]= i; |
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2123 qi += i; |
2718
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
2124 } |
3489
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2125 |
2944
3785497656c9
Correctly skip unknown matrices (patch by Matthieu Castet) and disable comment reading
alex
parents:
2943
diff
changeset
|
2126 if (qi > 63) { |
2943
6bf62c1cf1b6
Fixing theora _again_. DONT BOTHER BREAKING THIS AGAIN. Added support for Theora 3.4 and stream created by Elphel cameras are decodable.
alex
parents:
2942
diff
changeset
|
2127 av_log(avctx, AV_LOG_ERROR, "invalid qi %d > 63\n", qi); |
2979 | 2128 return -1; |
2129 } | |
3489
9aacd9410e57
attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents:
3488
diff
changeset
|
2130 s->qr_count[inter][plane]= qri; |
2718
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
2131 } |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
2132 } |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
2133 } |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
2134 |
2944
3785497656c9
Correctly skip unknown matrices (patch by Matthieu Castet) and disable comment reading
alex
parents:
2943
diff
changeset
|
2135 /* Huffman tables */ |
2718
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
2136 for (s->hti = 0; s->hti < 80; s->hti++) { |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
2137 s->entries = 0; |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
2138 s->huff_code_size = 1; |
5513 | 2139 if (!get_bits1(gb)) { |
2718
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
2140 s->hbits = 0; |
8770 | 2141 if(read_huffman_tree(avctx, gb)) |
2142 return -1; | |
2718
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
2143 s->hbits = 1; |
8770 | 2144 if(read_huffman_tree(avctx, gb)) |
2145 return -1; | |
2718
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
2146 } |
158dc437c783
read Huffman tables from Theora header (patch courtesy of
melanson
parents:
2714
diff
changeset
|
2147 } |
2967 | 2148 |
1516
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2149 s->theora_tables = 1; |
2967 | 2150 |
1516
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2151 return 0; |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2152 } |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2153 |
9007
043574c5c153
Add missing av_cold in static init/close functions.
stefano
parents:
8770
diff
changeset
|
2154 static av_cold int theora_decode_init(AVCodecContext *avctx) |
1516
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2155 { |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2156 Vp3DecodeContext *s = avctx->priv_data; |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2157 GetBitContext gb; |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2158 int ptype; |
4723
b62a3a46856c
use generic xiph header spliting func to split theora headers
aurel
parents:
4594
diff
changeset
|
2159 uint8_t *header_start[3]; |
b62a3a46856c
use generic xiph header spliting func to split theora headers
aurel
parents:
4594
diff
changeset
|
2160 int header_len[3]; |
b62a3a46856c
use generic xiph header spliting func to split theora headers
aurel
parents:
4594
diff
changeset
|
2161 int i; |
2967 | 2162 |
1516
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2163 s->theora = 1; |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2164 |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2165 if (!avctx->extradata_size) |
2943
6bf62c1cf1b6
Fixing theora _again_. DONT BOTHER BREAKING THIS AGAIN. Added support for Theora 3.4 and stream created by Elphel cameras are decodable.
alex
parents:
2942
diff
changeset
|
2166 { |
6bf62c1cf1b6
Fixing theora _again_. DONT BOTHER BREAKING THIS AGAIN. Added support for Theora 3.4 and stream created by Elphel cameras are decodable.
alex
parents:
2942
diff
changeset
|
2167 av_log(avctx, AV_LOG_ERROR, "Missing extradata!\n"); |
2979 | 2168 return -1; |
2943
6bf62c1cf1b6
Fixing theora _again_. DONT BOTHER BREAKING THIS AGAIN. Added support for Theora 3.4 and stream created by Elphel cameras are decodable.
alex
parents:
2942
diff
changeset
|
2169 } |
1516
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2170 |
4723
b62a3a46856c
use generic xiph header spliting func to split theora headers
aurel
parents:
4594
diff
changeset
|
2171 if (ff_split_xiph_headers(avctx->extradata, avctx->extradata_size, |
b62a3a46856c
use generic xiph header spliting func to split theora headers
aurel
parents:
4594
diff
changeset
|
2172 42, header_start, header_len) < 0) { |
b62a3a46856c
use generic xiph header spliting func to split theora headers
aurel
parents:
4594
diff
changeset
|
2173 av_log(avctx, AV_LOG_ERROR, "Corrupt extradata\n"); |
b62a3a46856c
use generic xiph header spliting func to split theora headers
aurel
parents:
4594
diff
changeset
|
2174 return -1; |
b62a3a46856c
use generic xiph header spliting func to split theora headers
aurel
parents:
4594
diff
changeset
|
2175 } |
b62a3a46856c
use generic xiph header spliting func to split theora headers
aurel
parents:
4594
diff
changeset
|
2176 |
2533 | 2177 for(i=0;i<3;i++) { |
10247 | 2178 init_get_bits(&gb, header_start[i], header_len[i] * 8); |
1516
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2179 |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2180 ptype = get_bits(&gb, 8); |
2967 | 2181 |
2943
6bf62c1cf1b6
Fixing theora _again_. DONT BOTHER BREAKING THIS AGAIN. Added support for Theora 3.4 and stream created by Elphel cameras are decodable.
alex
parents:
2942
diff
changeset
|
2182 if (!(ptype & 0x80)) |
6bf62c1cf1b6
Fixing theora _again_. DONT BOTHER BREAKING THIS AGAIN. Added support for Theora 3.4 and stream created by Elphel cameras are decodable.
alex
parents:
2942
diff
changeset
|
2183 { |
6bf62c1cf1b6
Fixing theora _again_. DONT BOTHER BREAKING THIS AGAIN. Added support for Theora 3.4 and stream created by Elphel cameras are decodable.
alex
parents:
2942
diff
changeset
|
2184 av_log(avctx, AV_LOG_ERROR, "Invalid extradata!\n"); |
3484
9a70c6d3c653
check how many bits are left after decoding extradata
michael
parents:
3483
diff
changeset
|
2185 // return -1; |
2967 | 2186 } |
2943
6bf62c1cf1b6
Fixing theora _again_. DONT BOTHER BREAKING THIS AGAIN. Added support for Theora 3.4 and stream created by Elphel cameras are decodable.
alex
parents:
2942
diff
changeset
|
2187 |
4561 | 2188 // FIXME: Check for this as well. |
9637 | 2189 skip_bits_long(&gb, 6*8); /* "theora" */ |
2967 | 2190 |
1516
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2191 switch(ptype) |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2192 { |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2193 case 0x80: |
3484
9a70c6d3c653
check how many bits are left after decoding extradata
michael
parents:
3483
diff
changeset
|
2194 theora_decode_header(avctx, &gb); |
2979 | 2195 break; |
2196 case 0x81: | |
2944
3785497656c9
Correctly skip unknown matrices (patch by Matthieu Castet) and disable comment reading
alex
parents:
2943
diff
changeset
|
2197 // FIXME: is this needed? it breaks sometimes |
2979 | 2198 // theora_decode_comments(avctx, gb); |
2199 break; | |
2200 case 0x82: | |
8770 | 2201 if (theora_decode_tables(avctx, &gb)) |
2202 return -1; | |
2979 | 2203 break; |
2204 default: | |
2205 av_log(avctx, AV_LOG_ERROR, "Unknown Theora config packet: %d\n", ptype&~0x80); | |
2206 break; | |
1516
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2207 } |
7943
3ff31e4454cd
Downgrade severity of leftover bits in header packets, and don't check for the comment header
conrad
parents:
7938
diff
changeset
|
2208 if(ptype != 0x81 && 8*header_len[i] != get_bits_count(&gb)) |
3ff31e4454cd
Downgrade severity of leftover bits in header packets, and don't check for the comment header
conrad
parents:
7938
diff
changeset
|
2209 av_log(avctx, AV_LOG_WARNING, "%d bits left in packet %X\n", 8*header_len[i] - get_bits_count(&gb), ptype); |
3490
b43d45362038
fix playback of theora.ogg on mphq patch by (matthieu castet %% castet dat matthieu ot free dat fr %%)
michael
parents:
3489
diff
changeset
|
2210 if (s->theora < 0x030200) |
b43d45362038
fix playback of theora.ogg on mphq patch by (matthieu castet %% castet dat matthieu ot free dat fr %%)
michael
parents:
3489
diff
changeset
|
2211 break; |
2533 | 2212 } |
1516
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2213 |
9925
2978d5f0ac0a
Remove useless ret variable added in last revision again.
reimar
parents:
9924
diff
changeset
|
2214 return vp3_decode_init(avctx); |
1516
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2215 } |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2216 |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2217 AVCodec theora_decoder = { |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2218 "theora", |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
11477
diff
changeset
|
2219 AVMEDIA_TYPE_VIDEO, |
1516
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2220 CODEC_ID_THEORA, |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2221 sizeof(Vp3DecodeContext), |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2222 theora_decode_init, |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2223 NULL, |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2224 vp3_decode_end, |
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2225 vp3_decode_frame, |
11132
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
2226 CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND, |
6710 | 2227 NULL, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
7038
diff
changeset
|
2228 .long_name = NULL_IF_CONFIG_SMALL("Theora"), |
1516
0f0e9dfa6723
theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents:
1463
diff
changeset
|
2229 }; |
4823
cff8c7ecac71
Fix compilation when Theora decoder is disabled, but VP3 is enabled.
diego
parents:
4801
diff
changeset
|
2230 #endif |
4825
3f32f0e5a77b
cosmetics: Move one code block to save an #ifdef in the next commit.
diego
parents:
4824
diff
changeset
|
2231 |
3f32f0e5a77b
cosmetics: Move one code block to save an #ifdef in the next commit.
diego
parents:
4824
diff
changeset
|
2232 AVCodec vp3_decoder = { |
3f32f0e5a77b
cosmetics: Move one code block to save an #ifdef in the next commit.
diego
parents:
4824
diff
changeset
|
2233 "vp3", |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
11477
diff
changeset
|
2234 AVMEDIA_TYPE_VIDEO, |
4825
3f32f0e5a77b
cosmetics: Move one code block to save an #ifdef in the next commit.
diego
parents:
4824
diff
changeset
|
2235 CODEC_ID_VP3, |
3f32f0e5a77b
cosmetics: Move one code block to save an #ifdef in the next commit.
diego
parents:
4824
diff
changeset
|
2236 sizeof(Vp3DecodeContext), |
3f32f0e5a77b
cosmetics: Move one code block to save an #ifdef in the next commit.
diego
parents:
4824
diff
changeset
|
2237 vp3_decode_init, |
3f32f0e5a77b
cosmetics: Move one code block to save an #ifdef in the next commit.
diego
parents:
4824
diff
changeset
|
2238 NULL, |
3f32f0e5a77b
cosmetics: Move one code block to save an #ifdef in the next commit.
diego
parents:
4824
diff
changeset
|
2239 vp3_decode_end, |
3f32f0e5a77b
cosmetics: Move one code block to save an #ifdef in the next commit.
diego
parents:
4824
diff
changeset
|
2240 vp3_decode_frame, |
11132
449c12b6c3a0
Implement CODEC_CAP_DRAW_HORIZ_BAND for VP3 decoder
conrad
parents:
11131
diff
changeset
|
2241 CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND, |
6710 | 2242 NULL, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
7038
diff
changeset
|
2243 .long_name = NULL_IF_CONFIG_SMALL("On2 VP3"), |
4825
3f32f0e5a77b
cosmetics: Move one code block to save an #ifdef in the next commit.
diego
parents:
4824
diff
changeset
|
2244 }; |