4 * @author Denes Balatoni ( dbalatoni programozo hu )
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.
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.
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 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 #define ALT_BITSTREAM_READER_LE
28 #include "bitstream.h"
35 #define V_MAX_VLCS (1<<16)
44 /* Helper functions */
47 * reads 0-32 bits when using the ALT_BITSTREAM_READER_LE bitstream reader
49 unsigned int get_bits_long_le(GetBitContext
*s
, int n
){
50 if(n
<=17) return get_bits(s
, n
);
52 int ret
= get_bits(s
, 16);
53 return ret
| (get_bits(s
, n
-16) << 16);
57 #define ilog(i) av_log2(2*(i))
59 static unsigned int nth_root(unsigned int x
, unsigned int n
) { // x^(1/n)
60 unsigned int ret
=0, i
, j
;
64 for(i
=0,j
=ret
;i
<n
-1;i
++) j
*=ret
;
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));
78 // Generate vlc codes from vorbis huffman code lengths
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};
91 for(p
=0;(bits
[p
]==0) && (p
<num
);++p
);
93 // av_log(vc->avccontext, AV_LOG_INFO, "An empty codebook. Heh?! \n");
98 for(i
=0;i
<bits
[p
];++i
) {
99 exit_at_level
[i
+1]=1<<i
;
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");
108 av_log(vc
->avccontext
, AV_LOG_INFO
, "\n");
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;
119 if (!i
) return 1; // overspecified tree
120 code
=exit_at_level
[i
];
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));
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");
134 av_log(vc
->avccontext
, AV_LOG_INFO
, "\n");
139 //FIXME no exits should be left (underspecified tree - ie. unused valid vlcs - not allowed by SPEC)
144 // Free all allocated memory -----------------------------------------
146 static void vorbis_free(vorbis_context
*vc
) {
149 av_freep(&vc
->channel_residues
);
150 av_freep(&vc
->channel_floors
);
151 av_freep(&vc
->saved
);
154 av_freep(&vc
->buf_tmp
);
156 av_freep(&vc
->residues
);
157 av_freep(&vc
->modes
);
159 ff_mdct_end(&vc
->mdct0
);
160 ff_mdct_end(&vc
->mdct1
);
162 for(i
=0;i
<vc
->codebook_count
;++i
) {
163 av_free(vc
->codebooks
[i
].codevectors
);
164 free_vlc(&vc
->codebooks
[i
].vlc
);
166 av_freep(&vc
->codebooks
);
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
);
174 av_freep(&vc
->floors
);
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
);
181 av_freep(&vc
->mappings
);
184 // Parse setup header -------------------------------------------------
186 // Process codebooks part
188 static int vorbis_parse_setup_hdr_codebooks(vorbis_context
*vc
) {
190 uint_fast8_t *tmp_vlc_bits
;
191 uint_fast32_t *tmp_vlc_codes
;
192 GetBitContext
*gb
=&vc
->gb
;
194 vc
->codebook_count
=get_bits(gb
,8)+1;
196 AV_DEBUG(" Codebooks: %d \n", vc
->codebook_count
);
198 vc
->codebooks
=(vorbis_codebook
*)av_mallocz(vc
->codebook_count
* sizeof(vorbis_codebook
));
199 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));
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
;
208 AV_DEBUG(" %d. Codebook \n", cb
);
210 if (get_bits(gb
, 24)!=0x564342) {
211 av_log(vc
->avccontext
, AV_LOG_ERROR
, " %d. Codebook setup data corrupt. \n", cb
);
215 codebook_setup
->dimensions
=get_bits(gb
, 16);
216 if (codebook_setup
->dimensions
>16) {
217 av_log(vc
->avccontext
, AV_LOG_ERROR
, " %d. Codebook's dimension is too large (%d). \n", cb
, codebook_setup
->dimensions
);
220 entries
=get_bits(gb
, 24);
221 if (entries
>V_MAX_VLCS
) {
222 av_log(vc
->avccontext
, AV_LOG_ERROR
, " %d. Codebook has too many entries (%d). \n", cb
, entries
);
226 ordered
=get_bits1(gb
);
228 AV_DEBUG(" codebook_dimensions %d, codebook_entries %d \n", codebook_setup
->dimensions
, entries
);
233 uint_fast8_t sparse
=get_bits1(gb
);
235 AV_DEBUG(" not ordered \n");
238 AV_DEBUG(" sparse \n");
241 for(ce
=0;ce
<entries
;++ce
) {
244 tmp_vlc_bits
[ce
]=get_bits(gb
, 5)+1;
247 else tmp_vlc_bits
[ce
]=0;
250 AV_DEBUG(" not sparse \n");
252 used_entries
=entries
;
253 for(ce
=0;ce
<entries
;++ce
) {
254 tmp_vlc_bits
[ce
]=get_bits(gb
, 5)+1;
258 uint_fast16_t current_entry
=0;
259 uint_fast8_t current_length
=get_bits(gb
, 5)+1;
261 AV_DEBUG(" ordered, current length: %d \n", current_length
); //FIXME
263 used_entries
=entries
;
264 for(;current_entry
<used_entries
;++current_length
) {
265 uint_fast16_t i
, number
;
267 AV_DEBUG(" number bits: %d ", ilog(entries
- current_entry
));
269 number
=get_bits(gb
, ilog(entries
- current_entry
));
271 AV_DEBUG(" number: %d \n", number
);
273 for(i
=current_entry
;i
<number
+current_entry
;++i
) {
274 if (i
<used_entries
) tmp_vlc_bits
[i
]=current_length
;
277 current_entry
+=number
;
279 if (current_entry
>used_entries
) {
280 av_log(vc
->avccontext
, AV_LOG_ERROR
, " More codelengths than codes in codebook. \n");
285 codebook_setup
->lookup_type
=get_bits(gb
, 4);
287 AV_DEBUG(" lookup type: %d : %s \n", codebook_setup
->lookup_type
, codebook_setup
->lookup_type
? "vq" : "no lookup" );
289 // If the codebook is used for (inverse) VQ, calculate codevectors.
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
];
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
);
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
);
304 for(i
=0;i
<codebook_lookup_values
;++i
) {
305 codebook_multiplicands
[i
]=get_bits(gb
, codebook_value_bits
);
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
]);
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
;
316 if (tmp_vlc_bits
[i
]) {
318 uint_fast32_t lookup_offset
=i
;
321 av_log(vc
->avccontext
, AV_LOG_INFO
, "Lookup offset %d ,", i
);
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
];
330 lookup_offset
/=codebook_lookup_values
;
332 tmp_vlc_bits
[j
]=tmp_vlc_bits
[i
];
335 av_log(vc
->avccontext
, AV_LOG_INFO
, "real lookup offset %d, vector: ", j
);
337 av_log(vc
->avccontext
, AV_LOG_INFO
, " %f ", codebook_setup
->codevectors
[j
*dim
+k
]);
339 av_log(vc
->avccontext
, AV_LOG_INFO
, "\n");
345 if (j
!=used_entries
) {
346 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Bug in codevector vector building code. \n");
349 entries
=used_entries
;
351 else if (codebook_setup
->lookup_type
>=2) {
352 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Codebook lookup type not supported. \n");
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");
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
];
365 if(codebook_setup
->maxdepth
> 3*V_NB_BITS
) codebook_setup
->nb_bits
=V_NB_BITS2
;
366 else codebook_setup
->nb_bits
=V_NB_BITS
;
368 codebook_setup
->maxdepth
=(codebook_setup
->maxdepth
+codebook_setup
->nb_bits
-1)/codebook_setup
->nb_bits
;
370 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 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Error generating vlc tables. \n");
376 av_free(tmp_vlc_bits
);
377 av_free(tmp_vlc_codes
);
382 av_free(tmp_vlc_bits
);
383 av_free(tmp_vlc_codes
);
387 // Process time domain transforms part (unused in Vorbis I)
389 static int vorbis_parse_setup_hdr_tdtransforms(vorbis_context
*vc
) {
390 GetBitContext
*gb
=&vc
->gb
;
392 uint_fast8_t vorbis_time_count
=get_bits(gb
, 6)+1;
394 for(i
=0;i
<vorbis_time_count
;++i
) {
395 uint_fast16_t vorbis_tdtransform
=get_bits(gb
, 16);
397 AV_DEBUG(" Vorbis time domain transform %d: %d \n", vorbis_time_count
, vorbis_tdtransform
);
399 if (vorbis_tdtransform
) {
400 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Vorbis time domain transform data nonzero. \n");
407 // Process floors part - only floor type 1 is supported
409 static int vorbis_parse_setup_hdr_floors(vorbis_context
*vc
) {
410 GetBitContext
*gb
=&vc
->gb
;
413 vc
->floor_count
=get_bits(gb
, 6)+1;
415 vc
->floors
=(vorbis_floor
*)av_mallocz(vc
->floor_count
* sizeof(vorbis_floor
));
417 for (i
=0;i
<vc
->floor_count
;++i
) {
418 vorbis_floor
*floor_setup
=&vc
->floors
[i
];
420 floor_setup
->floor_type
=get_bits(gb
, 16);
422 AV_DEBUG(" %d. floor type %d \n", i
, floor_setup
->floor_type
);
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;
429 floor_setup
->partitions
=get_bits(gb
, 5);
431 AV_DEBUG(" %d.floor: %d partitions \n", i
, floor_setup
->partitions
);
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
];
437 AV_DEBUG(" %d. floor %d partition class %d \n", i
, j
, floor_setup
->partition_class
[j
]);
441 AV_DEBUG(" maximum class %d \n", maximum_class
);
443 floor_setup
->maximum_class
=maximum_class
;
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);
449 AV_DEBUG(" %d floor %d class dim: %d subclasses %d \n", i
, j
, floor_setup
->class_dimensions
[j
], floor_setup
->class_subclasses
[j
]);
451 if (floor_setup
->class_subclasses
[j
]) {
452 floor_setup
->class_masterbook
[j
]=get_bits(gb
, 8);
454 AV_DEBUG(" masterbook: %d \n", floor_setup
->class_masterbook
[j
]);
457 for(k
=0;k
<(1<<floor_setup
->class_subclasses
[j
]);++k
) {
458 floor_setup
->subclass_books
[j
][k
]=get_bits(gb
, 8)-1;
460 AV_DEBUG(" book %d. : %d \n", k
, floor_setup
->subclass_books
[j
][k
]);
464 floor_setup
->multiplier
=get_bits(gb
, 2)+1;
465 floor_setup
->x_list_dim
=2;
467 for(j
=0;j
<floor_setup
->partitions
;++j
) {
468 floor_setup
->x_list_dim
+=floor_setup
->class_dimensions
[floor_setup
->partition_class
[j
]];
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));
477 rangebits
=get_bits(gb
, 4);
478 floor_setup
->x_list
[0] = 0;
479 floor_setup
->x_list
[1] = (1<<rangebits
);
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
);
485 AV_DEBUG(" %d. floor1 Y coord. %d \n", floor1_values
, floor_setup
->x_list
[floor1_values
]);
489 // Precalculate order of x coordinates - needed for decode
491 for(k
=0;k
<floor_setup
->x_list_dim
;++k
) {
492 floor_setup
->x_list_order
[k
]=k
;
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
;
505 // Precalculate low and high neighbours
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
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
;
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
;
524 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Only floor type 1 supported. \n");
531 // Process residues part
533 static int vorbis_parse_setup_hdr_residues(vorbis_context
*vc
){
534 GetBitContext
*gb
=&vc
->gb
;
535 uint_fast8_t i
, j
, k
;
537 vc
->residue_count
=get_bits(gb
, 6)+1;
538 vc
->residues
=(vorbis_residue
*)av_mallocz(vc
->residue_count
* sizeof(vorbis_residue
));
540 AV_DEBUG(" There are %d residues. \n", vc
->residue_count
);
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
;
548 res_setup
->type
=get_bits(gb
, 16);
550 AV_DEBUG(" %d. residue type %d \n", i
, res_setup
->type
);
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);
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
);
561 for(j
=0;j
<res_setup
->classifications
;++j
) {
563 low_bits
=get_bits(gb
, 3);
565 high_bits
=get_bits(gb
, 5);
567 cascade
[j
]=(high_bits
<<3)+low_bits
;
569 AV_DEBUG(" %d class casscade depth: %d \n", j
, ilog(cascade
[j
]));
572 res_setup
->maxpass
=0;
573 for(j
=0;j
<res_setup
->classifications
;++j
) {
575 if (cascade
[j
]&(1<<k
)) {
576 res_setup
->books
[j
][k
]=get_bits(gb
, 8);
578 AV_DEBUG(" %d class casscade depth %d book: %d \n", j
, k
, res_setup
->books
[j
][k
]);
580 if (k
>res_setup
->maxpass
) {
581 res_setup
->maxpass
=k
;
584 res_setup
->books
[j
][k
]=-1;
592 // Process mappings part
594 static int vorbis_parse_setup_hdr_mappings(vorbis_context
*vc
) {
595 GetBitContext
*gb
=&vc
->gb
;
598 vc
->mapping_count
=get_bits(gb
, 6)+1;
599 vc
->mappings
=(vorbis_mapping
*)av_mallocz(vc
->mapping_count
* sizeof(vorbis_mapping
));
601 AV_DEBUG(" There are %d mappings. \n", vc
->mapping_count
);
603 for(i
=0;i
<vc
->mapping_count
;++i
) {
604 vorbis_mapping
*mapping_setup
=&vc
->mappings
[i
];
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");
611 mapping_setup
->submaps
=get_bits(gb
, 4)+1;
613 mapping_setup
->submaps
=1;
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
626 mapping_setup
->coupling_steps
=0;
629 AV_DEBUG(" %d mapping coupling steps: %d \n", i
, mapping_setup
->coupling_steps
);
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.
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);
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);
648 AV_DEBUG(" %d mapping %d submap : floor %d, residue %d \n", i
, j
, mapping_setup
->submap_floor
[j
], mapping_setup
->submap_residue
[j
]);
654 // Process modes part
656 static int vorbis_parse_setup_hdr_modes(vorbis_context
*vc
) {
657 GetBitContext
*gb
=&vc
->gb
;
660 vc
->mode_count
=get_bits(gb
, 6)+1;
661 vc
->modes
=(vorbis_mode
*)av_mallocz(vc
->mode_count
* sizeof(vorbis_mode
));
663 AV_DEBUG(" There are %d modes.\n", vc
->mode_count
);
665 for(i
=0;i
<vc
->mode_count
;++i
) {
666 vorbis_mode
*mode_setup
=&vc
->modes
[i
];
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
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
);
678 // Process the whole setup header using the functions above
680 static int vorbis_parse_setup_hdr(vorbis_context
*vc
) {
681 GetBitContext
*gb
=&vc
->gb
;
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");
690 if (vorbis_parse_setup_hdr_codebooks(vc
)) {
691 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (codebooks). \n");
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");
698 if (vorbis_parse_setup_hdr_floors(vc
)) {
699 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (floors). \n");
702 if (vorbis_parse_setup_hdr_residues(vc
)) {
703 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (residues). \n");
706 if (vorbis_parse_setup_hdr_mappings(vc
)) {
707 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (mappings). \n");
710 if (vorbis_parse_setup_hdr_modes(vc
)) {
711 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (modes). \n");
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
722 // Process the identification header
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
};
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");
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);
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");
750 vc
->swin
=vwin
[bl0
-6];
751 vc
->lwin
=vwin
[bl1
-6];
753 if ((get_bits1(gb
)) == 0) {
754 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis id header packet corrupt (framing flag not set). \n");
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 vc
->buf
=(float *)av_malloc(vc
->blocksize_1
* sizeof(float));
763 vc
->buf_tmp
=(float *)av_malloc(vc
->blocksize_1
* sizeof(float));
766 ff_mdct_init(&vc
->mdct0
, bl0
, 1);
767 ff_mdct_init(&vc
->mdct1
, bl1
, 1);
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
);
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)));
782 // Process the extradata using the functions above (identification header, setup header)
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 uint8_t *header_start
[3];
790 GetBitContext
*gb
= &(vc
->gb
);
793 vc
->avccontext
= avccontext
;
796 av_log(avccontext
, AV_LOG_ERROR
, "Extradata corrupt.\n");
800 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
];
807 } else if(headers
[0] == 2) {
808 for(j
=1,i
=0;i
<2;++i
, ++j
) {
810 while(j
<headers_len
&& headers
[j
]==0xff) {
814 if (j
>=headers_len
) {
815 av_log(avccontext
, AV_LOG_ERROR
, "Extradata corrupt.\n");
818 header_len
[i
]+=headers
[j
];
820 header_len
[2]=headers_len
-header_len
[0]-header_len
[1]-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];
826 av_log(avccontext
, AV_LOG_ERROR
, "Extradata corrupt.\n");
830 init_get_bits(gb
, header_start
[0], header_len
[0]*8);
831 hdr_type
=get_bits(gb
, 8);
833 av_log(avccontext
, AV_LOG_ERROR
, "First header is not the id header.\n");
836 if (vorbis_parse_id_hdr(vc
)) {
837 av_log(avccontext
, AV_LOG_ERROR
, "Id header corrupt.\n");
842 init_get_bits(gb
, header_start
[2], header_len
[2]*8);
843 hdr_type
=get_bits(gb
, 8);
845 av_log(avccontext
, AV_LOG_ERROR
, "Third header is not the setup header.\n");
848 if (vorbis_parse_setup_hdr(vc
)) {
849 av_log(avccontext
, AV_LOG_ERROR
, "Setup header corrupt.\n");
854 avccontext
->channels
= vc
->audio_channels
;
855 avccontext
->sample_rate
= vc
->audio_samplerate
;
860 // Decode audiopackets -------------------------------------------------
862 // Read and decode floor (type 1 only)
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
];
877 uint_fast16_t offset
;
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;
885 if (!get_bits1(gb
)) return 1; // silence
887 // Read values (or differences) for the floor's points
889 floor1_Y
[0]=get_bits(gb
, ilog(range
-1));
890 floor1_Y
[1]=get_bits(gb
, ilog(range
-1));
892 AV_DEBUG("floor 0 Y %d floor 1 Y %d \n", floor1_Y
[0], floor1_Y
[1]);
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_
];
902 AV_DEBUG("Cbits %d \n", cbits
);
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 vc
->codebooks
[vf
->class_masterbook
[class_
]].nb_bits
, 3);
909 for(j
=0;j
<cdim
;++j
) {
910 book
=vf
->subclass_books
[class_
][cval
& csub
];
912 AV_DEBUG("book %d Cbits %d cval %d bits:%d \n", book
, cbits
, cval
, get_bits_count(gb
));
916 floor1_Y
[offset
+j
]=get_vlc2(gb
, vc
->codebooks
[book
].vlc
.table
,
917 vc
->codebooks
[book
].nb_bits
, 3);
919 floor1_Y
[offset
+j
]=0;
922 AV_DEBUG(" floor(%d) = %d \n", vf
->x_list
[offset
+j
], floor1_Y
[offset
+j
]);
927 // Amplitude calculation from the differences
931 floor1_Y_final
[0]=floor1_Y
[0];
932 floor1_Y_final
[1]=floor1_Y
[1];
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
;
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
];
944 err
=ady
*(vf
->x_list
[i
]-vf
->x_list
[low_neigh_offs
]);
947 predicted
=floor1_Y_final
[low_neigh_offs
]-off
;
949 predicted
=floor1_Y_final
[low_neigh_offs
]+off
;
950 } // render_point end
953 highroom
=range
-predicted
;
955 if (highroom
< lowroom
) {
958 room
=lowroom
*2; // SPEC mispelling
961 floor1_flag
[low_neigh_offs
]=1;
962 floor1_flag
[high_neigh_offs
]=1;
965 if (highroom
> lowroom
) {
966 floor1_Y_final
[i
]=val
-lowroom
+predicted
;
968 floor1_Y_final
[i
]=predicted
-val
+highroom
-1;
972 floor1_Y_final
[i
]=predicted
-(val
+1)/2;
974 floor1_Y_final
[i
]=predicted
+val
/2;
979 floor1_Y_final
[i
]=predicted
;
982 AV_DEBUG(" Decoded floor(%d) = %d / val %d \n", vf
->x_list
[i
], floor1_Y_final
[i
], val
);
985 // Curve synth - connect the calculated dots and convert from dB scale FIXME optimize ?
989 ly
=floor1_Y_final
[0]*vf
->multiplier
; // conforms to SPEC
991 vec
[0]=floor1_inverse_db_table
[ly
];
993 for(i
=1;i
<vf
->x_list_dim
;++i
) {
994 AV_DEBUG(" Looking at post %d \n", i
);
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 ?????
999 hy
=floor1_Y_final
[floor_x_sort
[i
]]*vf
->multiplier
;
1000 hx
=vf
->x_list
[floor_x_sort
[i
]];
1004 ady
= (dy
<0) ? -dy
:dy
;//ABS(dy);
1007 AV_DEBUG(" dy %d adx %d base %d = %d \n", dy
, adx
, base
, dy
/adx
);
1017 ady
=ady
-(base
<0 ? -base
: base
)*adx
;
1018 vec
[x
]=floor1_inverse_db_table
[y
];
1020 AV_DEBUG(" vec[ %d ] = %d \n", x
, y
);
1022 for(x
=lx
+1;(x
<hx
) && (x
<vf
->x_list
[1]);++x
) {
1030 vec
[x
]=floor1_inverse_db_table
[y
];
1032 AV_DEBUG(" vec[ %d ] = %d \n", x
, y
);
1035 /* for(j=1;j<hx-lx+1;++j) { // iterating render_point
1038 ady= dy<0 ? -dy : dy;
1046 if (lx+j < vf->x_list[1]) {
1047 vec[lx+j]=floor1_inverse_db_table[predicted];
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
];
1062 AV_DEBUG(" Floor decoded\n");
1067 // Read and decode residue
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 uint_fast8_t classifs
[ptns_to_read
*vc
->audio_channels
];
1076 uint_fast8_t ch_used
;
1082 do_not_decode
[0]&=do_not_decode
[j
]; // FIXME - clobbering input
1084 if (do_not_decode
[0]) return 0;
1090 AV_DEBUG(" residue type 0/1/2 decode begin, ch: %d cpc %d \n", ch
, c_p_c
);
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
;
1098 for(partition_count
=0;partition_count
<ptns_to_read
;) { // SPEC error
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 vc
->codebooks
[vr
->classbook
].nb_bits
, 3);
1105 AV_DEBUG("Classword: %d \n", temp
);
1107 assert(vr
->classifications
> 1 && vr
->classifications
<256 && temp
<=65536); //needed for inverse[]
1108 for(i
=0;i
<c_p_c
;++i
) {
1109 uint_fast32_t temp2
;
1111 temp2
=(((uint_fast64_t)temp
) * inverse
[vr
->classifications
])>>32;
1112 classifs
[j_times_ptns_to_read
+partition_count
+c_p_c
-1-i
]=temp
-temp2
*vr
->classifications
;
1116 j_times_ptns_to_read
+=ptns_to_read
;
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
;
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
];
1128 uint_fast16_t coffs
;
1129 uint_fast16_t step
=vr
->partition_size
/vc
->codebooks
[vqbook
].dimensions
;
1130 vorbis_codebook codebook
= vc
->codebooks
[vqbook
];
1134 voffs
=voffset
+j
*vlen
;
1135 for(k
=0;k
<step
;++k
) {
1136 coffs
=get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * codebook
.dimensions
;
1137 for(l
=0;l
<codebook
.dimensions
;++l
) {
1138 vec
[voffs
+k
+l
*step
]+=codebook
.codevectors
[coffs
+l
]; // FPMATH
1142 else if (vr
->type
==1) {
1143 voffs
=voffset
+j
*vlen
;
1144 for(k
=0;k
<step
;++k
) {
1145 coffs
=get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * codebook
.dimensions
;
1146 for(l
=0;l
<codebook
.dimensions
;++l
, ++voffs
) {
1147 vec
[voffs
]+=codebook
.codevectors
[coffs
+l
]; // FPMATH
1149 AV_DEBUG(" pass %d offs: %d curr: %f change: %f cv offs.: %d \n", pass
, voffs
, vec
[voffs
], codebook
.codevectors
[coffs
+l
], coffs
);
1153 else if (vr
->type
==2 && ch
==2 && (voffset
&1)==0 && (codebook
.dimensions
&1)==0) { // most frequent case optimized
1156 for(k
=0;k
<step
;++k
) {
1157 coffs
=get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * codebook
.dimensions
;
1158 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
1162 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
);
1167 else if (vr
->type
==2) {
1170 for(k
=0;k
<step
;++k
) {
1171 coffs
=get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * codebook
.dimensions
;
1172 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 %
1175 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
);
1179 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Invalid residue type while residue decode?! \n");
1184 j_times_ptns_to_read
+=ptns_to_read
;
1187 voffset
+=vr
->partition_size
;
1194 // Decode the audio packet using the functions above
1197 static int vorbis_parse_audio_packet(vorbis_context
*vc
) {
1198 GetBitContext
*gb
=&vc
->gb
;
1200 uint_fast8_t previous_window
=0,next_window
=0;
1201 uint_fast8_t mode_number
;
1202 uint_fast16_t blocksize
;
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;
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
1219 if (vc
->mode_count
==1) {
1222 mode_number
=get_bits(gb
, ilog(vc
->mode_count
-1));
1224 mapping
=&vc
->mappings
[vc
->modes
[mode_number
].mapping
];
1226 AV_DEBUG(" Mode number: %d , mapping: %d , blocktype %d \n", mode_number
, vc
->modes
[mode_number
].mapping
, vc
->modes
[mode_number
].blockflag
);
1228 if (vc
->modes
[mode_number
].blockflag
) {
1229 previous_window
=get_bits1(gb
);
1230 next_window
=get_bits1(gb
);
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 ?
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
]]];
1244 floor
=&vc
->floors
[mapping
->submap_floor
[0]];
1247 no_residue
[i
]=vorbis_floor1_decode(vc
, floor
, ch_floor_ptr
);
1248 ch_floor_ptr
+=blocksize
/2;
1251 // Nonzero vector propagate
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;
1262 for(i
=0;i
<mapping
->submaps
;++i
) {
1263 vorbis_residue
*residue
;
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;
1272 do_not_decode
[ch
]=0;
1278 residue
=&vc
->residues
[mapping
->submap_residue
[i
]];
1279 vorbis_residue_decode(vc
, residue
, ch
, do_not_decode
, ch_res_ptr
, blocksize
/2);
1281 ch_res_ptr
+=ch
*blocksize
/2;
1286 for(i
=mapping
->coupling_steps
-1;i
>=0;--i
) { //warning: i has to be signed
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
) {
1295 ang
[j
]=mag
[j
]-ang
[j
];
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;
1318 for(i
=0;i
<blocksize
/2;++i
) {
1319 ch_floor_ptr
[i
]*=ch_res_ptr
[i
]; //FPMATH
1323 // MDCT, overlap/add, save data for next overlapping FPMATH
1325 for(j
=0;j
<vc
->audio_channels
;++j
) {
1326 uint_fast8_t step
=vc
->audio_channels
;
1328 float *saved
=vc
->saved
+j
*vc
->blocksize_1
/2;
1330 const float *lwin
=vc
->lwin
;
1331 const float *swin
=vc
->swin
;
1333 float *buf_tmp
=vc
->buf_tmp
;
1335 ch_floor_ptr
=vc
->channel_floors
+j
*blocksize
/2;
1337 saved_start
=vc
->saved_start
;
1339 ff_imdct_calc(vc
->modes
[mode_number
].blockflag
? &vc
->mdct1
: &vc
->mdct0
, buf
, ch_floor_ptr
, buf_tmp
);
1341 if (vc
->modes
[mode_number
].blockflag
) {
1343 if (previous_window
) {
1344 for(k
=j
, i
=0;i
<vc
->blocksize_1
/2;++i
, k
+=step
) {
1345 ret
[k
]=saved
[i
]+buf
[i
]*lwin
[i
]+BIAS
;
1347 retlen
=vc
->blocksize_1
/2;
1349 buf
+= (vc
->blocksize_1
-vc
->blocksize_0
)/4;
1350 for(k
=j
, i
=0;i
<vc
->blocksize_0
/2;++i
, k
+=step
) {
1351 ret
[k
]=saved
[i
]+buf
[i
]*swin
[i
]+BIAS
;
1353 buf
+= vc
->blocksize_0
/2;
1354 for(i
=0;i
<(vc
->blocksize_1
-vc
->blocksize_0
)/4;++i
, k
+=step
) {
1358 retlen
=vc
->blocksize_0
/2+(vc
->blocksize_1
-vc
->blocksize_0
)/4;
1362 buf
+= vc
->blocksize_1
/2;
1363 lwin
+= vc
->blocksize_1
/2-1;
1364 for(i
=0;i
<vc
->blocksize_1
/2;++i
) {
1365 saved
[i
]=buf
[i
]*lwin
[-i
];
1369 saved_start
=(vc
->blocksize_1
-vc
->blocksize_0
)/4;
1370 buf
+= vc
->blocksize_1
/2;
1371 for(i
=0;i
<saved_start
;++i
) {
1374 swin
+= vc
->blocksize_0
/2-1;
1375 for(i
=0;i
<vc
->blocksize_0
/2;++i
) {
1376 saved
[saved_start
+i
]=buf
[saved_start
+i
]*swin
[-i
];
1381 for(k
=j
, i
=0;i
<saved_start
;++i
, k
+=step
) {
1382 ret
[k
]=saved
[i
]+BIAS
;
1384 for(i
=0;i
<vc
->blocksize_0
/2;++i
, k
+=step
) {
1385 ret
[k
]=saved
[saved_start
+i
]+buf
[i
]*swin
[i
]+BIAS
;
1387 retlen
=saved_start
+vc
->blocksize_0
/2;
1389 buf
+= vc
->blocksize_0
/2;
1390 swin
+= vc
->blocksize_0
/2-1;
1391 for(i
=0;i
<vc
->blocksize_0
/2;++i
) {
1392 saved
[i
]=buf
[i
]*swin
[-i
];
1397 vc
->saved_start
=saved_start
;
1399 return retlen
*vc
->audio_channels
;
1402 // Return the decoded audio packet through the standard api
1404 static int vorbis_decode_frame(AVCodecContext
*avccontext
,
1405 void *data
, int *data_size
,
1406 uint8_t *buf
, int buf_size
)
1408 vorbis_context
*vc
= avccontext
->priv_data
;
1409 GetBitContext
*gb
= &(vc
->gb
);
1411 int_fast16_t i
, len
;
1417 AV_DEBUG("packet length %d \n", buf_size
);
1419 init_get_bits(gb
, buf
, buf_size
*8);
1421 len
=vorbis_parse_audio_packet(vc
);
1428 if (!vc
->first_frame
) {
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
);
1436 for(i
=0;i
<len
;++i
) {
1437 int_fast32_t tmp
= ((int32_t*)vc
->ret
)[i
];
1439 // tmp= (0x43c0ffff - tmp)>>31; //ask gcc devs why this is slower
1440 if(tmp
> 0x43c0ffff) tmp
= 0xFFFF;
1443 ((int16_t*)data
)[i
]=tmp
- 0x8000;
1453 static int vorbis_decode_close(AVCodecContext
*avccontext
) {
1454 vorbis_context
*vc
= avccontext
->priv_data
;
1461 AVCodec vorbis_decoder
= {
1465 sizeof(vorbis_context
),
1468 vorbis_decode_close
,
1469 vorbis_decode_frame
,