2 * @file libavcodec/vorbis_dec.c
4 * @author Denes Balatoni ( dbalatoni programozo hu )
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 //#define AV_DEBUG(...) av_log(NULL, AV_LOG_INFO, __VA_ARGS__)
29 #define ALT_BITSTREAM_READER_LE
39 #define V_MAX_VLCS (1<<16)
40 #define V_MAX_PARTITIONS (1<<20)
50 uint_fast8_t dimensions
;
51 uint_fast8_t lookup_type
;
52 uint_fast8_t maxdepth
;
58 typedef union vorbis_floor_u vorbis_floor_data
;
59 typedef struct vorbis_floor0_s vorbis_floor0
;
60 typedef struct vorbis_floor1_s vorbis_floor1
;
61 struct vorbis_context_s
;
63 uint_fast8_t (* vorbis_floor_decode_func
)
64 (struct vorbis_context_s
*, vorbis_floor_data
*, float *);
66 uint_fast8_t floor_type
;
67 vorbis_floor_decode_func decode
;
70 struct vorbis_floor0_s
74 uint_fast16_t bark_map_size
;
75 int_fast32_t * map
[2];
76 uint_fast32_t map_size
[2];
77 uint_fast8_t amplitude_bits
;
78 uint_fast8_t amplitude_offset
;
79 uint_fast8_t num_books
;
80 uint_fast8_t * book_list
;
83 struct vorbis_floor1_s
85 uint_fast8_t partitions
;
86 uint_fast8_t maximum_class
;
87 uint_fast8_t partition_class
[32];
88 uint_fast8_t class_dimensions
[16];
89 uint_fast8_t class_subclasses
[16];
90 uint_fast8_t class_masterbook
[16];
91 int_fast16_t subclass_books
[16][8];
92 uint_fast8_t multiplier
;
93 uint_fast16_t x_list_dim
;
94 vorbis_floor1_entry
* list
;
103 uint_fast32_t partition_size
;
104 uint_fast8_t classifications
;
105 uint_fast8_t classbook
;
106 int_fast16_t books
[64][8];
107 uint_fast8_t maxpass
;
111 uint_fast8_t submaps
;
112 uint_fast16_t coupling_steps
;
113 uint_fast8_t *magnitude
;
116 uint_fast8_t submap_floor
[16];
117 uint_fast8_t submap_residue
[16];
121 uint_fast8_t blockflag
;
122 uint_fast16_t windowtype
;
123 uint_fast16_t transformtype
;
124 uint_fast8_t mapping
;
127 typedef struct vorbis_context_s
{
128 AVCodecContext
*avccontext
;
133 uint_fast8_t first_frame
;
134 uint_fast32_t version
;
135 uint_fast8_t audio_channels
;
136 uint_fast32_t audio_samplerate
;
137 uint_fast32_t bitrate_maximum
;
138 uint_fast32_t bitrate_nominal
;
139 uint_fast32_t bitrate_minimum
;
140 uint_fast32_t blocksize
[2];
141 const float * win
[2];
142 uint_fast16_t codebook_count
;
143 vorbis_codebook
*codebooks
;
144 uint_fast8_t floor_count
;
145 vorbis_floor
*floors
;
146 uint_fast8_t residue_count
;
147 vorbis_residue
*residues
;
148 uint_fast8_t mapping_count
;
149 vorbis_mapping
*mappings
;
150 uint_fast8_t mode_count
;
152 uint_fast8_t mode_number
; // mode number for the current packet
153 uint_fast8_t previous_window
;
154 float *channel_residues
;
155 float *channel_floors
;
157 uint_fast32_t add_bias
; // for float->int conversion
158 uint_fast32_t exp_bias
;
161 /* Helper functions */
164 (13.1f*atan(0.00074f*(x))+2.24f*atan(1.85e-8f*(x)*(x))+1e-4f*(x))
166 static float vorbisfloat2float(uint_fast32_t val
) {
167 double mant
=val
&0x1fffff;
168 long exp
=(val
&0x7fe00000L
)>>21;
169 if (val
&0x80000000) mant
=-mant
;
170 return ldexp(mant
, exp
- 20 - 768);
174 // Free all allocated memory -----------------------------------------
176 static void vorbis_free(vorbis_context
*vc
) {
179 av_freep(&vc
->channel_residues
);
180 av_freep(&vc
->channel_floors
);
181 av_freep(&vc
->saved
);
183 av_freep(&vc
->residues
);
184 av_freep(&vc
->modes
);
186 ff_mdct_end(&vc
->mdct
[0]);
187 ff_mdct_end(&vc
->mdct
[1]);
189 for(i
=0;i
<vc
->codebook_count
;++i
) {
190 av_free(vc
->codebooks
[i
].codevectors
);
191 free_vlc(&vc
->codebooks
[i
].vlc
);
193 av_freep(&vc
->codebooks
);
195 for(i
=0;i
<vc
->floor_count
;++i
) {
196 if(vc
->floors
[i
].floor_type
==0) {
197 av_free(vc
->floors
[i
].data
.t0
.map
[0]);
198 av_free(vc
->floors
[i
].data
.t0
.map
[1]);
199 av_free(vc
->floors
[i
].data
.t0
.book_list
);
200 av_free(vc
->floors
[i
].data
.t0
.lsp
);
203 av_free(vc
->floors
[i
].data
.t1
.list
);
206 av_freep(&vc
->floors
);
208 for(i
=0;i
<vc
->mapping_count
;++i
) {
209 av_free(vc
->mappings
[i
].magnitude
);
210 av_free(vc
->mappings
[i
].angle
);
211 av_free(vc
->mappings
[i
].mux
);
213 av_freep(&vc
->mappings
);
216 // Parse setup header -------------------------------------------------
218 // Process codebooks part
220 static int vorbis_parse_setup_hdr_codebooks(vorbis_context
*vc
) {
222 uint8_t *tmp_vlc_bits
;
223 uint32_t *tmp_vlc_codes
;
224 GetBitContext
*gb
=&vc
->gb
;
226 vc
->codebook_count
=get_bits(gb
,8)+1;
228 AV_DEBUG(" Codebooks: %d \n", vc
->codebook_count
);
230 vc
->codebooks
=av_mallocz(vc
->codebook_count
* sizeof(vorbis_codebook
));
231 tmp_vlc_bits
=av_mallocz(V_MAX_VLCS
* sizeof(uint8_t));
232 tmp_vlc_codes
=av_mallocz(V_MAX_VLCS
* sizeof(uint32_t));
234 for(cb
=0;cb
<vc
->codebook_count
;++cb
) {
235 vorbis_codebook
*codebook_setup
=&vc
->codebooks
[cb
];
236 uint_fast8_t ordered
;
237 uint_fast32_t t
, used_entries
=0;
238 uint_fast32_t entries
;
240 AV_DEBUG(" %d. Codebook \n", cb
);
242 if (get_bits(gb
, 24)!=0x564342) {
243 av_log(vc
->avccontext
, AV_LOG_ERROR
, " %"PRIdFAST16
". Codebook setup data corrupt. \n", cb
);
247 codebook_setup
->dimensions
=get_bits(gb
, 16);
248 if (codebook_setup
->dimensions
>16||codebook_setup
->dimensions
==0) {
249 av_log(vc
->avccontext
, AV_LOG_ERROR
, " %"PRIdFAST16
". Codebook's dimension is invalid (%d). \n", cb
, codebook_setup
->dimensions
);
252 entries
=get_bits(gb
, 24);
253 if (entries
>V_MAX_VLCS
) {
254 av_log(vc
->avccontext
, AV_LOG_ERROR
, " %"PRIdFAST16
". Codebook has too many entries (%"PRIdFAST32
"). \n", cb
, entries
);
258 ordered
=get_bits1(gb
);
260 AV_DEBUG(" codebook_dimensions %d, codebook_entries %d \n", codebook_setup
->dimensions
, entries
);
265 uint_fast8_t sparse
=get_bits1(gb
);
267 AV_DEBUG(" not ordered \n");
270 AV_DEBUG(" sparse \n");
273 for(ce
=0;ce
<entries
;++ce
) {
276 tmp_vlc_bits
[ce
]=get_bits(gb
, 5)+1;
279 else tmp_vlc_bits
[ce
]=0;
282 AV_DEBUG(" not sparse \n");
284 used_entries
=entries
;
285 for(ce
=0;ce
<entries
;++ce
) {
286 tmp_vlc_bits
[ce
]=get_bits(gb
, 5)+1;
290 uint_fast16_t current_entry
=0;
291 uint_fast8_t current_length
=get_bits(gb
, 5)+1;
293 AV_DEBUG(" ordered, current length: %d \n", current_length
); //FIXME
295 used_entries
=entries
;
296 for(;current_entry
<used_entries
&& current_length
<= 32;++current_length
) {
297 uint_fast16_t i
, number
;
299 AV_DEBUG(" number bits: %d ", ilog(entries
- current_entry
));
301 number
=get_bits(gb
, ilog(entries
- current_entry
));
303 AV_DEBUG(" number: %d \n", number
);
305 for(i
=current_entry
;i
<number
+current_entry
;++i
) {
306 if (i
<used_entries
) tmp_vlc_bits
[i
]=current_length
;
309 current_entry
+=number
;
311 if (current_entry
>used_entries
) {
312 av_log(vc
->avccontext
, AV_LOG_ERROR
, " More codelengths than codes in codebook. \n");
317 codebook_setup
->lookup_type
=get_bits(gb
, 4);
319 AV_DEBUG(" lookup type: %d : %s \n", codebook_setup
->lookup_type
, codebook_setup
->lookup_type
? "vq" : "no lookup" );
321 // If the codebook is used for (inverse) VQ, calculate codevectors.
323 if (codebook_setup
->lookup_type
==1) {
324 uint_fast16_t i
, j
, k
;
325 uint_fast16_t codebook_lookup_values
=ff_vorbis_nth_root(entries
, codebook_setup
->dimensions
);
326 uint_fast16_t codebook_multiplicands
[codebook_lookup_values
];
328 float codebook_minimum_value
=vorbisfloat2float(get_bits_long(gb
, 32));
329 float codebook_delta_value
=vorbisfloat2float(get_bits_long(gb
, 32));
330 uint_fast8_t codebook_value_bits
=get_bits(gb
, 4)+1;
331 uint_fast8_t codebook_sequence_p
=get_bits1(gb
);
333 AV_DEBUG(" We expect %d numbers for building the codevectors. \n", codebook_lookup_values
);
334 AV_DEBUG(" delta %f minmum %f \n", codebook_delta_value
, codebook_minimum_value
);
336 for(i
=0;i
<codebook_lookup_values
;++i
) {
337 codebook_multiplicands
[i
]=get_bits(gb
, codebook_value_bits
);
339 AV_DEBUG(" multiplicands*delta+minmum : %e \n", (float)codebook_multiplicands
[i
]*codebook_delta_value
+codebook_minimum_value
);
340 AV_DEBUG(" multiplicand %d \n", codebook_multiplicands
[i
]);
343 // Weed out unused vlcs and build codevector vector
344 codebook_setup
->codevectors
=used_entries
? av_mallocz(used_entries
*codebook_setup
->dimensions
* sizeof(float)) : NULL
;
345 for(j
=0, i
=0;i
<entries
;++i
) {
346 uint_fast8_t dim
=codebook_setup
->dimensions
;
348 if (tmp_vlc_bits
[i
]) {
350 uint_fast32_t lookup_offset
=i
;
353 av_log(vc
->avccontext
, AV_LOG_INFO
, "Lookup offset %d ,", i
);
357 uint_fast32_t multiplicand_offset
= lookup_offset
% codebook_lookup_values
;
358 codebook_setup
->codevectors
[j
*dim
+k
]=codebook_multiplicands
[multiplicand_offset
]*codebook_delta_value
+codebook_minimum_value
+last
;
359 if (codebook_sequence_p
) {
360 last
=codebook_setup
->codevectors
[j
*dim
+k
];
362 lookup_offset
/=codebook_lookup_values
;
364 tmp_vlc_bits
[j
]=tmp_vlc_bits
[i
];
367 av_log(vc
->avccontext
, AV_LOG_INFO
, "real lookup offset %d, vector: ", j
);
369 av_log(vc
->avccontext
, AV_LOG_INFO
, " %f ", codebook_setup
->codevectors
[j
*dim
+k
]);
371 av_log(vc
->avccontext
, AV_LOG_INFO
, "\n");
377 if (j
!=used_entries
) {
378 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Bug in codevector vector building code. \n");
381 entries
=used_entries
;
383 else if (codebook_setup
->lookup_type
>=2) {
384 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Codebook lookup type not supported. \n");
388 // Initialize VLC table
389 if (ff_vorbis_len2vlc(tmp_vlc_bits
, tmp_vlc_codes
, entries
)) {
390 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Invalid code lengths while generating vlcs. \n");
393 codebook_setup
->maxdepth
=0;
394 for(t
=0;t
<entries
;++t
)
395 if (tmp_vlc_bits
[t
]>=codebook_setup
->maxdepth
) codebook_setup
->maxdepth
=tmp_vlc_bits
[t
];
397 if(codebook_setup
->maxdepth
> 3*V_NB_BITS
) codebook_setup
->nb_bits
=V_NB_BITS2
;
398 else codebook_setup
->nb_bits
=V_NB_BITS
;
400 codebook_setup
->maxdepth
=(codebook_setup
->maxdepth
+codebook_setup
->nb_bits
-1)/codebook_setup
->nb_bits
;
402 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
)) {
403 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Error generating vlc tables. \n");
408 av_free(tmp_vlc_bits
);
409 av_free(tmp_vlc_codes
);
414 av_free(tmp_vlc_bits
);
415 av_free(tmp_vlc_codes
);
419 // Process time domain transforms part (unused in Vorbis I)
421 static int vorbis_parse_setup_hdr_tdtransforms(vorbis_context
*vc
) {
422 GetBitContext
*gb
=&vc
->gb
;
424 uint_fast8_t vorbis_time_count
=get_bits(gb
, 6)+1;
426 for(i
=0;i
<vorbis_time_count
;++i
) {
427 uint_fast16_t vorbis_tdtransform
=get_bits(gb
, 16);
429 AV_DEBUG(" Vorbis time domain transform %d: %d \n", vorbis_time_count
, vorbis_tdtransform
);
431 if (vorbis_tdtransform
) {
432 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Vorbis time domain transform data nonzero. \n");
439 // Process floors part
441 static uint_fast8_t vorbis_floor0_decode(vorbis_context
*vc
,
442 vorbis_floor_data
*vfu
, float *vec
);
443 static void create_map( vorbis_context
* vc
, uint_fast8_t floor_number
);
444 static uint_fast8_t vorbis_floor1_decode(vorbis_context
*vc
,
445 vorbis_floor_data
*vfu
, float *vec
);
446 static int vorbis_parse_setup_hdr_floors(vorbis_context
*vc
) {
447 GetBitContext
*gb
=&vc
->gb
;
450 vc
->floor_count
=get_bits(gb
, 6)+1;
452 vc
->floors
=av_mallocz(vc
->floor_count
* sizeof(vorbis_floor
));
454 for (i
=0;i
<vc
->floor_count
;++i
) {
455 vorbis_floor
*floor_setup
=&vc
->floors
[i
];
457 floor_setup
->floor_type
=get_bits(gb
, 16);
459 AV_DEBUG(" %d. floor type %d \n", i
, floor_setup
->floor_type
);
461 if (floor_setup
->floor_type
==1) {
462 uint_fast8_t maximum_class
=0;
463 uint_fast8_t rangebits
;
464 uint_fast16_t floor1_values
=2;
466 floor_setup
->decode
=vorbis_floor1_decode
;
468 floor_setup
->data
.t1
.partitions
=get_bits(gb
, 5);
470 AV_DEBUG(" %d.floor: %d partitions \n", i
, floor_setup
->data
.t1
.partitions
);
472 for(j
=0;j
<floor_setup
->data
.t1
.partitions
;++j
) {
473 floor_setup
->data
.t1
.partition_class
[j
]=get_bits(gb
, 4);
474 if (floor_setup
->data
.t1
.partition_class
[j
]>maximum_class
) maximum_class
=floor_setup
->data
.t1
.partition_class
[j
];
476 AV_DEBUG(" %d. floor %d partition class %d \n", i
, j
, floor_setup
->data
.t1
.partition_class
[j
]);
480 AV_DEBUG(" maximum class %d \n", maximum_class
);
482 floor_setup
->data
.t1
.maximum_class
=maximum_class
;
484 for(j
=0;j
<=maximum_class
;++j
) {
485 floor_setup
->data
.t1
.class_dimensions
[j
]=get_bits(gb
, 3)+1;
486 floor_setup
->data
.t1
.class_subclasses
[j
]=get_bits(gb
, 2);
488 AV_DEBUG(" %d floor %d class dim: %d subclasses %d \n", i
, j
, floor_setup
->data
.t1
.class_dimensions
[j
], floor_setup
->data
.t1
.class_subclasses
[j
]);
490 if (floor_setup
->data
.t1
.class_subclasses
[j
]) {
491 int bits
=get_bits(gb
, 8);
492 if (bits
>=vc
->codebook_count
) {
493 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Masterbook index %d is out of range.\n", bits
);
496 floor_setup
->data
.t1
.class_masterbook
[j
]=bits
;
498 AV_DEBUG(" masterbook: %d \n", floor_setup
->data
.t1
.class_masterbook
[j
]);
501 for(k
=0;k
<(1<<floor_setup
->data
.t1
.class_subclasses
[j
]);++k
) {
502 int16_t bits
=get_bits(gb
, 8)-1;
503 if (bits
!=-1 && bits
>=vc
->codebook_count
) {
504 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Subclass book index %d is out of range.\n", bits
);
507 floor_setup
->data
.t1
.subclass_books
[j
][k
]=bits
;
509 AV_DEBUG(" book %d. : %d \n", k
, floor_setup
->data
.t1
.subclass_books
[j
][k
]);
513 floor_setup
->data
.t1
.multiplier
=get_bits(gb
, 2)+1;
514 floor_setup
->data
.t1
.x_list_dim
=2;
516 for(j
=0;j
<floor_setup
->data
.t1
.partitions
;++j
) {
517 floor_setup
->data
.t1
.x_list_dim
+=floor_setup
->data
.t1
.class_dimensions
[floor_setup
->data
.t1
.partition_class
[j
]];
520 floor_setup
->data
.t1
.list
=av_mallocz(floor_setup
->data
.t1
.x_list_dim
* sizeof(vorbis_floor1_entry
));
523 rangebits
=get_bits(gb
, 4);
524 floor_setup
->data
.t1
.list
[0].x
= 0;
525 floor_setup
->data
.t1
.list
[1].x
= (1<<rangebits
);
527 for(j
=0;j
<floor_setup
->data
.t1
.partitions
;++j
) {
528 for(k
=0;k
<floor_setup
->data
.t1
.class_dimensions
[floor_setup
->data
.t1
.partition_class
[j
]];++k
,++floor1_values
) {
529 floor_setup
->data
.t1
.list
[floor1_values
].x
=get_bits(gb
, rangebits
);
531 AV_DEBUG(" %d. floor1 Y coord. %d \n", floor1_values
, floor_setup
->data
.t1
.list
[floor1_values
].x
);
535 // Precalculate order of x coordinates - needed for decode
536 ff_vorbis_ready_floor1_list(floor_setup
->data
.t1
.list
, floor_setup
->data
.t1
.x_list_dim
);
538 else if(floor_setup
->floor_type
==0) {
539 uint_fast8_t max_codebook_dim
=0;
541 floor_setup
->decode
=vorbis_floor0_decode
;
543 floor_setup
->data
.t0
.order
=get_bits(gb
, 8);
544 floor_setup
->data
.t0
.rate
=get_bits(gb
, 16);
545 floor_setup
->data
.t0
.bark_map_size
=get_bits(gb
, 16);
546 floor_setup
->data
.t0
.amplitude_bits
=get_bits(gb
, 6);
547 /* zero would result in a div by zero later *
549 if (floor_setup
->data
.t0
.amplitude_bits
== 0) {
550 av_log(vc
->avccontext
, AV_LOG_ERROR
,
551 "Floor 0 amplitude bits is 0.\n");
554 floor_setup
->data
.t0
.amplitude_offset
=get_bits(gb
, 8);
555 floor_setup
->data
.t0
.num_books
=get_bits(gb
, 4)+1;
557 /* allocate mem for booklist */
558 floor_setup
->data
.t0
.book_list
=
559 av_malloc(floor_setup
->data
.t0
.num_books
);
560 if(!floor_setup
->data
.t0
.book_list
) { return -1; }
561 /* read book indexes */
564 uint_fast8_t book_idx
;
565 for (idx
=0;idx
<floor_setup
->data
.t0
.num_books
;++idx
) {
566 book_idx
=get_bits(gb
, 8);
567 if (book_idx
>=vc
->codebook_count
)
569 floor_setup
->data
.t0
.book_list
[idx
]=book_idx
;
570 if (vc
->codebooks
[book_idx
].dimensions
> max_codebook_dim
)
571 max_codebook_dim
=vc
->codebooks
[book_idx
].dimensions
;
577 /* allocate mem for lsp coefficients */
579 /* codebook dim is for padding if codebook dim doesn't *
580 * divide order+1 then we need to read more data */
581 floor_setup
->data
.t0
.lsp
=
582 av_malloc((floor_setup
->data
.t0
.order
+1 + max_codebook_dim
)
584 if(!floor_setup
->data
.t0
.lsp
) { return -1; }
587 #ifdef V_DEBUG /* debug output parsed headers */
588 AV_DEBUG("floor0 order: %u\n", floor_setup
->data
.t0
.order
);
589 AV_DEBUG("floor0 rate: %u\n", floor_setup
->data
.t0
.rate
);
590 AV_DEBUG("floor0 bark map size: %u\n",
591 floor_setup
->data
.t0
.bark_map_size
);
592 AV_DEBUG("floor0 amplitude bits: %u\n",
593 floor_setup
->data
.t0
.amplitude_bits
);
594 AV_DEBUG("floor0 amplitude offset: %u\n",
595 floor_setup
->data
.t0
.amplitude_offset
);
596 AV_DEBUG("floor0 number of books: %u\n",
597 floor_setup
->data
.t0
.num_books
);
598 AV_DEBUG("floor0 book list pointer: %p\n",
599 floor_setup
->data
.t0
.book_list
);
602 for (idx
=0;idx
<floor_setup
->data
.t0
.num_books
;++idx
) {
603 AV_DEBUG( " Book %d: %u\n",
605 floor_setup
->data
.t0
.book_list
[idx
] );
611 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Invalid floor type!\n");
618 // Process residues part
620 static int vorbis_parse_setup_hdr_residues(vorbis_context
*vc
){
621 GetBitContext
*gb
=&vc
->gb
;
622 uint_fast8_t i
, j
, k
;
624 vc
->residue_count
=get_bits(gb
, 6)+1;
625 vc
->residues
=av_mallocz(vc
->residue_count
* sizeof(vorbis_residue
));
627 AV_DEBUG(" There are %d residues. \n", vc
->residue_count
);
629 for(i
=0;i
<vc
->residue_count
;++i
) {
630 vorbis_residue
*res_setup
=&vc
->residues
[i
];
631 uint_fast8_t cascade
[64];
632 uint_fast8_t high_bits
;
633 uint_fast8_t low_bits
;
635 res_setup
->type
=get_bits(gb
, 16);
637 AV_DEBUG(" %d. residue type %d \n", i
, res_setup
->type
);
639 res_setup
->begin
=get_bits(gb
, 24);
640 res_setup
->end
=get_bits(gb
, 24);
641 res_setup
->partition_size
=get_bits(gb
, 24)+1;
642 /* Validations to prevent a buffer overflow later. */
643 if (res_setup
->begin
>res_setup
->end
644 || res_setup
->end
>vc
->blocksize
[1]/(res_setup
->type
==2?1:2)
645 || (res_setup
->end
-res_setup
->begin
)/res_setup
->partition_size
>V_MAX_PARTITIONS
) {
646 av_log(vc
->avccontext
, AV_LOG_ERROR
, "partition out of bounds: type, begin, end, size, blocksize: %"PRIdFAST16
", %"PRIdFAST32
", %"PRIdFAST32
", %"PRIdFAST32
", %"PRIdFAST32
"\n", res_setup
->type
, res_setup
->begin
, res_setup
->end
, res_setup
->partition_size
, vc
->blocksize
[1]/2);
650 res_setup
->classifications
=get_bits(gb
, 6)+1;
651 res_setup
->classbook
=get_bits(gb
, 8);
652 if (res_setup
->classbook
>=vc
->codebook_count
) {
653 av_log(vc
->avccontext
, AV_LOG_ERROR
, "classbook value %d out of range. \n", res_setup
->classbook
);
657 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
,
658 res_setup
->classifications
, res_setup
->classbook
);
660 for(j
=0;j
<res_setup
->classifications
;++j
) {
662 low_bits
=get_bits(gb
, 3);
664 high_bits
=get_bits(gb
, 5);
666 cascade
[j
]=(high_bits
<<3)+low_bits
;
668 AV_DEBUG(" %d class casscade depth: %d \n", j
, ilog(cascade
[j
]));
671 res_setup
->maxpass
=0;
672 for(j
=0;j
<res_setup
->classifications
;++j
) {
674 if (cascade
[j
]&(1<<k
)) {
675 int bits
=get_bits(gb
, 8);
676 if (bits
>=vc
->codebook_count
) {
677 av_log(vc
->avccontext
, AV_LOG_ERROR
, "book value %d out of range. \n", bits
);
680 res_setup
->books
[j
][k
]=bits
;
682 AV_DEBUG(" %d class casscade depth %d book: %d \n", j
, k
, res_setup
->books
[j
][k
]);
684 if (k
>res_setup
->maxpass
) {
685 res_setup
->maxpass
=k
;
688 res_setup
->books
[j
][k
]=-1;
696 // Process mappings part
698 static int vorbis_parse_setup_hdr_mappings(vorbis_context
*vc
) {
699 GetBitContext
*gb
=&vc
->gb
;
702 vc
->mapping_count
=get_bits(gb
, 6)+1;
703 vc
->mappings
=av_mallocz(vc
->mapping_count
* sizeof(vorbis_mapping
));
705 AV_DEBUG(" There are %d mappings. \n", vc
->mapping_count
);
707 for(i
=0;i
<vc
->mapping_count
;++i
) {
708 vorbis_mapping
*mapping_setup
=&vc
->mappings
[i
];
710 if (get_bits(gb
, 16)) {
711 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Other mappings than type 0 are not compliant with the Vorbis I specification. \n");
715 mapping_setup
->submaps
=get_bits(gb
, 4)+1;
717 mapping_setup
->submaps
=1;
721 mapping_setup
->coupling_steps
=get_bits(gb
, 8)+1;
722 mapping_setup
->magnitude
=av_mallocz(mapping_setup
->coupling_steps
* sizeof(uint_fast8_t));
723 mapping_setup
->angle
=av_mallocz(mapping_setup
->coupling_steps
* sizeof(uint_fast8_t));
724 for(j
=0;j
<mapping_setup
->coupling_steps
;++j
) {
725 mapping_setup
->magnitude
[j
]=get_bits(gb
, ilog(vc
->audio_channels
-1));
726 mapping_setup
->angle
[j
]=get_bits(gb
, ilog(vc
->audio_channels
-1));
727 if (mapping_setup
->magnitude
[j
]>=vc
->audio_channels
) {
728 av_log(vc
->avccontext
, AV_LOG_ERROR
, "magnitude channel %d out of range. \n", mapping_setup
->magnitude
[j
]);
731 if (mapping_setup
->angle
[j
]>=vc
->audio_channels
) {
732 av_log(vc
->avccontext
, AV_LOG_ERROR
, "angle channel %d out of range. \n", mapping_setup
->angle
[j
]);
737 mapping_setup
->coupling_steps
=0;
740 AV_DEBUG(" %d mapping coupling steps: %d \n", i
, mapping_setup
->coupling_steps
);
742 if(get_bits(gb
, 2)) {
743 av_log(vc
->avccontext
, AV_LOG_ERROR
, "%d. mapping setup data invalid. \n", i
);
744 return -1; // following spec.
747 if (mapping_setup
->submaps
>1) {
748 mapping_setup
->mux
=av_mallocz(vc
->audio_channels
* sizeof(uint_fast8_t));
749 for(j
=0;j
<vc
->audio_channels
;++j
) {
750 mapping_setup
->mux
[j
]=get_bits(gb
, 4);
754 for(j
=0;j
<mapping_setup
->submaps
;++j
) {
756 skip_bits(gb
, 8); // FIXME check?
757 bits
=get_bits(gb
, 8);
758 if (bits
>=vc
->floor_count
) {
759 av_log(vc
->avccontext
, AV_LOG_ERROR
, "submap floor value %d out of range. \n", bits
);
762 mapping_setup
->submap_floor
[j
]=bits
;
763 bits
=get_bits(gb
, 8);
764 if (bits
>=vc
->residue_count
) {
765 av_log(vc
->avccontext
, AV_LOG_ERROR
, "submap residue value %d out of range. \n", bits
);
768 mapping_setup
->submap_residue
[j
]=bits
;
770 AV_DEBUG(" %d mapping %d submap : floor %d, residue %d \n", i
, j
, mapping_setup
->submap_floor
[j
], mapping_setup
->submap_residue
[j
]);
776 // Process modes part
778 static void create_map( vorbis_context
* vc
, uint_fast8_t floor_number
)
780 vorbis_floor
* floors
=vc
->floors
;
783 int_fast8_t blockflag
;
785 int_fast32_t n
; //TODO: could theoretically be smaller?
787 for (blockflag
=0;blockflag
<2;++blockflag
)
789 n
=vc
->blocksize
[blockflag
]/2;
790 floors
[floor_number
].data
.t0
.map
[blockflag
]=
791 av_malloc((n
+1) * sizeof(int_fast32_t)); // n+sentinel
793 map
=floors
[floor_number
].data
.t0
.map
[blockflag
];
794 vf
=&floors
[floor_number
].data
.t0
;
796 for (idx
=0; idx
<n
;++idx
) {
797 map
[idx
]=floor( BARK((vf
->rate
*idx
)/(2.0f
*n
)) *
798 ((vf
->bark_map_size
)/
799 BARK(vf
->rate
/2.0f
)) );
800 if (vf
->bark_map_size
-1 < map
[idx
]) {
801 map
[idx
]=vf
->bark_map_size
-1;
805 vf
->map_size
[blockflag
]=n
;
809 for(idx
=0;idx
<=n
;++idx
) {
810 AV_DEBUG("floor0 map: map at pos %d is %d\n",
816 static int vorbis_parse_setup_hdr_modes(vorbis_context
*vc
) {
817 GetBitContext
*gb
=&vc
->gb
;
820 vc
->mode_count
=get_bits(gb
, 6)+1;
821 vc
->modes
=av_mallocz(vc
->mode_count
* sizeof(vorbis_mode
));
823 AV_DEBUG(" There are %d modes.\n", vc
->mode_count
);
825 for(i
=0;i
<vc
->mode_count
;++i
) {
826 vorbis_mode
*mode_setup
=&vc
->modes
[i
];
828 mode_setup
->blockflag
=get_bits1(gb
);
829 mode_setup
->windowtype
=get_bits(gb
, 16); //FIXME check
830 mode_setup
->transformtype
=get_bits(gb
, 16); //FIXME check
831 mode_setup
->mapping
=get_bits(gb
, 8);
832 if (mode_setup
->mapping
>=vc
->mapping_count
) {
833 av_log(vc
->avccontext
, AV_LOG_ERROR
, "mode mapping value %d out of range. \n", mode_setup
->mapping
);
837 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
);
842 // Process the whole setup header using the functions above
844 static int vorbis_parse_setup_hdr(vorbis_context
*vc
) {
845 GetBitContext
*gb
=&vc
->gb
;
847 if ((get_bits(gb
, 8)!='v') || (get_bits(gb
, 8)!='o') ||
848 (get_bits(gb
, 8)!='r') || (get_bits(gb
, 8)!='b') ||
849 (get_bits(gb
, 8)!='i') || (get_bits(gb
, 8)!='s')) {
850 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (no vorbis signature). \n");
854 if (vorbis_parse_setup_hdr_codebooks(vc
)) {
855 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (codebooks). \n");
858 if (vorbis_parse_setup_hdr_tdtransforms(vc
)) {
859 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (time domain transforms). \n");
862 if (vorbis_parse_setup_hdr_floors(vc
)) {
863 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (floors). \n");
866 if (vorbis_parse_setup_hdr_residues(vc
)) {
867 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (residues). \n");
870 if (vorbis_parse_setup_hdr_mappings(vc
)) {
871 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (mappings). \n");
874 if (vorbis_parse_setup_hdr_modes(vc
)) {
875 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (modes). \n");
878 if (!get_bits1(gb
)) {
879 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (framing flag). \n");
880 return -8; // framing flag bit unset error
886 // Process the identification header
888 static int vorbis_parse_id_hdr(vorbis_context
*vc
){
889 GetBitContext
*gb
=&vc
->gb
;
890 uint_fast8_t bl0
, bl1
;
892 if ((get_bits(gb
, 8)!='v') || (get_bits(gb
, 8)!='o') ||
893 (get_bits(gb
, 8)!='r') || (get_bits(gb
, 8)!='b') ||
894 (get_bits(gb
, 8)!='i') || (get_bits(gb
, 8)!='s')) {
895 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis id header packet corrupt (no vorbis signature). \n");
899 vc
->version
=get_bits_long(gb
, 32); //FIXME check 0
900 vc
->audio_channels
=get_bits(gb
, 8);
901 if(vc
->audio_channels
<= 0){
902 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Invalid number of channels\n");
905 vc
->audio_samplerate
=get_bits_long(gb
, 32);
906 if(vc
->audio_samplerate
<= 0){
907 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Invalid samplerate\n");
910 vc
->bitrate_maximum
=get_bits_long(gb
, 32);
911 vc
->bitrate_nominal
=get_bits_long(gb
, 32);
912 vc
->bitrate_minimum
=get_bits_long(gb
, 32);
915 vc
->blocksize
[0]=(1<<bl0
);
916 vc
->blocksize
[1]=(1<<bl1
);
917 if (bl0
>13 || bl0
<6 || bl1
>13 || bl1
<6 || bl1
<bl0
) {
918 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis id header packet corrupt (illegal blocksize). \n");
921 // output format int16
922 if (vc
->blocksize
[1]/2 * vc
->audio_channels
* 2 >
923 AVCODEC_MAX_AUDIO_FRAME_SIZE
) {
924 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Vorbis channel count makes "
925 "output packets too large.\n");
928 vc
->win
[0]=ff_vorbis_vwin
[bl0
-6];
929 vc
->win
[1]=ff_vorbis_vwin
[bl1
-6];
931 if ((get_bits1(gb
)) == 0) {
932 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis id header packet corrupt (framing flag not set). \n");
936 vc
->channel_residues
= av_malloc((vc
->blocksize
[1]/2)*vc
->audio_channels
* sizeof(float));
937 vc
->channel_floors
= av_malloc((vc
->blocksize
[1]/2)*vc
->audio_channels
* sizeof(float));
938 vc
->saved
= av_mallocz((vc
->blocksize
[1]/4)*vc
->audio_channels
* sizeof(float));
939 vc
->previous_window
=0;
941 ff_mdct_init(&vc
->mdct
[0], bl0
, 1, vc
->exp_bias
? -(1<<15) : -1.0);
942 ff_mdct_init(&vc
->mdct
[1], bl1
, 1, vc
->exp_bias
? -(1<<15) : -1.0);
944 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 ",
945 vc
->version
, vc
->audio_channels
, vc
->audio_samplerate
, vc
->bitrate_maximum
, vc
->bitrate_nominal
, vc
->bitrate_minimum
, vc
->blocksize
[0], vc
->blocksize
[1]);
948 BLK=vc->blocksize[0];
949 for(i=0;i<BLK/2;++i) {
950 vc->win[0][i]=sin(0.5*3.14159265358*(sin(((float)i+0.5)/(float)BLK*3.14159265358))*(sin(((float)i+0.5)/(float)BLK*3.14159265358)));
957 // Process the extradata using the functions above (identification header, setup header)
959 static av_cold
int vorbis_decode_init(AVCodecContext
*avccontext
) {
960 vorbis_context
*vc
= avccontext
->priv_data
;
961 uint8_t *headers
= avccontext
->extradata
;
962 int headers_len
=avccontext
->extradata_size
;
963 uint8_t *header_start
[3];
965 GetBitContext
*gb
= &(vc
->gb
);
968 vc
->avccontext
= avccontext
;
969 dsputil_init(&vc
->dsp
, avccontext
);
971 if(vc
->dsp
.float_to_int16_interleave
== ff_float_to_int16_interleave_c
) {
976 vc
->exp_bias
= 15<<23;
980 av_log(avccontext
, AV_LOG_ERROR
, "Extradata corrupt.\n");
984 if (ff_split_xiph_headers(headers
, headers_len
, 30, header_start
, header_len
) < 0) {
985 av_log(avccontext
, AV_LOG_ERROR
, "Extradata corrupt.\n");
989 init_get_bits(gb
, header_start
[0], header_len
[0]*8);
990 hdr_type
=get_bits(gb
, 8);
992 av_log(avccontext
, AV_LOG_ERROR
, "First header is not the id header.\n");
995 if (vorbis_parse_id_hdr(vc
)) {
996 av_log(avccontext
, AV_LOG_ERROR
, "Id header corrupt.\n");
1001 init_get_bits(gb
, header_start
[2], header_len
[2]*8);
1002 hdr_type
=get_bits(gb
, 8);
1004 av_log(avccontext
, AV_LOG_ERROR
, "Third header is not the setup header.\n");
1008 if (vorbis_parse_setup_hdr(vc
)) {
1009 av_log(avccontext
, AV_LOG_ERROR
, "Setup header corrupt.\n");
1014 avccontext
->channels
= vc
->audio_channels
;
1015 avccontext
->sample_rate
= vc
->audio_samplerate
;
1016 avccontext
->frame_size
= FFMIN(vc
->blocksize
[0], vc
->blocksize
[1])>>2;
1017 avccontext
->sample_fmt
= SAMPLE_FMT_S16
;
1022 // Decode audiopackets -------------------------------------------------
1024 // Read and decode floor
1026 static uint_fast8_t vorbis_floor0_decode(vorbis_context
*vc
,
1027 vorbis_floor_data
*vfu
, float *vec
) {
1028 vorbis_floor0
* vf
=&vfu
->t0
;
1029 float * lsp
=vf
->lsp
;
1030 uint_fast32_t amplitude
;
1031 uint_fast32_t book_idx
;
1032 uint_fast8_t blockflag
=vc
->modes
[vc
->mode_number
].blockflag
;
1034 amplitude
=get_bits(&vc
->gb
, vf
->amplitude_bits
);
1037 uint_fast16_t lsp_len
= 0;
1039 vorbis_codebook codebook
;
1041 book_idx
=get_bits(&vc
->gb
, ilog(vf
->num_books
));
1042 if ( book_idx
>= vf
->num_books
) {
1043 av_log( vc
->avccontext
, AV_LOG_ERROR
,
1044 "floor0 dec: booknumber too high!\n" );
1048 AV_DEBUG( "floor0 dec: booknumber: %u\n", book_idx
);
1049 codebook
=vc
->codebooks
[vf
->book_list
[book_idx
]];
1051 while (lsp_len
<vf
->order
) {
1054 AV_DEBUG( "floor0 dec: book dimension: %d\n", codebook
.dimensions
);
1055 AV_DEBUG( "floor0 dec: maximum depth: %d\n", codebook
.maxdepth
);
1056 /* read temp vector */
1057 vec_off
=get_vlc2(&vc
->gb
,
1060 codebook
.maxdepth
) *
1061 codebook
.dimensions
;
1062 AV_DEBUG( "floor0 dec: vector offset: %d\n", vec_off
);
1063 /* copy each vector component and add last to it */
1064 for (idx
=0; idx
<codebook
.dimensions
; ++idx
) {
1065 lsp
[lsp_len
+idx
]=codebook
.codevectors
[vec_off
+idx
]+last
;
1067 last
=lsp
[lsp_len
+idx
-1]; /* set last to last vector component */
1069 lsp_len
+= codebook
.dimensions
;
1072 /* DEBUG: output lsp coeffs */
1075 for ( idx
= 0; idx
< lsp_len
; ++idx
)
1076 AV_DEBUG("floor0 dec: coeff at %d is %f\n", idx
, lsp
[idx
] );
1080 /* synthesize floor output vector */
1083 int order
=vf
->order
;
1084 float wstep
=M_PI
/vf
->bark_map_size
;
1086 for(i
=0;i
<order
;i
++) { lsp
[i
]=2.0f
*cos(lsp
[i
]); }
1088 AV_DEBUG("floor0 synth: map_size=%d; m=%d; wstep=%f\n",
1089 vf
->map_size
, order
, wstep
);
1092 while(i
<vf
->map_size
[blockflag
]) {
1093 int j
, iter_cond
=vf
->map
[blockflag
][i
];
1096 float two_cos_w
=2.0f
*cos(wstep
*iter_cond
); // needed all times
1098 /* similar part for the q and p products */
1099 for(j
=0;j
+1<order
;j
+=2) {
1100 q
*= lsp
[j
] -two_cos_w
;
1101 p
*= lsp
[j
+1]-two_cos_w
;
1103 if(j
==order
) { // even order
1104 p
*= p
*(2.0f
-two_cos_w
);
1105 q
*= q
*(2.0f
+two_cos_w
);
1108 q
*= two_cos_w
-lsp
[j
]; // one more time for q
1110 /* final step and square */
1111 p
*= p
*(4.f
-two_cos_w
*two_cos_w
);
1115 /* calculate linear floor value */
1118 ( (amplitude
*vf
->amplitude_offset
)/
1119 (((1<<vf
->amplitude_bits
)-1) * sqrt(p
+q
)) )
1120 - vf
->amplitude_offset
) * .11512925f
1125 do { vec
[i
]=q
; ++i
; }while(vf
->map
[blockflag
][i
]==iter_cond
);
1130 /* this channel is unused */
1134 AV_DEBUG(" Floor0 decoded\n");
1139 static uint_fast8_t vorbis_floor1_decode(vorbis_context
*vc
, vorbis_floor_data
*vfu
, float *vec
) {
1140 vorbis_floor1
* vf
=&vfu
->t1
;
1141 GetBitContext
*gb
=&vc
->gb
;
1142 uint_fast16_t range_v
[4]={ 256, 128, 86, 64 };
1143 uint_fast16_t range
=range_v
[vf
->multiplier
-1];
1144 uint_fast16_t floor1_Y
[vf
->x_list_dim
];
1145 uint_fast16_t floor1_Y_final
[vf
->x_list_dim
];
1146 int floor1_flag
[vf
->x_list_dim
];
1147 uint_fast8_t class_
;
1153 uint_fast16_t offset
;
1155 /*u*/int_fast16_t adx
, ady
, off
, predicted
; // WTF ? dy/adx= (unsigned)dy/adx ?
1156 int_fast16_t dy
, err
;
1159 if (!get_bits1(gb
)) return 1; // silence
1161 // Read values (or differences) for the floor's points
1163 floor1_Y
[0]=get_bits(gb
, ilog(range
-1));
1164 floor1_Y
[1]=get_bits(gb
, ilog(range
-1));
1166 AV_DEBUG("floor 0 Y %d floor 1 Y %d \n", floor1_Y
[0], floor1_Y
[1]);
1169 for(i
=0;i
<vf
->partitions
;++i
) {
1170 class_
=vf
->partition_class
[i
];
1171 cdim
=vf
->class_dimensions
[class_
];
1172 cbits
=vf
->class_subclasses
[class_
];
1176 AV_DEBUG("Cbits %d \n", cbits
);
1178 if (cbits
) { // this reads all subclasses for this partition's class
1179 cval
=get_vlc2(gb
, vc
->codebooks
[vf
->class_masterbook
[class_
]].vlc
.table
,
1180 vc
->codebooks
[vf
->class_masterbook
[class_
]].nb_bits
, 3);
1183 for(j
=0;j
<cdim
;++j
) {
1184 book
=vf
->subclass_books
[class_
][cval
& csub
];
1186 AV_DEBUG("book %d Cbits %d cval %d bits:%d \n", book
, cbits
, cval
, get_bits_count(gb
));
1190 floor1_Y
[offset
+j
]=get_vlc2(gb
, vc
->codebooks
[book
].vlc
.table
,
1191 vc
->codebooks
[book
].nb_bits
, 3);
1193 floor1_Y
[offset
+j
]=0;
1196 AV_DEBUG(" floor(%d) = %d \n", vf
->list
[offset
+j
].x
, floor1_Y
[offset
+j
]);
1201 // Amplitude calculation from the differences
1205 floor1_Y_final
[0]=floor1_Y
[0];
1206 floor1_Y_final
[1]=floor1_Y
[1];
1208 for(i
=2;i
<vf
->x_list_dim
;++i
) {
1209 uint_fast16_t val
, highroom
, lowroom
, room
;
1210 uint_fast16_t high_neigh_offs
;
1211 uint_fast16_t low_neigh_offs
;
1213 low_neigh_offs
=vf
->list
[i
].low
;
1214 high_neigh_offs
=vf
->list
[i
].high
;
1215 dy
=floor1_Y_final
[high_neigh_offs
]-floor1_Y_final
[low_neigh_offs
]; // render_point begin
1216 adx
=vf
->list
[high_neigh_offs
].x
-vf
->list
[low_neigh_offs
].x
;
1218 err
=ady
*(vf
->list
[i
].x
-vf
->list
[low_neigh_offs
].x
);
1219 off
=(int16_t)err
/(int16_t)adx
;
1221 predicted
=floor1_Y_final
[low_neigh_offs
]-off
;
1223 predicted
=floor1_Y_final
[low_neigh_offs
]+off
;
1224 } // render_point end
1227 highroom
=range
-predicted
;
1229 if (highroom
< lowroom
) {
1232 room
=lowroom
*2; // SPEC mispelling
1235 floor1_flag
[low_neigh_offs
]=1;
1236 floor1_flag
[high_neigh_offs
]=1;
1239 if (highroom
> lowroom
) {
1240 floor1_Y_final
[i
]=val
-lowroom
+predicted
;
1242 floor1_Y_final
[i
]=predicted
-val
+highroom
-1;
1246 floor1_Y_final
[i
]=predicted
-(val
+1)/2;
1248 floor1_Y_final
[i
]=predicted
+val
/2;
1253 floor1_Y_final
[i
]=predicted
;
1256 AV_DEBUG(" Decoded floor(%d) = %d / val %d \n", vf
->list
[i
].x
, floor1_Y_final
[i
], val
);
1259 // Curve synth - connect the calculated dots and convert from dB scale FIXME optimize ?
1261 ff_vorbis_floor1_render_list(vf
->list
, vf
->x_list_dim
, floor1_Y_final
, floor1_flag
, vf
->multiplier
, vec
, vf
->list
[1].x
);
1263 AV_DEBUG(" Floor decoded\n");
1268 // Read and decode residue
1270 static av_always_inline
int vorbis_residue_decode_internal(vorbis_context
*vc
, vorbis_residue
*vr
, uint_fast8_t ch
, uint_fast8_t *do_not_decode
, float *vec
, uint_fast16_t vlen
, int vr_type
) {
1271 GetBitContext
*gb
=&vc
->gb
;
1272 uint_fast8_t c_p_c
=vc
->codebooks
[vr
->classbook
].dimensions
;
1273 uint_fast16_t n_to_read
=vr
->end
-vr
->begin
;
1274 uint_fast16_t ptns_to_read
=n_to_read
/vr
->partition_size
;
1275 uint_fast8_t classifs
[ptns_to_read
*vc
->audio_channels
];
1277 uint_fast8_t ch_used
;
1283 do_not_decode
[0]&=do_not_decode
[j
]; // FIXME - clobbering input
1285 if (do_not_decode
[0]) return 0;
1291 AV_DEBUG(" residue type 0/1/2 decode begin, ch: %d cpc %d \n", ch
, c_p_c
);
1293 for(pass
=0;pass
<=vr
->maxpass
;++pass
) { // FIXME OPTIMIZE?
1294 uint_fast16_t voffset
;
1295 uint_fast16_t partition_count
;
1296 uint_fast16_t j_times_ptns_to_read
;
1299 for(partition_count
=0;partition_count
<ptns_to_read
;) { // SPEC error
1301 uint_fast32_t inverse_class
= ff_inverse
[vr
->classifications
];
1302 for(j_times_ptns_to_read
=0, j
=0;j
<ch_used
;++j
) {
1303 if (!do_not_decode
[j
]) {
1304 uint_fast32_t temp
=get_vlc2(gb
, vc
->codebooks
[vr
->classbook
].vlc
.table
,
1305 vc
->codebooks
[vr
->classbook
].nb_bits
, 3);
1307 AV_DEBUG("Classword: %d \n", temp
);
1309 assert(vr
->classifications
> 1 && temp
<=65536); //needed for inverse[]
1310 for(i
=0;i
<c_p_c
;++i
) {
1311 uint_fast32_t temp2
;
1313 temp2
=(((uint_fast64_t)temp
) * inverse_class
)>>32;
1314 if (partition_count
+c_p_c
-1-i
< ptns_to_read
) {
1315 classifs
[j_times_ptns_to_read
+partition_count
+c_p_c
-1-i
]=temp
-temp2
*vr
->classifications
;
1320 j_times_ptns_to_read
+=ptns_to_read
;
1323 for(i
=0;(i
<c_p_c
) && (partition_count
<ptns_to_read
);++i
) {
1324 for(j_times_ptns_to_read
=0, j
=0;j
<ch_used
;++j
) {
1325 uint_fast16_t voffs
;
1327 if (!do_not_decode
[j
]) {
1328 uint_fast8_t vqclass
=classifs
[j_times_ptns_to_read
+partition_count
];
1329 int_fast16_t vqbook
=vr
->books
[vqclass
][pass
];
1331 if (vqbook
>=0 && vc
->codebooks
[vqbook
].codevectors
) {
1332 uint_fast16_t coffs
;
1333 unsigned dim
= vc
->codebooks
[vqbook
].dimensions
; // not uint_fast8_t: 64bit is slower here on amd64
1334 uint_fast16_t step
= dim
==1 ? vr
->partition_size
1335 : FASTDIV(vr
->partition_size
, dim
);
1336 vorbis_codebook codebook
= vc
->codebooks
[vqbook
];
1340 voffs
=voffset
+j
*vlen
;
1341 for(k
=0;k
<step
;++k
) {
1342 coffs
=get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * dim
;
1343 for(l
=0;l
<dim
;++l
) {
1344 vec
[voffs
+k
+l
*step
]+=codebook
.codevectors
[coffs
+l
]; // FPMATH
1348 else if (vr_type
==1) {
1349 voffs
=voffset
+j
*vlen
;
1350 for(k
=0;k
<step
;++k
) {
1351 coffs
=get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * dim
;
1352 for(l
=0;l
<dim
;++l
, ++voffs
) {
1353 vec
[voffs
]+=codebook
.codevectors
[coffs
+l
]; // FPMATH
1355 AV_DEBUG(" pass %d offs: %d curr: %f change: %f cv offs.: %d \n", pass
, voffs
, vec
[voffs
], codebook
.codevectors
[coffs
+l
], coffs
);
1359 else if (vr_type
==2 && ch
==2 && (voffset
&1)==0 && (dim
&1)==0) { // most frequent case optimized
1363 for(k
=0;k
<step
;++k
) {
1364 coffs
=get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * 2;
1365 vec
[voffs
+k
]+=codebook
.codevectors
[coffs
]; // FPMATH
1366 vec
[voffs
+k
+vlen
]+=codebook
.codevectors
[coffs
+1]; // FPMATH
1369 for(k
=0;k
<step
;++k
, voffs
+=2) {
1370 coffs
=get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * 4;
1371 vec
[voffs
]+=codebook
.codevectors
[coffs
]; // FPMATH
1372 vec
[voffs
+1 ]+=codebook
.codevectors
[coffs
+2]; // FPMATH
1373 vec
[voffs
+vlen
]+=codebook
.codevectors
[coffs
+1]; // FPMATH
1374 vec
[voffs
+vlen
+1]+=codebook
.codevectors
[coffs
+3]; // FPMATH
1377 for(k
=0;k
<step
;++k
) {
1378 coffs
=get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * dim
;
1379 for(l
=0;l
<dim
;l
+=2, voffs
++) {
1380 vec
[voffs
]+=codebook
.codevectors
[coffs
+l
]; // FPMATH
1381 vec
[voffs
+vlen
]+=codebook
.codevectors
[coffs
+l
+1]; // FPMATH
1383 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
);
1388 else if (vr_type
==2) {
1391 for(k
=0;k
<step
;++k
) {
1392 coffs
=get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * dim
;
1393 for(l
=0;l
<dim
;++l
, ++voffs
) {
1394 vec
[voffs
/ch
+(voffs
%ch
)*vlen
]+=codebook
.codevectors
[coffs
+l
]; // FPMATH FIXME use if and counter instead of / and %
1396 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
);
1402 j_times_ptns_to_read
+=ptns_to_read
;
1405 voffset
+=vr
->partition_size
;
1412 static inline 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
)
1415 return vorbis_residue_decode_internal(vc
, vr
, ch
, do_not_decode
, vec
, vlen
, 2);
1416 else if (vr
->type
==1)
1417 return vorbis_residue_decode_internal(vc
, vr
, ch
, do_not_decode
, vec
, vlen
, 1);
1418 else if (vr
->type
==0)
1419 return vorbis_residue_decode_internal(vc
, vr
, ch
, do_not_decode
, vec
, vlen
, 0);
1421 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Invalid residue type while residue decode?! \n");
1426 void vorbis_inverse_coupling(float *mag
, float *ang
, int blocksize
)
1429 for(i
=0; i
<blocksize
; i
++)
1433 ang
[i
]=mag
[i
]-ang
[i
];
1451 static void copy_normalize(float *dst
, float *src
, int len
, int exp_bias
, float add_bias
)
1455 memcpy(dst
, src
, len
* sizeof(float));
1457 for(i
=0; i
<len
; i
++)
1458 dst
[i
] = src
[i
] + add_bias
;
1462 // Decode the audio packet using the functions above
1464 static int vorbis_parse_audio_packet(vorbis_context
*vc
) {
1465 GetBitContext
*gb
=&vc
->gb
;
1467 uint_fast8_t previous_window
=vc
->previous_window
;
1468 uint_fast8_t mode_number
;
1469 uint_fast8_t blockflag
;
1470 uint_fast16_t blocksize
;
1472 uint_fast8_t no_residue
[vc
->audio_channels
];
1473 uint_fast8_t do_not_decode
[vc
->audio_channels
];
1474 vorbis_mapping
*mapping
;
1475 float *ch_res_ptr
=vc
->channel_residues
;
1476 float *ch_floor_ptr
=vc
->channel_floors
;
1477 uint_fast8_t res_chan
[vc
->audio_channels
];
1478 uint_fast8_t res_num
=0;
1479 int_fast16_t retlen
=0;
1480 float fadd_bias
= vc
->add_bias
;
1482 if (get_bits1(gb
)) {
1483 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Not a Vorbis I audio packet.\n");
1484 return -1; // packet type not audio
1487 if (vc
->mode_count
==1) {
1490 mode_number
=get_bits(gb
, ilog(vc
->mode_count
-1));
1492 if (mode_number
>=vc
->mode_count
) {
1493 av_log(vc
->avccontext
, AV_LOG_ERROR
, "mode number %d out of range.\n", mode_number
);
1496 vc
->mode_number
=mode_number
;
1497 mapping
=&vc
->mappings
[vc
->modes
[mode_number
].mapping
];
1499 AV_DEBUG(" Mode number: %d , mapping: %d , blocktype %d \n", mode_number
, vc
->modes
[mode_number
].mapping
, vc
->modes
[mode_number
].blockflag
);
1501 blockflag
=vc
->modes
[mode_number
].blockflag
;
1502 blocksize
=vc
->blocksize
[blockflag
];
1504 skip_bits(gb
, 2); // previous_window, next_window
1507 memset(ch_res_ptr
, 0, sizeof(float)*vc
->audio_channels
*blocksize
/2); //FIXME can this be removed ?
1508 memset(ch_floor_ptr
, 0, sizeof(float)*vc
->audio_channels
*blocksize
/2); //FIXME can this be removed ?
1512 for(i
=0;i
<vc
->audio_channels
;++i
) {
1513 vorbis_floor
*floor
;
1514 if (mapping
->submaps
>1) {
1515 floor
=&vc
->floors
[mapping
->submap_floor
[mapping
->mux
[i
]]];
1517 floor
=&vc
->floors
[mapping
->submap_floor
[0]];
1520 no_residue
[i
]=floor
->decode(vc
, &floor
->data
, ch_floor_ptr
);
1521 ch_floor_ptr
+=blocksize
/2;
1524 // Nonzero vector propagate
1526 for(i
=mapping
->coupling_steps
-1;i
>=0;--i
) {
1527 if (!(no_residue
[mapping
->magnitude
[i
]] & no_residue
[mapping
->angle
[i
]])) {
1528 no_residue
[mapping
->magnitude
[i
]]=0;
1529 no_residue
[mapping
->angle
[i
]]=0;
1535 for(i
=0;i
<mapping
->submaps
;++i
) {
1536 vorbis_residue
*residue
;
1539 for(j
=0;j
<vc
->audio_channels
;++j
) {
1540 if ((mapping
->submaps
==1) || (i
==mapping
->mux
[j
])) {
1541 res_chan
[j
]=res_num
;
1542 if (no_residue
[j
]) {
1543 do_not_decode
[ch
]=1;
1545 do_not_decode
[ch
]=0;
1551 residue
=&vc
->residues
[mapping
->submap_residue
[i
]];
1552 vorbis_residue_decode(vc
, residue
, ch
, do_not_decode
, ch_res_ptr
, blocksize
/2);
1554 ch_res_ptr
+=ch
*blocksize
/2;
1559 for(i
=mapping
->coupling_steps
-1;i
>=0;--i
) { //warning: i has to be signed
1562 mag
=vc
->channel_residues
+res_chan
[mapping
->magnitude
[i
]]*blocksize
/2;
1563 ang
=vc
->channel_residues
+res_chan
[mapping
->angle
[i
]]*blocksize
/2;
1564 vc
->dsp
.vorbis_inverse_coupling(mag
, ang
, blocksize
/2);
1569 for(j
=vc
->audio_channels
-1;j
>=0;j
--) {
1570 ch_floor_ptr
=vc
->channel_floors
+j
*blocksize
/2;
1571 ch_res_ptr
=vc
->channel_residues
+res_chan
[j
]*blocksize
/2;
1572 vc
->dsp
.vector_fmul(ch_floor_ptr
, ch_res_ptr
, blocksize
/2);
1573 ff_imdct_half(&vc
->mdct
[blockflag
], ch_res_ptr
, ch_floor_ptr
);
1576 // Overlap/add, save data for next overlapping FPMATH
1578 retlen
= (blocksize
+ vc
->blocksize
[previous_window
])/4;
1579 for(j
=0;j
<vc
->audio_channels
;j
++) {
1580 uint_fast16_t bs0
=vc
->blocksize
[0];
1581 uint_fast16_t bs1
=vc
->blocksize
[1];
1582 float *residue
=vc
->channel_residues
+res_chan
[j
]*blocksize
/2;
1583 float *saved
=vc
->saved
+j
*bs1
/4;
1584 float *ret
=vc
->channel_floors
+j
*retlen
;
1586 const float *win
=vc
->win
[blockflag
&previous_window
];
1588 if(blockflag
== previous_window
) {
1589 vc
->dsp
.vector_fmul_window(ret
, saved
, buf
, win
, fadd_bias
, blocksize
/4);
1590 } else if(blockflag
> previous_window
) {
1591 vc
->dsp
.vector_fmul_window(ret
, saved
, buf
, win
, fadd_bias
, bs0
/4);
1592 copy_normalize(ret
+bs0
/2, buf
+bs0
/4, (bs1
-bs0
)/4, vc
->exp_bias
, fadd_bias
);
1594 copy_normalize(ret
, saved
, (bs1
-bs0
)/4, vc
->exp_bias
, fadd_bias
);
1595 vc
->dsp
.vector_fmul_window(ret
+(bs1
-bs0
)/4, saved
+(bs1
-bs0
)/4, buf
, win
, fadd_bias
, bs0
/4);
1597 memcpy(saved
, buf
+blocksize
/4, blocksize
/4*sizeof(float));
1600 vc
->previous_window
= blockflag
;
1604 // Return the decoded audio packet through the standard api
1606 static int vorbis_decode_frame(AVCodecContext
*avccontext
,
1607 void *data
, int *data_size
,
1610 const uint8_t *buf
= avpkt
->data
;
1611 int buf_size
= avpkt
->size
;
1612 vorbis_context
*vc
= avccontext
->priv_data
;
1613 GetBitContext
*gb
= &(vc
->gb
);
1614 const float *channel_ptrs
[vc
->audio_channels
];
1623 AV_DEBUG("packet length %d \n", buf_size
);
1625 init_get_bits(gb
, buf
, buf_size
*8);
1627 len
=vorbis_parse_audio_packet(vc
);
1634 if (!vc
->first_frame
) {
1640 AV_DEBUG("parsed %d bytes %d bits, returned %d samples (*ch*bits) \n", get_bits_count(gb
)/8, get_bits_count(gb
)%8, len
);
1642 for(i
=0; i
<vc
->audio_channels
; i
++)
1643 channel_ptrs
[i
] = vc
->channel_floors
+i
*len
;
1644 vc
->dsp
.float_to_int16_interleave(data
, channel_ptrs
, len
, vc
->audio_channels
);
1645 *data_size
=len
*2*vc
->audio_channels
;
1652 static av_cold
int vorbis_decode_close(AVCodecContext
*avccontext
) {
1653 vorbis_context
*vc
= avccontext
->priv_data
;
1660 AVCodec vorbis_decoder
= {
1664 sizeof(vorbis_context
),
1667 vorbis_decode_close
,
1668 vorbis_decode_frame
,
1669 .long_name
= NULL_IF_CONFIG_SMALL("Vorbis"),