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
26 * @author Denes Balatoni ( dbalatoni programozo hu )
32 #define BITSTREAM_READER_LE
33 #include "libavutil/float_dsp.h"
34 #include "libavutil/avassert.h"
38 #include "fmtconvert.h"
42 #include "vorbisdsp.h"
47 #define V_MAX_VLCS (1 << 16)
48 #define V_MAX_PARTITIONS (1 << 20)
59 typedef union vorbis_floor_u vorbis_floor_data
;
60 typedef struct vorbis_floor0_s vorbis_floor0
;
61 typedef struct vorbis_floor1_s vorbis_floor1
;
62 struct vorbis_context_s
;
64 int (* vorbis_floor_decode_func
)
65 (struct vorbis_context_s
*, vorbis_floor_data
*, float *);
68 vorbis_floor_decode_func decode
;
69 union vorbis_floor_u
{
70 struct vorbis_floor0_s
{
73 uint16_t bark_map_size
;
76 uint8_t amplitude_bits
;
77 uint8_t amplitude_offset
;
82 struct vorbis_floor1_s
{
84 uint8_t partition_class
[32];
85 uint8_t class_dimensions
[16];
86 uint8_t class_subclasses
[16];
87 uint8_t class_masterbook
[16];
88 int16_t subclass_books
[16][8];
91 vorbis_floor1_entry
*list
;
100 unsigned partition_size
;
101 uint8_t classifications
;
103 int16_t books
[64][8];
105 uint16_t ptns_to_read
;
111 uint16_t coupling_steps
;
115 uint8_t submap_floor
[16];
116 uint8_t submap_residue
[16];
122 uint16_t transformtype
;
126 typedef struct vorbis_context_s
{
127 AVCodecContext
*avctx
;
129 VorbisDSPContext dsp
;
130 AVFloatDSPContext fdsp
;
131 FmtConvertContext fmt_conv
;
136 uint8_t audio_channels
;
137 uint32_t audio_samplerate
;
138 uint32_t bitrate_maximum
;
139 uint32_t bitrate_nominal
;
140 uint32_t bitrate_minimum
;
141 uint32_t blocksize
[2];
143 uint16_t codebook_count
;
144 vorbis_codebook
*codebooks
;
146 vorbis_floor
*floors
;
147 uint8_t residue_count
;
148 vorbis_residue
*residues
;
149 uint8_t mapping_count
;
150 vorbis_mapping
*mappings
;
153 uint8_t mode_number
; // mode number for the current packet
154 int8_t previous_window
;
155 float *channel_residues
;
159 /* Helper functions */
162 (13.1f * atan(0.00074f * (x)) + 2.24f * atan(1.85e-8f * (x) * (x)) + 1e-4f * (x))
164 static const char idx_err_str
[] = "Index value %d out of range (0 - %d) for %s at %s:%i\n";
165 #define VALIDATE_INDEX(idx, limit) \
167 av_log(vc->avctx, AV_LOG_ERROR,\
169 (int)(idx), (int)(limit - 1), #idx, __FILE__, __LINE__);\
170 return AVERROR_INVALIDDATA;\
172 #define GET_VALIDATED_INDEX(idx, bits, limit) \
174 idx = get_bits(gb, bits);\
175 VALIDATE_INDEX(idx, limit)\
178 static float vorbisfloat2float(unsigned val
)
180 double mant
= val
& 0x1fffff;
181 long exp
= (val
& 0x7fe00000L
) >> 21;
182 if (val
& 0x80000000)
184 return ldexp(mant
, exp
- 20 - 768);
188 // Free all allocated memory -----------------------------------------
190 static void vorbis_free(vorbis_context
*vc
)
194 av_freep(&vc
->channel_residues
);
195 av_freep(&vc
->saved
);
198 for (i
= 0; i
< vc
->residue_count
; i
++)
199 av_free(vc
->residues
[i
].classifs
);
200 av_freep(&vc
->residues
);
201 av_freep(&vc
->modes
);
203 ff_mdct_end(&vc
->mdct
[0]);
204 ff_mdct_end(&vc
->mdct
[1]);
207 for (i
= 0; i
< vc
->codebook_count
; ++i
) {
208 av_free(vc
->codebooks
[i
].codevectors
);
209 ff_free_vlc(&vc
->codebooks
[i
].vlc
);
211 av_freep(&vc
->codebooks
);
214 for (i
= 0; i
< vc
->floor_count
; ++i
) {
215 if (vc
->floors
[i
].floor_type
== 0) {
216 av_free(vc
->floors
[i
].data
.t0
.map
[0]);
217 av_free(vc
->floors
[i
].data
.t0
.map
[1]);
218 av_free(vc
->floors
[i
].data
.t0
.book_list
);
219 av_free(vc
->floors
[i
].data
.t0
.lsp
);
221 av_free(vc
->floors
[i
].data
.t1
.list
);
224 av_freep(&vc
->floors
);
227 for (i
= 0; i
< vc
->mapping_count
; ++i
) {
228 av_free(vc
->mappings
[i
].magnitude
);
229 av_free(vc
->mappings
[i
].angle
);
230 av_free(vc
->mappings
[i
].mux
);
232 av_freep(&vc
->mappings
);
235 // Parse setup header -------------------------------------------------
237 // Process codebooks part
239 static int vorbis_parse_setup_hdr_codebooks(vorbis_context
*vc
)
242 uint8_t *tmp_vlc_bits
= NULL
;
243 uint32_t *tmp_vlc_codes
= NULL
;
244 GetBitContext
*gb
= &vc
->gb
;
245 uint16_t *codebook_multiplicands
= NULL
;
248 vc
->codebook_count
= get_bits(gb
, 8) + 1;
250 av_dlog(NULL
, " Codebooks: %d \n", vc
->codebook_count
);
252 vc
->codebooks
= av_mallocz(vc
->codebook_count
* sizeof(*vc
->codebooks
));
253 tmp_vlc_bits
= av_mallocz(V_MAX_VLCS
* sizeof(*tmp_vlc_bits
));
254 tmp_vlc_codes
= av_mallocz(V_MAX_VLCS
* sizeof(*tmp_vlc_codes
));
255 codebook_multiplicands
= av_malloc(V_MAX_VLCS
* sizeof(*codebook_multiplicands
));
256 if (!vc
->codebooks
||
257 !tmp_vlc_bits
|| !tmp_vlc_codes
|| !codebook_multiplicands
) {
258 ret
= AVERROR(ENOMEM
);
262 for (cb
= 0; cb
< vc
->codebook_count
; ++cb
) {
263 vorbis_codebook
*codebook_setup
= &vc
->codebooks
[cb
];
264 unsigned ordered
, t
, entries
, used_entries
= 0;
266 av_dlog(NULL
, " %u. Codebook\n", cb
);
268 if (get_bits(gb
, 24) != 0x564342) {
269 av_log(vc
->avctx
, AV_LOG_ERROR
,
270 " %u. Codebook setup data corrupt.\n", cb
);
271 ret
= AVERROR_INVALIDDATA
;
275 codebook_setup
->dimensions
=get_bits(gb
, 16);
276 if (codebook_setup
->dimensions
> 16 || codebook_setup
->dimensions
== 0) {
277 av_log(vc
->avctx
, AV_LOG_ERROR
,
278 " %u. Codebook's dimension is invalid (%d).\n",
279 cb
, codebook_setup
->dimensions
);
280 ret
= AVERROR_INVALIDDATA
;
283 entries
= get_bits(gb
, 24);
284 if (entries
> V_MAX_VLCS
) {
285 av_log(vc
->avctx
, AV_LOG_ERROR
,
286 " %u. Codebook has too many entries (%u).\n",
288 ret
= AVERROR_INVALIDDATA
;
292 ordered
= get_bits1(gb
);
294 av_dlog(NULL
, " codebook_dimensions %d, codebook_entries %u\n",
295 codebook_setup
->dimensions
, entries
);
299 unsigned sparse
= get_bits1(gb
);
301 av_dlog(NULL
, " not ordered \n");
304 av_dlog(NULL
, " sparse \n");
307 for (ce
= 0; ce
< entries
; ++ce
) {
308 flag
= get_bits1(gb
);
310 tmp_vlc_bits
[ce
] = get_bits(gb
, 5) + 1;
313 tmp_vlc_bits
[ce
] = 0;
316 av_dlog(NULL
, " not sparse \n");
318 used_entries
= entries
;
319 for (ce
= 0; ce
< entries
; ++ce
)
320 tmp_vlc_bits
[ce
] = get_bits(gb
, 5) + 1;
323 unsigned current_entry
= 0;
324 unsigned current_length
= get_bits(gb
, 5) + 1;
326 av_dlog(NULL
, " ordered, current length: %u\n", current_length
); //FIXME
328 used_entries
= entries
;
329 for (; current_entry
< used_entries
&& current_length
<= 32; ++current_length
) {
332 av_dlog(NULL
, " number bits: %u ", ilog(entries
- current_entry
));
334 number
= get_bits(gb
, ilog(entries
- current_entry
));
336 av_dlog(NULL
, " number: %u\n", number
);
338 for (i
= current_entry
; i
< number
+current_entry
; ++i
)
339 if (i
< used_entries
)
340 tmp_vlc_bits
[i
] = current_length
;
342 current_entry
+=number
;
344 if (current_entry
>used_entries
) {
345 av_log(vc
->avctx
, AV_LOG_ERROR
, " More codelengths than codes in codebook. \n");
346 ret
= AVERROR_INVALIDDATA
;
351 codebook_setup
->lookup_type
= get_bits(gb
, 4);
353 av_dlog(NULL
, " lookup type: %d : %s \n", codebook_setup
->lookup_type
,
354 codebook_setup
->lookup_type
? "vq" : "no lookup");
356 // If the codebook is used for (inverse) VQ, calculate codevectors.
358 if (codebook_setup
->lookup_type
== 1) {
360 unsigned codebook_lookup_values
= ff_vorbis_nth_root(entries
, codebook_setup
->dimensions
);
362 float codebook_minimum_value
= vorbisfloat2float(get_bits_long(gb
, 32));
363 float codebook_delta_value
= vorbisfloat2float(get_bits_long(gb
, 32));
364 unsigned codebook_value_bits
= get_bits(gb
, 4) + 1;
365 unsigned codebook_sequence_p
= get_bits1(gb
);
367 av_dlog(NULL
, " We expect %d numbers for building the codevectors. \n",
368 codebook_lookup_values
);
369 av_dlog(NULL
, " delta %f minmum %f \n",
370 codebook_delta_value
, codebook_minimum_value
);
372 for (i
= 0; i
< codebook_lookup_values
; ++i
) {
373 codebook_multiplicands
[i
] = get_bits(gb
, codebook_value_bits
);
375 av_dlog(NULL
, " multiplicands*delta+minmum : %e \n",
376 (float)codebook_multiplicands
[i
] * codebook_delta_value
+ codebook_minimum_value
);
377 av_dlog(NULL
, " multiplicand %u\n", codebook_multiplicands
[i
]);
380 // Weed out unused vlcs and build codevector vector
381 codebook_setup
->codevectors
= used_entries
? av_mallocz_array(used_entries
,
382 codebook_setup
->dimensions
*
383 sizeof(*codebook_setup
->codevectors
))
385 for (j
= 0, i
= 0; i
< entries
; ++i
) {
386 unsigned dim
= codebook_setup
->dimensions
;
388 if (tmp_vlc_bits
[i
]) {
390 unsigned lookup_offset
= i
;
392 av_dlog(vc
->avctx
, "Lookup offset %u ,", i
);
394 for (k
= 0; k
< dim
; ++k
) {
395 unsigned multiplicand_offset
= lookup_offset
% codebook_lookup_values
;
396 codebook_setup
->codevectors
[j
* dim
+ k
] = codebook_multiplicands
[multiplicand_offset
] * codebook_delta_value
+ codebook_minimum_value
+ last
;
397 if (codebook_sequence_p
)
398 last
= codebook_setup
->codevectors
[j
* dim
+ k
];
399 lookup_offset
/=codebook_lookup_values
;
401 tmp_vlc_bits
[j
] = tmp_vlc_bits
[i
];
403 av_dlog(vc
->avctx
, "real lookup offset %u, vector: ", j
);
404 for (k
= 0; k
< dim
; ++k
)
405 av_dlog(vc
->avctx
, " %f ",
406 codebook_setup
->codevectors
[j
* dim
+ k
]);
407 av_dlog(vc
->avctx
, "\n");
412 if (j
!= used_entries
) {
413 av_log(vc
->avctx
, AV_LOG_ERROR
, "Bug in codevector vector building code. \n");
414 ret
= AVERROR_INVALIDDATA
;
417 entries
= used_entries
;
418 } else if (codebook_setup
->lookup_type
>= 2) {
419 av_log(vc
->avctx
, AV_LOG_ERROR
, "Codebook lookup type not supported. \n");
420 ret
= AVERROR_INVALIDDATA
;
424 // Initialize VLC table
425 if (ff_vorbis_len2vlc(tmp_vlc_bits
, tmp_vlc_codes
, entries
)) {
426 av_log(vc
->avctx
, AV_LOG_ERROR
, " Invalid code lengths while generating vlcs. \n");
427 ret
= AVERROR_INVALIDDATA
;
430 codebook_setup
->maxdepth
= 0;
431 for (t
= 0; t
< entries
; ++t
)
432 if (tmp_vlc_bits
[t
] >= codebook_setup
->maxdepth
)
433 codebook_setup
->maxdepth
= tmp_vlc_bits
[t
];
435 if (codebook_setup
->maxdepth
> 3 * V_NB_BITS
)
436 codebook_setup
->nb_bits
= V_NB_BITS2
;
438 codebook_setup
->nb_bits
= V_NB_BITS
;
440 codebook_setup
->maxdepth
= (codebook_setup
->maxdepth
+codebook_setup
->nb_bits
- 1) / codebook_setup
->nb_bits
;
442 if ((ret
= init_vlc(&codebook_setup
->vlc
, codebook_setup
->nb_bits
,
443 entries
, tmp_vlc_bits
, sizeof(*tmp_vlc_bits
),
444 sizeof(*tmp_vlc_bits
), tmp_vlc_codes
,
445 sizeof(*tmp_vlc_codes
), sizeof(*tmp_vlc_codes
),
447 av_log(vc
->avctx
, AV_LOG_ERROR
, " Error generating vlc tables. \n");
452 av_free(tmp_vlc_bits
);
453 av_free(tmp_vlc_codes
);
454 av_free(codebook_multiplicands
);
459 av_free(tmp_vlc_bits
);
460 av_free(tmp_vlc_codes
);
461 av_free(codebook_multiplicands
);
465 // Process time domain transforms part (unused in Vorbis I)
467 static int vorbis_parse_setup_hdr_tdtransforms(vorbis_context
*vc
)
469 GetBitContext
*gb
= &vc
->gb
;
470 unsigned i
, vorbis_time_count
= get_bits(gb
, 6) + 1;
472 for (i
= 0; i
< vorbis_time_count
; ++i
) {
473 unsigned vorbis_tdtransform
= get_bits(gb
, 16);
475 av_dlog(NULL
, " Vorbis time domain transform %u: %u\n",
476 vorbis_time_count
, vorbis_tdtransform
);
478 if (vorbis_tdtransform
) {
479 av_log(vc
->avctx
, AV_LOG_ERROR
, "Vorbis time domain transform data nonzero. \n");
480 return AVERROR_INVALIDDATA
;
486 // Process floors part
488 static int vorbis_floor0_decode(vorbis_context
*vc
,
489 vorbis_floor_data
*vfu
, float *vec
);
490 static int create_map(vorbis_context
*vc
, unsigned floor_number
);
491 static int vorbis_floor1_decode(vorbis_context
*vc
,
492 vorbis_floor_data
*vfu
, float *vec
);
493 static int vorbis_parse_setup_hdr_floors(vorbis_context
*vc
)
495 GetBitContext
*gb
= &vc
->gb
;
498 vc
->floor_count
= get_bits(gb
, 6) + 1;
500 vc
->floors
= av_mallocz(vc
->floor_count
* sizeof(*vc
->floors
));
502 return AVERROR(ENOMEM
);
504 for (i
= 0; i
< vc
->floor_count
; ++i
) {
505 vorbis_floor
*floor_setup
= &vc
->floors
[i
];
507 floor_setup
->floor_type
= get_bits(gb
, 16);
509 av_dlog(NULL
, " %d. floor type %d \n", i
, floor_setup
->floor_type
);
511 if (floor_setup
->floor_type
== 1) {
512 int maximum_class
= -1;
513 unsigned rangebits
, rangemax
, floor1_values
= 2;
515 floor_setup
->decode
= vorbis_floor1_decode
;
517 floor_setup
->data
.t1
.partitions
= get_bits(gb
, 5);
519 av_dlog(NULL
, " %d.floor: %d partitions \n",
520 i
, floor_setup
->data
.t1
.partitions
);
522 for (j
= 0; j
< floor_setup
->data
.t1
.partitions
; ++j
) {
523 floor_setup
->data
.t1
.partition_class
[j
] = get_bits(gb
, 4);
524 if (floor_setup
->data
.t1
.partition_class
[j
] > maximum_class
)
525 maximum_class
= floor_setup
->data
.t1
.partition_class
[j
];
527 av_dlog(NULL
, " %d. floor %d partition class %d \n",
528 i
, j
, floor_setup
->data
.t1
.partition_class
[j
]);
532 av_dlog(NULL
, " maximum class %d \n", maximum_class
);
534 for (j
= 0; j
<= maximum_class
; ++j
) {
535 floor_setup
->data
.t1
.class_dimensions
[j
] = get_bits(gb
, 3) + 1;
536 floor_setup
->data
.t1
.class_subclasses
[j
] = get_bits(gb
, 2);
538 av_dlog(NULL
, " %d floor %d class dim: %d subclasses %d \n", i
, j
,
539 floor_setup
->data
.t1
.class_dimensions
[j
],
540 floor_setup
->data
.t1
.class_subclasses
[j
]);
542 if (floor_setup
->data
.t1
.class_subclasses
[j
]) {
543 GET_VALIDATED_INDEX(floor_setup
->data
.t1
.class_masterbook
[j
], 8, vc
->codebook_count
)
545 av_dlog(NULL
, " masterbook: %d \n", floor_setup
->data
.t1
.class_masterbook
[j
]);
548 for (k
= 0; k
< (1 << floor_setup
->data
.t1
.class_subclasses
[j
]); ++k
) {
549 int16_t bits
= get_bits(gb
, 8) - 1;
551 VALIDATE_INDEX(bits
, vc
->codebook_count
)
552 floor_setup
->data
.t1
.subclass_books
[j
][k
] = bits
;
554 av_dlog(NULL
, " book %d. : %d \n", k
, floor_setup
->data
.t1
.subclass_books
[j
][k
]);
558 floor_setup
->data
.t1
.multiplier
= get_bits(gb
, 2) + 1;
559 floor_setup
->data
.t1
.x_list_dim
= 2;
561 for (j
= 0; j
< floor_setup
->data
.t1
.partitions
; ++j
)
562 floor_setup
->data
.t1
.x_list_dim
+=floor_setup
->data
.t1
.class_dimensions
[floor_setup
->data
.t1
.partition_class
[j
]];
564 floor_setup
->data
.t1
.list
= av_mallocz_array(floor_setup
->data
.t1
.x_list_dim
,
565 sizeof(*floor_setup
->data
.t1
.list
));
566 if (!floor_setup
->data
.t1
.list
)
567 return AVERROR(ENOMEM
);
569 rangebits
= get_bits(gb
, 4);
570 rangemax
= (1 << rangebits
);
571 if (rangemax
> vc
->blocksize
[1] / 2) {
572 av_log(vc
->avctx
, AV_LOG_ERROR
,
573 "Floor value is too large for blocksize: %u (%"PRIu32
")\n",
574 rangemax
, vc
->blocksize
[1] / 2);
575 return AVERROR_INVALIDDATA
;
577 floor_setup
->data
.t1
.list
[0].x
= 0;
578 floor_setup
->data
.t1
.list
[1].x
= rangemax
;
580 for (j
= 0; j
< floor_setup
->data
.t1
.partitions
; ++j
) {
581 for (k
= 0; k
< floor_setup
->data
.t1
.class_dimensions
[floor_setup
->data
.t1
.partition_class
[j
]]; ++k
, ++floor1_values
) {
582 floor_setup
->data
.t1
.list
[floor1_values
].x
= get_bits(gb
, rangebits
);
584 av_dlog(NULL
, " %u. floor1 Y coord. %d\n", floor1_values
,
585 floor_setup
->data
.t1
.list
[floor1_values
].x
);
589 // Precalculate order of x coordinates - needed for decode
590 if (ff_vorbis_ready_floor1_list(vc
->avctx
,
591 floor_setup
->data
.t1
.list
,
592 floor_setup
->data
.t1
.x_list_dim
)) {
593 return AVERROR_INVALIDDATA
;
595 } else if (floor_setup
->floor_type
== 0) {
596 unsigned max_codebook_dim
= 0;
598 floor_setup
->decode
= vorbis_floor0_decode
;
600 floor_setup
->data
.t0
.order
= get_bits(gb
, 8);
601 if (!floor_setup
->data
.t0
.order
) {
602 av_log(vc
->avctx
, AV_LOG_ERROR
, "Floor 0 order is 0.\n");
603 return AVERROR_INVALIDDATA
;
605 floor_setup
->data
.t0
.rate
= get_bits(gb
, 16);
606 if (!floor_setup
->data
.t0
.rate
) {
607 av_log(vc
->avctx
, AV_LOG_ERROR
, "Floor 0 rate is 0.\n");
608 return AVERROR_INVALIDDATA
;
610 floor_setup
->data
.t0
.bark_map_size
= get_bits(gb
, 16);
611 if (!floor_setup
->data
.t0
.bark_map_size
) {
612 av_log(vc
->avctx
, AV_LOG_ERROR
,
613 "Floor 0 bark map size is 0.\n");
614 return AVERROR_INVALIDDATA
;
616 floor_setup
->data
.t0
.amplitude_bits
= get_bits(gb
, 6);
617 floor_setup
->data
.t0
.amplitude_offset
= get_bits(gb
, 8);
618 floor_setup
->data
.t0
.num_books
= get_bits(gb
, 4) + 1;
620 /* allocate mem for booklist */
621 floor_setup
->data
.t0
.book_list
=
622 av_malloc(floor_setup
->data
.t0
.num_books
);
623 if (!floor_setup
->data
.t0
.book_list
)
624 return AVERROR(ENOMEM
);
625 /* read book indexes */
629 for (idx
= 0; idx
< floor_setup
->data
.t0
.num_books
; ++idx
) {
630 GET_VALIDATED_INDEX(book_idx
, 8, vc
->codebook_count
)
631 floor_setup
->data
.t0
.book_list
[idx
] = book_idx
;
632 if (vc
->codebooks
[book_idx
].dimensions
> max_codebook_dim
)
633 max_codebook_dim
= vc
->codebooks
[book_idx
].dimensions
;
637 if ((ret
= create_map(vc
, i
)) < 0)
640 /* codebook dim is for padding if codebook dim doesn't *
641 * divide order+1 then we need to read more data */
642 floor_setup
->data
.t0
.lsp
=
643 av_malloc_array((floor_setup
->data
.t0
.order
+ 1 + max_codebook_dim
),
644 sizeof(*floor_setup
->data
.t0
.lsp
));
645 if (!floor_setup
->data
.t0
.lsp
)
646 return AVERROR(ENOMEM
);
648 /* debug output parsed headers */
649 av_dlog(NULL
, "floor0 order: %u\n", floor_setup
->data
.t0
.order
);
650 av_dlog(NULL
, "floor0 rate: %u\n", floor_setup
->data
.t0
.rate
);
651 av_dlog(NULL
, "floor0 bark map size: %u\n",
652 floor_setup
->data
.t0
.bark_map_size
);
653 av_dlog(NULL
, "floor0 amplitude bits: %u\n",
654 floor_setup
->data
.t0
.amplitude_bits
);
655 av_dlog(NULL
, "floor0 amplitude offset: %u\n",
656 floor_setup
->data
.t0
.amplitude_offset
);
657 av_dlog(NULL
, "floor0 number of books: %u\n",
658 floor_setup
->data
.t0
.num_books
);
659 av_dlog(NULL
, "floor0 book list pointer: %p\n",
660 floor_setup
->data
.t0
.book_list
);
663 for (idx
= 0; idx
< floor_setup
->data
.t0
.num_books
; ++idx
) {
664 av_dlog(NULL
, " Book %d: %u\n", idx
+ 1,
665 floor_setup
->data
.t0
.book_list
[idx
]);
669 av_log(vc
->avctx
, AV_LOG_ERROR
, "Invalid floor type!\n");
670 return AVERROR_INVALIDDATA
;
676 // Process residues part
678 static int vorbis_parse_setup_hdr_residues(vorbis_context
*vc
)
680 GetBitContext
*gb
= &vc
->gb
;
683 vc
->residue_count
= get_bits(gb
, 6)+1;
684 vc
->residues
= av_mallocz(vc
->residue_count
* sizeof(*vc
->residues
));
686 return AVERROR(ENOMEM
);
688 av_dlog(NULL
, " There are %d residues. \n", vc
->residue_count
);
690 for (i
= 0; i
< vc
->residue_count
; ++i
) {
691 vorbis_residue
*res_setup
= &vc
->residues
[i
];
693 unsigned high_bits
, low_bits
;
695 res_setup
->type
= get_bits(gb
, 16);
697 av_dlog(NULL
, " %u. residue type %d\n", i
, res_setup
->type
);
699 res_setup
->begin
= get_bits(gb
, 24);
700 res_setup
->end
= get_bits(gb
, 24);
701 res_setup
->partition_size
= get_bits(gb
, 24) + 1;
702 /* Validations to prevent a buffer overflow later. */
703 if (res_setup
->begin
>res_setup
->end
||
704 (res_setup
->end
-res_setup
->begin
) / res_setup
->partition_size
> FFMIN(V_MAX_PARTITIONS
, 65535)) {
705 av_log(vc
->avctx
, AV_LOG_ERROR
,
706 "partition out of bounds: type, begin, end, size, blocksize: %"PRIu16
", %"PRIu32
", %"PRIu32
", %u, %"PRIu32
"\n",
707 res_setup
->type
, res_setup
->begin
, res_setup
->end
,
708 res_setup
->partition_size
, vc
->blocksize
[1] / 2);
709 return AVERROR_INVALIDDATA
;
712 res_setup
->classifications
= get_bits(gb
, 6) + 1;
713 GET_VALIDATED_INDEX(res_setup
->classbook
, 8, vc
->codebook_count
)
715 res_setup
->ptns_to_read
=
716 (res_setup
->end
- res_setup
->begin
) / res_setup
->partition_size
;
717 res_setup
->classifs
= av_malloc_array(res_setup
->ptns_to_read
,
719 sizeof(*res_setup
->classifs
));
720 if (!res_setup
->classifs
)
721 return AVERROR(ENOMEM
);
723 av_dlog(NULL
, " begin %d end %d part.size %d classif.s %d classbook %d \n",
724 res_setup
->begin
, res_setup
->end
, res_setup
->partition_size
,
725 res_setup
->classifications
, res_setup
->classbook
);
727 for (j
= 0; j
< res_setup
->classifications
; ++j
) {
729 low_bits
= get_bits(gb
, 3);
731 high_bits
= get_bits(gb
, 5);
732 cascade
[j
] = (high_bits
<< 3) + low_bits
;
734 av_dlog(NULL
, " %u class cascade depth: %d\n", j
, ilog(cascade
[j
]));
737 res_setup
->maxpass
= 0;
738 for (j
= 0; j
< res_setup
->classifications
; ++j
) {
739 for (k
= 0; k
< 8; ++k
) {
740 if (cascade
[j
]&(1 << k
)) {
741 GET_VALIDATED_INDEX(res_setup
->books
[j
][k
], 8, vc
->codebook_count
)
743 av_dlog(NULL
, " %u class cascade depth %u book: %d\n",
744 j
, k
, res_setup
->books
[j
][k
]);
746 if (k
>res_setup
->maxpass
)
747 res_setup
->maxpass
= k
;
749 res_setup
->books
[j
][k
] = -1;
757 // Process mappings part
759 static int vorbis_parse_setup_hdr_mappings(vorbis_context
*vc
)
761 GetBitContext
*gb
= &vc
->gb
;
764 vc
->mapping_count
= get_bits(gb
, 6)+1;
765 vc
->mappings
= av_mallocz(vc
->mapping_count
* sizeof(*vc
->mappings
));
767 return AVERROR(ENOMEM
);
769 av_dlog(NULL
, " There are %d mappings. \n", vc
->mapping_count
);
771 for (i
= 0; i
< vc
->mapping_count
; ++i
) {
772 vorbis_mapping
*mapping_setup
= &vc
->mappings
[i
];
774 if (get_bits(gb
, 16)) {
775 av_log(vc
->avctx
, AV_LOG_ERROR
, "Other mappings than type 0 are not compliant with the Vorbis I specification. \n");
776 return AVERROR_INVALIDDATA
;
779 mapping_setup
->submaps
= get_bits(gb
, 4) + 1;
781 mapping_setup
->submaps
= 1;
785 mapping_setup
->coupling_steps
= get_bits(gb
, 8) + 1;
786 mapping_setup
->magnitude
= av_mallocz(mapping_setup
->coupling_steps
*
787 sizeof(*mapping_setup
->magnitude
));
788 mapping_setup
->angle
= av_mallocz(mapping_setup
->coupling_steps
*
789 sizeof(*mapping_setup
->angle
));
790 if (!mapping_setup
->angle
|| !mapping_setup
->magnitude
)
791 return AVERROR(ENOMEM
);
793 for (j
= 0; j
< mapping_setup
->coupling_steps
; ++j
) {
794 GET_VALIDATED_INDEX(mapping_setup
->magnitude
[j
], ilog(vc
->audio_channels
- 1), vc
->audio_channels
)
795 GET_VALIDATED_INDEX(mapping_setup
->angle
[j
], ilog(vc
->audio_channels
- 1), vc
->audio_channels
)
798 mapping_setup
->coupling_steps
= 0;
801 av_dlog(NULL
, " %u mapping coupling steps: %d\n",
802 i
, mapping_setup
->coupling_steps
);
804 if (get_bits(gb
, 2)) {
805 av_log(vc
->avctx
, AV_LOG_ERROR
, "%u. mapping setup data invalid.\n", i
);
806 return AVERROR_INVALIDDATA
; // following spec.
809 if (mapping_setup
->submaps
>1) {
810 mapping_setup
->mux
= av_mallocz_array(vc
->audio_channels
,
811 sizeof(*mapping_setup
->mux
));
812 if (!mapping_setup
->mux
)
813 return AVERROR(ENOMEM
);
815 for (j
= 0; j
< vc
->audio_channels
; ++j
)
816 mapping_setup
->mux
[j
] = get_bits(gb
, 4);
819 for (j
= 0; j
< mapping_setup
->submaps
; ++j
) {
820 skip_bits(gb
, 8); // FIXME check?
821 GET_VALIDATED_INDEX(mapping_setup
->submap_floor
[j
], 8, vc
->floor_count
)
822 GET_VALIDATED_INDEX(mapping_setup
->submap_residue
[j
], 8, vc
->residue_count
)
824 av_dlog(NULL
, " %u mapping %u submap : floor %d, residue %d\n", i
, j
,
825 mapping_setup
->submap_floor
[j
],
826 mapping_setup
->submap_residue
[j
]);
832 // Process modes part
834 static int create_map(vorbis_context
*vc
, unsigned floor_number
)
836 vorbis_floor
*floors
= vc
->floors
;
842 for (blockflag
= 0; blockflag
< 2; ++blockflag
) {
843 n
= vc
->blocksize
[blockflag
] / 2;
844 floors
[floor_number
].data
.t0
.map
[blockflag
] =
845 av_malloc_array(n
+ 1, sizeof(int32_t)); // n + sentinel
846 if (!floors
[floor_number
].data
.t0
.map
[blockflag
])
847 return AVERROR(ENOMEM
);
849 map
= floors
[floor_number
].data
.t0
.map
[blockflag
];
850 vf
= &floors
[floor_number
].data
.t0
;
852 for (idx
= 0; idx
< n
; ++idx
) {
853 map
[idx
] = floor(BARK((vf
->rate
* idx
) / (2.0f
* n
)) *
854 (vf
->bark_map_size
/ BARK(vf
->rate
/ 2.0f
)));
855 if (vf
->bark_map_size
-1 < map
[idx
])
856 map
[idx
] = vf
->bark_map_size
- 1;
859 vf
->map_size
[blockflag
] = n
;
862 for (idx
= 0; idx
<= n
; ++idx
) {
863 av_dlog(NULL
, "floor0 map: map at pos %d is %d\n", idx
, map
[idx
]);
869 static int vorbis_parse_setup_hdr_modes(vorbis_context
*vc
)
871 GetBitContext
*gb
= &vc
->gb
;
874 vc
->mode_count
= get_bits(gb
, 6) + 1;
875 vc
->modes
= av_mallocz(vc
->mode_count
* sizeof(*vc
->modes
));
877 return AVERROR(ENOMEM
);
879 av_dlog(NULL
, " There are %d modes.\n", vc
->mode_count
);
881 for (i
= 0; i
< vc
->mode_count
; ++i
) {
882 vorbis_mode
*mode_setup
= &vc
->modes
[i
];
884 mode_setup
->blockflag
= get_bits1(gb
);
885 mode_setup
->windowtype
= get_bits(gb
, 16); //FIXME check
886 mode_setup
->transformtype
= get_bits(gb
, 16); //FIXME check
887 GET_VALIDATED_INDEX(mode_setup
->mapping
, 8, vc
->mapping_count
);
889 av_dlog(NULL
, " %u mode: blockflag %d, windowtype %d, transformtype %d, mapping %d\n",
890 i
, mode_setup
->blockflag
, mode_setup
->windowtype
,
891 mode_setup
->transformtype
, mode_setup
->mapping
);
896 // Process the whole setup header using the functions above
898 static int vorbis_parse_setup_hdr(vorbis_context
*vc
)
900 GetBitContext
*gb
= &vc
->gb
;
903 if ((get_bits(gb
, 8) != 'v') || (get_bits(gb
, 8) != 'o') ||
904 (get_bits(gb
, 8) != 'r') || (get_bits(gb
, 8) != 'b') ||
905 (get_bits(gb
, 8) != 'i') || (get_bits(gb
, 8) != 's')) {
906 av_log(vc
->avctx
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (no vorbis signature). \n");
907 return AVERROR_INVALIDDATA
;
910 if ((ret
= vorbis_parse_setup_hdr_codebooks(vc
))) {
911 av_log(vc
->avctx
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (codebooks). \n");
914 if ((ret
= vorbis_parse_setup_hdr_tdtransforms(vc
))) {
915 av_log(vc
->avctx
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (time domain transforms). \n");
918 if ((ret
= vorbis_parse_setup_hdr_floors(vc
))) {
919 av_log(vc
->avctx
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (floors). \n");
922 if ((ret
= vorbis_parse_setup_hdr_residues(vc
))) {
923 av_log(vc
->avctx
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (residues). \n");
926 if ((ret
= vorbis_parse_setup_hdr_mappings(vc
))) {
927 av_log(vc
->avctx
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (mappings). \n");
930 if ((ret
= vorbis_parse_setup_hdr_modes(vc
))) {
931 av_log(vc
->avctx
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (modes). \n");
934 if (!get_bits1(gb
)) {
935 av_log(vc
->avctx
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (framing flag). \n");
936 return AVERROR_INVALIDDATA
; // framing flag bit unset error
942 // Process the identification header
944 static int vorbis_parse_id_hdr(vorbis_context
*vc
)
946 GetBitContext
*gb
= &vc
->gb
;
949 if ((get_bits(gb
, 8) != 'v') || (get_bits(gb
, 8) != 'o') ||
950 (get_bits(gb
, 8) != 'r') || (get_bits(gb
, 8) != 'b') ||
951 (get_bits(gb
, 8) != 'i') || (get_bits(gb
, 8) != 's')) {
952 av_log(vc
->avctx
, AV_LOG_ERROR
, " Vorbis id header packet corrupt (no vorbis signature). \n");
953 return AVERROR_INVALIDDATA
;
956 vc
->version
= get_bits_long(gb
, 32); //FIXME check 0
957 vc
->audio_channels
= get_bits(gb
, 8);
958 if (vc
->audio_channels
<= 0) {
959 av_log(vc
->avctx
, AV_LOG_ERROR
, "Invalid number of channels\n");
960 return AVERROR_INVALIDDATA
;
962 vc
->audio_samplerate
= get_bits_long(gb
, 32);
963 if (vc
->audio_samplerate
<= 0) {
964 av_log(vc
->avctx
, AV_LOG_ERROR
, "Invalid samplerate\n");
965 return AVERROR_INVALIDDATA
;
967 vc
->bitrate_maximum
= get_bits_long(gb
, 32);
968 vc
->bitrate_nominal
= get_bits_long(gb
, 32);
969 vc
->bitrate_minimum
= get_bits_long(gb
, 32);
970 bl0
= get_bits(gb
, 4);
971 bl1
= get_bits(gb
, 4);
972 if (bl0
> 13 || bl0
< 6 || bl1
> 13 || bl1
< 6 || bl1
< bl0
) {
973 av_log(vc
->avctx
, AV_LOG_ERROR
, " Vorbis id header packet corrupt (illegal blocksize). \n");
974 return AVERROR_INVALIDDATA
;
976 vc
->blocksize
[0] = (1 << bl0
);
977 vc
->blocksize
[1] = (1 << bl1
);
978 vc
->win
[0] = ff_vorbis_vwin
[bl0
- 6];
979 vc
->win
[1] = ff_vorbis_vwin
[bl1
- 6];
981 if ((get_bits1(gb
)) == 0) {
982 av_log(vc
->avctx
, AV_LOG_ERROR
, " Vorbis id header packet corrupt (framing flag not set). \n");
983 return AVERROR_INVALIDDATA
;
986 vc
->channel_residues
= av_malloc_array(vc
->blocksize
[1] / 2, vc
->audio_channels
* sizeof(*vc
->channel_residues
));
987 vc
->saved
= av_mallocz_array(vc
->blocksize
[1] / 4, vc
->audio_channels
* sizeof(*vc
->saved
));
988 if (!vc
->channel_residues
|| !vc
->saved
)
989 return AVERROR(ENOMEM
);
991 vc
->previous_window
= -1;
993 ff_mdct_init(&vc
->mdct
[0], bl0
, 1, -1.0);
994 ff_mdct_init(&vc
->mdct
[1], bl1
, 1, -1.0);
996 av_dlog(NULL
, " 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 ",
997 vc
->version
, vc
->audio_channels
, vc
->audio_samplerate
, vc
->bitrate_maximum
, vc
->bitrate_nominal
, vc
->bitrate_minimum
, vc
->blocksize
[0], vc
->blocksize
[1]);
1000 BLK = vc->blocksize[0];
1001 for (i = 0; i < BLK / 2; ++i) {
1002 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)));
1009 // Process the extradata using the functions above (identification header, setup header)
1011 static av_cold
int vorbis_decode_init(AVCodecContext
*avctx
)
1013 vorbis_context
*vc
= avctx
->priv_data
;
1014 uint8_t *headers
= avctx
->extradata
;
1015 int headers_len
= avctx
->extradata_size
;
1016 uint8_t *header_start
[3];
1018 GetBitContext
*gb
= &vc
->gb
;
1022 ff_vorbisdsp_init(&vc
->dsp
);
1023 avpriv_float_dsp_init(&vc
->fdsp
, avctx
->flags
& CODEC_FLAG_BITEXACT
);
1024 ff_fmt_convert_init(&vc
->fmt_conv
, avctx
);
1026 avctx
->sample_fmt
= AV_SAMPLE_FMT_FLTP
;
1029 av_log(avctx
, AV_LOG_ERROR
, "Extradata missing.\n");
1030 return AVERROR_INVALIDDATA
;
1033 if ((ret
= avpriv_split_xiph_headers(headers
, headers_len
, 30, header_start
, header_len
)) < 0) {
1034 av_log(avctx
, AV_LOG_ERROR
, "Extradata corrupt.\n");
1038 init_get_bits(gb
, header_start
[0], header_len
[0]*8);
1039 hdr_type
= get_bits(gb
, 8);
1040 if (hdr_type
!= 1) {
1041 av_log(avctx
, AV_LOG_ERROR
, "First header is not the id header.\n");
1042 return AVERROR_INVALIDDATA
;
1044 if ((ret
= vorbis_parse_id_hdr(vc
))) {
1045 av_log(avctx
, AV_LOG_ERROR
, "Id header corrupt.\n");
1050 init_get_bits(gb
, header_start
[2], header_len
[2]*8);
1051 hdr_type
= get_bits(gb
, 8);
1052 if (hdr_type
!= 5) {
1053 av_log(avctx
, AV_LOG_ERROR
, "Third header is not the setup header.\n");
1055 return AVERROR_INVALIDDATA
;
1057 if ((ret
= vorbis_parse_setup_hdr(vc
))) {
1058 av_log(avctx
, AV_LOG_ERROR
, "Setup header corrupt.\n");
1063 if (vc
->audio_channels
> 8)
1064 avctx
->channel_layout
= 0;
1066 avctx
->channel_layout
= ff_vorbis_channel_layouts
[vc
->audio_channels
- 1];
1068 avctx
->channels
= vc
->audio_channels
;
1069 avctx
->sample_rate
= vc
->audio_samplerate
;
1074 // Decode audiopackets -------------------------------------------------
1076 // Read and decode floor
1078 static int vorbis_floor0_decode(vorbis_context
*vc
,
1079 vorbis_floor_data
*vfu
, float *vec
)
1081 vorbis_floor0
*vf
= &vfu
->t0
;
1082 float *lsp
= vf
->lsp
;
1083 unsigned amplitude
, book_idx
;
1084 unsigned blockflag
= vc
->modes
[vc
->mode_number
].blockflag
;
1086 if (!vf
->amplitude_bits
)
1089 amplitude
= get_bits(&vc
->gb
, vf
->amplitude_bits
);
1090 if (amplitude
> 0) {
1092 unsigned idx
, lsp_len
= 0;
1093 vorbis_codebook codebook
;
1095 book_idx
= get_bits(&vc
->gb
, ilog(vf
->num_books
));
1096 if (book_idx
>= vf
->num_books
) {
1097 av_log(vc
->avctx
, AV_LOG_ERROR
, "floor0 dec: booknumber too high!\n");
1100 av_dlog(NULL
, "floor0 dec: booknumber: %u\n", book_idx
);
1101 codebook
= vc
->codebooks
[vf
->book_list
[book_idx
]];
1102 /* Invalid codebook! */
1103 if (!codebook
.codevectors
)
1104 return AVERROR_INVALIDDATA
;
1106 while (lsp_len
<vf
->order
) {
1109 av_dlog(NULL
, "floor0 dec: book dimension: %d\n", codebook
.dimensions
);
1110 av_dlog(NULL
, "floor0 dec: maximum depth: %d\n", codebook
.maxdepth
);
1111 /* read temp vector */
1112 vec_off
= get_vlc2(&vc
->gb
, codebook
.vlc
.table
,
1113 codebook
.nb_bits
, codebook
.maxdepth
)
1114 * codebook
.dimensions
;
1115 av_dlog(NULL
, "floor0 dec: vector offset: %d\n", vec_off
);
1116 /* copy each vector component and add last to it */
1117 for (idx
= 0; idx
< codebook
.dimensions
; ++idx
)
1118 lsp
[lsp_len
+idx
] = codebook
.codevectors
[vec_off
+idx
] + last
;
1119 last
= lsp
[lsp_len
+idx
-1]; /* set last to last vector component */
1121 lsp_len
+= codebook
.dimensions
;
1123 /* DEBUG: output lsp coeffs */
1126 for (idx
= 0; idx
< lsp_len
; ++idx
)
1127 av_dlog(NULL
, "floor0 dec: coeff at %d is %f\n", idx
, lsp
[idx
]);
1130 /* synthesize floor output vector */
1133 int order
= vf
->order
;
1134 float wstep
= M_PI
/ vf
->bark_map_size
;
1136 for (i
= 0; i
< order
; i
++)
1137 lsp
[i
] = 2.0f
* cos(lsp
[i
]);
1139 av_dlog(NULL
, "floor0 synth: map_size = %"PRIu32
"; m = %d; wstep = %f\n",
1140 vf
->map_size
[blockflag
], order
, wstep
);
1143 while (i
< vf
->map_size
[blockflag
]) {
1144 int j
, iter_cond
= vf
->map
[blockflag
][i
];
1147 float two_cos_w
= 2.0f
* cos(wstep
* iter_cond
); // needed all times
1149 /* similar part for the q and p products */
1150 for (j
= 0; j
+ 1 < order
; j
+= 2) {
1151 q
*= lsp
[j
] - two_cos_w
;
1152 p
*= lsp
[j
+ 1] - two_cos_w
;
1154 if (j
== order
) { // even order
1155 p
*= p
* (2.0f
- two_cos_w
);
1156 q
*= q
* (2.0f
+ two_cos_w
);
1157 } else { // odd order
1158 q
*= two_cos_w
-lsp
[j
]; // one more time for q
1160 /* final step and square */
1161 p
*= p
* (4.f
- two_cos_w
* two_cos_w
);
1165 /* calculate linear floor value */
1166 q
= exp((((amplitude
*vf
->amplitude_offset
) /
1167 (((1 << vf
->amplitude_bits
) - 1) * sqrt(p
+ q
)))
1168 - vf
->amplitude_offset
) * .11512925f
);
1173 } while (vf
->map
[blockflag
][i
] == iter_cond
);
1177 /* this channel is unused */
1181 av_dlog(NULL
, " Floor0 decoded\n");
1186 static int vorbis_floor1_decode(vorbis_context
*vc
,
1187 vorbis_floor_data
*vfu
, float *vec
)
1189 vorbis_floor1
*vf
= &vfu
->t1
;
1190 GetBitContext
*gb
= &vc
->gb
;
1191 uint16_t range_v
[4] = { 256, 128, 86, 64 };
1192 unsigned range
= range_v
[vf
->multiplier
- 1];
1193 uint16_t floor1_Y
[258];
1194 uint16_t floor1_Y_final
[258];
1195 int floor1_flag
[258];
1196 unsigned partition_class
, cdim
, cbits
, csub
, cval
, offset
, i
, j
;
1197 int book
, adx
, ady
, dy
, off
, predicted
, err
;
1200 if (!get_bits1(gb
)) // silence
1203 // Read values (or differences) for the floor's points
1205 floor1_Y
[0] = get_bits(gb
, ilog(range
- 1));
1206 floor1_Y
[1] = get_bits(gb
, ilog(range
- 1));
1208 av_dlog(NULL
, "floor 0 Y %d floor 1 Y %d \n", floor1_Y
[0], floor1_Y
[1]);
1211 for (i
= 0; i
< vf
->partitions
; ++i
) {
1212 partition_class
= vf
->partition_class
[i
];
1213 cdim
= vf
->class_dimensions
[partition_class
];
1214 cbits
= vf
->class_subclasses
[partition_class
];
1215 csub
= (1 << cbits
) - 1;
1218 av_dlog(NULL
, "Cbits %u\n", cbits
);
1220 if (cbits
) // this reads all subclasses for this partition's class
1221 cval
= get_vlc2(gb
, vc
->codebooks
[vf
->class_masterbook
[partition_class
]].vlc
.table
,
1222 vc
->codebooks
[vf
->class_masterbook
[partition_class
]].nb_bits
, 3);
1224 for (j
= 0; j
< cdim
; ++j
) {
1225 book
= vf
->subclass_books
[partition_class
][cval
& csub
];
1227 av_dlog(NULL
, "book %d Cbits %u cval %u bits:%d\n",
1228 book
, cbits
, cval
, get_bits_count(gb
));
1230 cval
= cval
>> cbits
;
1232 int v
= get_vlc2(gb
, vc
->codebooks
[book
].vlc
.table
,
1233 vc
->codebooks
[book
].nb_bits
, 3);
1235 return AVERROR_INVALIDDATA
;
1236 floor1_Y
[offset
+j
] = v
;
1238 floor1_Y
[offset
+j
] = 0;
1241 av_dlog(NULL
, " floor(%d) = %d \n",
1242 vf
->list
[offset
+j
].x
, floor1_Y
[offset
+j
]);
1247 // Amplitude calculation from the differences
1251 floor1_Y_final
[0] = floor1_Y
[0];
1252 floor1_Y_final
[1] = floor1_Y
[1];
1254 for (i
= 2; i
< vf
->x_list_dim
; ++i
) {
1255 unsigned val
, highroom
, lowroom
, room
, high_neigh_offs
, low_neigh_offs
;
1257 low_neigh_offs
= vf
->list
[i
].low
;
1258 high_neigh_offs
= vf
->list
[i
].high
;
1259 dy
= floor1_Y_final
[high_neigh_offs
] - floor1_Y_final
[low_neigh_offs
]; // render_point begin
1260 adx
= vf
->list
[high_neigh_offs
].x
- vf
->list
[low_neigh_offs
].x
;
1262 err
= ady
* (vf
->list
[i
].x
- vf
->list
[low_neigh_offs
].x
);
1265 predicted
= floor1_Y_final
[low_neigh_offs
] - off
;
1267 predicted
= floor1_Y_final
[low_neigh_offs
] + off
;
1268 } // render_point end
1271 highroom
= range
-predicted
;
1272 lowroom
= predicted
;
1273 if (highroom
< lowroom
) {
1274 room
= highroom
* 2;
1276 room
= lowroom
* 2; // SPEC misspelling
1279 floor1_flag
[low_neigh_offs
] = 1;
1280 floor1_flag
[high_neigh_offs
] = 1;
1283 if (highroom
> lowroom
) {
1284 floor1_Y_final
[i
] = av_clip_uint16(val
- lowroom
+ predicted
);
1286 floor1_Y_final
[i
] = av_clip_uint16(predicted
- val
+ highroom
- 1);
1290 floor1_Y_final
[i
] = av_clip_uint16(predicted
- (val
+ 1) / 2);
1292 floor1_Y_final
[i
] = av_clip_uint16(predicted
+ val
/ 2);
1297 floor1_Y_final
[i
] = av_clip_uint16(predicted
);
1300 av_dlog(NULL
, " Decoded floor(%d) = %u / val %u\n",
1301 vf
->list
[i
].x
, floor1_Y_final
[i
], val
);
1304 // Curve synth - connect the calculated dots and convert from dB scale FIXME optimize ?
1306 ff_vorbis_floor1_render_list(vf
->list
, vf
->x_list_dim
, floor1_Y_final
, floor1_flag
, vf
->multiplier
, vec
, vf
->list
[1].x
);
1308 av_dlog(NULL
, " Floor decoded\n");
1313 static av_always_inline
int setup_classifs(vorbis_context
*vc
,
1315 uint8_t *do_not_decode
,
1317 int partition_count
,
1322 unsigned c_p_c
= vc
->codebooks
[vr
->classbook
].dimensions
;
1323 unsigned inverse_class
= ff_inverse
[vr
->classifications
];
1324 unsigned temp
, temp2
;
1325 for (p
= 0, j
= 0; j
< ch_used
; ++j
) {
1326 if (!do_not_decode
[j
]) {
1327 temp
= get_vlc2(&vc
->gb
, vc
->codebooks
[vr
->classbook
].vlc
.table
,
1328 vc
->codebooks
[vr
->classbook
].nb_bits
, 3);
1330 av_dlog(NULL
, "Classword: %u\n", temp
);
1335 av_assert0(vr
->classifications
> 1); //needed for inverse[]
1337 if (temp
<= 65536) {
1338 for (i
= partition_count
+ c_p_c
- 1; i
>= partition_count
; i
--) {
1339 temp2
= (((uint64_t)temp
) * inverse_class
) >> 32;
1341 if (i
< ptns_to_read
)
1342 vr
->classifs
[p
+ i
] = temp
- temp2
* vr
->classifications
;
1346 for (i
= partition_count
+ c_p_c
- 1; i
>= partition_count
; i
--) {
1347 temp2
= temp
/ vr
->classifications
;
1349 if (i
< ptns_to_read
)
1350 vr
->classifs
[p
+ i
] = temp
- temp2
* vr
->classifications
;
1359 // Read and decode residue
1361 static av_always_inline
int vorbis_residue_decode_internal(vorbis_context
*vc
,
1364 uint8_t *do_not_decode
,
1370 GetBitContext
*gb
= &vc
->gb
;
1371 unsigned c_p_c
= vc
->codebooks
[vr
->classbook
].dimensions
;
1372 uint8_t *classifs
= vr
->classifs
;
1373 unsigned pass
, ch_used
, i
, j
, k
, l
;
1374 unsigned max_output
= (ch
- 1) * vlen
;
1375 int ptns_to_read
= vr
->ptns_to_read
;
1376 int libvorbis_bug
= 0;
1379 for (j
= 1; j
< ch
; ++j
)
1380 do_not_decode
[0] &= do_not_decode
[j
]; // FIXME - clobbering input
1381 if (do_not_decode
[0])
1384 max_output
+= vr
->end
/ ch
;
1387 max_output
+= vr
->end
;
1390 if (max_output
> ch_left
* vlen
) {
1391 if (max_output
<= ch_left
* vlen
+ vr
->partition_size
*ch_used
/ch
) {
1395 av_log(vc
->avctx
, AV_LOG_ERROR
, "Insufficient output buffer\n");
1396 return AVERROR_INVALIDDATA
;
1400 av_dlog(NULL
, " residue type 0/1/2 decode begin, ch: %d cpc %d \n", ch
, c_p_c
);
1402 for (pass
= 0; pass
<= vr
->maxpass
; ++pass
) { // FIXME OPTIMIZE?
1403 int voffset
, partition_count
, j_times_ptns_to_read
;
1405 voffset
= vr
->begin
;
1406 for (partition_count
= 0; partition_count
< ptns_to_read
;) { // SPEC error
1409 if ((ret
= setup_classifs(vc
, vr
, do_not_decode
, ch_used
, partition_count
, ptns_to_read
)) < 0)
1412 for (i
= 0; (i
< c_p_c
) && (partition_count
< ptns_to_read
); ++i
) {
1413 for (j_times_ptns_to_read
= 0, j
= 0; j
< ch_used
; ++j
) {
1416 if (!do_not_decode
[j
]) {
1417 unsigned vqclass
= classifs
[j_times_ptns_to_read
+ partition_count
];
1418 int vqbook
= vr
->books
[vqclass
][pass
];
1420 if (vqbook
>= 0 && vc
->codebooks
[vqbook
].codevectors
) {
1422 unsigned dim
= vc
->codebooks
[vqbook
].dimensions
;
1423 unsigned step
= FASTDIV(vr
->partition_size
<< 1, dim
<< 1);
1424 vorbis_codebook codebook
= vc
->codebooks
[vqbook
];
1428 voffs
= voffset
+j
*vlen
;
1429 for (k
= 0; k
< step
; ++k
) {
1430 coffs
= get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * dim
;
1431 for (l
= 0; l
< dim
; ++l
)
1432 vec
[voffs
+ k
+ l
* step
] += codebook
.codevectors
[coffs
+ l
];
1434 } else if (vr_type
== 1) {
1435 voffs
= voffset
+ j
* vlen
;
1436 for (k
= 0; k
< step
; ++k
) {
1437 coffs
= get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * dim
;
1438 for (l
= 0; l
< dim
; ++l
, ++voffs
) {
1439 vec
[voffs
]+=codebook
.codevectors
[coffs
+l
];
1441 av_dlog(NULL
, " pass %d offs: %d curr: %f change: %f cv offs.: %d \n",
1442 pass
, voffs
, vec
[voffs
], codebook
.codevectors
[coffs
+l
], coffs
);
1445 } else if (vr_type
== 2 && ch
== 2 && (voffset
& 1) == 0 && (dim
& 1) == 0) { // most frequent case optimized
1446 voffs
= voffset
>> 1;
1449 for (k
= 0; k
< step
; ++k
) {
1450 coffs
= get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * 2;
1451 vec
[voffs
+ k
] += codebook
.codevectors
[coffs
];
1452 vec
[voffs
+ k
+ vlen
] += codebook
.codevectors
[coffs
+ 1];
1454 } else if (dim
== 4) {
1455 for (k
= 0; k
< step
; ++k
, voffs
+= 2) {
1456 coffs
= get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * 4;
1457 vec
[voffs
] += codebook
.codevectors
[coffs
];
1458 vec
[voffs
+ 1 ] += codebook
.codevectors
[coffs
+ 2];
1459 vec
[voffs
+ vlen
] += codebook
.codevectors
[coffs
+ 1];
1460 vec
[voffs
+ vlen
+ 1] += codebook
.codevectors
[coffs
+ 3];
1463 for (k
= 0; k
< step
; ++k
) {
1464 coffs
= get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * dim
;
1465 for (l
= 0; l
< dim
; l
+= 2, voffs
++) {
1466 vec
[voffs
] += codebook
.codevectors
[coffs
+ l
];
1467 vec
[voffs
+ vlen
] += codebook
.codevectors
[coffs
+ l
+ 1];
1469 av_dlog(NULL
, " pass %d offs: %d curr: %f change: %f cv offs.: %d+%d \n",
1470 pass
, voffset
/ ch
+ (voffs
% ch
) * vlen
,
1471 vec
[voffset
/ ch
+ (voffs
% ch
) * vlen
],
1472 codebook
.codevectors
[coffs
+ l
], coffs
, l
);
1476 } else if (vr_type
== 2) {
1477 unsigned voffs_div
= FASTDIV(voffset
<< 1, ch
<<1);
1478 unsigned voffs_mod
= voffset
- voffs_div
* ch
;
1480 for (k
= 0; k
< step
; ++k
) {
1481 coffs
= get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * dim
;
1482 for (l
= 0; l
< dim
; ++l
) {
1483 vec
[voffs_div
+ voffs_mod
* vlen
] +=
1484 codebook
.codevectors
[coffs
+ l
];
1486 av_dlog(NULL
, " pass %d offs: %d curr: %f change: %f cv offs.: %d+%d \n",
1487 pass
, voffs_div
+ voffs_mod
* vlen
,
1488 vec
[voffs_div
+ voffs_mod
* vlen
],
1489 codebook
.codevectors
[coffs
+ l
], coffs
, l
);
1491 if (++voffs_mod
== ch
) {
1500 j_times_ptns_to_read
+= ptns_to_read
;
1503 voffset
+= vr
->partition_size
;
1506 if (libvorbis_bug
&& !pass
) {
1507 for (j
= 0; j
< ch_used
; ++j
) {
1508 if (!do_not_decode
[j
]) {
1509 get_vlc2(&vc
->gb
, vc
->codebooks
[vr
->classbook
].vlc
.table
,
1510 vc
->codebooks
[vr
->classbook
].nb_bits
, 3);
1518 static inline int vorbis_residue_decode(vorbis_context
*vc
, vorbis_residue
*vr
,
1520 uint8_t *do_not_decode
,
1521 float *vec
, unsigned vlen
,
1525 return vorbis_residue_decode_internal(vc
, vr
, ch
, do_not_decode
, vec
, vlen
, ch_left
, 2);
1526 else if (vr
->type
== 1)
1527 return vorbis_residue_decode_internal(vc
, vr
, ch
, do_not_decode
, vec
, vlen
, ch_left
, 1);
1528 else if (vr
->type
== 0)
1529 return vorbis_residue_decode_internal(vc
, vr
, ch
, do_not_decode
, vec
, vlen
, ch_left
, 0);
1531 av_log(vc
->avctx
, AV_LOG_ERROR
, " Invalid residue type while residue decode?! \n");
1532 return AVERROR_INVALIDDATA
;
1536 void ff_vorbis_inverse_coupling(float *mag
, float *ang
, intptr_t blocksize
)
1539 for (i
= 0; i
< blocksize
; i
++) {
1542 ang
[i
] = mag
[i
] - ang
[i
];
1544 float temp
= ang
[i
];
1552 float temp
= ang
[i
];
1560 // Decode the audio packet using the functions above
1562 static int vorbis_parse_audio_packet(vorbis_context
*vc
, float **floor_ptr
)
1564 GetBitContext
*gb
= &vc
->gb
;
1566 int previous_window
= vc
->previous_window
;
1567 unsigned mode_number
, blockflag
, blocksize
;
1569 uint8_t no_residue
[255];
1570 uint8_t do_not_decode
[255];
1571 vorbis_mapping
*mapping
;
1572 float *ch_res_ptr
= vc
->channel_residues
;
1573 uint8_t res_chan
[255];
1574 unsigned res_num
= 0;
1576 unsigned ch_left
= vc
->audio_channels
;
1579 if (get_bits1(gb
)) {
1580 av_log(vc
->avctx
, AV_LOG_ERROR
, "Not a Vorbis I audio packet.\n");
1581 return AVERROR_INVALIDDATA
; // packet type not audio
1584 if (vc
->mode_count
== 1) {
1587 GET_VALIDATED_INDEX(mode_number
, ilog(vc
->mode_count
-1), vc
->mode_count
)
1589 vc
->mode_number
= mode_number
;
1590 mapping
= &vc
->mappings
[vc
->modes
[mode_number
].mapping
];
1592 av_dlog(NULL
, " Mode number: %u , mapping: %d , blocktype %d\n", mode_number
,
1593 vc
->modes
[mode_number
].mapping
, vc
->modes
[mode_number
].blockflag
);
1595 blockflag
= vc
->modes
[mode_number
].blockflag
;
1596 blocksize
= vc
->blocksize
[blockflag
];
1597 vlen
= blocksize
/ 2;
1599 int code
= get_bits(gb
, 2);
1600 if (previous_window
< 0)
1601 previous_window
= code
>>1;
1602 } else if (previous_window
< 0)
1603 previous_window
= 0;
1605 memset(ch_res_ptr
, 0, sizeof(float) * vc
->audio_channels
* vlen
); //FIXME can this be removed ?
1606 for (i
= 0; i
< vc
->audio_channels
; ++i
)
1607 memset(floor_ptr
[i
], 0, vlen
* sizeof(floor_ptr
[0][0])); //FIXME can this be removed ?
1611 for (i
= 0; i
< vc
->audio_channels
; ++i
) {
1612 vorbis_floor
*floor
;
1614 if (mapping
->submaps
> 1) {
1615 floor
= &vc
->floors
[mapping
->submap_floor
[mapping
->mux
[i
]]];
1617 floor
= &vc
->floors
[mapping
->submap_floor
[0]];
1620 ret
= floor
->decode(vc
, &floor
->data
, floor_ptr
[i
]);
1623 av_log(vc
->avctx
, AV_LOG_ERROR
, "Invalid codebook in vorbis_floor_decode.\n");
1624 return AVERROR_INVALIDDATA
;
1626 no_residue
[i
] = ret
;
1629 // Nonzero vector propagate
1631 for (i
= mapping
->coupling_steps
- 1; i
>= 0; --i
) {
1632 if (!(no_residue
[mapping
->magnitude
[i
]] & no_residue
[mapping
->angle
[i
]])) {
1633 no_residue
[mapping
->magnitude
[i
]] = 0;
1634 no_residue
[mapping
->angle
[i
]] = 0;
1640 for (i
= 0; i
< mapping
->submaps
; ++i
) {
1641 vorbis_residue
*residue
;
1645 for (j
= 0; j
< vc
->audio_channels
; ++j
) {
1646 if ((mapping
->submaps
== 1) || (i
== mapping
->mux
[j
])) {
1647 res_chan
[j
] = res_num
;
1648 if (no_residue
[j
]) {
1649 do_not_decode
[ch
] = 1;
1651 do_not_decode
[ch
] = 0;
1657 residue
= &vc
->residues
[mapping
->submap_residue
[i
]];
1659 av_log(vc
->avctx
, AV_LOG_ERROR
, "Too many channels in vorbis_floor_decode.\n");
1660 return AVERROR_INVALIDDATA
;
1663 ret
= vorbis_residue_decode(vc
, residue
, ch
, do_not_decode
, ch_res_ptr
, vlen
, ch_left
);
1668 ch_res_ptr
+= ch
* vlen
;
1673 return AVERROR_INVALIDDATA
;
1677 for (i
= mapping
->coupling_steps
- 1; i
>= 0; --i
) { //warning: i has to be signed
1680 mag
= vc
->channel_residues
+res_chan
[mapping
->magnitude
[i
]] * blocksize
/ 2;
1681 ang
= vc
->channel_residues
+res_chan
[mapping
->angle
[i
]] * blocksize
/ 2;
1682 vc
->dsp
.vorbis_inverse_coupling(mag
, ang
, blocksize
/ 2);
1687 mdct
= &vc
->mdct
[blockflag
];
1689 for (j
= vc
->audio_channels
-1;j
>= 0; j
--) {
1690 ch_res_ptr
= vc
->channel_residues
+ res_chan
[j
] * blocksize
/ 2;
1691 vc
->fdsp
.vector_fmul(floor_ptr
[j
], floor_ptr
[j
], ch_res_ptr
, blocksize
/ 2);
1692 mdct
->imdct_half(mdct
, ch_res_ptr
, floor_ptr
[j
]);
1695 // Overlap/add, save data for next overlapping
1697 retlen
= (blocksize
+ vc
->blocksize
[previous_window
]) / 4;
1698 for (j
= 0; j
< vc
->audio_channels
; j
++) {
1699 unsigned bs0
= vc
->blocksize
[0];
1700 unsigned bs1
= vc
->blocksize
[1];
1701 float *residue
= vc
->channel_residues
+ res_chan
[j
] * blocksize
/ 2;
1702 float *saved
= vc
->saved
+ j
* bs1
/ 4;
1703 float *ret
= floor_ptr
[j
];
1704 float *buf
= residue
;
1705 const float *win
= vc
->win
[blockflag
& previous_window
];
1707 if (blockflag
== previous_window
) {
1708 vc
->fdsp
.vector_fmul_window(ret
, saved
, buf
, win
, blocksize
/ 4);
1709 } else if (blockflag
> previous_window
) {
1710 vc
->fdsp
.vector_fmul_window(ret
, saved
, buf
, win
, bs0
/ 4);
1711 memcpy(ret
+bs0
/2, buf
+bs0
/4, ((bs1
-bs0
)/4) * sizeof(float));
1713 memcpy(ret
, saved
, ((bs1
- bs0
) / 4) * sizeof(float));
1714 vc
->fdsp
.vector_fmul_window(ret
+ (bs1
- bs0
) / 4, saved
+ (bs1
- bs0
) / 4, buf
, win
, bs0
/ 4);
1716 memcpy(saved
, buf
+ blocksize
/ 4, blocksize
/ 4 * sizeof(float));
1719 vc
->previous_window
= blockflag
;
1723 // Return the decoded audio packet through the standard api
1725 static int vorbis_decode_frame(AVCodecContext
*avctx
, void *data
,
1726 int *got_frame_ptr
, AVPacket
*avpkt
)
1728 const uint8_t *buf
= avpkt
->data
;
1729 int buf_size
= avpkt
->size
;
1730 vorbis_context
*vc
= avctx
->priv_data
;
1731 AVFrame
*frame
= data
;
1732 GetBitContext
*gb
= &vc
->gb
;
1733 float *channel_ptrs
[255];
1736 av_dlog(NULL
, "packet length %d \n", buf_size
);
1738 if (*buf
== 1 && buf_size
> 7) {
1739 init_get_bits(gb
, buf
+1, buf_size
*8 - 8);
1741 if ((ret
= vorbis_parse_id_hdr(vc
))) {
1742 av_log(avctx
, AV_LOG_ERROR
, "Id header corrupt.\n");
1747 if (vc
->audio_channels
> 8)
1748 avctx
->channel_layout
= 0;
1750 avctx
->channel_layout
= ff_vorbis_channel_layouts
[vc
->audio_channels
- 1];
1752 avctx
->channels
= vc
->audio_channels
;
1753 avctx
->sample_rate
= vc
->audio_samplerate
;
1757 if (*buf
== 3 && buf_size
> 7) {
1758 av_log(avctx
, AV_LOG_DEBUG
, "Ignoring comment header\n");
1762 if (*buf
== 5 && buf_size
> 7 && vc
->channel_residues
&& !vc
->modes
) {
1763 init_get_bits(gb
, buf
+1, buf_size
*8 - 8);
1764 if ((ret
= vorbis_parse_setup_hdr(vc
))) {
1765 av_log(avctx
, AV_LOG_ERROR
, "Setup header corrupt.\n");
1772 if (!vc
->channel_residues
|| !vc
->modes
) {
1773 av_log(avctx
, AV_LOG_ERROR
, "Data packet before valid headers\n");
1774 return AVERROR_INVALIDDATA
;
1777 /* get output buffer */
1778 frame
->nb_samples
= vc
->blocksize
[1] / 2;
1779 if ((ret
= ff_get_buffer(avctx
, frame
, 0)) < 0)
1782 if (vc
->audio_channels
> 8) {
1783 for (i
= 0; i
< vc
->audio_channels
; i
++)
1784 channel_ptrs
[i
] = (float *)frame
->extended_data
[i
];
1786 for (i
= 0; i
< vc
->audio_channels
; i
++) {
1787 int ch
= ff_vorbis_channel_layout_offsets
[vc
->audio_channels
- 1][i
];
1788 channel_ptrs
[ch
] = (float *)frame
->extended_data
[i
];
1792 init_get_bits(gb
, buf
, buf_size
*8);
1794 if ((len
= vorbis_parse_audio_packet(vc
, channel_ptrs
)) <= 0)
1797 if (!vc
->first_frame
) {
1798 vc
->first_frame
= 1;
1800 av_frame_unref(frame
);
1804 av_dlog(NULL
, "parsed %d bytes %d bits, returned %d samples (*ch*bits) \n",
1805 get_bits_count(gb
) / 8, get_bits_count(gb
) % 8, len
);
1807 frame
->nb_samples
= len
;
1815 static av_cold
int vorbis_decode_close(AVCodecContext
*avctx
)
1817 vorbis_context
*vc
= avctx
->priv_data
;
1824 static av_cold
void vorbis_decode_flush(AVCodecContext
*avctx
)
1826 vorbis_context
*vc
= avctx
->priv_data
;
1829 memset(vc
->saved
, 0, (vc
->blocksize
[1] / 4) * vc
->audio_channels
*
1830 sizeof(*vc
->saved
));
1832 vc
->previous_window
= -1;
1833 vc
->first_frame
= 0;
1836 AVCodec ff_vorbis_decoder
= {
1838 .long_name
= NULL_IF_CONFIG_SMALL("Vorbis"),
1839 .type
= AVMEDIA_TYPE_AUDIO
,
1840 .id
= AV_CODEC_ID_VORBIS
,
1841 .priv_data_size
= sizeof(vorbis_context
),
1842 .init
= vorbis_decode_init
,
1843 .close
= vorbis_decode_close
,
1844 .decode
= vorbis_decode_frame
,
1845 .flush
= vorbis_decode_flush
,
1846 .capabilities
= CODEC_CAP_DR1
,
1847 .channel_layouts
= ff_vorbis_channel_layouts
,
1848 .sample_fmts
= (const enum AVSampleFormat
[]) { AV_SAMPLE_FMT_FLTP
,
1849 AV_SAMPLE_FMT_NONE
},