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