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