ffmpeg / libavcodec / vorbis.c @ 5509bffa
History | View | Annotate | Download (50.3 KB)
1 | 0bde73d9 | Michael Niedermayer | /**
|
---|---|---|---|
2 | * @file vorbis.c
|
||
3 | * Vorbis I decoder
|
||
4 | * @author Denes Balatoni ( dbalatoni programozo hu )
|
||
5 | 84a96d6a | Denes Balatoni | |
6 | * This library is free software; you can redistribute it and/or
|
||
7 | * modify it under the terms of the GNU Lesser General Public
|
||
8 | * License as published by the Free Software Foundation; either
|
||
9 | * version 2 of the License, or (at your option) any later version.
|
||
10 | *
|
||
11 | * This library is distributed in the hope that it will be useful,
|
||
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
|
||
17 | * License along with this library; if not, write to the Free Software
|
||
18 | 5509bffa | Diego Biurrun | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
19 | 84a96d6a | Denes Balatoni | *
|
20 | 0bde73d9 | Michael Niedermayer | */
|
21 | |||
22 | #undef V_DEBUG
|
||
23 | |||
24 | #include <math.h> |
||
25 | |||
26 | #define ALT_BITSTREAM_READER_LE
|
||
27 | #include "avcodec.h" |
||
28 | #include "bitstream.h" |
||
29 | #include "dsputil.h" |
||
30 | |||
31 | #include "vorbis.h" |
||
32 | |||
33 | 5a408f91 | Michael Niedermayer | #define V_NB_BITS 8 |
34 | #define V_NB_BITS2 11 |
||
35 | 0bde73d9 | Michael Niedermayer | #define V_MAX_VLCS (1<<16) |
36 | |||
37 | #ifndef V_DEBUG
|
||
38 | #define AV_DEBUG(...)
|
||
39 | #endif
|
||
40 | |||
41 | f4e61cd1 | Michael Niedermayer | #undef NDEBUG
|
42 | #include <assert.h> |
||
43 | 0bde73d9 | Michael Niedermayer | |
44 | /* Helper functions */
|
||
45 | |||
46 | /**
|
||
47 | * reads 0-32 bits when using the ALT_BITSTREAM_READER_LE bitstream reader
|
||
48 | */
|
||
49 | unsigned int get_bits_long_le(GetBitContext *s, int n){ |
||
50 | if(n<=17) return get_bits(s, n); |
||
51 | else{
|
||
52 | int ret= get_bits(s, 16); |
||
53 | return ret | (get_bits(s, n-16) << 16); |
||
54 | } |
||
55 | } |
||
56 | |||
57 | e19ca845 | Michael Niedermayer | #define ilog(i) av_log2(2*(i)) |
58 | 0bde73d9 | Michael Niedermayer | |
59 | static unsigned int nth_root(unsigned int x, unsigned int n) { // x^(1/n) |
||
60 | unsigned int ret=0, i, j; |
||
61 | |||
62 | do {
|
||
63 | ++ret; |
||
64 | for(i=0,j=ret;i<n-1;i++) j*=ret; |
||
65 | } while (j<=x);
|
||
66 | |||
67 | return (ret-1); |
||
68 | } |
||
69 | |||
70 | static float vorbisfloat2float(uint_fast32_t val) { |
||
71 | double mant=val&0x1fffff; |
||
72 | long exp=(val&0x7fe00000L)>>21; |
||
73 | if (val&0x80000000) mant=-mant; |
||
74 | return(ldexp(mant, exp-20-768)); |
||
75 | } |
||
76 | |||
77 | |||
78 | // Generate vlc codes from vorbis huffman code lengths
|
||
79 | |||
80 | static int vorbis_len2vlc(vorbis_context *vc, uint_fast8_t *bits, uint_fast32_t *codes, uint_fast32_t num) { |
||
81 | uint_fast32_t exit_at_level[33]={404,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
||
82 | 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; |
||
83 | |||
84 | uint_fast8_t i,j; |
||
85 | uint_fast32_t code,p; |
||
86 | |||
87 | #ifdef V_DEBUG
|
||
88 | GetBitContext gb; |
||
89 | #endif
|
||
90 | |||
91 | for(p=0;(bits[p]==0) && (p<num);++p); |
||
92 | if (p==num) {
|
||
93 | // av_log(vc->avccontext, AV_LOG_INFO, "An empty codebook. Heh?! \n");
|
||
94 | return 0; |
||
95 | } |
||
96 | |||
97 | codes[p]=0;
|
||
98 | for(i=0;i<bits[p];++i) { |
||
99 | exit_at_level[i+1]=1<<i; |
||
100 | } |
||
101 | |||
102 | #ifdef V_DEBUG
|
||
103 | av_log(vc->avccontext, AV_LOG_INFO, " %d. of %d code len %d code %d - ", p, num, bits[p], codes[p]);
|
||
104 | init_get_bits(&gb, (uint_fast8_t *)&codes[p], bits[p]); |
||
105 | for(i=0;i<bits[p];++i) { |
||
106 | av_log(vc->avccontext, AV_LOG_INFO, "%s", get_bits1(&gb) ? "1" : "0"); |
||
107 | } |
||
108 | av_log(vc->avccontext, AV_LOG_INFO, "\n");
|
||
109 | #endif
|
||
110 | |||
111 | ++p; |
||
112 | |||
113 | for(;p<num;++p) {
|
||
114 | if (bits[p]==0) continue; |
||
115 | // find corresponding exit(node which the tree can grow further from)
|
||
116 | for(i=bits[p];i>0;--i) { |
||
117 | if (exit_at_level[i]) break; |
||
118 | } |
||
119 | if (!i) return 1; // overspecified tree |
||
120 | code=exit_at_level[i]; |
||
121 | exit_at_level[i]=0;
|
||
122 | // construct code (append 0s to end) and introduce new exits
|
||
123 | for(j=i+1;j<=bits[p];++j) { |
||
124 | exit_at_level[j]=code+(1<<(j-1)); |
||
125 | } |
||
126 | codes[p]=code; |
||
127 | |||
128 | #ifdef V_DEBUG
|
||
129 | av_log(vc->avccontext, AV_LOG_INFO, " %d. code len %d code %d - ", p, bits[p], codes[p]);
|
||
130 | init_get_bits(&gb, (uint_fast8_t *)&codes[p], bits[p]); |
||
131 | for(i=0;i<bits[p];++i) { |
||
132 | av_log(vc->avccontext, AV_LOG_INFO, "%s", get_bits1(&gb) ? "1" : "0"); |
||
133 | } |
||
134 | av_log(vc->avccontext, AV_LOG_INFO, "\n");
|
||
135 | #endif
|
||
136 | |||
137 | } |
||
138 | |||
139 | //FIXME no exits should be left (underspecified tree - ie. unused valid vlcs - not allowed by SPEC)
|
||
140 | |||
141 | return 0; |
||
142 | } |
||
143 | |||
144 | // Free all allocated memory -----------------------------------------
|
||
145 | |||
146 | static void vorbis_free(vorbis_context *vc) { |
||
147 | int_fast16_t i; |
||
148 | |||
149 | av_freep(&vc->channel_residues); |
||
150 | av_freep(&vc->channel_floors); |
||
151 | av_freep(&vc->saved); |
||
152 | av_freep(&vc->ret); |
||
153 | 13c2469d | Michael Niedermayer | av_freep(&vc->buf); |
154 | av_freep(&vc->buf_tmp); |
||
155 | 0bde73d9 | Michael Niedermayer | |
156 | av_freep(&vc->residues); |
||
157 | av_freep(&vc->modes); |
||
158 | |||
159 | ff_mdct_end(&vc->mdct0); |
||
160 | ff_mdct_end(&vc->mdct1); |
||
161 | |||
162 | for(i=0;i<vc->codebook_count;++i) { |
||
163 | av_free(vc->codebooks[i].codevectors); |
||
164 | free_vlc(&vc->codebooks[i].vlc); |
||
165 | } |
||
166 | av_freep(&vc->codebooks); |
||
167 | |||
168 | for(i=0;i<vc->floor_count;++i) { |
||
169 | av_free(vc->floors[i].x_list); |
||
170 | av_free(vc->floors[i].x_list_order); |
||
171 | av_free(vc->floors[i].low_neighbour); |
||
172 | av_free(vc->floors[i].high_neighbour); |
||
173 | } |
||
174 | av_freep(&vc->floors); |
||
175 | |||
176 | for(i=0;i<vc->mapping_count;++i) { |
||
177 | av_free(vc->mappings[i].magnitude); |
||
178 | av_free(vc->mappings[i].angle); |
||
179 | av_free(vc->mappings[i].mux); |
||
180 | } |
||
181 | av_freep(&vc->mappings); |
||
182 | } |
||
183 | |||
184 | // Parse setup header -------------------------------------------------
|
||
185 | |||
186 | // Process codebooks part
|
||
187 | |||
188 | static int vorbis_parse_setup_hdr_codebooks(vorbis_context *vc) { |
||
189 | uint_fast16_t cb; |
||
190 | 84a96d6a | Denes Balatoni | uint_fast8_t *tmp_vlc_bits; |
191 | uint_fast32_t *tmp_vlc_codes; |
||
192 | 0bde73d9 | Michael Niedermayer | GetBitContext *gb=&vc->gb; |
193 | |||
194 | vc->codebook_count=get_bits(gb,8)+1; |
||
195 | |||
196 | AV_DEBUG(" Codebooks: %d \n", vc->codebook_count);
|
||
197 | |||
198 | vc->codebooks=(vorbis_codebook *)av_mallocz(vc->codebook_count * sizeof(vorbis_codebook));
|
||
199 | 84a96d6a | Denes Balatoni | tmp_vlc_bits=(uint_fast8_t *)av_mallocz(V_MAX_VLCS * sizeof(uint_fast8_t));
|
200 | tmp_vlc_codes=(uint_fast32_t *)av_mallocz(V_MAX_VLCS * sizeof(uint_fast32_t));
|
||
201 | 0bde73d9 | Michael Niedermayer | |
202 | for(cb=0;cb<vc->codebook_count;++cb) { |
||
203 | vorbis_codebook *codebook_setup=&vc->codebooks[cb]; |
||
204 | uint_fast8_t ordered; |
||
205 | uint_fast32_t t, used_entries=0;
|
||
206 | uint_fast32_t entries; |
||
207 | |||
208 | AV_DEBUG(" %d. Codebook \n", cb);
|
||
209 | |||
210 | if (get_bits(gb, 24)!=0x564342) { |
||
211 | 4733abcb | Måns Rullgård | av_log(vc->avccontext, AV_LOG_ERROR, " %"PRIdFAST16". Codebook setup data corrupt. \n", cb); |
212 | 84a96d6a | Denes Balatoni | goto error;
|
213 | 0bde73d9 | Michael Niedermayer | } |
214 | |||
215 | codebook_setup->dimensions=get_bits(gb, 16);
|
||
216 | if (codebook_setup->dimensions>16) { |
||
217 | 4733abcb | Måns Rullgård | av_log(vc->avccontext, AV_LOG_ERROR, " %"PRIdFAST16". Codebook's dimension is too large (%d). \n", cb, codebook_setup->dimensions); |
218 | 84a96d6a | Denes Balatoni | goto error;
|
219 | 0bde73d9 | Michael Niedermayer | } |
220 | entries=get_bits(gb, 24);
|
||
221 | if (entries>V_MAX_VLCS) {
|
||
222 | 4733abcb | Måns Rullgård | av_log(vc->avccontext, AV_LOG_ERROR, " %"PRIdFAST16". Codebook has too many entries (%"PRIdFAST32"). \n", cb, entries); |
223 | 84a96d6a | Denes Balatoni | goto error;
|
224 | 0bde73d9 | Michael Niedermayer | } |
225 | |||
226 | ordered=get_bits1(gb); |
||
227 | |||
228 | AV_DEBUG(" codebook_dimensions %d, codebook_entries %d \n", codebook_setup->dimensions, entries);
|
||
229 | |||
230 | if (!ordered) {
|
||
231 | uint_fast16_t ce; |
||
232 | uint_fast8_t flag; |
||
233 | uint_fast8_t sparse=get_bits1(gb); |
||
234 | |||
235 | AV_DEBUG(" not ordered \n");
|
||
236 | |||
237 | if (sparse) {
|
||
238 | AV_DEBUG(" sparse \n");
|
||
239 | |||
240 | used_entries=0;
|
||
241 | for(ce=0;ce<entries;++ce) { |
||
242 | flag=get_bits1(gb); |
||
243 | if (flag) {
|
||
244 | tmp_vlc_bits[ce]=get_bits(gb, 5)+1; |
||
245 | ++used_entries; |
||
246 | } |
||
247 | else tmp_vlc_bits[ce]=0; |
||
248 | } |
||
249 | } else {
|
||
250 | AV_DEBUG(" not sparse \n");
|
||
251 | |||
252 | used_entries=entries; |
||
253 | for(ce=0;ce<entries;++ce) { |
||
254 | tmp_vlc_bits[ce]=get_bits(gb, 5)+1; |
||
255 | } |
||
256 | } |
||
257 | } else {
|
||
258 | uint_fast16_t current_entry=0;
|
||
259 | uint_fast8_t current_length=get_bits(gb, 5)+1; |
||
260 | |||
261 | AV_DEBUG(" ordered, current length: %d \n", current_length); //FIXME |
||
262 | |||
263 | used_entries=entries; |
||
264 | for(;current_entry<used_entries;++current_length) {
|
||
265 | uint_fast16_t i, number; |
||
266 | |||
267 | AV_DEBUG(" number bits: %d ", ilog(entries - current_entry));
|
||
268 | |||
269 | number=get_bits(gb, ilog(entries - current_entry)); |
||
270 | |||
271 | AV_DEBUG(" number: %d \n", number);
|
||
272 | |||
273 | for(i=current_entry;i<number+current_entry;++i) {
|
||
274 | if (i<used_entries) tmp_vlc_bits[i]=current_length;
|
||
275 | } |
||
276 | |||
277 | current_entry+=number; |
||
278 | } |
||
279 | if (current_entry>used_entries) {
|
||
280 | av_log(vc->avccontext, AV_LOG_ERROR, " More codelengths than codes in codebook. \n");
|
||
281 | 84a96d6a | Denes Balatoni | goto error;
|
282 | 0bde73d9 | Michael Niedermayer | } |
283 | } |
||
284 | |||
285 | codebook_setup->lookup_type=get_bits(gb, 4);
|
||
286 | |||
287 | AV_DEBUG(" lookup type: %d : %s \n", codebook_setup->lookup_type, codebook_setup->lookup_type ? "vq" : "no lookup" ); |
||
288 | |||
289 | // If the codebook is used for (inverse) VQ, calculate codevectors.
|
||
290 | |||
291 | if (codebook_setup->lookup_type==1) { |
||
292 | uint_fast16_t i, j, k; |
||
293 | uint_fast16_t codebook_lookup_values=nth_root(entries, codebook_setup->dimensions); |
||
294 | uint_fast16_t codebook_multiplicands[codebook_lookup_values]; |
||
295 | |||
296 | float codebook_minimum_value=vorbisfloat2float(get_bits_long_le(gb, 32)); |
||
297 | float codebook_delta_value=vorbisfloat2float(get_bits_long_le(gb, 32)); |
||
298 | uint_fast8_t codebook_value_bits=get_bits(gb, 4)+1; |
||
299 | uint_fast8_t codebook_sequence_p=get_bits1(gb); |
||
300 | |||
301 | AV_DEBUG(" We expect %d numbers for building the codevectors. \n", codebook_lookup_values);
|
||
302 | AV_DEBUG(" delta %f minmum %f \n", codebook_delta_value, codebook_minimum_value);
|
||
303 | |||
304 | for(i=0;i<codebook_lookup_values;++i) { |
||
305 | codebook_multiplicands[i]=get_bits(gb, codebook_value_bits); |
||
306 | |||
307 | AV_DEBUG(" multiplicands*delta+minmum : %e \n", (float)codebook_multiplicands[i]*codebook_delta_value+codebook_minimum_value); |
||
308 | AV_DEBUG(" multiplicand %d \n", codebook_multiplicands[i]);
|
||
309 | } |
||
310 | |||
311 | // Weed out unused vlcs and build codevector vector
|
||
312 | codebook_setup->codevectors=(float *)av_mallocz(used_entries*codebook_setup->dimensions * sizeof(float)); |
||
313 | for(j=0, i=0;i<entries;++i) { |
||
314 | uint_fast8_t dim=codebook_setup->dimensions; |
||
315 | |||
316 | if (tmp_vlc_bits[i]) {
|
||
317 | float last=0.0; |
||
318 | uint_fast32_t lookup_offset=i; |
||
319 | |||
320 | #ifdef V_DEBUG
|
||
321 | av_log(vc->avccontext, AV_LOG_INFO, "Lookup offset %d ,", i);
|
||
322 | #endif
|
||
323 | |||
324 | for(k=0;k<dim;++k) { |
||
325 | uint_fast32_t multiplicand_offset = lookup_offset % codebook_lookup_values; |
||
326 | codebook_setup->codevectors[j*dim+k]=codebook_multiplicands[multiplicand_offset]*codebook_delta_value+codebook_minimum_value+last; |
||
327 | if (codebook_sequence_p) {
|
||
328 | last=codebook_setup->codevectors[j*dim+k]; |
||
329 | } |
||
330 | lookup_offset/=codebook_lookup_values; |
||
331 | } |
||
332 | tmp_vlc_bits[j]=tmp_vlc_bits[i]; |
||
333 | |||
334 | #ifdef V_DEBUG
|
||
335 | av_log(vc->avccontext, AV_LOG_INFO, "real lookup offset %d, vector: ", j);
|
||
336 | for(k=0;k<dim;++k) { |
||
337 | av_log(vc->avccontext, AV_LOG_INFO, " %f ", codebook_setup->codevectors[j*dim+k]);
|
||
338 | } |
||
339 | av_log(vc->avccontext, AV_LOG_INFO, "\n");
|
||
340 | #endif
|
||
341 | |||
342 | ++j; |
||
343 | } |
||
344 | } |
||
345 | if (j!=used_entries) {
|
||
346 | av_log(vc->avccontext, AV_LOG_ERROR, "Bug in codevector vector building code. \n");
|
||
347 | 84a96d6a | Denes Balatoni | goto error;
|
348 | 0bde73d9 | Michael Niedermayer | } |
349 | entries=used_entries; |
||
350 | } |
||
351 | else if (codebook_setup->lookup_type>=2) { |
||
352 | av_log(vc->avccontext, AV_LOG_ERROR, "Codebook lookup type not supported. \n");
|
||
353 | 84a96d6a | Denes Balatoni | goto error;
|
354 | 0bde73d9 | Michael Niedermayer | } |
355 | |||
356 | // Initialize VLC table
|
||
357 | if (vorbis_len2vlc(vc, tmp_vlc_bits, tmp_vlc_codes, entries)) {
|
||
358 | av_log(vc->avccontext, AV_LOG_ERROR, " Invalid code lengths while generating vlcs. \n");
|
||
359 | 84a96d6a | Denes Balatoni | goto error;
|
360 | 0bde73d9 | Michael Niedermayer | } |
361 | codebook_setup->maxdepth=0;
|
||
362 | for(t=0;t<entries;++t) |
||
363 | if (tmp_vlc_bits[t]>=codebook_setup->maxdepth) codebook_setup->maxdepth=tmp_vlc_bits[t];
|
||
364 | |||
365 | 5a408f91 | Michael Niedermayer | if(codebook_setup->maxdepth > 3*V_NB_BITS) codebook_setup->nb_bits=V_NB_BITS2; |
366 | else codebook_setup->nb_bits=V_NB_BITS;
|
||
367 | 0bde73d9 | Michael Niedermayer | |
368 | 5a408f91 | Michael Niedermayer | codebook_setup->maxdepth=(codebook_setup->maxdepth+codebook_setup->nb_bits-1)/codebook_setup->nb_bits;
|
369 | 115329f1 | Diego Biurrun | |
370 | 5a408f91 | Michael Niedermayer | if (init_vlc(&codebook_setup->vlc, codebook_setup->nb_bits, entries, tmp_vlc_bits, sizeof(*tmp_vlc_bits), sizeof(*tmp_vlc_bits), tmp_vlc_codes, sizeof(*tmp_vlc_codes), sizeof(*tmp_vlc_codes), INIT_VLC_LE)) { |
371 | 0bde73d9 | Michael Niedermayer | av_log(vc->avccontext, AV_LOG_ERROR, " Error generating vlc tables. \n");
|
372 | 84a96d6a | Denes Balatoni | goto error;
|
373 | 0bde73d9 | Michael Niedermayer | } |
374 | } |
||
375 | 84a96d6a | Denes Balatoni | |
376 | av_free(tmp_vlc_bits); |
||
377 | av_free(tmp_vlc_codes); |
||
378 | 0bde73d9 | Michael Niedermayer | return 0; |
379 | 84a96d6a | Denes Balatoni | |
380 | // Error:
|
||
381 | error:
|
||
382 | av_free(tmp_vlc_bits); |
||
383 | av_free(tmp_vlc_codes); |
||
384 | return 1; |
||
385 | 0bde73d9 | Michael Niedermayer | } |
386 | |||
387 | // Process time domain transforms part (unused in Vorbis I)
|
||
388 | |||
389 | static int vorbis_parse_setup_hdr_tdtransforms(vorbis_context *vc) { |
||
390 | GetBitContext *gb=&vc->gb; |
||
391 | uint_fast8_t i; |
||
392 | uint_fast8_t vorbis_time_count=get_bits(gb, 6)+1; |
||
393 | |||
394 | for(i=0;i<vorbis_time_count;++i) { |
||
395 | uint_fast16_t vorbis_tdtransform=get_bits(gb, 16);
|
||
396 | |||
397 | AV_DEBUG(" Vorbis time domain transform %d: %d \n", vorbis_time_count, vorbis_tdtransform);
|
||
398 | |||
399 | if (vorbis_tdtransform) {
|
||
400 | av_log(vc->avccontext, AV_LOG_ERROR, "Vorbis time domain transform data nonzero. \n");
|
||
401 | return 1; |
||
402 | } |
||
403 | } |
||
404 | return 0; |
||
405 | } |
||
406 | |||
407 | // Process floors part - only floor type 1 is supported
|
||
408 | |||
409 | static int vorbis_parse_setup_hdr_floors(vorbis_context *vc) { |
||
410 | GetBitContext *gb=&vc->gb; |
||
411 | uint_fast16_t i,j,k; |
||
412 | |||
413 | vc->floor_count=get_bits(gb, 6)+1; |
||
414 | |||
415 | vc->floors=(vorbis_floor *)av_mallocz(vc->floor_count * sizeof(vorbis_floor));
|
||
416 | |||
417 | for (i=0;i<vc->floor_count;++i) { |
||
418 | vorbis_floor *floor_setup=&vc->floors[i]; |
||
419 | |||
420 | floor_setup->floor_type=get_bits(gb, 16);
|
||
421 | |||
422 | AV_DEBUG(" %d. floor type %d \n", i, floor_setup->floor_type);
|
||
423 | |||
424 | if (floor_setup->floor_type==1) { |
||
425 | uint_fast8_t maximum_class=0;
|
||
426 | uint_fast8_t rangebits; |
||
427 | uint_fast16_t floor1_values=2;
|
||
428 | |||
429 | floor_setup->partitions=get_bits(gb, 5);
|
||
430 | |||
431 | AV_DEBUG(" %d.floor: %d partitions \n", i, floor_setup->partitions);
|
||
432 | |||
433 | for(j=0;j<floor_setup->partitions;++j) { |
||
434 | floor_setup->partition_class[j]=get_bits(gb, 4);
|
||
435 | if (floor_setup->partition_class[j]>maximum_class) maximum_class=floor_setup->partition_class[j];
|
||
436 | |||
437 | AV_DEBUG(" %d. floor %d partition class %d \n", i, j, floor_setup->partition_class[j]);
|
||
438 | |||
439 | } |
||
440 | |||
441 | AV_DEBUG(" maximum class %d \n", maximum_class);
|
||
442 | |||
443 | floor_setup->maximum_class=maximum_class; |
||
444 | |||
445 | for(j=0;j<=maximum_class;++j) { |
||
446 | floor_setup->class_dimensions[j]=get_bits(gb, 3)+1; |
||
447 | floor_setup->class_subclasses[j]=get_bits(gb, 2);
|
||
448 | |||
449 | AV_DEBUG(" %d floor %d class dim: %d subclasses %d \n", i, j, floor_setup->class_dimensions[j], floor_setup->class_subclasses[j]);
|
||
450 | |||
451 | if (floor_setup->class_subclasses[j]) {
|
||
452 | floor_setup->class_masterbook[j]=get_bits(gb, 8);
|
||
453 | |||
454 | AV_DEBUG(" masterbook: %d \n", floor_setup->class_masterbook[j]);
|
||
455 | } |
||
456 | |||
457 | for(k=0;k<(1<<floor_setup->class_subclasses[j]);++k) { |
||
458 | floor_setup->subclass_books[j][k]=get_bits(gb, 8)-1; |
||
459 | |||
460 | AV_DEBUG(" book %d. : %d \n", k, floor_setup->subclass_books[j][k]);
|
||
461 | } |
||
462 | } |
||
463 | |||
464 | floor_setup->multiplier=get_bits(gb, 2)+1; |
||
465 | floor_setup->x_list_dim=2;
|
||
466 | |||
467 | for(j=0;j<floor_setup->partitions;++j) { |
||
468 | floor_setup->x_list_dim+=floor_setup->class_dimensions[floor_setup->partition_class[j]]; |
||
469 | } |
||
470 | |||
471 | floor_setup->x_list=(uint_fast16_t *)av_mallocz(floor_setup->x_list_dim * sizeof(uint_fast16_t));
|
||
472 | floor_setup->x_list_order=(uint_fast16_t *)av_mallocz(floor_setup->x_list_dim * sizeof(uint_fast16_t));
|
||
473 | floor_setup->low_neighbour=(uint_fast16_t *)av_mallocz(floor_setup->x_list_dim * sizeof(uint_fast16_t));
|
||
474 | floor_setup->high_neighbour=(uint_fast16_t *)av_mallocz(floor_setup->x_list_dim * sizeof(uint_fast16_t));
|
||
475 | |||
476 | |||
477 | rangebits=get_bits(gb, 4);
|
||
478 | floor_setup->x_list[0] = 0; |
||
479 | floor_setup->x_list[1] = (1<<rangebits); |
||
480 | |||
481 | for(j=0;j<floor_setup->partitions;++j) { |
||
482 | for(k=0;k<floor_setup->class_dimensions[floor_setup->partition_class[j]];++k,++floor1_values) { |
||
483 | floor_setup->x_list[floor1_values]=get_bits(gb, rangebits); |
||
484 | |||
485 | AV_DEBUG(" %d. floor1 Y coord. %d \n", floor1_values, floor_setup->x_list[floor1_values]);
|
||
486 | } |
||
487 | } |
||
488 | |||
489 | // Precalculate order of x coordinates - needed for decode
|
||
490 | |||
491 | for(k=0;k<floor_setup->x_list_dim;++k) { |
||
492 | floor_setup->x_list_order[k]=k; |
||
493 | } |
||
494 | |||
495 | for(k=0;k<floor_setup->x_list_dim-1;++k) { // FIXME optimize sorting ? |
||
496 | for(j=k+1;j<floor_setup->x_list_dim;++j) { |
||
497 | if(floor_setup->x_list[floor_setup->x_list_order[k]]>floor_setup->x_list[floor_setup->x_list_order[j]]) {
|
||
498 | uint_fast16_t tmp=floor_setup->x_list_order[k]; |
||
499 | floor_setup->x_list_order[k]=floor_setup->x_list_order[j]; |
||
500 | floor_setup->x_list_order[j]=tmp; |
||
501 | } |
||
502 | } |
||
503 | } |
||
504 | |||
505 | // Precalculate low and high neighbours
|
||
506 | |||
507 | for(k=2;k<floor_setup->x_list_dim;++k) { |
||
508 | floor_setup->low_neighbour[k]=0;
|
||
509 | floor_setup->high_neighbour[k]=1; // correct according to SPEC requirements |
||
510 | |||
511 | for (j=0;j<k;++j) { |
||
512 | if ((floor_setup->x_list[j]<floor_setup->x_list[k]) &&
|
||
513 | (floor_setup->x_list[j]>floor_setup->x_list[floor_setup->low_neighbour[k]])) { |
||
514 | floor_setup->low_neighbour[k]=j; |
||
515 | } |
||
516 | if ((floor_setup->x_list[j]>floor_setup->x_list[k]) &&
|
||
517 | (floor_setup->x_list[j]<floor_setup->x_list[floor_setup->high_neighbour[k]])) { |
||
518 | floor_setup->high_neighbour[k]=j; |
||
519 | } |
||
520 | } |
||
521 | } |
||
522 | } |
||
523 | else {
|
||
524 | av_log(vc->avccontext, AV_LOG_ERROR, "Only floor type 1 supported. \n");
|
||
525 | return 1; |
||
526 | } |
||
527 | } |
||
528 | return 0; |
||
529 | } |
||
530 | |||
531 | // Process residues part
|
||
532 | |||
533 | static int vorbis_parse_setup_hdr_residues(vorbis_context *vc){ |
||
534 | GetBitContext *gb=&vc->gb; |
||
535 | uint_fast8_t i, j, k; |
||
536 | |||
537 | vc->residue_count=get_bits(gb, 6)+1; |
||
538 | vc->residues=(vorbis_residue *)av_mallocz(vc->residue_count * sizeof(vorbis_residue));
|
||
539 | |||
540 | AV_DEBUG(" There are %d residues. \n", vc->residue_count);
|
||
541 | |||
542 | for(i=0;i<vc->residue_count;++i) { |
||
543 | vorbis_residue *res_setup=&vc->residues[i]; |
||
544 | uint_fast8_t cascade[64];
|
||
545 | uint_fast8_t high_bits; |
||
546 | uint_fast8_t low_bits; |
||
547 | |||
548 | res_setup->type=get_bits(gb, 16);
|
||
549 | |||
550 | AV_DEBUG(" %d. residue type %d \n", i, res_setup->type);
|
||
551 | |||
552 | res_setup->begin=get_bits(gb, 24);
|
||
553 | res_setup->end=get_bits(gb, 24);
|
||
554 | res_setup->partition_size=get_bits(gb, 24)+1; |
||
555 | res_setup->classifications=get_bits(gb, 6)+1; |
||
556 | res_setup->classbook=get_bits(gb, 8);
|
||
557 | |||
558 | AV_DEBUG(" begin %d end %d part.size %d classif.s %d classbook %d \n", res_setup->begin, res_setup->end, res_setup->partition_size,
|
||
559 | res_setup->classifications, res_setup->classbook); |
||
560 | |||
561 | for(j=0;j<res_setup->classifications;++j) { |
||
562 | high_bits=0;
|
||
563 | low_bits=get_bits(gb, 3);
|
||
564 | if (get_bits1(gb)) {
|
||
565 | high_bits=get_bits(gb, 5);
|
||
566 | } |
||
567 | cascade[j]=(high_bits<<3)+low_bits;
|
||
568 | |||
569 | AV_DEBUG(" %d class casscade depth: %d \n", j, ilog(cascade[j]));
|
||
570 | } |
||
571 | |||
572 | res_setup->maxpass=0;
|
||
573 | for(j=0;j<res_setup->classifications;++j) { |
||
574 | for(k=0;k<8;++k) { |
||
575 | if (cascade[j]&(1<<k)) { |
||
576 | res_setup->books[j][k]=get_bits(gb, 8);
|
||
577 | |||
578 | AV_DEBUG(" %d class casscade depth %d book: %d \n", j, k, res_setup->books[j][k]);
|
||
579 | |||
580 | if (k>res_setup->maxpass) {
|
||
581 | res_setup->maxpass=k; |
||
582 | } |
||
583 | } else {
|
||
584 | res_setup->books[j][k]=-1;
|
||
585 | } |
||
586 | } |
||
587 | } |
||
588 | } |
||
589 | return 0; |
||
590 | } |
||
591 | |||
592 | // Process mappings part
|
||
593 | |||
594 | static int vorbis_parse_setup_hdr_mappings(vorbis_context *vc) { |
||
595 | GetBitContext *gb=&vc->gb; |
||
596 | uint_fast8_t i, j; |
||
597 | |||
598 | vc->mapping_count=get_bits(gb, 6)+1; |
||
599 | vc->mappings=(vorbis_mapping *)av_mallocz(vc->mapping_count * sizeof(vorbis_mapping));
|
||
600 | |||
601 | AV_DEBUG(" There are %d mappings. \n", vc->mapping_count);
|
||
602 | |||
603 | for(i=0;i<vc->mapping_count;++i) { |
||
604 | vorbis_mapping *mapping_setup=&vc->mappings[i]; |
||
605 | |||
606 | if (get_bits(gb, 16)) { |
||
607 | av_log(vc->avccontext, AV_LOG_ERROR, "Other mappings than type 0 are not compliant with the Vorbis I specification. \n");
|
||
608 | return 1; |
||
609 | } |
||
610 | if (get_bits1(gb)) {
|
||
611 | mapping_setup->submaps=get_bits(gb, 4)+1; |
||
612 | } else {
|
||
613 | mapping_setup->submaps=1;
|
||
614 | } |
||
615 | |||
616 | if (get_bits1(gb)) {
|
||
617 | mapping_setup->coupling_steps=get_bits(gb, 8)+1; |
||
618 | mapping_setup->magnitude=(uint_fast8_t *)av_mallocz(mapping_setup->coupling_steps * sizeof(uint_fast8_t));
|
||
619 | mapping_setup->angle=(uint_fast8_t *)av_mallocz(mapping_setup->coupling_steps * sizeof(uint_fast8_t));
|
||
620 | for(j=0;j<mapping_setup->coupling_steps;++j) { |
||
621 | mapping_setup->magnitude[j]=get_bits(gb, ilog(vc->audio_channels-1));
|
||
622 | mapping_setup->angle[j]=get_bits(gb, ilog(vc->audio_channels-1));
|
||
623 | // FIXME: sanity checks
|
||
624 | } |
||
625 | } else {
|
||
626 | mapping_setup->coupling_steps=0;
|
||
627 | } |
||
628 | |||
629 | AV_DEBUG(" %d mapping coupling steps: %d \n", i, mapping_setup->coupling_steps);
|
||
630 | |||
631 | if(get_bits(gb, 2)) { |
||
632 | av_log(vc->avccontext, AV_LOG_ERROR, "%d. mapping setup data invalid. \n", i);
|
||
633 | return 1; // following spec. |
||
634 | } |
||
635 | |||
636 | if (mapping_setup->submaps>1) { |
||
637 | mapping_setup->mux=(uint_fast8_t *)av_mallocz(vc->audio_channels * sizeof(uint_fast8_t));
|
||
638 | for(j=0;j<vc->audio_channels;++j) { |
||
639 | mapping_setup->mux[j]=get_bits(gb, 4);
|
||
640 | } |
||
641 | } |
||
642 | |||
643 | for(j=0;j<mapping_setup->submaps;++j) { |
||
644 | get_bits(gb, 8); // FIXME check? |
||
645 | mapping_setup->submap_floor[j]=get_bits(gb, 8);
|
||
646 | mapping_setup->submap_residue[j]=get_bits(gb, 8);
|
||
647 | |||
648 | AV_DEBUG(" %d mapping %d submap : floor %d, residue %d \n", i, j, mapping_setup->submap_floor[j], mapping_setup->submap_residue[j]);
|
||
649 | } |
||
650 | } |
||
651 | return 0; |
||
652 | } |
||
653 | |||
654 | // Process modes part
|
||
655 | |||
656 | static int vorbis_parse_setup_hdr_modes(vorbis_context *vc) { |
||
657 | GetBitContext *gb=&vc->gb; |
||
658 | uint_fast8_t i; |
||
659 | |||
660 | vc->mode_count=get_bits(gb, 6)+1; |
||
661 | vc->modes=(vorbis_mode *)av_mallocz(vc->mode_count * sizeof(vorbis_mode));
|
||
662 | |||
663 | AV_DEBUG(" There are %d modes.\n", vc->mode_count);
|
||
664 | |||
665 | for(i=0;i<vc->mode_count;++i) { |
||
666 | vorbis_mode *mode_setup=&vc->modes[i]; |
||
667 | |||
668 | mode_setup->blockflag=get_bits(gb, 1);
|
||
669 | mode_setup->windowtype=get_bits(gb, 16); //FIXME check |
||
670 | mode_setup->transformtype=get_bits(gb, 16); //FIXME check |
||
671 | mode_setup->mapping=get_bits(gb, 8); //FIXME check |
||
672 | |||
673 | AV_DEBUG(" %d mode: blockflag %d, windowtype %d, transformtype %d, mapping %d \n", i, mode_setup->blockflag, mode_setup->windowtype, mode_setup->transformtype, mode_setup->mapping);
|
||
674 | } |
||
675 | return 0; |
||
676 | } |
||
677 | |||
678 | // Process the whole setup header using the functions above
|
||
679 | |||
680 | static int vorbis_parse_setup_hdr(vorbis_context *vc) { |
||
681 | GetBitContext *gb=&vc->gb; |
||
682 | |||
683 | if ((get_bits(gb, 8)!='v') || (get_bits(gb, 8)!='o') || |
||
684 | (get_bits(gb, 8)!='r') || (get_bits(gb, 8)!='b') || |
||
685 | (get_bits(gb, 8)!='i') || (get_bits(gb, 8)!='s')) { |
||
686 | av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (no vorbis signature). \n");
|
||
687 | return 1; |
||
688 | } |
||
689 | |||
690 | if (vorbis_parse_setup_hdr_codebooks(vc)) {
|
||
691 | av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (codebooks). \n");
|
||
692 | return 2; |
||
693 | } |
||
694 | if (vorbis_parse_setup_hdr_tdtransforms(vc)) {
|
||
695 | av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (time domain transforms). \n");
|
||
696 | return 3; |
||
697 | } |
||
698 | if (vorbis_parse_setup_hdr_floors(vc)) {
|
||
699 | av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (floors). \n");
|
||
700 | return 4; |
||
701 | } |
||
702 | if (vorbis_parse_setup_hdr_residues(vc)) {
|
||
703 | av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (residues). \n");
|
||
704 | return 5; |
||
705 | } |
||
706 | if (vorbis_parse_setup_hdr_mappings(vc)) {
|
||
707 | av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (mappings). \n");
|
||
708 | return 6; |
||
709 | } |
||
710 | if (vorbis_parse_setup_hdr_modes(vc)) {
|
||
711 | av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (modes). \n");
|
||
712 | return 7; |
||
713 | } |
||
714 | if (!get_bits1(gb)) {
|
||
715 | av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (framing flag). \n");
|
||
716 | return 8; // framing flag bit unset error |
||
717 | } |
||
718 | |||
719 | return 0; |
||
720 | } |
||
721 | |||
722 | // Process the identification header
|
||
723 | |||
724 | static int vorbis_parse_id_hdr(vorbis_context *vc){ |
||
725 | GetBitContext *gb=&vc->gb; |
||
726 | uint_fast8_t bl0, bl1; |
||
727 | const float *vwin[8]={ vwin64, vwin128, vwin256, vwin512, vwin1024, vwin2048, vwin4096, vwin8192 }; |
||
728 | |||
729 | if ((get_bits(gb, 8)!='v') || (get_bits(gb, 8)!='o') || |
||
730 | (get_bits(gb, 8)!='r') || (get_bits(gb, 8)!='b') || |
||
731 | (get_bits(gb, 8)!='i') || (get_bits(gb, 8)!='s')) { |
||
732 | av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis id header packet corrupt (no vorbis signature). \n");
|
||
733 | return 1; |
||
734 | } |
||
735 | |||
736 | vc->version=get_bits_long_le(gb, 32); //FIXME check 0 |
||
737 | vc->audio_channels=get_bits(gb, 8); //FIXME check >0 |
||
738 | vc->audio_samplerate=get_bits_long_le(gb, 32); //FIXME check >0 |
||
739 | vc->bitrate_maximum=get_bits_long_le(gb, 32);
|
||
740 | vc->bitrate_nominal=get_bits_long_le(gb, 32);
|
||
741 | vc->bitrate_minimum=get_bits_long_le(gb, 32);
|
||
742 | bl0=get_bits(gb, 4);
|
||
743 | bl1=get_bits(gb, 4);
|
||
744 | vc->blocksize_0=(1<<bl0);
|
||
745 | vc->blocksize_1=(1<<bl1);
|
||
746 | if (bl0>13 || bl0<6 || bl1>13 || bl1<6) { |
||
747 | av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis id header packet corrupt (illegal blocksize). \n");
|
||
748 | return 3; |
||
749 | } |
||
750 | vc->swin=vwin[bl0-6];
|
||
751 | vc->lwin=vwin[bl1-6];
|
||
752 | |||
753 | if ((get_bits1(gb)) == 0) { |
||
754 | av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis id header packet corrupt (framing flag not set). \n");
|
||
755 | return 2; |
||
756 | } |
||
757 | |||
758 | vc->channel_residues=(float *)av_malloc((vc->blocksize_1/2)*vc->audio_channels * sizeof(float)); |
||
759 | vc->channel_floors=(float *)av_malloc((vc->blocksize_1/2)*vc->audio_channels * sizeof(float)); |
||
760 | vc->saved=(float *)av_malloc((vc->blocksize_1/2)*vc->audio_channels * sizeof(float)); |
||
761 | vc->ret=(float *)av_malloc((vc->blocksize_1/2)*vc->audio_channels * sizeof(float)); |
||
762 | 13c2469d | Michael Niedermayer | vc->buf=(float *)av_malloc(vc->blocksize_1 * sizeof(float)); |
763 | vc->buf_tmp=(float *)av_malloc(vc->blocksize_1 * sizeof(float)); |
||
764 | 0bde73d9 | Michael Niedermayer | vc->saved_start=0;
|
765 | |||
766 | ff_mdct_init(&vc->mdct0, bl0, 1);
|
||
767 | ff_mdct_init(&vc->mdct1, bl1, 1);
|
||
768 | |||
769 | AV_DEBUG(" vorbis version %d \n audio_channels %d \n audio_samplerate %d \n bitrate_max %d \n bitrate_nom %d \n bitrate_min %d \n blk_0 %d blk_1 %d \n ",
|
||
770 | vc->version, vc->audio_channels, vc->audio_samplerate, vc->bitrate_maximum, vc->bitrate_nominal, vc->bitrate_minimum, vc->blocksize_0, vc->blocksize_1); |
||
771 | |||
772 | /*
|
||
773 | BLK=vc->blocksize_0;
|
||
774 | for(i=0;i<BLK/2;++i) {
|
||
775 | vc->swin[i]=sin(0.5*3.14159265358*(sin(((float)i+0.5)/(float)BLK*3.14159265358))*(sin(((float)i+0.5)/(float)BLK*3.14159265358)));
|
||
776 | }
|
||
777 | */
|
||
778 | |||
779 | return 0; |
||
780 | } |
||
781 | |||
782 | // Process the extradata using the functions above (identification header, setup header)
|
||
783 | |||
784 | static int vorbis_decode_init(AVCodecContext *avccontext) { |
||
785 | vorbis_context *vc = avccontext->priv_data ; |
||
786 | uint8_t *headers = avccontext->extradata; |
||
787 | int headers_len=avccontext->extradata_size;
|
||
788 | 2c578058 | Måns Rullgård | uint8_t *header_start[3];
|
789 | 0bde73d9 | Michael Niedermayer | int header_len[3]; |
790 | GetBitContext *gb = &(vc->gb); |
||
791 | int i, j, hdr_type;
|
||
792 | |||
793 | vc->avccontext = avccontext; |
||
794 | |||
795 | 2c578058 | Måns Rullgård | if (!headers_len) {
|
796 | 0bde73d9 | Michael Niedermayer | av_log(avccontext, AV_LOG_ERROR, "Extradata corrupt.\n");
|
797 | return -1; |
||
798 | } |
||
799 | |||
800 | 2c578058 | Måns Rullgård | if(headers[0] == 0 && headers[1] == 30) { |
801 | for(i = 0; i < 3; i++){ |
||
802 | header_len[i] = *headers++ << 8;
|
||
803 | header_len[i] += *headers++; |
||
804 | header_start[i] = headers; |
||
805 | headers += header_len[i]; |
||
806 | 0bde73d9 | Michael Niedermayer | } |
807 | 2c578058 | Måns Rullgård | } else if(headers[0] == 2) { |
808 | for(j=1,i=0;i<2;++i, ++j) { |
||
809 | header_len[i]=0;
|
||
810 | while(j<headers_len && headers[j]==0xff) { |
||
811 | header_len[i]+=0xff;
|
||
812 | ++j; |
||
813 | } |
||
814 | if (j>=headers_len) {
|
||
815 | av_log(avccontext, AV_LOG_ERROR, "Extradata corrupt.\n");
|
||
816 | return -1; |
||
817 | } |
||
818 | header_len[i]+=headers[j]; |
||
819 | 0bde73d9 | Michael Niedermayer | } |
820 | 2c578058 | Måns Rullgård | header_len[2]=headers_len-header_len[0]-header_len[1]-j; |
821 | headers+=j; |
||
822 | header_start[0] = headers;
|
||
823 | header_start[1] = header_start[0] + header_len[0]; |
||
824 | header_start[2] = header_start[1] + header_len[1]; |
||
825 | } else {
|
||
826 | av_log(avccontext, AV_LOG_ERROR, "Extradata corrupt.\n");
|
||
827 | return -1; |
||
828 | 0bde73d9 | Michael Niedermayer | } |
829 | |||
830 | 2c578058 | Måns Rullgård | init_get_bits(gb, header_start[0], header_len[0]*8); |
831 | 0bde73d9 | Michael Niedermayer | hdr_type=get_bits(gb, 8);
|
832 | if (hdr_type!=1) { |
||
833 | av_log(avccontext, AV_LOG_ERROR, "First header is not the id header.\n");
|
||
834 | return -1; |
||
835 | } |
||
836 | if (vorbis_parse_id_hdr(vc)) {
|
||
837 | av_log(avccontext, AV_LOG_ERROR, "Id header corrupt.\n");
|
||
838 | vorbis_free(vc); |
||
839 | return -1; |
||
840 | } |
||
841 | |||
842 | 2c578058 | Måns Rullgård | init_get_bits(gb, header_start[2], header_len[2]*8); |
843 | 0bde73d9 | Michael Niedermayer | hdr_type=get_bits(gb, 8);
|
844 | if (hdr_type!=5) { |
||
845 | av_log(avccontext, AV_LOG_ERROR, "Third header is not the setup header.\n");
|
||
846 | return -1; |
||
847 | } |
||
848 | if (vorbis_parse_setup_hdr(vc)) {
|
||
849 | av_log(avccontext, AV_LOG_ERROR, "Setup header corrupt.\n");
|
||
850 | vorbis_free(vc); |
||
851 | return -1; |
||
852 | } |
||
853 | |||
854 | avccontext->channels = vc->audio_channels; |
||
855 | avccontext->sample_rate = vc->audio_samplerate; |
||
856 | |||
857 | return 0 ; |
||
858 | } |
||
859 | |||
860 | // Decode audiopackets -------------------------------------------------
|
||
861 | |||
862 | // Read and decode floor (type 1 only)
|
||
863 | |||
864 | static uint_fast8_t vorbis_floor1_decode(vorbis_context *vc, vorbis_floor *vf, float *vec) { |
||
865 | GetBitContext *gb=&vc->gb; |
||
866 | uint_fast16_t range_v[4]={ 256, 128, 86, 64 }; |
||
867 | uint_fast16_t range=range_v[vf->multiplier-1];
|
||
868 | uint_fast16_t floor1_Y[vf->x_list_dim]; |
||
869 | uint_fast16_t floor1_Y_final[vf->x_list_dim]; |
||
870 | uint_fast8_t floor1_flag[vf->x_list_dim]; |
||
871 | uint_fast8_t class_; |
||
872 | uint_fast8_t cdim; |
||
873 | uint_fast8_t cbits; |
||
874 | uint_fast8_t csub; |
||
875 | uint_fast8_t cval; |
||
876 | int_fast16_t book; |
||
877 | uint_fast16_t offset; |
||
878 | uint_fast16_t i,j; |
||
879 | uint_fast16_t *floor_x_sort=vf->x_list_order; |
||
880 | /*u*/int_fast16_t adx, ady, off, predicted; // WTF ? dy/adx= (unsigned)dy/adx ? |
||
881 | int_fast16_t dy, err; |
||
882 | uint_fast16_t lx,hx, ly, hy=0;
|
||
883 | |||
884 | |||
885 | if (!get_bits1(gb)) return 1; // silence |
||
886 | |||
887 | // Read values (or differences) for the floor's points
|
||
888 | |||
889 | floor1_Y[0]=get_bits(gb, ilog(range-1)); |
||
890 | floor1_Y[1]=get_bits(gb, ilog(range-1)); |
||
891 | |||
892 | AV_DEBUG("floor 0 Y %d floor 1 Y %d \n", floor1_Y[0], floor1_Y[1]); |
||
893 | |||
894 | offset=2;
|
||
895 | for(i=0;i<vf->partitions;++i) { |
||
896 | class_=vf->partition_class[i]; |
||
897 | cdim=vf->class_dimensions[class_]; |
||
898 | cbits=vf->class_subclasses[class_]; |
||
899 | csub=(1<<cbits)-1; |
||
900 | cval=0;
|
||
901 | |||
902 | AV_DEBUG("Cbits %d \n", cbits);
|
||
903 | |||
904 | if (cbits) { // this reads all subclasses for this partition's class |
||
905 | cval=get_vlc2(gb, vc->codebooks[vf->class_masterbook[class_]].vlc.table, |
||
906 | 5a408f91 | Michael Niedermayer | vc->codebooks[vf->class_masterbook[class_]].nb_bits, 3);
|
907 | 0bde73d9 | Michael Niedermayer | } |
908 | |||
909 | for(j=0;j<cdim;++j) { |
||
910 | book=vf->subclass_books[class_][cval & csub]; |
||
911 | |||
912 | AV_DEBUG("book %d Cbits %d cval %d bits:%d \n", book, cbits, cval, get_bits_count(gb));
|
||
913 | |||
914 | cval=cval>>cbits; |
||
915 | if (book>0) { |
||
916 | floor1_Y[offset+j]=get_vlc2(gb, vc->codebooks[book].vlc.table, |
||
917 | 5a408f91 | Michael Niedermayer | vc->codebooks[book].nb_bits, 3);
|
918 | 0bde73d9 | Michael Niedermayer | } else {
|
919 | floor1_Y[offset+j]=0;
|
||
920 | } |
||
921 | |||
922 | AV_DEBUG(" floor(%d) = %d \n", vf->x_list[offset+j], floor1_Y[offset+j]);
|
||
923 | } |
||
924 | offset+=cdim; |
||
925 | } |
||
926 | |||
927 | // Amplitude calculation from the differences
|
||
928 | |||
929 | floor1_flag[0]=1; |
||
930 | floor1_flag[1]=1; |
||
931 | floor1_Y_final[0]=floor1_Y[0]; |
||
932 | floor1_Y_final[1]=floor1_Y[1]; |
||
933 | |||
934 | for(i=2;i<vf->x_list_dim;++i) { |
||
935 | uint_fast16_t val, highroom, lowroom, room; |
||
936 | uint_fast16_t high_neigh_offs; |
||
937 | uint_fast16_t low_neigh_offs; |
||
938 | |||
939 | low_neigh_offs=vf->low_neighbour[i]; |
||
940 | high_neigh_offs=vf->high_neighbour[i]; |
||
941 | dy=floor1_Y_final[high_neigh_offs]-floor1_Y_final[low_neigh_offs]; // render_point begin
|
||
942 | adx=vf->x_list[high_neigh_offs]-vf->x_list[low_neigh_offs]; |
||
943 | ady= ABS(dy); |
||
944 | err=ady*(vf->x_list[i]-vf->x_list[low_neigh_offs]); |
||
945 | off=err/adx; |
||
946 | if (dy<0) { |
||
947 | predicted=floor1_Y_final[low_neigh_offs]-off; |
||
948 | } else {
|
||
949 | predicted=floor1_Y_final[low_neigh_offs]+off; |
||
950 | } // render_point end
|
||
951 | |||
952 | val=floor1_Y[i]; |
||
953 | highroom=range-predicted; |
||
954 | lowroom=predicted; |
||
955 | if (highroom < lowroom) {
|
||
956 | room=highroom*2;
|
||
957 | } else {
|
||
958 | room=lowroom*2; // SPEC mispelling |
||
959 | } |
||
960 | if (val) {
|
||
961 | floor1_flag[low_neigh_offs]=1;
|
||
962 | floor1_flag[high_neigh_offs]=1;
|
||
963 | floor1_flag[i]=1;
|
||
964 | if (val>=room) {
|
||
965 | if (highroom > lowroom) {
|
||
966 | floor1_Y_final[i]=val-lowroom+predicted; |
||
967 | } else {
|
||
968 | floor1_Y_final[i]=predicted-val+highroom-1;
|
||
969 | } |
||
970 | } else {
|
||
971 | if (val & 1) { |
||
972 | floor1_Y_final[i]=predicted-(val+1)/2; |
||
973 | } else {
|
||
974 | floor1_Y_final[i]=predicted+val/2;
|
||
975 | } |
||
976 | } |
||
977 | } else {
|
||
978 | floor1_flag[i]=0;
|
||
979 | floor1_Y_final[i]=predicted; |
||
980 | } |
||
981 | |||
982 | AV_DEBUG(" Decoded floor(%d) = %d / val %d \n", vf->x_list[i], floor1_Y_final[i], val);
|
||
983 | } |
||
984 | |||
985 | // Curve synth - connect the calculated dots and convert from dB scale FIXME optimize ?
|
||
986 | |||
987 | hx=0;
|
||
988 | lx=0;
|
||
989 | ly=floor1_Y_final[0]*vf->multiplier; // conforms to SPEC |
||
990 | |||
991 | vec[0]=floor1_inverse_db_table[ly];
|
||
992 | |||
993 | for(i=1;i<vf->x_list_dim;++i) { |
||
994 | AV_DEBUG(" Looking at post %d \n", i);
|
||
995 | |||
996 | if (floor1_flag[floor_x_sort[i]]) { // SPEC mispelled |
||
997 | int_fast16_t x, y, dy, base, sy; // if uncommented: dy = -32 adx = 2 base = 2blablabla ?????
|
||
998 | |||
999 | hy=floor1_Y_final[floor_x_sort[i]]*vf->multiplier; |
||
1000 | hx=vf->x_list[floor_x_sort[i]]; |
||
1001 | |||
1002 | dy=hy-ly; |
||
1003 | adx=hx-lx; |
||
1004 | ady= (dy<0) ? -dy:dy;//ABS(dy); |
||
1005 | base=dy/adx; |
||
1006 | |||
1007 | AV_DEBUG(" dy %d adx %d base %d = %d \n", dy, adx, base, dy/adx);
|
||
1008 | |||
1009 | x=lx; |
||
1010 | y=ly; |
||
1011 | err=0;
|
||
1012 | if (dy<0) { |
||
1013 | sy=base-1;
|
||
1014 | } else {
|
||
1015 | sy=base+1;
|
||
1016 | } |
||
1017 | ady=ady-(base<0 ? -base : base)*adx;
|
||
1018 | vec[x]=floor1_inverse_db_table[y]; |
||
1019 | |||
1020 | AV_DEBUG(" vec[ %d ] = %d \n", x, y);
|
||
1021 | |||
1022 | for(x=lx+1;(x<hx) && (x<vf->x_list[1]);++x) { |
||
1023 | err+=ady; |
||
1024 | if (err>=adx) {
|
||
1025 | err-=adx; |
||
1026 | y+=sy; |
||
1027 | } else {
|
||
1028 | y+=base; |
||
1029 | } |
||
1030 | vec[x]=floor1_inverse_db_table[y]; |
||
1031 | |||
1032 | AV_DEBUG(" vec[ %d ] = %d \n", x, y);
|
||
1033 | } |
||
1034 | |||
1035 | /* for(j=1;j<hx-lx+1;++j) { // iterating render_point
|
||
1036 | dy=hy-ly;
|
||
1037 | adx=hx-lx;
|
||
1038 | ady= dy<0 ? -dy : dy;
|
||
1039 | err=ady*j;
|
||
1040 | off=err/adx;
|
||
1041 | if (dy<0) {
|
||
1042 | predicted=ly-off;
|
||
1043 | } else {
|
||
1044 | predicted=ly+off;
|
||
1045 | }
|
||
1046 | if (lx+j < vf->x_list[1]) {
|
||
1047 | vec[lx+j]=floor1_inverse_db_table[predicted];
|
||
1048 | }
|
||
1049 | }*/
|
||
1050 | |||
1051 | lx=hx; |
||
1052 | ly=hy; |
||
1053 | } |
||
1054 | } |
||
1055 | |||
1056 | if (hx<vf->x_list[1]) { |
||
1057 | for(i=hx;i<vf->x_list[1];++i) { |
||
1058 | vec[i]=floor1_inverse_db_table[hy]; |
||
1059 | } |
||
1060 | } |
||
1061 | |||
1062 | AV_DEBUG(" Floor decoded\n");
|
||
1063 | |||
1064 | return 0; |
||
1065 | } |
||
1066 | |||
1067 | // Read and decode residue
|
||
1068 | |||
1069 | static int vorbis_residue_decode(vorbis_context *vc, vorbis_residue *vr, uint_fast8_t ch, uint_fast8_t *do_not_decode, float *vec, uint_fast16_t vlen) { |
||
1070 | GetBitContext *gb=&vc->gb; |
||
1071 | uint_fast8_t c_p_c=vc->codebooks[vr->classbook].dimensions; |
||
1072 | uint_fast16_t n_to_read=vr->end-vr->begin; |
||
1073 | uint_fast16_t ptns_to_read=n_to_read/vr->partition_size; |
||
1074 | d381c505 | Måns Rullgård | uint_fast8_t classifs[ptns_to_read*vc->audio_channels]; |
1075 | 0bde73d9 | Michael Niedermayer | uint_fast8_t pass; |
1076 | uint_fast8_t ch_used; |
||
1077 | uint_fast8_t i,j,l; |
||
1078 | uint_fast16_t k; |
||
1079 | |||
1080 | if (vr->type==2) { |
||
1081 | for(j=1;j<ch;++j) { |
||
1082 | do_not_decode[0]&=do_not_decode[j]; // FIXME - clobbering input |
||
1083 | } |
||
1084 | if (do_not_decode[0]) return 0; |
||
1085 | ch_used=1;
|
||
1086 | } else {
|
||
1087 | ch_used=ch; |
||
1088 | } |
||
1089 | |||
1090 | AV_DEBUG(" residue type 0/1/2 decode begin, ch: %d cpc %d \n", ch, c_p_c);
|
||
1091 | |||
1092 | for(pass=0;pass<=vr->maxpass;++pass) { // FIXME OPTIMIZE? |
||
1093 | uint_fast16_t voffset; |
||
1094 | uint_fast16_t partition_count; |
||
1095 | uint_fast16_t j_times_ptns_to_read; |
||
1096 | |||
1097 | voffset=vr->begin; |
||
1098 | for(partition_count=0;partition_count<ptns_to_read;) { // SPEC error |
||
1099 | if (!pass) {
|
||
1100 | for(j_times_ptns_to_read=0, j=0;j<ch_used;++j) { |
||
1101 | if (!do_not_decode[j]) {
|
||
1102 | uint_fast32_t temp=get_vlc2(gb, vc->codebooks[vr->classbook].vlc.table, |
||
1103 | 5a408f91 | Michael Niedermayer | vc->codebooks[vr->classbook].nb_bits, 3);
|
1104 | 0bde73d9 | Michael Niedermayer | |
1105 | AV_DEBUG("Classword: %d \n", temp);
|
||
1106 | |||
1107 | f4e61cd1 | Michael Niedermayer | assert(vr->classifications > 1 && vr->classifications<256 && temp<=65536); //needed for inverse[] |
1108 | 0bde73d9 | Michael Niedermayer | for(i=0;i<c_p_c;++i) { |
1109 | uint_fast32_t temp2; |
||
1110 | |||
1111 | f4e61cd1 | Michael Niedermayer | temp2=(((uint_fast64_t)temp) * inverse[vr->classifications])>>32;
|
1112 | 0bde73d9 | Michael Niedermayer | classifs[j_times_ptns_to_read+partition_count+c_p_c-1-i]=temp-temp2*vr->classifications;
|
1113 | temp=temp2; |
||
1114 | } |
||
1115 | } |
||
1116 | j_times_ptns_to_read+=ptns_to_read; |
||
1117 | } |
||
1118 | } |
||
1119 | for(i=0;(i<c_p_c) && (partition_count<ptns_to_read);++i) { |
||
1120 | for(j_times_ptns_to_read=0, j=0;j<ch_used;++j) { |
||
1121 | uint_fast16_t voffs; |
||
1122 | |||
1123 | if (!do_not_decode[j]) {
|
||
1124 | uint_fast8_t vqclass=classifs[j_times_ptns_to_read+partition_count]; |
||
1125 | int_fast16_t vqbook=vr->books[vqclass][pass]; |
||
1126 | |||
1127 | if (vqbook>=0) { |
||
1128 | uint_fast16_t coffs; |
||
1129 | f4e61cd1 | Michael Niedermayer | uint_fast16_t step=vr->partition_size/vc->codebooks[vqbook].dimensions; |
1130 | vorbis_codebook codebook= vc->codebooks[vqbook]; |
||
1131 | 0bde73d9 | Michael Niedermayer | |
1132 | if (vr->type==0) { |
||
1133 | |||
1134 | voffs=voffset+j*vlen; |
||
1135 | for(k=0;k<step;++k) { |
||
1136 | 5a408f91 | Michael Niedermayer | coffs=get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * codebook.dimensions;
|
1137 | f4e61cd1 | Michael Niedermayer | for(l=0;l<codebook.dimensions;++l) { |
1138 | vec[voffs+k+l*step]+=codebook.codevectors[coffs+l]; // FPMATH
|
||
1139 | 0bde73d9 | Michael Niedermayer | } |
1140 | } |
||
1141 | } |
||
1142 | else if (vr->type==1) { |
||
1143 | voffs=voffset+j*vlen; |
||
1144 | f4e61cd1 | Michael Niedermayer | for(k=0;k<step;++k) { |
1145 | 5a408f91 | Michael Niedermayer | coffs=get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * codebook.dimensions;
|
1146 | f4e61cd1 | Michael Niedermayer | for(l=0;l<codebook.dimensions;++l, ++voffs) { |
1147 | vec[voffs]+=codebook.codevectors[coffs+l]; // FPMATH
|
||
1148 | 0bde73d9 | Michael Niedermayer | |
1149 | f4e61cd1 | Michael Niedermayer | AV_DEBUG(" pass %d offs: %d curr: %f change: %f cv offs.: %d \n", pass, voffs, vec[voffs], codebook.codevectors[coffs+l], coffs);
|
1150 | 0bde73d9 | Michael Niedermayer | } |
1151 | } |
||
1152 | } |
||
1153 | f4e61cd1 | Michael Niedermayer | else if (vr->type==2 && ch==2 && (voffset&1)==0 && (codebook.dimensions&1)==0) { // most frequent case optimized |
1154 | voffs=voffset>>1;
|
||
1155 | 0bde73d9 | Michael Niedermayer | |
1156 | f4e61cd1 | Michael Niedermayer | for(k=0;k<step;++k) { |
1157 | 5a408f91 | Michael Niedermayer | coffs=get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * codebook.dimensions;
|
1158 | f4e61cd1 | Michael Niedermayer | for(l=0;l<codebook.dimensions;l+=2, voffs++) { |
1159 | vec[voffs ]+=codebook.codevectors[coffs+l ]; // FPMATH
|
||
1160 | vec[voffs+vlen]+=codebook.codevectors[coffs+l+1]; // FPMATH |
||
1161 | 0bde73d9 | Michael Niedermayer | |
1162 | f4e61cd1 | Michael Niedermayer | AV_DEBUG(" pass %d offs: %d curr: %f change: %f cv offs.: %d+%d \n", pass, voffset/ch+(voffs%ch)*vlen, vec[voffset/ch+(voffs%ch)*vlen], codebook.codevectors[coffs+l], coffs, l);
|
1163 | 0bde73d9 | Michael Niedermayer | } |
1164 | } |
||
1165 | |||
1166 | } |
||
1167 | else if (vr->type==2) { |
||
1168 | voffs=voffset; |
||
1169 | |||
1170 | f4e61cd1 | Michael Niedermayer | for(k=0;k<step;++k) { |
1171 | 5a408f91 | Michael Niedermayer | coffs=get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * codebook.dimensions;
|
1172 | f4e61cd1 | Michael Niedermayer | for(l=0;l<codebook.dimensions;++l, ++voffs) { |
1173 | vec[voffs/ch+(voffs%ch)*vlen]+=codebook.codevectors[coffs+l]; // FPMATH FIXME use if and counter instead of / and %
|
||
1174 | 0bde73d9 | Michael Niedermayer | |
1175 | f4e61cd1 | Michael Niedermayer | AV_DEBUG(" pass %d offs: %d curr: %f change: %f cv offs.: %d+%d \n", pass, voffset/ch+(voffs%ch)*vlen, vec[voffset/ch+(voffs%ch)*vlen], codebook.codevectors[coffs+l], coffs, l);
|
1176 | 0bde73d9 | Michael Niedermayer | } |
1177 | } |
||
1178 | } else {
|
||
1179 | av_log(vc->avccontext, AV_LOG_ERROR, " Invalid residue type while residue decode?! \n");
|
||
1180 | return 1; |
||
1181 | } |
||
1182 | } |
||
1183 | } |
||
1184 | d381c505 | Måns Rullgård | j_times_ptns_to_read+=ptns_to_read; |
1185 | 0bde73d9 | Michael Niedermayer | } |
1186 | ++partition_count; |
||
1187 | voffset+=vr->partition_size; |
||
1188 | } |
||
1189 | } |
||
1190 | } |
||
1191 | return 0; |
||
1192 | } |
||
1193 | |||
1194 | // Decode the audio packet using the functions above
|
||
1195 | de312e51 | Michael Niedermayer | #define BIAS 385 |
1196 | 0bde73d9 | Michael Niedermayer | |
1197 | static int vorbis_parse_audio_packet(vorbis_context *vc) { |
||
1198 | GetBitContext *gb=&vc->gb; |
||
1199 | |||
1200 | uint_fast8_t previous_window=0,next_window=0; |
||
1201 | uint_fast8_t mode_number; |
||
1202 | uint_fast16_t blocksize; |
||
1203 | int_fast32_t i,j; |
||
1204 | uint_fast8_t no_residue[vc->audio_channels]; |
||
1205 | uint_fast8_t do_not_decode[vc->audio_channels]; |
||
1206 | vorbis_mapping *mapping; |
||
1207 | float *ch_res_ptr=vc->channel_residues;
|
||
1208 | float *ch_floor_ptr=vc->channel_floors;
|
||
1209 | uint_fast8_t res_chan[vc->audio_channels]; |
||
1210 | uint_fast8_t res_num=0;
|
||
1211 | int_fast16_t retlen=0;
|
||
1212 | uint_fast16_t saved_start=0;
|
||
1213 | |||
1214 | if (get_bits1(gb)) {
|
||
1215 | av_log(vc->avccontext, AV_LOG_ERROR, "Not a Vorbis I audio packet.\n");
|
||
1216 | return -1; // packet type not audio |
||
1217 | } |
||
1218 | |||
1219 | 84a96d6a | Denes Balatoni | if (vc->mode_count==1) { |
1220 | mode_number=0;
|
||
1221 | } else {
|
||
1222 | mode_number=get_bits(gb, ilog(vc->mode_count-1));
|
||
1223 | } |
||
1224 | 0bde73d9 | Michael Niedermayer | mapping=&vc->mappings[vc->modes[mode_number].mapping]; |
1225 | |||
1226 | AV_DEBUG(" Mode number: %d , mapping: %d , blocktype %d \n", mode_number, vc->modes[mode_number].mapping, vc->modes[mode_number].blockflag);
|
||
1227 | |||
1228 | if (vc->modes[mode_number].blockflag) {
|
||
1229 | previous_window=get_bits1(gb); |
||
1230 | next_window=get_bits1(gb); |
||
1231 | } |
||
1232 | |||
1233 | blocksize=vc->modes[mode_number].blockflag ? vc->blocksize_1 : vc->blocksize_0; |
||
1234 | memset(ch_res_ptr, 0, sizeof(float)*vc->audio_channels*blocksize/2); //FIXME can this be removed ? |
||
1235 | memset(ch_floor_ptr, 0, sizeof(float)*vc->audio_channels*blocksize/2); //FIXME can this be removed ? |
||
1236 | |||
1237 | // Decode floor(1)
|
||
1238 | |||
1239 | for(i=0;i<vc->audio_channels;++i) { |
||
1240 | vorbis_floor *floor; |
||
1241 | if (mapping->submaps>1) { |
||
1242 | floor=&vc->floors[mapping->submap_floor[mapping->mux[i]]]; |
||
1243 | } else {
|
||
1244 | floor=&vc->floors[mapping->submap_floor[0]];
|
||
1245 | } |
||
1246 | |||
1247 | no_residue[i]=vorbis_floor1_decode(vc, floor, ch_floor_ptr); |
||
1248 | ch_floor_ptr+=blocksize/2;
|
||
1249 | } |
||
1250 | |||
1251 | // Nonzero vector propagate
|
||
1252 | |||
1253 | for(i=mapping->coupling_steps-1;i>=0;--i) { |
||
1254 | if (!(no_residue[mapping->magnitude[i]] & no_residue[mapping->angle[i]])) {
|
||
1255 | no_residue[mapping->magnitude[i]]=0;
|
||
1256 | no_residue[mapping->angle[i]]=0;
|
||
1257 | } |
||
1258 | } |
||
1259 | |||
1260 | // Decode residue
|
||
1261 | |||
1262 | for(i=0;i<mapping->submaps;++i) { |
||
1263 | vorbis_residue *residue; |
||
1264 | uint_fast8_t ch=0;
|
||
1265 | |||
1266 | for(j=0;j<vc->audio_channels;++j) { |
||
1267 | if ((mapping->submaps==1) || (i=mapping->mux[j])) { |
||
1268 | res_chan[j]=res_num; |
||
1269 | if (no_residue[j]) {
|
||
1270 | do_not_decode[ch]=1;
|
||
1271 | } else {
|
||
1272 | do_not_decode[ch]=0;
|
||
1273 | } |
||
1274 | ++ch; |
||
1275 | ++res_num; |
||
1276 | } |
||
1277 | } |
||
1278 | residue=&vc->residues[mapping->submap_residue[i]]; |
||
1279 | vorbis_residue_decode(vc, residue, ch, do_not_decode, ch_res_ptr, blocksize/2);
|
||
1280 | |||
1281 | ch_res_ptr+=ch*blocksize/2;
|
||
1282 | } |
||
1283 | |||
1284 | // Inverse coupling
|
||
1285 | |||
1286 | for(i=mapping->coupling_steps-1;i>=0;--i) { //warning: i has to be signed |
||
1287 | float *mag, *ang;
|
||
1288 | |||
1289 | mag=vc->channel_residues+res_chan[mapping->magnitude[i]]*blocksize/2;
|
||
1290 | ang=vc->channel_residues+res_chan[mapping->angle[i]]*blocksize/2;
|
||
1291 | for(j=0;j<blocksize/2;++j) { |
||
1292 | float temp;
|
||
1293 | if (mag[j]>0.0) { |
||
1294 | if (ang[j]>0.0) { |
||
1295 | ang[j]=mag[j]-ang[j]; |
||
1296 | } else {
|
||
1297 | temp=ang[j]; |
||
1298 | ang[j]=mag[j]; |
||
1299 | mag[j]+=temp; |
||
1300 | } |
||
1301 | } else {
|
||
1302 | if (ang[j]>0.0) { |
||
1303 | ang[j]+=mag[j]; |
||
1304 | } else {
|
||
1305 | temp=ang[j]; |
||
1306 | ang[j]=mag[j]; |
||
1307 | mag[j]-=temp; |
||
1308 | } |
||
1309 | } |
||
1310 | } |
||
1311 | } |
||
1312 | |||
1313 | // Dotproduct
|
||
1314 | |||
1315 | for(j=0, ch_floor_ptr=vc->channel_floors;j<vc->audio_channels;++j,ch_floor_ptr+=blocksize/2) { |
||
1316 | ch_res_ptr=vc->channel_residues+res_chan[j]*blocksize/2;
|
||
1317 | |||
1318 | for(i=0;i<blocksize/2;++i) { |
||
1319 | ch_floor_ptr[i]*=ch_res_ptr[i]; //FPMATH
|
||
1320 | } |
||
1321 | } |
||
1322 | |||
1323 | // MDCT, overlap/add, save data for next overlapping FPMATH
|
||
1324 | |||
1325 | for(j=0;j<vc->audio_channels;++j) { |
||
1326 | uint_fast8_t step=vc->audio_channels; |
||
1327 | uint_fast16_t k; |
||
1328 | float *saved=vc->saved+j*vc->blocksize_1/2; |
||
1329 | float *ret=vc->ret;
|
||
1330 | const float *lwin=vc->lwin; |
||
1331 | const float *swin=vc->swin; |
||
1332 | 13c2469d | Michael Niedermayer | float *buf=vc->buf;
|
1333 | float *buf_tmp=vc->buf_tmp;
|
||
1334 | 0bde73d9 | Michael Niedermayer | |
1335 | ch_floor_ptr=vc->channel_floors+j*blocksize/2;
|
||
1336 | |||
1337 | saved_start=vc->saved_start; |
||
1338 | |||
1339 | ff_imdct_calc(vc->modes[mode_number].blockflag ? &vc->mdct1 : &vc->mdct0, buf, ch_floor_ptr, buf_tmp); |
||
1340 | |||
1341 | if (vc->modes[mode_number].blockflag) {
|
||
1342 | // -- overlap/add
|
||
1343 | if (previous_window) {
|
||
1344 | for(k=j, i=0;i<vc->blocksize_1/2;++i, k+=step) { |
||
1345 | f56f96d8 | Michael Niedermayer | ret[k]=saved[i]+buf[i]*lwin[i]+BIAS; |
1346 | 0bde73d9 | Michael Niedermayer | } |
1347 | retlen=vc->blocksize_1/2;
|
||
1348 | } else {
|
||
1349 | de312e51 | Michael Niedermayer | buf += (vc->blocksize_1-vc->blocksize_0)/4;
|
1350 | 0bde73d9 | Michael Niedermayer | for(k=j, i=0;i<vc->blocksize_0/2;++i, k+=step) { |
1351 | de312e51 | Michael Niedermayer | ret[k]=saved[i]+buf[i]*swin[i]+BIAS; |
1352 | 0bde73d9 | Michael Niedermayer | } |
1353 | de312e51 | Michael Niedermayer | buf += vc->blocksize_0/2;
|
1354 | 0bde73d9 | Michael Niedermayer | for(i=0;i<(vc->blocksize_1-vc->blocksize_0)/4;++i, k+=step) { |
1355 | de312e51 | Michael Niedermayer | ret[k]=buf[i]+BIAS; |
1356 | 0bde73d9 | Michael Niedermayer | } |
1357 | de312e51 | Michael Niedermayer | buf=vc->buf; |
1358 | 0bde73d9 | Michael Niedermayer | retlen=vc->blocksize_0/2+(vc->blocksize_1-vc->blocksize_0)/4; |
1359 | } |
||
1360 | // -- save
|
||
1361 | if (next_window) {
|
||
1362 | de312e51 | Michael Niedermayer | buf += vc->blocksize_1/2;
|
1363 | lwin += vc->blocksize_1/2-1; |
||
1364 | 0bde73d9 | Michael Niedermayer | for(i=0;i<vc->blocksize_1/2;++i) { |
1365 | de312e51 | Michael Niedermayer | saved[i]=buf[i]*lwin[-i]; |
1366 | 0bde73d9 | Michael Niedermayer | } |
1367 | saved_start=0;
|
||
1368 | } else {
|
||
1369 | saved_start=(vc->blocksize_1-vc->blocksize_0)/4;
|
||
1370 | de312e51 | Michael Niedermayer | buf += vc->blocksize_1/2;
|
1371 | 0bde73d9 | Michael Niedermayer | for(i=0;i<saved_start;++i) { |
1372 | de312e51 | Michael Niedermayer | saved[i]=buf[i]; |
1373 | 0bde73d9 | Michael Niedermayer | } |
1374 | de312e51 | Michael Niedermayer | swin += vc->blocksize_0/2-1; |
1375 | 0bde73d9 | Michael Niedermayer | for(i=0;i<vc->blocksize_0/2;++i) { |
1376 | de312e51 | Michael Niedermayer | saved[saved_start+i]=buf[saved_start+i]*swin[-i]; |
1377 | 0bde73d9 | Michael Niedermayer | } |
1378 | } |
||
1379 | } else {
|
||
1380 | // --overlap/add
|
||
1381 | for(k=j, i=0;i<saved_start;++i, k+=step) { |
||
1382 | f56f96d8 | Michael Niedermayer | ret[k]=saved[i]+BIAS; |
1383 | 0bde73d9 | Michael Niedermayer | } |
1384 | for(i=0;i<vc->blocksize_0/2;++i, k+=step) { |
||
1385 | f56f96d8 | Michael Niedermayer | ret[k]=saved[saved_start+i]+buf[i]*swin[i]+BIAS; |
1386 | 0bde73d9 | Michael Niedermayer | } |
1387 | retlen=saved_start+vc->blocksize_0/2;
|
||
1388 | // -- save
|
||
1389 | de312e51 | Michael Niedermayer | buf += vc->blocksize_0/2;
|
1390 | swin += vc->blocksize_0/2-1; |
||
1391 | 0bde73d9 | Michael Niedermayer | for(i=0;i<vc->blocksize_0/2;++i) { |
1392 | de312e51 | Michael Niedermayer | saved[i]=buf[i]*swin[-i]; |
1393 | 0bde73d9 | Michael Niedermayer | } |
1394 | saved_start=0;
|
||
1395 | } |
||
1396 | } |
||
1397 | vc->saved_start=saved_start; |
||
1398 | |||
1399 | return retlen*vc->audio_channels;
|
||
1400 | } |
||
1401 | |||
1402 | // Return the decoded audio packet through the standard api
|
||
1403 | |||
1404 | static int vorbis_decode_frame(AVCodecContext *avccontext, |
||
1405 | void *data, int *data_size, |
||
1406 | uint8_t *buf, int buf_size)
|
||
1407 | { |
||
1408 | vorbis_context *vc = avccontext->priv_data ; |
||
1409 | GetBitContext *gb = &(vc->gb); |
||
1410 | |||
1411 | int_fast16_t i, len; |
||
1412 | |||
1413 | if(!buf_size){
|
||
1414 | return 0; |
||
1415 | } |
||
1416 | |||
1417 | AV_DEBUG("packet length %d \n", buf_size);
|
||
1418 | |||
1419 | init_get_bits(gb, buf, buf_size*8);
|
||
1420 | |||
1421 | len=vorbis_parse_audio_packet(vc); |
||
1422 | |||
1423 | if (len<=0) { |
||
1424 | *data_size=0;
|
||
1425 | return buf_size;
|
||
1426 | } |
||
1427 | |||
1428 | if (!vc->first_frame) {
|
||
1429 | vc->first_frame=1;
|
||
1430 | *data_size=0;
|
||
1431 | return buf_size ;
|
||
1432 | } |
||
1433 | |||
1434 | AV_DEBUG("parsed %d bytes %d bits, returned %d samples (*ch*bits) \n", get_bits_count(gb)/8, get_bits_count(gb)%8, len); |
||
1435 | |||
1436 | for(i=0;i<len;++i) { |
||
1437 | f56f96d8 | Michael Niedermayer | int_fast32_t tmp= ((int32_t*)vc->ret)[i]; |
1438 | de312e51 | Michael Niedermayer | if(tmp & 0xf0000){ |
1439 | // tmp= (0x43c0ffff - tmp)>>31; //ask gcc devs why this is slower
|
||
1440 | if(tmp > 0x43c0ffff) tmp= 0xFFFF; |
||
1441 | else tmp= 0; |
||
1442 | } |
||
1443 | ((int16_t*)data)[i]=tmp - 0x8000;
|
||
1444 | 0bde73d9 | Michael Niedermayer | } |
1445 | f56f96d8 | Michael Niedermayer | |
1446 | 0bde73d9 | Michael Niedermayer | *data_size=len*2;
|
1447 | |||
1448 | return buf_size ;
|
||
1449 | } |
||
1450 | |||
1451 | // Close decoder
|
||
1452 | |||
1453 | static int vorbis_decode_close(AVCodecContext *avccontext) { |
||
1454 | vorbis_context *vc = avccontext->priv_data; |
||
1455 | |||
1456 | vorbis_free(vc); |
||
1457 | |||
1458 | return 0 ; |
||
1459 | } |
||
1460 | |||
1461 | AVCodec vorbis_decoder = { |
||
1462 | "vorbis",
|
||
1463 | CODEC_TYPE_AUDIO, |
||
1464 | CODEC_ID_VORBIS, |
||
1465 | sizeof(vorbis_context),
|
||
1466 | vorbis_decode_init, |
||
1467 | NULL,
|
||
1468 | vorbis_decode_close, |
||
1469 | vorbis_decode_frame, |
||
1470 | }; |