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