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 float vorbisfloat2float(uint_fast32_t val
)
165 double mant
= val
& 0x1fffff;
166 long exp
= (val
& 0x7fe00000L
) >> 21;
167 if (val
& 0x80000000)
169 return ldexp(mant
, exp
- 20 - 768);
173 // Free all allocated memory -----------------------------------------
175 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
);
202 av_free(vc
->floors
[i
].data
.t1
.list
);
205 av_freep(&vc
->floors
);
207 for (i
= 0; i
< vc
->mapping_count
; ++i
) {
208 av_free(vc
->mappings
[i
].magnitude
);
209 av_free(vc
->mappings
[i
].angle
);
210 av_free(vc
->mappings
[i
].mux
);
212 av_freep(&vc
->mappings
);
215 // Parse setup header -------------------------------------------------
217 // Process codebooks part
219 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
) {
274 flag
= get_bits1(gb
);
276 tmp_vlc_bits
[ce
] = get_bits(gb
, 5) + 1;
279 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;
289 uint_fast16_t current_entry
= 0;
290 uint_fast8_t current_length
= get_bits(gb
, 5)+1;
292 AV_DEBUG(" ordered, current length: %d \n", current_length
); //FIXME
294 used_entries
= entries
;
295 for (; current_entry
< used_entries
&& current_length
<= 32; ++current_length
) {
296 uint_fast16_t i
, number
;
298 AV_DEBUG(" number bits: %d ", ilog(entries
- current_entry
));
300 number
= get_bits(gb
, ilog(entries
- current_entry
));
302 AV_DEBUG(" number: %d \n", number
);
304 for (i
= current_entry
; i
< number
+current_entry
; ++i
)
305 if (i
< used_entries
)
306 tmp_vlc_bits
[i
] = current_length
;
308 current_entry
+=number
;
310 if (current_entry
>used_entries
) {
311 av_log(vc
->avccontext
, AV_LOG_ERROR
, " More codelengths than codes in codebook. \n");
316 codebook_setup
->lookup_type
= get_bits(gb
, 4);
318 AV_DEBUG(" lookup type: %d : %s \n", codebook_setup
->lookup_type
, codebook_setup
->lookup_type
? "vq" : "no lookup");
320 // If the codebook is used for (inverse) VQ, calculate codevectors.
322 if (codebook_setup
->lookup_type
== 1) {
323 uint_fast16_t i
, j
, k
;
324 uint_fast16_t codebook_lookup_values
= ff_vorbis_nth_root(entries
, codebook_setup
->dimensions
);
325 uint_fast16_t codebook_multiplicands
[codebook_lookup_values
];
327 float codebook_minimum_value
= vorbisfloat2float(get_bits_long(gb
, 32));
328 float codebook_delta_value
= vorbisfloat2float(get_bits_long(gb
, 32));
329 uint_fast8_t codebook_value_bits
= get_bits(gb
, 4)+1;
330 uint_fast8_t codebook_sequence_p
= get_bits1(gb
);
332 AV_DEBUG(" We expect %d numbers for building the codevectors. \n", codebook_lookup_values
);
333 AV_DEBUG(" delta %f minmum %f \n", codebook_delta_value
, codebook_minimum_value
);
335 for (i
= 0; i
< codebook_lookup_values
; ++i
) {
336 codebook_multiplicands
[i
] = get_bits(gb
, codebook_value_bits
);
338 AV_DEBUG(" multiplicands*delta+minmum : %e \n", (float)codebook_multiplicands
[i
]*codebook_delta_value
+codebook_minimum_value
);
339 AV_DEBUG(" multiplicand %d \n", codebook_multiplicands
[i
]);
342 // Weed out unused vlcs and build codevector vector
343 codebook_setup
->codevectors
= used_entries
? av_mallocz(used_entries
*codebook_setup
->dimensions
* sizeof(float)) : NULL
;
344 for (j
= 0, i
= 0; i
< entries
; ++i
) {
345 uint_fast8_t dim
= codebook_setup
->dimensions
;
347 if (tmp_vlc_bits
[i
]) {
349 uint_fast32_t lookup_offset
= i
;
352 av_log(vc
->avccontext
, AV_LOG_INFO
, "Lookup offset %d ,", i
);
355 for (k
= 0; k
< dim
; ++k
) {
356 uint_fast32_t multiplicand_offset
= lookup_offset
% codebook_lookup_values
;
357 codebook_setup
->codevectors
[j
* dim
+ k
] = codebook_multiplicands
[multiplicand_offset
] * codebook_delta_value
+ codebook_minimum_value
+ last
;
358 if (codebook_sequence_p
)
359 last
= codebook_setup
->codevectors
[j
* dim
+ k
];
360 lookup_offset
/=codebook_lookup_values
;
362 tmp_vlc_bits
[j
] = tmp_vlc_bits
[i
];
365 av_log(vc
->avccontext
, AV_LOG_INFO
, "real lookup offset %d, vector: ", j
);
366 for (k
= 0; k
< dim
; ++k
)
367 av_log(vc
->avccontext
, AV_LOG_INFO
, " %f ", codebook_setup
->codevectors
[j
* dim
+ k
]);
368 av_log(vc
->avccontext
, AV_LOG_INFO
, "\n");
374 if (j
!= used_entries
) {
375 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Bug in codevector vector building code. \n");
378 entries
= used_entries
;
379 } else if (codebook_setup
->lookup_type
>= 2) {
380 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Codebook lookup type not supported. \n");
384 // Initialize VLC table
385 if (ff_vorbis_len2vlc(tmp_vlc_bits
, tmp_vlc_codes
, entries
)) {
386 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Invalid code lengths while generating vlcs. \n");
389 codebook_setup
->maxdepth
= 0;
390 for (t
= 0; t
< entries
; ++t
)
391 if (tmp_vlc_bits
[t
] >= codebook_setup
->maxdepth
)
392 codebook_setup
->maxdepth
= tmp_vlc_bits
[t
];
394 if (codebook_setup
->maxdepth
> 3 * V_NB_BITS
)
395 codebook_setup
->nb_bits
= V_NB_BITS2
;
397 codebook_setup
->nb_bits
= V_NB_BITS
;
399 codebook_setup
->maxdepth
= (codebook_setup
->maxdepth
+codebook_setup
->nb_bits
- 1) / codebook_setup
->nb_bits
;
401 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
)) {
402 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Error generating vlc tables. \n");
407 av_free(tmp_vlc_bits
);
408 av_free(tmp_vlc_codes
);
413 av_free(tmp_vlc_bits
);
414 av_free(tmp_vlc_codes
);
418 // Process time domain transforms part (unused in Vorbis I)
420 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
)
448 GetBitContext
*gb
= &vc
->gb
;
451 vc
->floor_count
= get_bits(gb
, 6) + 1;
453 vc
->floors
= av_mallocz(vc
->floor_count
* sizeof(vorbis_floor
));
455 for (i
= 0; i
< vc
->floor_count
; ++i
) {
456 vorbis_floor
*floor_setup
= &vc
->floors
[i
];
458 floor_setup
->floor_type
= get_bits(gb
, 16);
460 AV_DEBUG(" %d. floor type %d \n", i
, floor_setup
->floor_type
);
462 if (floor_setup
->floor_type
== 1) {
463 uint_fast8_t maximum_class
= 0;
464 uint_fast8_t rangebits
;
465 uint_fast16_t floor1_values
= 2;
467 floor_setup
->decode
= vorbis_floor1_decode
;
469 floor_setup
->data
.t1
.partitions
= get_bits(gb
, 5);
471 AV_DEBUG(" %d.floor: %d partitions \n", i
, floor_setup
->data
.t1
.partitions
);
473 for (j
= 0; j
< floor_setup
->data
.t1
.partitions
; ++j
) {
474 floor_setup
->data
.t1
.partition_class
[j
] = get_bits(gb
, 4);
475 if (floor_setup
->data
.t1
.partition_class
[j
] > maximum_class
)
476 maximum_class
= floor_setup
->data
.t1
.partition_class
[j
];
478 AV_DEBUG(" %d. floor %d partition class %d \n", i
, j
, floor_setup
->data
.t1
.partition_class
[j
]);
482 AV_DEBUG(" maximum class %d \n", maximum_class
);
484 floor_setup
->data
.t1
.maximum_class
= maximum_class
;
486 for (j
= 0; j
<= maximum_class
; ++j
) {
487 floor_setup
->data
.t1
.class_dimensions
[j
] = get_bits(gb
, 3) + 1;
488 floor_setup
->data
.t1
.class_subclasses
[j
] = get_bits(gb
, 2);
490 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
]);
492 if (floor_setup
->data
.t1
.class_subclasses
[j
]) {
493 int bits
= get_bits(gb
, 8);
494 if (bits
>= vc
->codebook_count
) {
495 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Masterbook index %d is out of range.\n", bits
);
498 floor_setup
->data
.t1
.class_masterbook
[j
] = bits
;
500 AV_DEBUG(" masterbook: %d \n", floor_setup
->data
.t1
.class_masterbook
[j
]);
503 for (k
= 0; k
< (1 << floor_setup
->data
.t1
.class_subclasses
[j
]); ++k
) {
504 int16_t bits
= get_bits(gb
, 8) - 1;
505 if (bits
!= -1 && bits
>= vc
->codebook_count
) {
506 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Subclass book index %d is out of range.\n", bits
);
509 floor_setup
->data
.t1
.subclass_books
[j
][k
] = bits
;
511 AV_DEBUG(" book %d. : %d \n", k
, floor_setup
->data
.t1
.subclass_books
[j
][k
]);
515 floor_setup
->data
.t1
.multiplier
= get_bits(gb
, 2) + 1;
516 floor_setup
->data
.t1
.x_list_dim
= 2;
518 for (j
= 0; j
< floor_setup
->data
.t1
.partitions
; ++j
)
519 floor_setup
->data
.t1
.x_list_dim
+=floor_setup
->data
.t1
.class_dimensions
[floor_setup
->data
.t1
.partition_class
[j
]];
521 floor_setup
->data
.t1
.list
= av_mallocz(floor_setup
->data
.t1
.x_list_dim
* sizeof(vorbis_floor1_entry
));
524 rangebits
= get_bits(gb
, 4);
525 floor_setup
->data
.t1
.list
[0].x
= 0;
526 floor_setup
->data
.t1
.list
[1].x
= (1 << rangebits
);
528 for (j
= 0; j
< floor_setup
->data
.t1
.partitions
; ++j
) {
529 for (k
= 0; k
< floor_setup
->data
.t1
.class_dimensions
[floor_setup
->data
.t1
.partition_class
[j
]]; ++k
, ++floor1_values
) {
530 floor_setup
->data
.t1
.list
[floor1_values
].x
= get_bits(gb
, rangebits
);
532 AV_DEBUG(" %d. floor1 Y coord. %d \n", floor1_values
, floor_setup
->data
.t1
.list
[floor1_values
].x
);
536 // Precalculate order of x coordinates - needed for decode
537 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
)
562 /* read book indexes */
565 uint_fast8_t book_idx
;
566 for (idx
= 0; idx
< floor_setup
->data
.t0
.num_books
; ++idx
) {
567 book_idx
= get_bits(gb
, 8);
568 if (book_idx
>= vc
->codebook_count
)
570 floor_setup
->data
.t0
.book_list
[idx
] = book_idx
;
571 if (vc
->codebooks
[book_idx
].dimensions
> max_codebook_dim
)
572 max_codebook_dim
= vc
->codebooks
[book_idx
].dimensions
;
578 /* allocate mem for lsp coefficients */
580 /* codebook dim is for padding if codebook dim doesn't *
581 * divide order+1 then we need to read more data */
582 floor_setup
->data
.t0
.lsp
=
583 av_malloc((floor_setup
->data
.t0
.order
+1 + max_codebook_dim
)
585 if (!floor_setup
->data
.t0
.lsp
)
589 #ifdef V_DEBUG /* debug output parsed headers */
590 AV_DEBUG("floor0 order: %u\n", floor_setup
->data
.t0
.order
);
591 AV_DEBUG("floor0 rate: %u\n", floor_setup
->data
.t0
.rate
);
592 AV_DEBUG("floor0 bark map size: %u\n",
593 floor_setup
->data
.t0
.bark_map_size
);
594 AV_DEBUG("floor0 amplitude bits: %u\n",
595 floor_setup
->data
.t0
.amplitude_bits
);
596 AV_DEBUG("floor0 amplitude offset: %u\n",
597 floor_setup
->data
.t0
.amplitude_offset
);
598 AV_DEBUG("floor0 number of books: %u\n",
599 floor_setup
->data
.t0
.num_books
);
600 AV_DEBUG("floor0 book list pointer: %p\n",
601 floor_setup
->data
.t0
.book_list
);
604 for (idx
= 0; idx
< floor_setup
->data
.t0
.num_books
; ++idx
) {
605 AV_DEBUG(" Book %d: %u\n",
607 floor_setup
->data
.t0
.book_list
[idx
]);
612 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Invalid floor type!\n");
619 // Process residues part
621 static int vorbis_parse_setup_hdr_residues(vorbis_context
*vc
)
623 GetBitContext
*gb
= &vc
->gb
;
624 uint_fast8_t i
, j
, k
;
626 vc
->residue_count
= get_bits(gb
, 6)+1;
627 vc
->residues
= av_mallocz(vc
->residue_count
* sizeof(vorbis_residue
));
629 AV_DEBUG(" There are %d residues. \n", vc
->residue_count
);
631 for (i
= 0; i
< vc
->residue_count
; ++i
) {
632 vorbis_residue
*res_setup
= &vc
->residues
[i
];
633 uint_fast8_t cascade
[64];
634 uint_fast8_t high_bits
;
635 uint_fast8_t low_bits
;
637 res_setup
->type
= get_bits(gb
, 16);
639 AV_DEBUG(" %d. residue type %d \n", i
, res_setup
->type
);
641 res_setup
->begin
= get_bits(gb
, 24);
642 res_setup
->end
= get_bits(gb
, 24);
643 res_setup
->partition_size
= get_bits(gb
, 24) + 1;
644 /* Validations to prevent a buffer overflow later. */
645 if (res_setup
->begin
>res_setup
->end
||
646 res_setup
->end
>vc
->blocksize
[1] / (res_setup
->type
== 2 ? 1 : 2) ||
647 (res_setup
->end
-res_setup
->begin
) / res_setup
->partition_size
> V_MAX_PARTITIONS
) {
648 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);
652 res_setup
->classifications
= get_bits(gb
, 6) + 1;
653 res_setup
->classbook
= get_bits(gb
, 8);
654 if (res_setup
->classbook
>= vc
->codebook_count
) {
655 av_log(vc
->avccontext
, AV_LOG_ERROR
, "classbook value %d out of range. \n", res_setup
->classbook
);
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 int bits
= get_bits(gb
, 8);
677 if (bits
>= vc
->codebook_count
) {
678 av_log(vc
->avccontext
, AV_LOG_ERROR
, "book value %d out of range. \n", bits
);
681 res_setup
->books
[j
][k
] = bits
;
683 AV_DEBUG(" %d class casscade depth %d book: %d \n", j
, k
, res_setup
->books
[j
][k
]);
685 if (k
>res_setup
->maxpass
)
686 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
)
700 GetBitContext
*gb
= &vc
->gb
;
703 vc
->mapping_count
= get_bits(gb
, 6)+1;
704 vc
->mappings
= av_mallocz(vc
->mapping_count
* sizeof(vorbis_mapping
));
706 AV_DEBUG(" There are %d mappings. \n", vc
->mapping_count
);
708 for (i
= 0; i
< vc
->mapping_count
; ++i
) {
709 vorbis_mapping
*mapping_setup
= &vc
->mappings
[i
];
711 if (get_bits(gb
, 16)) {
712 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Other mappings than type 0 are not compliant with the Vorbis I specification. \n");
716 mapping_setup
->submaps
= get_bits(gb
, 4) + 1;
718 mapping_setup
->submaps
= 1;
722 mapping_setup
->coupling_steps
= get_bits(gb
, 8) + 1;
723 mapping_setup
->magnitude
= av_mallocz(mapping_setup
->coupling_steps
* sizeof(uint_fast8_t));
724 mapping_setup
->angle
= av_mallocz(mapping_setup
->coupling_steps
* sizeof(uint_fast8_t));
725 for (j
= 0; j
< mapping_setup
->coupling_steps
; ++j
) {
726 mapping_setup
->magnitude
[j
] = get_bits(gb
, ilog(vc
->audio_channels
- 1));
727 mapping_setup
->angle
[j
] = get_bits(gb
, ilog(vc
->audio_channels
- 1));
728 if (mapping_setup
->magnitude
[j
] >= vc
->audio_channels
) {
729 av_log(vc
->avccontext
, AV_LOG_ERROR
, "magnitude channel %d out of range. \n", mapping_setup
->magnitude
[j
]);
732 if (mapping_setup
->angle
[j
] >= vc
->audio_channels
) {
733 av_log(vc
->avccontext
, AV_LOG_ERROR
, "angle channel %d out of range. \n", mapping_setup
->angle
[j
]);
738 mapping_setup
->coupling_steps
= 0;
741 AV_DEBUG(" %d mapping coupling steps: %d \n", i
, mapping_setup
->coupling_steps
);
743 if (get_bits(gb
, 2)) {
744 av_log(vc
->avccontext
, AV_LOG_ERROR
, "%d. mapping setup data invalid. \n", i
);
745 return -1; // following spec.
748 if (mapping_setup
->submaps
>1) {
749 mapping_setup
->mux
= av_mallocz(vc
->audio_channels
* sizeof(uint_fast8_t));
750 for (j
= 0; j
< vc
->audio_channels
; ++j
)
751 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
) {
788 n
= vc
->blocksize
[blockflag
] / 2;
789 floors
[floor_number
].data
.t0
.map
[blockflag
] =
790 av_malloc((n
+1) * sizeof(int_fast32_t)); // n + sentinel
792 map
= floors
[floor_number
].data
.t0
.map
[blockflag
];
793 vf
= &floors
[floor_number
].data
.t0
;
795 for (idx
= 0; idx
< n
; ++idx
) {
796 map
[idx
] = floor(BARK((vf
->rate
* idx
) / (2.0f
* n
)) *
797 ((vf
->bark_map_size
) /
798 BARK(vf
->rate
/ 2.0f
)));
799 if (vf
->bark_map_size
-1 < map
[idx
])
800 map
[idx
] = vf
->bark_map_size
- 1;
803 vf
->map_size
[blockflag
] = n
;
807 for (idx
= 0; idx
<= n
; ++idx
) {
808 AV_DEBUG("floor0 map: map at pos %d is %d\n",
814 static int vorbis_parse_setup_hdr_modes(vorbis_context
*vc
)
816 GetBitContext
*gb
= &vc
->gb
;
819 vc
->mode_count
= get_bits(gb
, 6) + 1;
820 vc
->modes
= av_mallocz(vc
->mode_count
* sizeof(vorbis_mode
));
822 AV_DEBUG(" There are %d modes.\n", vc
->mode_count
);
824 for (i
= 0; i
< vc
->mode_count
; ++i
) {
825 vorbis_mode
*mode_setup
= &vc
->modes
[i
];
827 mode_setup
->blockflag
= get_bits1(gb
);
828 mode_setup
->windowtype
= get_bits(gb
, 16); //FIXME check
829 mode_setup
->transformtype
= get_bits(gb
, 16); //FIXME check
830 mode_setup
->mapping
= get_bits(gb
, 8);
831 if (mode_setup
->mapping
>= vc
->mapping_count
) {
832 av_log(vc
->avccontext
, AV_LOG_ERROR
, "mode mapping value %d out of range. \n", mode_setup
->mapping
);
836 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
);
841 // Process the whole setup header using the functions above
843 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
)
890 GetBitContext
*gb
= &vc
->gb
;
891 uint_fast8_t bl0
, bl1
;
893 if ((get_bits(gb
, 8) != 'v') || (get_bits(gb
, 8) != 'o') ||
894 (get_bits(gb
, 8) != 'r') || (get_bits(gb
, 8) != 'b') ||
895 (get_bits(gb
, 8) != 'i') || (get_bits(gb
, 8) != 's')) {
896 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis id header packet corrupt (no vorbis signature). \n");
900 vc
->version
= get_bits_long(gb
, 32); //FIXME check 0
901 vc
->audio_channels
= get_bits(gb
, 8);
902 if (vc
->audio_channels
<= 0) {
903 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Invalid number of channels\n");
906 vc
->audio_samplerate
= get_bits_long(gb
, 32);
907 if (vc
->audio_samplerate
<= 0) {
908 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Invalid samplerate\n");
911 vc
->bitrate_maximum
= get_bits_long(gb
, 32);
912 vc
->bitrate_nominal
= get_bits_long(gb
, 32);
913 vc
->bitrate_minimum
= get_bits_long(gb
, 32);
914 bl0
= get_bits(gb
, 4);
915 bl1
= get_bits(gb
, 4);
916 vc
->blocksize
[0] = (1 << bl0
);
917 vc
->blocksize
[1] = (1 << bl1
);
918 if (bl0
> 13 || bl0
< 6 || bl1
> 13 || bl1
< 6 || bl1
< bl0
) {
919 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Vorbis id header packet corrupt (illegal blocksize). \n");
922 // output format int16
923 if (vc
->blocksize
[1] / 2 * vc
->audio_channels
* 2 > 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
)
961 vorbis_context
*vc
= avccontext
->priv_data
;
962 uint8_t *headers
= avccontext
->extradata
;
963 int headers_len
= avccontext
->extradata_size
;
964 uint8_t *header_start
[3];
966 GetBitContext
*gb
= &(vc
->gb
);
969 vc
->avccontext
= avccontext
;
970 dsputil_init(&vc
->dsp
, avccontext
);
972 if (vc
->dsp
.float_to_int16_interleave
== ff_float_to_int16_interleave_c
) {
977 vc
->exp_bias
= 15 << 23;
981 av_log(avccontext
, AV_LOG_ERROR
, "Extradata corrupt.\n");
985 if (ff_split_xiph_headers(headers
, headers_len
, 30, header_start
, header_len
) < 0) {
986 av_log(avccontext
, AV_LOG_ERROR
, "Extradata corrupt.\n");
990 init_get_bits(gb
, header_start
[0], header_len
[0]*8);
991 hdr_type
= get_bits(gb
, 8);
993 av_log(avccontext
, AV_LOG_ERROR
, "First header is not the id header.\n");
996 if (vorbis_parse_id_hdr(vc
)) {
997 av_log(avccontext
, AV_LOG_ERROR
, "Id header corrupt.\n");
1002 init_get_bits(gb
, header_start
[2], header_len
[2]*8);
1003 hdr_type
= get_bits(gb
, 8);
1004 if (hdr_type
!= 5) {
1005 av_log(avccontext
, AV_LOG_ERROR
, "Third header is not the setup header.\n");
1009 if (vorbis_parse_setup_hdr(vc
)) {
1010 av_log(avccontext
, AV_LOG_ERROR
, "Setup header corrupt.\n");
1015 if (vc
->audio_channels
> 6)
1016 avccontext
->channel_layout
= 0;
1018 avccontext
->channel_layout
= ff_vorbis_channel_layouts
[vc
->audio_channels
- 1];
1020 avccontext
->channels
= vc
->audio_channels
;
1021 avccontext
->sample_rate
= vc
->audio_samplerate
;
1022 avccontext
->frame_size
= FFMIN(vc
->blocksize
[0], vc
->blocksize
[1]) >> 2;
1023 avccontext
->sample_fmt
= SAMPLE_FMT_S16
;
1028 // Decode audiopackets -------------------------------------------------
1030 // Read and decode floor
1032 static uint_fast8_t vorbis_floor0_decode(vorbis_context
*vc
,
1033 vorbis_floor_data
*vfu
, float *vec
)
1035 vorbis_floor0
*vf
= &vfu
->t0
;
1036 float *lsp
= vf
->lsp
;
1037 uint_fast32_t amplitude
;
1038 uint_fast32_t book_idx
;
1039 uint_fast8_t blockflag
= vc
->modes
[vc
->mode_number
].blockflag
;
1041 amplitude
= get_bits(&vc
->gb
, vf
->amplitude_bits
);
1042 if (amplitude
> 0) {
1044 uint_fast16_t lsp_len
= 0;
1046 vorbis_codebook codebook
;
1048 book_idx
= get_bits(&vc
->gb
, ilog(vf
->num_books
));
1049 if (book_idx
>= vf
->num_books
) {
1050 av_log(vc
->avccontext
, AV_LOG_ERROR
,
1051 "floor0 dec: booknumber too high!\n");
1055 AV_DEBUG("floor0 dec: booknumber: %u\n", book_idx
);
1056 codebook
= vc
->codebooks
[vf
->book_list
[book_idx
]];
1058 while (lsp_len
<vf
->order
) {
1061 AV_DEBUG("floor0 dec: book dimension: %d\n", codebook
.dimensions
);
1062 AV_DEBUG("floor0 dec: maximum depth: %d\n", codebook
.maxdepth
);
1063 /* read temp vector */
1064 vec_off
= get_vlc2(&vc
->gb
, codebook
.vlc
.table
,
1065 codebook
.nb_bits
, codebook
.maxdepth
)
1066 * codebook
.dimensions
;
1067 AV_DEBUG("floor0 dec: vector offset: %d\n", vec_off
);
1068 /* copy each vector component and add last to it */
1069 for (idx
= 0; idx
< codebook
.dimensions
; ++idx
)
1070 lsp
[lsp_len
+idx
] = codebook
.codevectors
[vec_off
+idx
] + last
;
1071 last
= lsp
[lsp_len
+idx
-1]; /* set last to last vector component */
1073 lsp_len
+= codebook
.dimensions
;
1076 /* DEBUG: output lsp coeffs */
1079 for (idx
= 0; idx
< lsp_len
; ++idx
)
1080 AV_DEBUG("floor0 dec: coeff at %d is %f\n", idx
, lsp
[idx
]);
1084 /* synthesize floor output vector */
1087 int order
= vf
->order
;
1088 float wstep
= M_PI
/ vf
->bark_map_size
;
1090 for (i
= 0; i
< order
; i
++)
1091 lsp
[i
] = 2.0f
* cos(lsp
[i
]);
1093 AV_DEBUG("floor0 synth: map_size = %d; m = %d; wstep = %f\n",
1094 vf
->map_size
, order
, wstep
);
1097 while (i
< vf
->map_size
[blockflag
]) {
1098 int j
, iter_cond
= vf
->map
[blockflag
][i
];
1101 float two_cos_w
= 2.0f
* cos(wstep
* iter_cond
); // needed all times
1103 /* similar part for the q and p products */
1104 for (j
= 0; j
+ 1 < order
; j
+= 2) {
1105 q
*= lsp
[j
] - two_cos_w
;
1106 p
*= lsp
[j
+ 1] - two_cos_w
;
1108 if (j
== order
) { // even order
1109 p
*= p
* (2.0f
- two_cos_w
);
1110 q
*= q
* (2.0f
+ two_cos_w
);
1111 } else { // odd order
1112 q
*= two_cos_w
-lsp
[j
]; // one more time for q
1114 /* final step and square */
1115 p
*= p
* (4.f
- two_cos_w
* two_cos_w
);
1119 /* calculate linear floor value */
1121 q
= exp((((amplitude
*vf
->amplitude_offset
) /
1122 (((1 << vf
->amplitude_bits
) - 1) * sqrt(p
+ q
)))
1123 - vf
->amplitude_offset
) * .11512925f
);
1129 } while (vf
->map
[blockflag
][i
] == iter_cond
);
1133 /* this channel is unused */
1137 AV_DEBUG(" Floor0 decoded\n");
1142 static uint_fast8_t vorbis_floor1_decode(vorbis_context
*vc
,
1143 vorbis_floor_data
*vfu
, float *vec
)
1145 vorbis_floor1
*vf
= &vfu
->t1
;
1146 GetBitContext
*gb
= &vc
->gb
;
1147 uint_fast16_t range_v
[4] = { 256, 128, 86, 64 };
1148 uint_fast16_t range
= range_v
[vf
->multiplier
-1];
1149 uint_fast16_t floor1_Y
[vf
->x_list_dim
];
1150 uint_fast16_t floor1_Y_final
[vf
->x_list_dim
];
1151 int floor1_flag
[vf
->x_list_dim
];
1152 uint_fast8_t class_
;
1158 uint_fast16_t offset
;
1160 /*u*/int_fast16_t adx
, ady
, off
, predicted
; // WTF ? dy/adx = (unsigned)dy/adx ?
1161 int_fast16_t dy
, err
;
1164 if (!get_bits1(gb
)) // silence
1167 // Read values (or differences) for the floor's points
1169 floor1_Y
[0] = get_bits(gb
, ilog(range
- 1));
1170 floor1_Y
[1] = get_bits(gb
, ilog(range
- 1));
1172 AV_DEBUG("floor 0 Y %d floor 1 Y %d \n", floor1_Y
[0], floor1_Y
[1]);
1175 for (i
= 0; i
< vf
->partitions
; ++i
) {
1176 class_
= vf
->partition_class
[i
];
1177 cdim
= vf
->class_dimensions
[class_
];
1178 cbits
= vf
->class_subclasses
[class_
];
1179 csub
= (1 << cbits
) - 1;
1182 AV_DEBUG("Cbits %d \n", cbits
);
1184 if (cbits
) // this reads all subclasses for this partition's class
1185 cval
= get_vlc2(gb
, vc
->codebooks
[vf
->class_masterbook
[class_
]].vlc
.table
,
1186 vc
->codebooks
[vf
->class_masterbook
[class_
]].nb_bits
, 3);
1188 for (j
= 0; j
< cdim
; ++j
) {
1189 book
= vf
->subclass_books
[class_
][cval
& csub
];
1191 AV_DEBUG("book %d Cbits %d cval %d bits:%d \n", book
, cbits
, cval
, get_bits_count(gb
));
1193 cval
= cval
>> cbits
;
1195 floor1_Y
[offset
+j
] = get_vlc2(gb
, vc
->codebooks
[book
].vlc
.table
,
1196 vc
->codebooks
[book
].nb_bits
, 3);
1198 floor1_Y
[offset
+j
] = 0;
1201 AV_DEBUG(" floor(%d) = %d \n", vf
->list
[offset
+j
].x
, floor1_Y
[offset
+j
]);
1206 // Amplitude calculation from the differences
1210 floor1_Y_final
[0] = floor1_Y
[0];
1211 floor1_Y_final
[1] = floor1_Y
[1];
1213 for (i
= 2; i
< vf
->x_list_dim
; ++i
) {
1214 uint_fast16_t val
, highroom
, lowroom
, room
;
1215 uint_fast16_t high_neigh_offs
;
1216 uint_fast16_t low_neigh_offs
;
1218 low_neigh_offs
= vf
->list
[i
].low
;
1219 high_neigh_offs
= vf
->list
[i
].high
;
1220 dy
= floor1_Y_final
[high_neigh_offs
] - floor1_Y_final
[low_neigh_offs
]; // render_point begin
1221 adx
= vf
->list
[high_neigh_offs
].x
- vf
->list
[low_neigh_offs
].x
;
1223 err
= ady
* (vf
->list
[i
].x
- vf
->list
[low_neigh_offs
].x
);
1224 off
= (int16_t)err
/ (int16_t)adx
;
1226 predicted
= floor1_Y_final
[low_neigh_offs
] - off
;
1228 predicted
= floor1_Y_final
[low_neigh_offs
] + off
;
1229 } // render_point end
1232 highroom
= range
-predicted
;
1233 lowroom
= predicted
;
1234 if (highroom
< lowroom
) {
1235 room
= highroom
* 2;
1237 room
= lowroom
* 2; // SPEC mispelling
1240 floor1_flag
[low_neigh_offs
] = 1;
1241 floor1_flag
[high_neigh_offs
] = 1;
1244 if (highroom
> lowroom
) {
1245 floor1_Y_final
[i
] = val
- lowroom
+ predicted
;
1247 floor1_Y_final
[i
] = predicted
- val
+ highroom
- 1;
1251 floor1_Y_final
[i
] = predicted
- (val
+ 1) / 2;
1253 floor1_Y_final
[i
] = predicted
+ val
/ 2;
1258 floor1_Y_final
[i
] = predicted
;
1261 AV_DEBUG(" Decoded floor(%d) = %d / val %d \n", vf
->list
[i
].x
, floor1_Y_final
[i
], val
);
1264 // Curve synth - connect the calculated dots and convert from dB scale FIXME optimize ?
1266 ff_vorbis_floor1_render_list(vf
->list
, vf
->x_list_dim
, floor1_Y_final
, floor1_flag
, vf
->multiplier
, vec
, vf
->list
[1].x
);
1268 AV_DEBUG(" Floor decoded\n");
1273 // Read and decode residue
1275 static av_always_inline
int vorbis_residue_decode_internal(vorbis_context
*vc
,
1278 uint_fast8_t *do_not_decode
,
1283 GetBitContext
*gb
= &vc
->gb
;
1284 uint_fast8_t c_p_c
= vc
->codebooks
[vr
->classbook
].dimensions
;
1285 uint_fast16_t n_to_read
= vr
->end
-vr
->begin
;
1286 uint_fast16_t ptns_to_read
= n_to_read
/vr
->partition_size
;
1287 uint_fast8_t classifs
[ptns_to_read
*vc
->audio_channels
];
1289 uint_fast8_t ch_used
;
1294 for (j
= 1; j
< ch
; ++j
)
1295 do_not_decode
[0] &= do_not_decode
[j
]; // FIXME - clobbering input
1296 if (do_not_decode
[0])
1303 AV_DEBUG(" residue type 0/1/2 decode begin, ch: %d cpc %d \n", ch
, c_p_c
);
1305 for (pass
= 0; pass
<= vr
->maxpass
; ++pass
) { // FIXME OPTIMIZE?
1306 uint_fast16_t voffset
;
1307 uint_fast16_t partition_count
;
1308 uint_fast16_t j_times_ptns_to_read
;
1310 voffset
= vr
->begin
;
1311 for (partition_count
= 0; partition_count
< ptns_to_read
;) { // SPEC error
1313 uint_fast32_t inverse_class
= ff_inverse
[vr
->classifications
];
1314 for (j_times_ptns_to_read
= 0, j
= 0; j
< ch_used
; ++j
) {
1315 if (!do_not_decode
[j
]) {
1316 uint_fast32_t temp
= get_vlc2(gb
, vc
->codebooks
[vr
->classbook
].vlc
.table
,
1317 vc
->codebooks
[vr
->classbook
].nb_bits
, 3);
1319 AV_DEBUG("Classword: %d \n", temp
);
1321 assert(vr
->classifications
> 1 && temp
<= 65536); //needed for inverse[]
1322 for (i
= 0; i
< c_p_c
; ++i
) {
1323 uint_fast32_t temp2
;
1325 temp2
= (((uint_fast64_t)temp
) * inverse_class
) >> 32;
1326 if (partition_count
+ c_p_c
- 1 - i
< ptns_to_read
)
1327 classifs
[j_times_ptns_to_read
+ partition_count
+ c_p_c
- 1 - i
] = temp
- temp2
* vr
->classifications
;
1331 j_times_ptns_to_read
+= ptns_to_read
;
1334 for (i
= 0; (i
< c_p_c
) && (partition_count
< ptns_to_read
); ++i
) {
1335 for (j_times_ptns_to_read
= 0, j
= 0; j
< ch_used
; ++j
) {
1336 uint_fast16_t voffs
;
1338 if (!do_not_decode
[j
]) {
1339 uint_fast8_t vqclass
= classifs
[j_times_ptns_to_read
+partition_count
];
1340 int_fast16_t vqbook
= vr
->books
[vqclass
][pass
];
1342 if (vqbook
>= 0 && vc
->codebooks
[vqbook
].codevectors
) {
1343 uint_fast16_t coffs
;
1344 unsigned dim
= vc
->codebooks
[vqbook
].dimensions
; // not uint_fast8_t: 64bit is slower here on amd64
1345 uint_fast16_t step
= dim
== 1 ? vr
->partition_size
1346 : FASTDIV(vr
->partition_size
, dim
);
1347 vorbis_codebook codebook
= vc
->codebooks
[vqbook
];
1351 voffs
= voffset
+j
*vlen
;
1352 for (k
= 0; k
< step
; ++k
) {
1353 coffs
= get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * dim
;
1354 for (l
= 0; l
< dim
; ++l
)
1355 vec
[voffs
+ k
+ l
* step
] += codebook
.codevectors
[coffs
+ l
]; // FPMATH
1357 } else if (vr_type
== 1) {
1358 voffs
= voffset
+ j
* vlen
;
1359 for (k
= 0; k
< step
; ++k
) {
1360 coffs
= get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * dim
;
1361 for (l
= 0; l
< dim
; ++l
, ++voffs
) {
1362 vec
[voffs
]+=codebook
.codevectors
[coffs
+l
]; // FPMATH
1364 AV_DEBUG(" pass %d offs: %d curr: %f change: %f cv offs.: %d \n", pass
, voffs
, vec
[voffs
], codebook
.codevectors
[coffs
+l
], coffs
);
1367 } else if (vr_type
== 2 && ch
== 2 && (voffset
& 1) == 0 && (dim
& 1) == 0) { // most frequent case optimized
1368 voffs
= voffset
>> 1;
1371 for (k
= 0; k
< step
; ++k
) {
1372 coffs
= get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * 2;
1373 vec
[voffs
+ k
] += codebook
.codevectors
[coffs
]; // FPMATH
1374 vec
[voffs
+ k
+ vlen
] += codebook
.codevectors
[coffs
+ 1]; // FPMATH
1376 } else if (dim
== 4) {
1377 for (k
= 0; k
< step
; ++k
, voffs
+= 2) {
1378 coffs
= get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * 4;
1379 vec
[voffs
] += codebook
.codevectors
[coffs
]; // FPMATH
1380 vec
[voffs
+ 1 ] += codebook
.codevectors
[coffs
+ 2]; // FPMATH
1381 vec
[voffs
+ vlen
] += codebook
.codevectors
[coffs
+ 1]; // FPMATH
1382 vec
[voffs
+ vlen
+ 1] += codebook
.codevectors
[coffs
+ 3]; // FPMATH
1385 for (k
= 0; k
< step
; ++k
) {
1386 coffs
= get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * dim
;
1387 for (l
= 0; l
< dim
; l
+= 2, voffs
++) {
1388 vec
[voffs
] += codebook
.codevectors
[coffs
+ l
]; // FPMATH
1389 vec
[voffs
+ vlen
] += codebook
.codevectors
[coffs
+ l
+ 1]; // FPMATH
1391 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
);
1395 } else if (vr_type
== 2) {
1398 for (k
= 0; k
< step
; ++k
) {
1399 coffs
= get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * dim
;
1400 for (l
= 0; l
< dim
; ++l
, ++voffs
) {
1401 vec
[voffs
/ ch
+ (voffs
% ch
) * vlen
] += codebook
.codevectors
[coffs
+ l
]; // FPMATH FIXME use if and counter instead of / and %
1403 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
);
1409 j_times_ptns_to_read
+= ptns_to_read
;
1412 voffset
+= vr
->partition_size
;
1419 static inline int vorbis_residue_decode(vorbis_context
*vc
, vorbis_residue
*vr
,
1421 uint_fast8_t *do_not_decode
,
1422 float *vec
, uint_fast16_t vlen
)
1425 return vorbis_residue_decode_internal(vc
, vr
, ch
, do_not_decode
, vec
, vlen
, 2);
1426 else if (vr
->type
== 1)
1427 return vorbis_residue_decode_internal(vc
, vr
, ch
, do_not_decode
, vec
, vlen
, 1);
1428 else if (vr
->type
== 0)
1429 return vorbis_residue_decode_internal(vc
, vr
, ch
, do_not_decode
, vec
, vlen
, 0);
1431 av_log(vc
->avccontext
, AV_LOG_ERROR
, " Invalid residue type while residue decode?! \n");
1436 void vorbis_inverse_coupling(float *mag
, float *ang
, int blocksize
)
1439 for (i
= 0; i
< blocksize
; i
++) {
1442 ang
[i
] = mag
[i
] - ang
[i
];
1444 float temp
= ang
[i
];
1452 float temp
= ang
[i
];
1460 static void copy_normalize(float *dst
, float *src
, int len
, int exp_bias
,
1465 memcpy(dst
, src
, len
* sizeof(float));
1467 for (i
= 0; i
< len
; i
++)
1468 dst
[i
] = src
[i
] + add_bias
;
1472 // Decode the audio packet using the functions above
1474 static int vorbis_parse_audio_packet(vorbis_context
*vc
)
1476 GetBitContext
*gb
= &vc
->gb
;
1478 uint_fast8_t previous_window
= vc
->previous_window
;
1479 uint_fast8_t mode_number
;
1480 uint_fast8_t blockflag
;
1481 uint_fast16_t blocksize
;
1483 uint_fast8_t no_residue
[vc
->audio_channels
];
1484 uint_fast8_t do_not_decode
[vc
->audio_channels
];
1485 vorbis_mapping
*mapping
;
1486 float *ch_res_ptr
= vc
->channel_residues
;
1487 float *ch_floor_ptr
= vc
->channel_floors
;
1488 uint_fast8_t res_chan
[vc
->audio_channels
];
1489 uint_fast8_t res_num
= 0;
1490 int_fast16_t retlen
= 0;
1491 float fadd_bias
= vc
->add_bias
;
1493 if (get_bits1(gb
)) {
1494 av_log(vc
->avccontext
, AV_LOG_ERROR
, "Not a Vorbis I audio packet.\n");
1495 return -1; // packet type not audio
1498 if (vc
->mode_count
== 1) {
1501 mode_number
= get_bits(gb
, ilog(vc
->mode_count
-1));
1503 if (mode_number
>= vc
->mode_count
) {
1504 av_log(vc
->avccontext
, AV_LOG_ERROR
, "mode number %d out of range.\n", mode_number
);
1507 vc
->mode_number
= mode_number
;
1508 mapping
= &vc
->mappings
[vc
->modes
[mode_number
].mapping
];
1510 AV_DEBUG(" Mode number: %d , mapping: %d , blocktype %d \n", mode_number
, vc
->modes
[mode_number
].mapping
, vc
->modes
[mode_number
].blockflag
);
1512 blockflag
= vc
->modes
[mode_number
].blockflag
;
1513 blocksize
= vc
->blocksize
[blockflag
];
1515 skip_bits(gb
, 2); // previous_window, next_window
1517 memset(ch_res_ptr
, 0, sizeof(float) * vc
->audio_channels
* blocksize
/ 2); //FIXME can this be removed ?
1518 memset(ch_floor_ptr
, 0, sizeof(float) * vc
->audio_channels
* blocksize
/ 2); //FIXME can this be removed ?
1522 for (i
= 0; i
< vc
->audio_channels
; ++i
) {
1523 vorbis_floor
*floor
;
1524 if (mapping
->submaps
> 1) {
1525 floor
= &vc
->floors
[mapping
->submap_floor
[mapping
->mux
[i
]]];
1527 floor
= &vc
->floors
[mapping
->submap_floor
[0]];
1530 no_residue
[i
] = floor
->decode(vc
, &floor
->data
, ch_floor_ptr
);
1531 ch_floor_ptr
+= blocksize
/ 2;
1534 // Nonzero vector propagate
1536 for (i
= mapping
->coupling_steps
- 1; i
>= 0; --i
) {
1537 if (!(no_residue
[mapping
->magnitude
[i
]] & no_residue
[mapping
->angle
[i
]])) {
1538 no_residue
[mapping
->magnitude
[i
]] = 0;
1539 no_residue
[mapping
->angle
[i
]] = 0;
1545 for (i
= 0; i
< mapping
->submaps
; ++i
) {
1546 vorbis_residue
*residue
;
1547 uint_fast8_t ch
= 0;
1549 for (j
= 0; j
< vc
->audio_channels
; ++j
) {
1550 if ((mapping
->submaps
== 1) || (i
== mapping
->mux
[j
])) {
1551 res_chan
[j
] = res_num
;
1552 if (no_residue
[j
]) {
1553 do_not_decode
[ch
] = 1;
1555 do_not_decode
[ch
] = 0;
1561 residue
= &vc
->residues
[mapping
->submap_residue
[i
]];
1562 vorbis_residue_decode(vc
, residue
, ch
, do_not_decode
, ch_res_ptr
, blocksize
/2);
1564 ch_res_ptr
+= ch
* blocksize
/ 2;
1569 for (i
= mapping
->coupling_steps
- 1; i
>= 0; --i
) { //warning: i has to be signed
1572 mag
= vc
->channel_residues
+res_chan
[mapping
->magnitude
[i
]] * blocksize
/ 2;
1573 ang
= vc
->channel_residues
+res_chan
[mapping
->angle
[i
]] * blocksize
/ 2;
1574 vc
->dsp
.vorbis_inverse_coupling(mag
, ang
, blocksize
/ 2);
1579 for (j
= vc
->audio_channels
-1;j
>= 0; j
--) {
1580 ch_floor_ptr
= vc
->channel_floors
+ j
* blocksize
/ 2;
1581 ch_res_ptr
= vc
->channel_residues
+ res_chan
[j
] * blocksize
/ 2;
1582 vc
->dsp
.vector_fmul(ch_floor_ptr
, ch_res_ptr
, blocksize
/ 2);
1583 ff_imdct_half(&vc
->mdct
[blockflag
], ch_res_ptr
, ch_floor_ptr
);
1586 // Overlap/add, save data for next overlapping FPMATH
1588 retlen
= (blocksize
+ vc
->blocksize
[previous_window
]) / 4;
1589 for (j
= 0; j
< vc
->audio_channels
; j
++) {
1590 uint_fast16_t bs0
= vc
->blocksize
[0];
1591 uint_fast16_t bs1
= vc
->blocksize
[1];
1592 float *residue
= vc
->channel_residues
+ res_chan
[j
] * blocksize
/ 2;
1593 float *saved
= vc
->saved
+ j
* bs1
/ 4;
1594 float *ret
= vc
->channel_floors
+ j
* retlen
;
1595 float *buf
= residue
;
1596 const float *win
= vc
->win
[blockflag
& previous_window
];
1598 if (blockflag
== previous_window
) {
1599 vc
->dsp
.vector_fmul_window(ret
, saved
, buf
, win
, fadd_bias
, blocksize
/ 4);
1600 } else if (blockflag
> previous_window
) {
1601 vc
->dsp
.vector_fmul_window(ret
, saved
, buf
, win
, fadd_bias
, bs0
/ 4);
1602 copy_normalize(ret
+bs0
/2, buf
+bs0
/4, (bs1
-bs0
)/4, vc
->exp_bias
, fadd_bias
);
1604 copy_normalize(ret
, saved
, (bs1
- bs0
) / 4, vc
->exp_bias
, fadd_bias
);
1605 vc
->dsp
.vector_fmul_window(ret
+ (bs1
- bs0
) / 4, saved
+ (bs1
- bs0
) / 4, buf
, win
, fadd_bias
, bs0
/ 4);
1607 memcpy(saved
, buf
+ blocksize
/ 4, blocksize
/ 4 * sizeof(float));
1610 vc
->previous_window
= blockflag
;
1614 // Return the decoded audio packet through the standard api
1616 static int vorbis_decode_frame(AVCodecContext
*avccontext
,
1617 void *data
, int *data_size
,
1620 const uint8_t *buf
= avpkt
->data
;
1621 int buf_size
= avpkt
->size
;
1622 vorbis_context
*vc
= avccontext
->priv_data
;
1623 GetBitContext
*gb
= &(vc
->gb
);
1624 const float *channel_ptrs
[vc
->audio_channels
];
1632 AV_DEBUG("packet length %d \n", buf_size
);
1634 init_get_bits(gb
, buf
, buf_size
*8);
1636 len
= vorbis_parse_audio_packet(vc
);
1643 if (!vc
->first_frame
) {
1644 vc
->first_frame
= 1;
1649 AV_DEBUG("parsed %d bytes %d bits, returned %d samples (*ch*bits) \n", get_bits_count(gb
)/8, get_bits_count(gb
)%8, len
);
1651 if (vc
->audio_channels
> 6) {
1652 for (i
= 0; i
< vc
->audio_channels
; i
++)
1653 channel_ptrs
[i
] = vc
->channel_floors
+ i
* len
;
1655 for (i
= 0; i
< vc
->audio_channels
; i
++)
1656 channel_ptrs
[i
] = vc
->channel_floors
+
1657 len
* ff_vorbis_channel_layout_offsets
[vc
->audio_channels
- 1][i
];
1660 vc
->dsp
.float_to_int16_interleave(data
, channel_ptrs
, len
, vc
->audio_channels
);
1661 *data_size
= len
* 2 * vc
->audio_channels
;
1668 static av_cold
int vorbis_decode_close(AVCodecContext
*avccontext
)
1670 vorbis_context
*vc
= avccontext
->priv_data
;
1677 AVCodec vorbis_decoder
= {
1681 sizeof(vorbis_context
),
1684 vorbis_decode_close
,
1685 vorbis_decode_frame
,
1686 .long_name
= NULL_IF_CONFIG_SMALL("Vorbis"),
1687 .channel_layouts
= ff_vorbis_channel_layouts
,