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