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
;
68 union vorbis_floor_u
{
69 struct vorbis_floor0_s
{
72 uint_fast16_t bark_map_size
;
74 uint_fast32_t map_size
[2];
75 uint_fast8_t amplitude_bits
;
76 uint_fast8_t amplitude_offset
;
77 uint_fast8_t num_books
;
78 uint_fast8_t *book_list
;
81 struct vorbis_floor1_s
{
82 uint_fast8_t partitions
;
83 uint_fast8_t maximum_class
;
84 uint_fast8_t partition_class
[32];
85 uint_fast8_t class_dimensions
[16];
86 uint_fast8_t class_subclasses
[16];
87 uint_fast8_t class_masterbook
[16];
88 int_fast16_t subclass_books
[16][8];
89 uint_fast8_t multiplier
;
90 uint_fast16_t x_list_dim
;
91 vorbis_floor1_entry
*list
;
100 uint_fast32_t partition_size
;
101 uint_fast8_t classifications
;
102 uint_fast8_t classbook
;
103 int_fast16_t books
[64][8];
104 uint_fast8_t maxpass
;
108 uint_fast8_t submaps
;
109 uint_fast16_t coupling_steps
;
110 uint_fast8_t *magnitude
;
113 uint_fast8_t submap_floor
[16];
114 uint_fast8_t submap_residue
[16];
118 uint_fast8_t blockflag
;
119 uint_fast16_t windowtype
;
120 uint_fast16_t transformtype
;
121 uint_fast8_t mapping
;
124 typedef struct vorbis_context_s
{
125 AVCodecContext
*avccontext
;
130 uint_fast8_t first_frame
;
131 uint_fast32_t version
;
132 uint_fast8_t audio_channels
;
133 uint_fast32_t audio_samplerate
;
134 uint_fast32_t bitrate_maximum
;
135 uint_fast32_t bitrate_nominal
;
136 uint_fast32_t bitrate_minimum
;
137 uint_fast32_t blocksize
[2];
139 uint_fast16_t codebook_count
;
140 vorbis_codebook
*codebooks
;
141 uint_fast8_t floor_count
;
142 vorbis_floor
*floors
;
143 uint_fast8_t residue_count
;
144 vorbis_residue
*residues
;
145 uint_fast8_t mapping_count
;
146 vorbis_mapping
*mappings
;
147 uint_fast8_t mode_count
;
149 uint_fast8_t mode_number
; // mode number for the current packet
150 uint_fast8_t previous_window
;
151 float *channel_residues
;
152 float *channel_floors
;
154 uint_fast32_t add_bias
; // for float->int conversion
155 uint_fast32_t exp_bias
;
158 /* Helper functions */
161 (13.1f * atan(0.00074f * (x)) + 2.24f * atan(1.85e-8f * (x) * (x)) + 1e-4f * (x))
163 static const char idx_err_str
[] = "Index value %d out of range (0 - %d) for %s at %s:%i\n";
164 #define VALIDATE_INDEX(idx, limit) \
166 av_log(vc->avccontext, AV_LOG_ERROR,\
168 (int)(idx), (int)(limit - 1), #idx, __FILE__, __LINE__);\
171 #define GET_VALIDATED_INDEX(idx, bits, limit) \
173 idx = get_bits(gb, bits);\
174 VALIDATE_INDEX(idx, limit)\
177 static float vorbisfloat2float(uint_fast32_t val
)
179 double mant
= val
& 0x1fffff;
180 long exp
= (val
& 0x7fe00000L
) >> 21;
181 if (val
& 0x80000000)
183 return ldexp(mant
, exp
- 20 - 768);
187 // Free all allocated memory -----------------------------------------
189 static void vorbis_free(vorbis_context
*vc
)
193 av_freep(&vc
->channel_residues
);
194 av_freep(&vc
->channel_floors
);
195 av_freep(&vc
->saved
);
197 av_freep(&vc
->residues
);
198 av_freep(&vc
->modes
);
200 ff_mdct_end(&vc
->mdct
[0]);
201 ff_mdct_end(&vc
->mdct
[1]);
203 for (i
= 0; i
< vc
->codebook_count
; ++i
) {
204 av_free(vc
->codebooks
[i
].codevectors
);
205 free_vlc(&vc
->codebooks
[i
].vlc
);
207 av_freep(&vc
->codebooks
);
209 for (i
= 0; i
< vc
->floor_count
; ++i
) {
210 if (vc
->floors
[i
].floor_type
== 0) {
211 av_free(vc
->floors
[i
].data
.t0
.map
[0]);
212 av_free(vc
->floors
[i
].data
.t0
.map
[1]);
213 av_free(vc
->floors
[i
].data
.t0
.book_list
);
214 av_free(vc
->floors
[i
].data
.t0
.lsp
);
216 av_free(vc
->floors
[i
].data
.t1
.list
);
219 av_freep(&vc
->floors
);
221 for (i
= 0; i
< vc
->mapping_count
; ++i
) {
222 av_free(vc
->mappings
[i
].magnitude
);
223 av_free(vc
->mappings
[i
].angle
);
224 av_free(vc
->mappings
[i
].mux
);
226 av_freep(&vc
->mappings
);
229 // Parse setup header -------------------------------------------------
231 // Process codebooks part
233 static int vorbis_parse_setup_hdr_codebooks(vorbis_context
*vc
)
236 uint8_t *tmp_vlc_bits
;
237 uint32_t *tmp_vlc_codes
;
238 GetBitContext
*gb
= &vc
->gb
;
240 vc
->codebook_count
= get_bits(gb
, 8) + 1;
242 AV_DEBUG(" Codebooks: %d \n", vc
->codebook_count
);
244 vc
->codebooks
= av_mallocz(vc
->codebook_count
* sizeof(vorbis_codebook
));
245 tmp_vlc_bits
= av_mallocz(V_MAX_VLCS
* sizeof(uint8_t));
246 tmp_vlc_codes
= av_mallocz(V_MAX_VLCS
* sizeof(uint32_t));
248 for (cb
= 0; cb
< vc
->codebook_count
; ++cb
) {
249 vorbis_codebook
*codebook_setup
= &vc
->codebooks
[cb
];
250 uint_fast8_t ordered
;
251 uint_fast32_t t
, used_entries
= 0;
252 uint_fast32_t entries
;
254 AV_DEBUG(" %d. Codebook \n", cb
);
256 if (get_bits(gb
, 24) != 0x564342) {
257 av_log(vc
->avccontext
, AV_LOG_ERROR
, " %"PRIdFAST16
". Codebook setup data corrupt. \n", cb
);
261 codebook_setup
->dimensions
=get_bits(gb
, 16);
262 if (codebook_setup
->dimensions
> 16 || codebook_setup
->dimensions
== 0) {
263 av_log(vc
->avccontext
, AV_LOG_ERROR
, " %"PRIdFAST16
". Codebook's dimension is invalid (%d). \n", cb
, codebook_setup
->dimensions
);
266 entries
= get_bits(gb
, 24);
267 if (entries
> V_MAX_VLCS
) {
268 av_log(vc
->avccontext
, AV_LOG_ERROR
, " %"PRIdFAST16
". Codebook has too many entries (%"PRIdFAST32
"). \n", cb
, entries
);
272 ordered
= get_bits1(gb
);
274 AV_DEBUG(" codebook_dimensions %d, codebook_entries %d \n", codebook_setup
->dimensions
, entries
);
279 uint_fast8_t sparse
= get_bits1(gb
);
281 AV_DEBUG(" not ordered \n");
284 AV_DEBUG(" sparse \n");
287 for (ce
= 0; ce
< entries
; ++ce
) {
288 flag
= get_bits1(gb
);
290 tmp_vlc_bits
[ce
] = get_bits(gb
, 5) + 1;
293 tmp_vlc_bits
[ce
] = 0;
296 AV_DEBUG(" not sparse \n");
298 used_entries
= entries
;
299 for (ce
= 0; ce
< entries
; ++ce
)
300 tmp_vlc_bits
[ce
] = get_bits(gb
, 5) + 1;
303 uint_fast16_t current_entry
= 0;
304 uint_fast8_t current_length
= get_bits(gb
, 5)+1;
306 AV_DEBUG(" ordered, current length: %d \n", current_length
); //FIXME
308 used_entries
= entries
;
309 for (; current_entry
< used_entries
&& current_length
<= 32; ++current_length
) {
310 uint_fast16_t i
, number
;
312 AV_DEBUG(" number bits: %d ", ilog(entries
- current_entry
));
314 number
= get_bits(gb
, ilog(entries
- current_entry
));
316 AV_DEBUG(" number: %d \n", number
);
318 for (i
= current_entry
; i
< number
+current_entry
; ++i
)
319 if (i
< used_entries
)
320 tmp_vlc_bits
[i
] = current_length
;
322 current_entry
+=number
;
324 if (current_entry
>used_entries
) {
325 av_log(vc
->avccontext
, AV_LOG_ERROR
, " More codelengths than codes in codebook. \n");
330 codebook_setup
->lookup_type
= get_bits(gb
, 4);
332 AV_DEBUG(" lookup type: %d : %s \n", codebook_setup
->lookup_type
, codebook_setup
->lookup_type
? "vq" : "no lookup");
334 // If the codebook is used for (inverse) VQ, calculate codevectors.
336 if (codebook_setup
->lookup_type
== 1) {
337 uint_fast16_t i
, j
, k
;
338 uint_fast16_t codebook_lookup_values
= ff_vorbis_nth_root(entries
, codebook_setup
->dimensions
);
339 uint_fast16_t codebook_multiplicands
[codebook_lookup_values
];
341 float codebook_minimum_value
= vorbisfloat2float(get_bits_long(gb
, 32));
342 float codebook_delta_value
= vorbisfloat2float(get_bits_long(gb
, 32));
343 uint_fast8_t codebook_value_bits
= get_bits(gb
, 4)+1;
344 uint_fast8_t codebook_sequence_p
= get_bits1(gb
);
346 AV_DEBUG(" We expect %d numbers for building the codevectors. \n", codebook_lookup_values
);
347 AV_DEBUG(" delta %f minmum %f \n", codebook_delta_value
, codebook_minimum_value
);
349 for (i
= 0; i
< codebook_lookup_values
; ++i
) {
350 codebook_multiplicands
[i
] = get_bits(gb
, codebook_value_bits
);
352 AV_DEBUG(" multiplicands*delta+minmum : %e \n", (float)codebook_multiplicands
[i
]*codebook_delta_value
+codebook_minimum_value
);
353 AV_DEBUG(" multiplicand %d \n", codebook_multiplicands
[i
]);
356 // Weed out unused vlcs and build codevector vector
357 codebook_setup
->codevectors
= used_entries
? av_mallocz(used_entries
*codebook_setup
->dimensions
* sizeof(float)) : NULL
;
358 for (j
= 0, i
= 0; i
< entries
; ++i
) {
359 uint_fast8_t dim
= codebook_setup
->dimensions
;
361 if (tmp_vlc_bits
[i
]) {
363 uint_fast32_t lookup_offset
= i
;
366 av_log(vc
->avccontext
, AV_LOG_INFO
, "Lookup offset %d ,", i
);
369 for (k
= 0; k
< dim
; ++k
) {
370 uint_fast32_t multiplicand_offset
= lookup_offset
% codebook_lookup_values
;
371 codebook_setup
->codevectors
[j
* dim
+ k
] = codebook_multiplicands
[multiplicand_offset
] * codebook_delta_value
+ codebook_minimum_value
+ last
;
372 if (codebook_sequence_p
)
373 last
= codebook_setup
->codevectors
[j
* dim
+ k
];
374 lookup_offset
/=codebook_lookup_values
;
376 tmp_vlc_bits
[j
] = tmp_vlc_bits
[i
];
379 av_log(vc
->avccontext
, AV_LOG_INFO
, "real lookup offset %d, vector: ", j
);
380 for (k
= 0; k
< dim
; ++k
)
381 av_log(vc
->avccontext
, AV_LOG_INFO
, " %f ", codebook_setup
->codevectors
[j
* dim
+ k
]);
382 av_log(vc
->avccontext
, AV_LOG_INFO
, "\n");
388 if (j
!= used_entries
) {
389 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Bug in codevector vector building code. \n");
392 entries
= used_entries
;
393 } else if (codebook_setup
->lookup_type
>= 2) {
394 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Codebook lookup type not supported. \n");
398 // Initialize VLC table
399 if (ff_vorbis_len2vlc(tmp_vlc_bits
, tmp_vlc_codes
, entries
)) {
400 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Invalid code lengths while generating vlcs. \n");
403 codebook_setup
->maxdepth
= 0;
404 for (t
= 0; t
< entries
; ++t
)
405 if (tmp_vlc_bits
[t
] >= codebook_setup
->maxdepth
)
406 codebook_setup
->maxdepth
= tmp_vlc_bits
[t
];
408 if (codebook_setup
->maxdepth
> 3 * V_NB_BITS
)
409 codebook_setup
->nb_bits
= V_NB_BITS2
;
411 codebook_setup
->nb_bits
= V_NB_BITS
;
413 codebook_setup
->maxdepth
= (codebook_setup
->maxdepth
+codebook_setup
->nb_bits
- 1) / codebook_setup
->nb_bits
;
415 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
)) {
416 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Error generating vlc tables. \n");
421 av_free(tmp_vlc_bits
);
422 av_free(tmp_vlc_codes
);
427 av_free(tmp_vlc_bits
);
428 av_free(tmp_vlc_codes
);
432 // Process time domain transforms part (unused in Vorbis I)
434 static int vorbis_parse_setup_hdr_tdtransforms(vorbis_context
*vc
)
436 GetBitContext
*gb
= &vc
->gb
;
438 uint_fast8_t vorbis_time_count
= get_bits(gb
, 6) + 1;
440 for (i
= 0; i
< vorbis_time_count
; ++i
) {
441 uint_fast16_t vorbis_tdtransform
= get_bits(gb
, 16);
443 AV_DEBUG(" Vorbis time domain transform %d: %d \n", vorbis_time_count
, vorbis_tdtransform
);
445 if (vorbis_tdtransform
) {
446 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Vorbis time domain transform data nonzero. \n");
453 // Process floors part
455 static uint_fast8_t vorbis_floor0_decode(vorbis_context
*vc
,
456 vorbis_floor_data
*vfu
, float *vec
);
457 static void create_map(vorbis_context
*vc
, uint_fast8_t floor_number
);
458 static uint_fast8_t vorbis_floor1_decode(vorbis_context
*vc
,
459 vorbis_floor_data
*vfu
, float *vec
);
460 static int vorbis_parse_setup_hdr_floors(vorbis_context
*vc
)
462 GetBitContext
*gb
= &vc
->gb
;
465 vc
->floor_count
= get_bits(gb
, 6) + 1;
467 vc
->floors
= av_mallocz(vc
->floor_count
* sizeof(vorbis_floor
));
469 for (i
= 0; i
< vc
->floor_count
; ++i
) {
470 vorbis_floor
*floor_setup
= &vc
->floors
[i
];
472 floor_setup
->floor_type
= get_bits(gb
, 16);
474 AV_DEBUG(" %d. floor type %d \n", i
, floor_setup
->floor_type
);
476 if (floor_setup
->floor_type
== 1) {
477 uint_fast8_t maximum_class
= 0;
478 uint_fast8_t rangebits
;
479 uint_fast16_t floor1_values
= 2;
481 floor_setup
->decode
= vorbis_floor1_decode
;
483 floor_setup
->data
.t1
.partitions
= get_bits(gb
, 5);
485 AV_DEBUG(" %d.floor: %d partitions \n", i
, floor_setup
->data
.t1
.partitions
);
487 for (j
= 0; j
< floor_setup
->data
.t1
.partitions
; ++j
) {
488 floor_setup
->data
.t1
.partition_class
[j
] = get_bits(gb
, 4);
489 if (floor_setup
->data
.t1
.partition_class
[j
] > maximum_class
)
490 maximum_class
= floor_setup
->data
.t1
.partition_class
[j
];
492 AV_DEBUG(" %d. floor %d partition class %d \n", i
, j
, floor_setup
->data
.t1
.partition_class
[j
]);
496 AV_DEBUG(" maximum class %d \n", maximum_class
);
498 floor_setup
->data
.t1
.maximum_class
= maximum_class
;
500 for (j
= 0; j
<= maximum_class
; ++j
) {
501 floor_setup
->data
.t1
.class_dimensions
[j
] = get_bits(gb
, 3) + 1;
502 floor_setup
->data
.t1
.class_subclasses
[j
] = get_bits(gb
, 2);
504 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
]);
506 if (floor_setup
->data
.t1
.class_subclasses
[j
]) {
507 GET_VALIDATED_INDEX(floor_setup
->data
.t1
.class_masterbook
[j
], 8, vc
->codebook_count
)
509 AV_DEBUG(" masterbook: %d \n", floor_setup
->data
.t1
.class_masterbook
[j
]);
512 for (k
= 0; k
< (1 << floor_setup
->data
.t1
.class_subclasses
[j
]); ++k
) {
513 int16_t bits
= get_bits(gb
, 8) - 1;
515 VALIDATE_INDEX(bits
, vc
->codebook_count
)
516 floor_setup
->data
.t1
.subclass_books
[j
][k
] = bits
;
518 AV_DEBUG(" book %d. : %d \n", k
, floor_setup
->data
.t1
.subclass_books
[j
][k
]);
522 floor_setup
->data
.t1
.multiplier
= get_bits(gb
, 2) + 1;
523 floor_setup
->data
.t1
.x_list_dim
= 2;
525 for (j
= 0; j
< floor_setup
->data
.t1
.partitions
; ++j
)
526 floor_setup
->data
.t1
.x_list_dim
+=floor_setup
->data
.t1
.class_dimensions
[floor_setup
->data
.t1
.partition_class
[j
]];
528 floor_setup
->data
.t1
.list
= av_mallocz(floor_setup
->data
.t1
.x_list_dim
* sizeof(vorbis_floor1_entry
));
531 rangebits
= get_bits(gb
, 4);
532 floor_setup
->data
.t1
.list
[0].x
= 0;
533 floor_setup
->data
.t1
.list
[1].x
= (1 << rangebits
);
535 for (j
= 0; j
< floor_setup
->data
.t1
.partitions
; ++j
) {
536 for (k
= 0; k
< floor_setup
->data
.t1
.class_dimensions
[floor_setup
->data
.t1
.partition_class
[j
]]; ++k
, ++floor1_values
) {
537 floor_setup
->data
.t1
.list
[floor1_values
].x
= get_bits(gb
, rangebits
);
539 AV_DEBUG(" %d. floor1 Y coord. %d \n", floor1_values
, floor_setup
->data
.t1
.list
[floor1_values
].x
);
543 // Precalculate order of x coordinates - needed for decode
544 ff_vorbis_ready_floor1_list(floor_setup
->data
.t1
.list
, floor_setup
->data
.t1
.x_list_dim
);
545 } else if (floor_setup
->floor_type
== 0) {
546 uint_fast8_t max_codebook_dim
= 0;
548 floor_setup
->decode
= vorbis_floor0_decode
;
550 floor_setup
->data
.t0
.order
= get_bits(gb
, 8);
551 floor_setup
->data
.t0
.rate
= get_bits(gb
, 16);
552 floor_setup
->data
.t0
.bark_map_size
= get_bits(gb
, 16);
553 floor_setup
->data
.t0
.amplitude_bits
= get_bits(gb
, 6);
554 /* zero would result in a div by zero later *
556 if (floor_setup
->data
.t0
.amplitude_bits
== 0) {
557 av_log(vc
->avccontext
, AV_LOG_ERROR
,
558 "Floor 0 amplitude bits is 0.\n");
561 floor_setup
->data
.t0
.amplitude_offset
= get_bits(gb
, 8);
562 floor_setup
->data
.t0
.num_books
= get_bits(gb
, 4) + 1;
564 /* allocate mem for booklist */
565 floor_setup
->data
.t0
.book_list
=
566 av_malloc(floor_setup
->data
.t0
.num_books
);
567 if (!floor_setup
->data
.t0
.book_list
)
569 /* read book indexes */
572 uint_fast8_t book_idx
;
573 for (idx
= 0; idx
< floor_setup
->data
.t0
.num_books
; ++idx
) {
574 GET_VALIDATED_INDEX(floor_setup
->data
.t0
.book_list
[idx
], 8, vc
->codebook_count
)
575 if (vc
->codebooks
[book_idx
].dimensions
> max_codebook_dim
)
576 max_codebook_dim
= vc
->codebooks
[book_idx
].dimensions
;
582 /* allocate mem for lsp coefficients */
584 /* codebook dim is for padding if codebook dim doesn't *
585 * divide order+1 then we need to read more data */
586 floor_setup
->data
.t0
.lsp
=
587 av_malloc((floor_setup
->data
.t0
.order
+1 + max_codebook_dim
)
589 if (!floor_setup
->data
.t0
.lsp
)
593 #ifdef V_DEBUG /* debug output parsed headers */
594 AV_DEBUG("floor0 order: %u\n", floor_setup
->data
.t0
.order
);
595 AV_DEBUG("floor0 rate: %u\n", floor_setup
->data
.t0
.rate
);
596 AV_DEBUG("floor0 bark map size: %u\n",
597 floor_setup
->data
.t0
.bark_map_size
);
598 AV_DEBUG("floor0 amplitude bits: %u\n",
599 floor_setup
->data
.t0
.amplitude_bits
);
600 AV_DEBUG("floor0 amplitude offset: %u\n",
601 floor_setup
->data
.t0
.amplitude_offset
);
602 AV_DEBUG("floor0 number of books: %u\n",
603 floor_setup
->data
.t0
.num_books
);
604 AV_DEBUG("floor0 book list pointer: %p\n",
605 floor_setup
->data
.t0
.book_list
);
608 for (idx
= 0; idx
< floor_setup
->data
.t0
.num_books
; ++idx
) {
609 AV_DEBUG(" Book %d: %u\n",
611 floor_setup
->data
.t0
.book_list
[idx
]);
616 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Invalid floor type!\n");
623 // Process residues part
625 static int vorbis_parse_setup_hdr_residues(vorbis_context
*vc
)
627 GetBitContext
*gb
= &vc
->gb
;
628 uint_fast8_t i
, j
, k
;
630 vc
->residue_count
= get_bits(gb
, 6)+1;
631 vc
->residues
= av_mallocz(vc
->residue_count
* sizeof(vorbis_residue
));
633 AV_DEBUG(" There are %d residues. \n", vc
->residue_count
);
635 for (i
= 0; i
< vc
->residue_count
; ++i
) {
636 vorbis_residue
*res_setup
= &vc
->residues
[i
];
637 uint_fast8_t cascade
[64];
638 uint_fast8_t high_bits
;
639 uint_fast8_t low_bits
;
641 res_setup
->type
= get_bits(gb
, 16);
643 AV_DEBUG(" %d. residue type %d \n", i
, res_setup
->type
);
645 res_setup
->begin
= get_bits(gb
, 24);
646 res_setup
->end
= get_bits(gb
, 24);
647 res_setup
->partition_size
= get_bits(gb
, 24) + 1;
648 /* Validations to prevent a buffer overflow later. */
649 if (res_setup
->begin
>res_setup
->end
||
650 res_setup
->end
>vc
->blocksize
[1] / (res_setup
->type
== 2 ? 1 : 2) ||
651 (res_setup
->end
-res_setup
->begin
) / res_setup
->partition_size
> V_MAX_PARTITIONS
) {
652 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);
656 res_setup
->classifications
= get_bits(gb
, 6) + 1;
657 GET_VALIDATED_INDEX(res_setup
->classbook
, 8, vc
->codebook_count
)
659 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
,
660 res_setup
->classifications
, res_setup
->classbook
);
662 for (j
= 0; j
< res_setup
->classifications
; ++j
) {
664 low_bits
= get_bits(gb
, 3);
666 high_bits
= get_bits(gb
, 5);
667 cascade
[j
] = (high_bits
<< 3) + low_bits
;
669 AV_DEBUG(" %d class casscade depth: %d \n", j
, ilog(cascade
[j
]));
672 res_setup
->maxpass
= 0;
673 for (j
= 0; j
< res_setup
->classifications
; ++j
) {
674 for (k
= 0; k
< 8; ++k
) {
675 if (cascade
[j
]&(1 << k
)) {
676 GET_VALIDATED_INDEX(res_setup
->books
[j
][k
], 8, vc
->codebook_count
)
678 AV_DEBUG(" %d class casscade depth %d book: %d \n", j
, k
, res_setup
->books
[j
][k
]);
680 if (k
>res_setup
->maxpass
)
681 res_setup
->maxpass
= k
;
683 res_setup
->books
[j
][k
] = -1;
691 // Process mappings part
693 static int vorbis_parse_setup_hdr_mappings(vorbis_context
*vc
)
695 GetBitContext
*gb
= &vc
->gb
;
698 vc
->mapping_count
= get_bits(gb
, 6)+1;
699 vc
->mappings
= av_mallocz(vc
->mapping_count
* sizeof(vorbis_mapping
));
701 AV_DEBUG(" There are %d mappings. \n", vc
->mapping_count
);
703 for (i
= 0; i
< vc
->mapping_count
; ++i
) {
704 vorbis_mapping
*mapping_setup
= &vc
->mappings
[i
];
706 if (get_bits(gb
, 16)) {
707 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Other mappings than type 0 are not compliant with the Vorbis I specification. \n");
711 mapping_setup
->submaps
= get_bits(gb
, 4) + 1;
713 mapping_setup
->submaps
= 1;
717 mapping_setup
->coupling_steps
= get_bits(gb
, 8) + 1;
718 mapping_setup
->magnitude
= av_mallocz(mapping_setup
->coupling_steps
* sizeof(uint_fast8_t));
719 mapping_setup
->angle
= av_mallocz(mapping_setup
->coupling_steps
* sizeof(uint_fast8_t));
720 for (j
= 0; j
< mapping_setup
->coupling_steps
; ++j
) {
721 GET_VALIDATED_INDEX(mapping_setup
->magnitude
[j
], ilog(vc
->audio_channels
- 1), vc
->audio_channels
)
722 GET_VALIDATED_INDEX(mapping_setup
->angle
[j
], ilog(vc
->audio_channels
- 1), vc
->audio_channels
)
725 mapping_setup
->coupling_steps
= 0;
728 AV_DEBUG(" %d mapping coupling steps: %d \n", i
, mapping_setup
->coupling_steps
);
730 if (get_bits(gb
, 2)) {
731 av_log(vc
->avccontext
, AV_LOG_ERROR
, "%d. mapping setup data invalid. \n", i
);
732 return -1; // following spec.
735 if (mapping_setup
->submaps
>1) {
736 mapping_setup
->mux
= av_mallocz(vc
->audio_channels
* sizeof(uint_fast8_t));
737 for (j
= 0; j
< vc
->audio_channels
; ++j
)
738 mapping_setup
->mux
[j
] = get_bits(gb
, 4);
741 for (j
= 0; j
< mapping_setup
->submaps
; ++j
) {
742 skip_bits(gb
, 8); // FIXME check?
743 GET_VALIDATED_INDEX(mapping_setup
->submap_floor
[j
], 8, vc
->floor_count
)
744 GET_VALIDATED_INDEX(mapping_setup
->submap_residue
[j
], 8, vc
->residue_count
)
746 AV_DEBUG(" %d mapping %d submap : floor %d, residue %d \n", i
, j
, mapping_setup
->submap_floor
[j
], mapping_setup
->submap_residue
[j
]);
752 // Process modes part
754 static void create_map(vorbis_context
*vc
, uint_fast8_t floor_number
)
756 vorbis_floor
*floors
= vc
->floors
;
759 int_fast8_t blockflag
;
761 int_fast32_t n
; //TODO: could theoretically be smaller?
763 for (blockflag
= 0; blockflag
< 2; ++blockflag
) {
764 n
= vc
->blocksize
[blockflag
] / 2;
765 floors
[floor_number
].data
.t0
.map
[blockflag
] =
766 av_malloc((n
+1) * sizeof(int_fast32_t)); // n + sentinel
768 map
= floors
[floor_number
].data
.t0
.map
[blockflag
];
769 vf
= &floors
[floor_number
].data
.t0
;
771 for (idx
= 0; idx
< n
; ++idx
) {
772 map
[idx
] = floor(BARK((vf
->rate
* idx
) / (2.0f
* n
)) *
773 ((vf
->bark_map_size
) /
774 BARK(vf
->rate
/ 2.0f
)));
775 if (vf
->bark_map_size
-1 < map
[idx
])
776 map
[idx
] = vf
->bark_map_size
- 1;
779 vf
->map_size
[blockflag
] = n
;
783 for (idx
= 0; idx
<= n
; ++idx
) {
784 AV_DEBUG("floor0 map: map at pos %d is %d\n",
790 static int vorbis_parse_setup_hdr_modes(vorbis_context
*vc
)
792 GetBitContext
*gb
= &vc
->gb
;
795 vc
->mode_count
= get_bits(gb
, 6) + 1;
796 vc
->modes
= av_mallocz(vc
->mode_count
* sizeof(vorbis_mode
));
798 AV_DEBUG(" There are %d modes.\n", vc
->mode_count
);
800 for (i
= 0; i
< vc
->mode_count
; ++i
) {
801 vorbis_mode
*mode_setup
= &vc
->modes
[i
];
803 mode_setup
->blockflag
= get_bits1(gb
);
804 mode_setup
->windowtype
= get_bits(gb
, 16); //FIXME check
805 mode_setup
->transformtype
= get_bits(gb
, 16); //FIXME check
806 GET_VALIDATED_INDEX(mode_setup
->mapping
, 8, vc
->mapping_count
);
808 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
);
813 // Process the whole setup header using the functions above
815 static int vorbis_parse_setup_hdr(vorbis_context
*vc
)
817 GetBitContext
*gb
= &vc
->gb
;
819 if ((get_bits(gb
, 8) != 'v') || (get_bits(gb
, 8) != 'o') ||
820 (get_bits(gb
, 8) != 'r') || (get_bits(gb
, 8) != 'b') ||
821 (get_bits(gb
, 8) != 'i') || (get_bits(gb
, 8) != 's')) {
822 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (no vorbis signature). \n");
826 if (vorbis_parse_setup_hdr_codebooks(vc
)) {
827 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (codebooks). \n");
830 if (vorbis_parse_setup_hdr_tdtransforms(vc
)) {
831 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (time domain transforms). \n");
834 if (vorbis_parse_setup_hdr_floors(vc
)) {
835 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (floors). \n");
838 if (vorbis_parse_setup_hdr_residues(vc
)) {
839 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (residues). \n");
842 if (vorbis_parse_setup_hdr_mappings(vc
)) {
843 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (mappings). \n");
846 if (vorbis_parse_setup_hdr_modes(vc
)) {
847 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (modes). \n");
850 if (!get_bits1(gb
)) {
851 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (framing flag). \n");
852 return -8; // framing flag bit unset error
858 // Process the identification header
860 static int vorbis_parse_id_hdr(vorbis_context
*vc
)
862 GetBitContext
*gb
= &vc
->gb
;
863 uint_fast8_t bl0
, bl1
;
865 if ((get_bits(gb
, 8) != 'v') || (get_bits(gb
, 8) != 'o') ||
866 (get_bits(gb
, 8) != 'r') || (get_bits(gb
, 8) != 'b') ||
867 (get_bits(gb
, 8) != 'i') || (get_bits(gb
, 8) != 's')) {
868 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis id header packet corrupt (no vorbis signature). \n");
872 vc
->version
= get_bits_long(gb
, 32); //FIXME check 0
873 vc
->audio_channels
= get_bits(gb
, 8);
874 if (vc
->audio_channels
<= 0) {
875 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Invalid number of channels\n");
878 vc
->audio_samplerate
= get_bits_long(gb
, 32);
879 if (vc
->audio_samplerate
<= 0) {
880 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Invalid samplerate\n");
883 vc
->bitrate_maximum
= get_bits_long(gb
, 32);
884 vc
->bitrate_nominal
= get_bits_long(gb
, 32);
885 vc
->bitrate_minimum
= get_bits_long(gb
, 32);
886 bl0
= get_bits(gb
, 4);
887 bl1
= get_bits(gb
, 4);
888 vc
->blocksize
[0] = (1 << bl0
);
889 vc
->blocksize
[1] = (1 << bl1
);
890 if (bl0
> 13 || bl0
< 6 || bl1
> 13 || bl1
< 6 || bl1
< bl0
) {
891 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis id header packet corrupt (illegal blocksize). \n");
894 // output format int16
895 if (vc
->blocksize
[1] / 2 * vc
->audio_channels
* 2 > AVCODEC_MAX_AUDIO_FRAME_SIZE
) {
896 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Vorbis channel count makes "
897 "output packets too large.\n");
900 vc
->win
[0] = ff_vorbis_vwin
[bl0
- 6];
901 vc
->win
[1] = ff_vorbis_vwin
[bl1
- 6];
903 if ((get_bits1(gb
)) == 0) {
904 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis id header packet corrupt (framing flag not set). \n");
908 vc
->channel_residues
= av_malloc((vc
->blocksize
[1] / 2) * vc
->audio_channels
* sizeof(float));
909 vc
->channel_floors
= av_malloc((vc
->blocksize
[1] / 2) * vc
->audio_channels
* sizeof(float));
910 vc
->saved
= av_mallocz((vc
->blocksize
[1] / 4) * vc
->audio_channels
* sizeof(float));
911 vc
->previous_window
= 0;
913 ff_mdct_init(&vc
->mdct
[0], bl0
, 1, vc
->exp_bias
? -(1 << 15) : -1.0);
914 ff_mdct_init(&vc
->mdct
[1], bl1
, 1, vc
->exp_bias
? -(1 << 15) : -1.0);
916 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 ",
917 vc
->version
, vc
->audio_channels
, vc
->audio_samplerate
, vc
->bitrate_maximum
, vc
->bitrate_nominal
, vc
->bitrate_minimum
, vc
->blocksize
[0], vc
->blocksize
[1]);
920 BLK = vc->blocksize[0];
921 for (i = 0; i < BLK / 2; ++i) {
922 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)));
929 // Process the extradata using the functions above (identification header, setup header)
931 static av_cold
int vorbis_decode_init(AVCodecContext
*avccontext
)
933 vorbis_context
*vc
= avccontext
->priv_data
;
934 uint8_t *headers
= avccontext
->extradata
;
935 int headers_len
= avccontext
->extradata_size
;
936 uint8_t *header_start
[3];
938 GetBitContext
*gb
= &(vc
->gb
);
941 vc
->avccontext
= avccontext
;
942 dsputil_init(&vc
->dsp
, avccontext
);
944 if (vc
->dsp
.float_to_int16_interleave
== ff_float_to_int16_interleave_c
) {
949 vc
->exp_bias
= 15 << 23;
953 av_log(avccontext
, AV_LOG_ERROR
, "Extradata corrupt.\n");
957 if (ff_split_xiph_headers(headers
, headers_len
, 30, header_start
, header_len
) < 0) {
958 av_log(avccontext
, AV_LOG_ERROR
, "Extradata corrupt.\n");
962 init_get_bits(gb
, header_start
[0], header_len
[0]*8);
963 hdr_type
= get_bits(gb
, 8);
965 av_log(avccontext
, AV_LOG_ERROR
, "First header is not the id header.\n");
968 if (vorbis_parse_id_hdr(vc
)) {
969 av_log(avccontext
, AV_LOG_ERROR
, "Id header corrupt.\n");
974 init_get_bits(gb
, header_start
[2], header_len
[2]*8);
975 hdr_type
= get_bits(gb
, 8);
977 av_log(avccontext
, AV_LOG_ERROR
, "Third header is not the setup header.\n");
981 if (vorbis_parse_setup_hdr(vc
)) {
982 av_log(avccontext
, AV_LOG_ERROR
, "Setup header corrupt.\n");
987 if (vc
->audio_channels
> 6)
988 avccontext
->channel_layout
= 0;
990 avccontext
->channel_layout
= ff_vorbis_channel_layouts
[vc
->audio_channels
- 1];
992 avccontext
->channels
= vc
->audio_channels
;
993 avccontext
->sample_rate
= vc
->audio_samplerate
;
994 avccontext
->frame_size
= FFMIN(vc
->blocksize
[0], vc
->blocksize
[1]) >> 2;
995 avccontext
->sample_fmt
= SAMPLE_FMT_S16
;
1000 // Decode audiopackets -------------------------------------------------
1002 // Read and decode floor
1004 static uint_fast8_t vorbis_floor0_decode(vorbis_context
*vc
,
1005 vorbis_floor_data
*vfu
, float *vec
)
1007 vorbis_floor0
*vf
= &vfu
->t0
;
1008 float *lsp
= vf
->lsp
;
1009 uint_fast32_t amplitude
;
1010 uint_fast32_t book_idx
;
1011 uint_fast8_t blockflag
= vc
->modes
[vc
->mode_number
].blockflag
;
1013 amplitude
= get_bits(&vc
->gb
, vf
->amplitude_bits
);
1014 if (amplitude
> 0) {
1016 uint_fast16_t lsp_len
= 0;
1018 vorbis_codebook codebook
;
1020 book_idx
= get_bits(&vc
->gb
, ilog(vf
->num_books
));
1021 if (book_idx
>= vf
->num_books
) {
1022 av_log(vc
->avccontext
, AV_LOG_ERROR
,
1023 "floor0 dec: booknumber too high!\n");
1027 AV_DEBUG("floor0 dec: booknumber: %u\n", book_idx
);
1028 codebook
= vc
->codebooks
[vf
->book_list
[book_idx
]];
1030 while (lsp_len
<vf
->order
) {
1033 AV_DEBUG("floor0 dec: book dimension: %d\n", codebook
.dimensions
);
1034 AV_DEBUG("floor0 dec: maximum depth: %d\n", codebook
.maxdepth
);
1035 /* read temp vector */
1036 vec_off
= get_vlc2(&vc
->gb
, codebook
.vlc
.table
,
1037 codebook
.nb_bits
, codebook
.maxdepth
)
1038 * codebook
.dimensions
;
1039 AV_DEBUG("floor0 dec: vector offset: %d\n", vec_off
);
1040 /* copy each vector component and add last to it */
1041 for (idx
= 0; idx
< codebook
.dimensions
; ++idx
)
1042 lsp
[lsp_len
+idx
] = codebook
.codevectors
[vec_off
+idx
] + last
;
1043 last
= lsp
[lsp_len
+idx
-1]; /* set last to last vector component */
1045 lsp_len
+= codebook
.dimensions
;
1048 /* DEBUG: output lsp coeffs */
1051 for (idx
= 0; idx
< lsp_len
; ++idx
)
1052 AV_DEBUG("floor0 dec: coeff at %d is %f\n", idx
, lsp
[idx
]);
1056 /* synthesize floor output vector */
1059 int order
= vf
->order
;
1060 float wstep
= M_PI
/ vf
->bark_map_size
;
1062 for (i
= 0; i
< order
; i
++)
1063 lsp
[i
] = 2.0f
* cos(lsp
[i
]);
1065 AV_DEBUG("floor0 synth: map_size = %d; m = %d; wstep = %f\n",
1066 vf
->map_size
, order
, wstep
);
1069 while (i
< vf
->map_size
[blockflag
]) {
1070 int j
, iter_cond
= vf
->map
[blockflag
][i
];
1073 float two_cos_w
= 2.0f
* cos(wstep
* iter_cond
); // needed all times
1075 /* similar part for the q and p products */
1076 for (j
= 0; j
+ 1 < order
; j
+= 2) {
1077 q
*= lsp
[j
] - two_cos_w
;
1078 p
*= lsp
[j
+ 1] - two_cos_w
;
1080 if (j
== order
) { // even order
1081 p
*= p
* (2.0f
- two_cos_w
);
1082 q
*= q
* (2.0f
+ two_cos_w
);
1083 } else { // odd order
1084 q
*= two_cos_w
-lsp
[j
]; // one more time for q
1086 /* final step and square */
1087 p
*= p
* (4.f
- two_cos_w
* two_cos_w
);
1091 /* calculate linear floor value */
1093 q
= exp((((amplitude
*vf
->amplitude_offset
) /
1094 (((1 << vf
->amplitude_bits
) - 1) * sqrt(p
+ q
)))
1095 - vf
->amplitude_offset
) * .11512925f
);
1101 } while (vf
->map
[blockflag
][i
] == iter_cond
);
1105 /* this channel is unused */
1109 AV_DEBUG(" Floor0 decoded\n");
1114 static uint_fast8_t vorbis_floor1_decode(vorbis_context
*vc
,
1115 vorbis_floor_data
*vfu
, float *vec
)
1117 vorbis_floor1
*vf
= &vfu
->t1
;
1118 GetBitContext
*gb
= &vc
->gb
;
1119 uint_fast16_t range_v
[4] = { 256, 128, 86, 64 };
1120 uint_fast16_t range
= range_v
[vf
->multiplier
-1];
1121 uint_fast16_t floor1_Y
[vf
->x_list_dim
];
1122 uint_fast16_t floor1_Y_final
[vf
->x_list_dim
];
1123 int floor1_flag
[vf
->x_list_dim
];
1124 uint_fast8_t class_
;
1130 uint_fast16_t offset
;
1132 /*u*/int_fast16_t adx
, ady
, off
, predicted
; // WTF ? dy/adx = (unsigned)dy/adx ?
1133 int_fast16_t dy
, err
;
1136 if (!get_bits1(gb
)) // silence
1139 // Read values (or differences) for the floor's points
1141 floor1_Y
[0] = get_bits(gb
, ilog(range
- 1));
1142 floor1_Y
[1] = get_bits(gb
, ilog(range
- 1));
1144 AV_DEBUG("floor 0 Y %d floor 1 Y %d \n", floor1_Y
[0], floor1_Y
[1]);
1147 for (i
= 0; i
< vf
->partitions
; ++i
) {
1148 class_
= vf
->partition_class
[i
];
1149 cdim
= vf
->class_dimensions
[class_
];
1150 cbits
= vf
->class_subclasses
[class_
];
1151 csub
= (1 << cbits
) - 1;
1154 AV_DEBUG("Cbits %d \n", cbits
);
1156 if (cbits
) // this reads all subclasses for this partition's class
1157 cval
= get_vlc2(gb
, vc
->codebooks
[vf
->class_masterbook
[class_
]].vlc
.table
,
1158 vc
->codebooks
[vf
->class_masterbook
[class_
]].nb_bits
, 3);
1160 for (j
= 0; j
< cdim
; ++j
) {
1161 book
= vf
->subclass_books
[class_
][cval
& csub
];
1163 AV_DEBUG("book %d Cbits %d cval %d bits:%d \n", book
, cbits
, cval
, get_bits_count(gb
));
1165 cval
= cval
>> cbits
;
1167 floor1_Y
[offset
+j
] = get_vlc2(gb
, vc
->codebooks
[book
].vlc
.table
,
1168 vc
->codebooks
[book
].nb_bits
, 3);
1170 floor1_Y
[offset
+j
] = 0;
1173 AV_DEBUG(" floor(%d) = %d \n", vf
->list
[offset
+j
].x
, floor1_Y
[offset
+j
]);
1178 // Amplitude calculation from the differences
1182 floor1_Y_final
[0] = floor1_Y
[0];
1183 floor1_Y_final
[1] = floor1_Y
[1];
1185 for (i
= 2; i
< vf
->x_list_dim
; ++i
) {
1186 uint_fast16_t val
, highroom
, lowroom
, room
;
1187 uint_fast16_t high_neigh_offs
;
1188 uint_fast16_t low_neigh_offs
;
1190 low_neigh_offs
= vf
->list
[i
].low
;
1191 high_neigh_offs
= vf
->list
[i
].high
;
1192 dy
= floor1_Y_final
[high_neigh_offs
] - floor1_Y_final
[low_neigh_offs
]; // render_point begin
1193 adx
= vf
->list
[high_neigh_offs
].x
- vf
->list
[low_neigh_offs
].x
;
1195 err
= ady
* (vf
->list
[i
].x
- vf
->list
[low_neigh_offs
].x
);
1196 off
= (int16_t)err
/ (int16_t)adx
;
1198 predicted
= floor1_Y_final
[low_neigh_offs
] - off
;
1200 predicted
= floor1_Y_final
[low_neigh_offs
] + off
;
1201 } // render_point end
1204 highroom
= range
-predicted
;
1205 lowroom
= predicted
;
1206 if (highroom
< lowroom
) {
1207 room
= highroom
* 2;
1209 room
= lowroom
* 2; // SPEC mispelling
1212 floor1_flag
[low_neigh_offs
] = 1;
1213 floor1_flag
[high_neigh_offs
] = 1;
1216 if (highroom
> lowroom
) {
1217 floor1_Y_final
[i
] = val
- lowroom
+ predicted
;
1219 floor1_Y_final
[i
] = predicted
- val
+ highroom
- 1;
1223 floor1_Y_final
[i
] = predicted
- (val
+ 1) / 2;
1225 floor1_Y_final
[i
] = predicted
+ val
/ 2;
1230 floor1_Y_final
[i
] = predicted
;
1233 AV_DEBUG(" Decoded floor(%d) = %d / val %d \n", vf
->list
[i
].x
, floor1_Y_final
[i
], val
);
1236 // Curve synth - connect the calculated dots and convert from dB scale FIXME optimize ?
1238 ff_vorbis_floor1_render_list(vf
->list
, vf
->x_list_dim
, floor1_Y_final
, floor1_flag
, vf
->multiplier
, vec
, vf
->list
[1].x
);
1240 AV_DEBUG(" Floor decoded\n");
1245 // Read and decode residue
1247 static av_always_inline
int vorbis_residue_decode_internal(vorbis_context
*vc
,
1250 uint_fast8_t *do_not_decode
,
1255 GetBitContext
*gb
= &vc
->gb
;
1256 uint_fast8_t c_p_c
= vc
->codebooks
[vr
->classbook
].dimensions
;
1257 uint_fast16_t n_to_read
= vr
->end
-vr
->begin
;
1258 uint_fast16_t ptns_to_read
= n_to_read
/vr
->partition_size
;
1259 uint_fast8_t classifs
[ptns_to_read
*vc
->audio_channels
];
1261 uint_fast8_t ch_used
;
1266 for (j
= 1; j
< ch
; ++j
)
1267 do_not_decode
[0] &= do_not_decode
[j
]; // FIXME - clobbering input
1268 if (do_not_decode
[0])
1275 AV_DEBUG(" residue type 0/1/2 decode begin, ch: %d cpc %d \n", ch
, c_p_c
);
1277 for (pass
= 0; pass
<= vr
->maxpass
; ++pass
) { // FIXME OPTIMIZE?
1278 uint_fast16_t voffset
;
1279 uint_fast16_t partition_count
;
1280 uint_fast16_t j_times_ptns_to_read
;
1282 voffset
= vr
->begin
;
1283 for (partition_count
= 0; partition_count
< ptns_to_read
;) { // SPEC error
1285 uint_fast32_t inverse_class
= ff_inverse
[vr
->classifications
];
1286 for (j_times_ptns_to_read
= 0, j
= 0; j
< ch_used
; ++j
) {
1287 if (!do_not_decode
[j
]) {
1288 uint_fast32_t temp
= get_vlc2(gb
, vc
->codebooks
[vr
->classbook
].vlc
.table
,
1289 vc
->codebooks
[vr
->classbook
].nb_bits
, 3);
1291 AV_DEBUG("Classword: %d \n", temp
);
1293 assert(vr
->classifications
> 1 && temp
<= 65536); //needed for inverse[]
1294 for (i
= 0; i
< c_p_c
; ++i
) {
1295 uint_fast32_t temp2
;
1297 temp2
= (((uint_fast64_t)temp
) * inverse_class
) >> 32;
1298 if (partition_count
+ c_p_c
- 1 - i
< ptns_to_read
)
1299 classifs
[j_times_ptns_to_read
+ partition_count
+ c_p_c
- 1 - i
] = temp
- temp2
* vr
->classifications
;
1303 j_times_ptns_to_read
+= ptns_to_read
;
1306 for (i
= 0; (i
< c_p_c
) && (partition_count
< ptns_to_read
); ++i
) {
1307 for (j_times_ptns_to_read
= 0, j
= 0; j
< ch_used
; ++j
) {
1308 uint_fast16_t voffs
;
1310 if (!do_not_decode
[j
]) {
1311 uint_fast8_t vqclass
= classifs
[j_times_ptns_to_read
+partition_count
];
1312 int_fast16_t vqbook
= vr
->books
[vqclass
][pass
];
1314 if (vqbook
>= 0 && vc
->codebooks
[vqbook
].codevectors
) {
1315 uint_fast16_t coffs
;
1316 unsigned dim
= vc
->codebooks
[vqbook
].dimensions
; // not uint_fast8_t: 64bit is slower here on amd64
1317 uint_fast16_t step
= dim
== 1 ? vr
->partition_size
1318 : FASTDIV(vr
->partition_size
, dim
);
1319 vorbis_codebook codebook
= vc
->codebooks
[vqbook
];
1323 voffs
= voffset
+j
*vlen
;
1324 for (k
= 0; k
< step
; ++k
) {
1325 coffs
= get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * dim
;
1326 for (l
= 0; l
< dim
; ++l
)
1327 vec
[voffs
+ k
+ l
* step
] += codebook
.codevectors
[coffs
+ l
]; // FPMATH
1329 } else if (vr_type
== 1) {
1330 voffs
= voffset
+ j
* vlen
;
1331 for (k
= 0; k
< step
; ++k
) {
1332 coffs
= get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * dim
;
1333 for (l
= 0; l
< dim
; ++l
, ++voffs
) {
1334 vec
[voffs
]+=codebook
.codevectors
[coffs
+l
]; // FPMATH
1336 AV_DEBUG(" pass %d offs: %d curr: %f change: %f cv offs.: %d \n", pass
, voffs
, vec
[voffs
], codebook
.codevectors
[coffs
+l
], coffs
);
1339 } else if (vr_type
== 2 && ch
== 2 && (voffset
& 1) == 0 && (dim
& 1) == 0) { // most frequent case optimized
1340 voffs
= voffset
>> 1;
1343 for (k
= 0; k
< step
; ++k
) {
1344 coffs
= get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * 2;
1345 vec
[voffs
+ k
] += codebook
.codevectors
[coffs
]; // FPMATH
1346 vec
[voffs
+ k
+ vlen
] += codebook
.codevectors
[coffs
+ 1]; // FPMATH
1348 } else if (dim
== 4) {
1349 for (k
= 0; k
< step
; ++k
, voffs
+= 2) {
1350 coffs
= get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * 4;
1351 vec
[voffs
] += codebook
.codevectors
[coffs
]; // FPMATH
1352 vec
[voffs
+ 1 ] += codebook
.codevectors
[coffs
+ 2]; // FPMATH
1353 vec
[voffs
+ vlen
] += codebook
.codevectors
[coffs
+ 1]; // FPMATH
1354 vec
[voffs
+ vlen
+ 1] += codebook
.codevectors
[coffs
+ 3]; // FPMATH
1357 for (k
= 0; k
< step
; ++k
) {
1358 coffs
= get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * dim
;
1359 for (l
= 0; l
< dim
; l
+= 2, voffs
++) {
1360 vec
[voffs
] += codebook
.codevectors
[coffs
+ l
]; // FPMATH
1361 vec
[voffs
+ vlen
] += codebook
.codevectors
[coffs
+ l
+ 1]; // FPMATH
1363 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
);
1367 } else if (vr_type
== 2) {
1370 for (k
= 0; k
< step
; ++k
) {
1371 coffs
= get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * dim
;
1372 for (l
= 0; l
< dim
; ++l
, ++voffs
) {
1373 vec
[voffs
/ ch
+ (voffs
% ch
) * vlen
] += codebook
.codevectors
[coffs
+ l
]; // FPMATH FIXME use if and counter instead of / and %
1375 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
);
1381 j_times_ptns_to_read
+= ptns_to_read
;
1384 voffset
+= vr
->partition_size
;
1391 static inline int vorbis_residue_decode(vorbis_context
*vc
, vorbis_residue
*vr
,
1393 uint_fast8_t *do_not_decode
,
1394 float *vec
, uint_fast16_t vlen
)
1397 return vorbis_residue_decode_internal(vc
, vr
, ch
, do_not_decode
, vec
, vlen
, 2);
1398 else if (vr
->type
== 1)
1399 return vorbis_residue_decode_internal(vc
, vr
, ch
, do_not_decode
, vec
, vlen
, 1);
1400 else if (vr
->type
== 0)
1401 return vorbis_residue_decode_internal(vc
, vr
, ch
, do_not_decode
, vec
, vlen
, 0);
1403 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Invalid residue type while residue decode?! \n");
1408 void vorbis_inverse_coupling(float *mag
, float *ang
, int blocksize
)
1411 for (i
= 0; i
< blocksize
; i
++) {
1414 ang
[i
] = mag
[i
] - ang
[i
];
1416 float temp
= ang
[i
];
1424 float temp
= ang
[i
];
1432 static void copy_normalize(float *dst
, float *src
, int len
, int exp_bias
,
1437 memcpy(dst
, src
, len
* sizeof(float));
1439 for (i
= 0; i
< len
; i
++)
1440 dst
[i
] = src
[i
] + add_bias
;
1444 // Decode the audio packet using the functions above
1446 static int vorbis_parse_audio_packet(vorbis_context
*vc
)
1448 GetBitContext
*gb
= &vc
->gb
;
1450 uint_fast8_t previous_window
= vc
->previous_window
;
1451 uint_fast8_t mode_number
;
1452 uint_fast8_t blockflag
;
1453 uint_fast16_t blocksize
;
1455 uint_fast8_t no_residue
[vc
->audio_channels
];
1456 uint_fast8_t do_not_decode
[vc
->audio_channels
];
1457 vorbis_mapping
*mapping
;
1458 float *ch_res_ptr
= vc
->channel_residues
;
1459 float *ch_floor_ptr
= vc
->channel_floors
;
1460 uint_fast8_t res_chan
[vc
->audio_channels
];
1461 uint_fast8_t res_num
= 0;
1462 int_fast16_t retlen
= 0;
1463 float fadd_bias
= vc
->add_bias
;
1465 if (get_bits1(gb
)) {
1466 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Not a Vorbis I audio packet.\n");
1467 return -1; // packet type not audio
1470 if (vc
->mode_count
== 1) {
1473 GET_VALIDATED_INDEX(mode_number
, ilog(vc
->mode_count
-1), vc
->mode_count
)
1475 vc
->mode_number
= mode_number
;
1476 mapping
= &vc
->mappings
[vc
->modes
[mode_number
].mapping
];
1478 AV_DEBUG(" Mode number: %d , mapping: %d , blocktype %d \n", mode_number
, vc
->modes
[mode_number
].mapping
, vc
->modes
[mode_number
].blockflag
);
1480 blockflag
= vc
->modes
[mode_number
].blockflag
;
1481 blocksize
= vc
->blocksize
[blockflag
];
1483 skip_bits(gb
, 2); // previous_window, next_window
1485 memset(ch_res_ptr
, 0, sizeof(float) * vc
->audio_channels
* blocksize
/ 2); //FIXME can this be removed ?
1486 memset(ch_floor_ptr
, 0, sizeof(float) * vc
->audio_channels
* blocksize
/ 2); //FIXME can this be removed ?
1490 for (i
= 0; i
< vc
->audio_channels
; ++i
) {
1491 vorbis_floor
*floor
;
1492 if (mapping
->submaps
> 1) {
1493 floor
= &vc
->floors
[mapping
->submap_floor
[mapping
->mux
[i
]]];
1495 floor
= &vc
->floors
[mapping
->submap_floor
[0]];
1498 no_residue
[i
] = floor
->decode(vc
, &floor
->data
, ch_floor_ptr
);
1499 ch_floor_ptr
+= blocksize
/ 2;
1502 // Nonzero vector propagate
1504 for (i
= mapping
->coupling_steps
- 1; i
>= 0; --i
) {
1505 if (!(no_residue
[mapping
->magnitude
[i
]] & no_residue
[mapping
->angle
[i
]])) {
1506 no_residue
[mapping
->magnitude
[i
]] = 0;
1507 no_residue
[mapping
->angle
[i
]] = 0;
1513 for (i
= 0; i
< mapping
->submaps
; ++i
) {
1514 vorbis_residue
*residue
;
1515 uint_fast8_t ch
= 0;
1517 for (j
= 0; j
< vc
->audio_channels
; ++j
) {
1518 if ((mapping
->submaps
== 1) || (i
== mapping
->mux
[j
])) {
1519 res_chan
[j
] = res_num
;
1520 if (no_residue
[j
]) {
1521 do_not_decode
[ch
] = 1;
1523 do_not_decode
[ch
] = 0;
1529 residue
= &vc
->residues
[mapping
->submap_residue
[i
]];
1530 vorbis_residue_decode(vc
, residue
, ch
, do_not_decode
, ch_res_ptr
, blocksize
/2);
1532 ch_res_ptr
+= ch
* blocksize
/ 2;
1537 for (i
= mapping
->coupling_steps
- 1; i
>= 0; --i
) { //warning: i has to be signed
1540 mag
= vc
->channel_residues
+res_chan
[mapping
->magnitude
[i
]] * blocksize
/ 2;
1541 ang
= vc
->channel_residues
+res_chan
[mapping
->angle
[i
]] * blocksize
/ 2;
1542 vc
->dsp
.vorbis_inverse_coupling(mag
, ang
, blocksize
/ 2);
1547 for (j
= vc
->audio_channels
-1;j
>= 0; j
--) {
1548 ch_floor_ptr
= vc
->channel_floors
+ j
* blocksize
/ 2;
1549 ch_res_ptr
= vc
->channel_residues
+ res_chan
[j
] * blocksize
/ 2;
1550 vc
->dsp
.vector_fmul(ch_floor_ptr
, ch_res_ptr
, blocksize
/ 2);
1551 ff_imdct_half(&vc
->mdct
[blockflag
], ch_res_ptr
, ch_floor_ptr
);
1554 // Overlap/add, save data for next overlapping FPMATH
1556 retlen
= (blocksize
+ vc
->blocksize
[previous_window
]) / 4;
1557 for (j
= 0; j
< vc
->audio_channels
; j
++) {
1558 uint_fast16_t bs0
= vc
->blocksize
[0];
1559 uint_fast16_t bs1
= vc
->blocksize
[1];
1560 float *residue
= vc
->channel_residues
+ res_chan
[j
] * blocksize
/ 2;
1561 float *saved
= vc
->saved
+ j
* bs1
/ 4;
1562 float *ret
= vc
->channel_floors
+ j
* retlen
;
1563 float *buf
= residue
;
1564 const float *win
= vc
->win
[blockflag
& previous_window
];
1566 if (blockflag
== previous_window
) {
1567 vc
->dsp
.vector_fmul_window(ret
, saved
, buf
, win
, fadd_bias
, blocksize
/ 4);
1568 } else if (blockflag
> previous_window
) {
1569 vc
->dsp
.vector_fmul_window(ret
, saved
, buf
, win
, fadd_bias
, bs0
/ 4);
1570 copy_normalize(ret
+bs0
/2, buf
+bs0
/4, (bs1
-bs0
)/4, vc
->exp_bias
, fadd_bias
);
1572 copy_normalize(ret
, saved
, (bs1
- bs0
) / 4, vc
->exp_bias
, fadd_bias
);
1573 vc
->dsp
.vector_fmul_window(ret
+ (bs1
- bs0
) / 4, saved
+ (bs1
- bs0
) / 4, buf
, win
, fadd_bias
, bs0
/ 4);
1575 memcpy(saved
, buf
+ blocksize
/ 4, blocksize
/ 4 * sizeof(float));
1578 vc
->previous_window
= blockflag
;
1582 // Return the decoded audio packet through the standard api
1584 static int vorbis_decode_frame(AVCodecContext
*avccontext
,
1585 void *data
, int *data_size
,
1588 const uint8_t *buf
= avpkt
->data
;
1589 int buf_size
= avpkt
->size
;
1590 vorbis_context
*vc
= avccontext
->priv_data
;
1591 GetBitContext
*gb
= &(vc
->gb
);
1592 const float *channel_ptrs
[vc
->audio_channels
];
1600 AV_DEBUG("packet length %d \n", buf_size
);
1602 init_get_bits(gb
, buf
, buf_size
*8);
1604 len
= vorbis_parse_audio_packet(vc
);
1611 if (!vc
->first_frame
) {
1612 vc
->first_frame
= 1;
1617 AV_DEBUG("parsed %d bytes %d bits, returned %d samples (*ch*bits) \n", get_bits_count(gb
)/8, get_bits_count(gb
)%8, len
);
1619 if (vc
->audio_channels
> 6) {
1620 for (i
= 0; i
< vc
->audio_channels
; i
++)
1621 channel_ptrs
[i
] = vc
->channel_floors
+ i
* len
;
1623 for (i
= 0; i
< vc
->audio_channels
; i
++)
1624 channel_ptrs
[i
] = vc
->channel_floors
+
1625 len
* ff_vorbis_channel_layout_offsets
[vc
->audio_channels
- 1][i
];
1628 vc
->dsp
.float_to_int16_interleave(data
, channel_ptrs
, len
, vc
->audio_channels
);
1629 *data_size
= len
* 2 * vc
->audio_channels
;
1636 static av_cold
int vorbis_decode_close(AVCodecContext
*avccontext
)
1638 vorbis_context
*vc
= avccontext
->priv_data
;
1645 AVCodec vorbis_decoder
= {
1649 sizeof(vorbis_context
),
1652 vorbis_decode_close
,
1653 vorbis_decode_frame
,
1654 .long_name
= NULL_IF_CONFIG_SMALL("Vorbis"),
1655 .channel_layouts
= ff_vorbis_channel_layouts
,