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