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
);
199 for (i
= 0; i
< vc
->residue_count
; i
++)
200 av_freep(&vc
->residues
[i
].classifs
);
201 av_freep(&vc
->residues
);
202 av_freep(&vc
->modes
);
204 ff_mdct_end(&vc
->mdct
[0]);
205 ff_mdct_end(&vc
->mdct
[1]);
208 for (i
= 0; i
< vc
->codebook_count
; ++i
) {
209 av_freep(&vc
->codebooks
[i
].codevectors
);
210 ff_free_vlc(&vc
->codebooks
[i
].vlc
);
212 av_freep(&vc
->codebooks
);
215 for (i
= 0; i
< vc
->floor_count
; ++i
) {
216 if (vc
->floors
[i
].floor_type
== 0) {
217 av_freep(&vc
->floors
[i
].data
.t0
.map
[0]);
218 av_freep(&vc
->floors
[i
].data
.t0
.map
[1]);
219 av_freep(&vc
->floors
[i
].data
.t0
.book_list
);
220 av_freep(&vc
->floors
[i
].data
.t0
.lsp
);
222 av_freep(&vc
->floors
[i
].data
.t1
.list
);
225 av_freep(&vc
->floors
);
228 for (i
= 0; i
< vc
->mapping_count
; ++i
) {
229 av_freep(&vc
->mappings
[i
].magnitude
);
230 av_freep(&vc
->mappings
[i
].angle
);
231 av_freep(&vc
->mappings
[i
].mux
);
233 av_freep(&vc
->mappings
);
236 // Parse setup header -------------------------------------------------
238 // Process codebooks part
240 static int vorbis_parse_setup_hdr_codebooks(vorbis_context
*vc
)
243 uint8_t *tmp_vlc_bits
= NULL
;
244 uint32_t *tmp_vlc_codes
= NULL
;
245 GetBitContext
*gb
= &vc
->gb
;
246 uint16_t *codebook_multiplicands
= NULL
;
249 vc
->codebook_count
= get_bits(gb
, 8) + 1;
251 av_dlog(NULL
, " Codebooks: %d \n", vc
->codebook_count
);
253 vc
->codebooks
= av_mallocz(vc
->codebook_count
* sizeof(*vc
->codebooks
));
254 tmp_vlc_bits
= av_mallocz(V_MAX_VLCS
* sizeof(*tmp_vlc_bits
));
255 tmp_vlc_codes
= av_mallocz(V_MAX_VLCS
* sizeof(*tmp_vlc_codes
));
256 codebook_multiplicands
= av_malloc(V_MAX_VLCS
* sizeof(*codebook_multiplicands
));
257 if (!vc
->codebooks
||
258 !tmp_vlc_bits
|| !tmp_vlc_codes
|| !codebook_multiplicands
) {
259 ret
= AVERROR(ENOMEM
);
263 for (cb
= 0; cb
< vc
->codebook_count
; ++cb
) {
264 vorbis_codebook
*codebook_setup
= &vc
->codebooks
[cb
];
265 unsigned ordered
, t
, entries
, used_entries
= 0;
267 av_dlog(NULL
, " %u. Codebook\n", cb
);
269 if (get_bits(gb
, 24) != 0x564342) {
270 av_log(vc
->avctx
, AV_LOG_ERROR
,
271 " %u. Codebook setup data corrupt.\n", cb
);
272 ret
= AVERROR_INVALIDDATA
;
276 codebook_setup
->dimensions
=get_bits(gb
, 16);
277 if (codebook_setup
->dimensions
> 16 || codebook_setup
->dimensions
== 0) {
278 av_log(vc
->avctx
, AV_LOG_ERROR
,
279 " %u. Codebook's dimension is invalid (%d).\n",
280 cb
, codebook_setup
->dimensions
);
281 ret
= AVERROR_INVALIDDATA
;
284 entries
= get_bits(gb
, 24);
285 if (entries
> V_MAX_VLCS
) {
286 av_log(vc
->avctx
, AV_LOG_ERROR
,
287 " %u. Codebook has too many entries (%u).\n",
289 ret
= AVERROR_INVALIDDATA
;
293 ordered
= get_bits1(gb
);
295 av_dlog(NULL
, " codebook_dimensions %d, codebook_entries %u\n",
296 codebook_setup
->dimensions
, entries
);
300 unsigned sparse
= get_bits1(gb
);
302 av_dlog(NULL
, " not ordered \n");
305 av_dlog(NULL
, " sparse \n");
308 for (ce
= 0; ce
< entries
; ++ce
) {
309 flag
= get_bits1(gb
);
311 tmp_vlc_bits
[ce
] = get_bits(gb
, 5) + 1;
314 tmp_vlc_bits
[ce
] = 0;
317 av_dlog(NULL
, " not sparse \n");
319 used_entries
= entries
;
320 for (ce
= 0; ce
< entries
; ++ce
)
321 tmp_vlc_bits
[ce
] = get_bits(gb
, 5) + 1;
324 unsigned current_entry
= 0;
325 unsigned current_length
= get_bits(gb
, 5) + 1;
327 av_dlog(NULL
, " ordered, current length: %u\n", current_length
); //FIXME
329 used_entries
= entries
;
330 for (; current_entry
< used_entries
&& current_length
<= 32; ++current_length
) {
333 av_dlog(NULL
, " number bits: %u ", ilog(entries
- current_entry
));
335 number
= get_bits(gb
, ilog(entries
- current_entry
));
337 av_dlog(NULL
, " number: %u\n", number
);
339 for (i
= current_entry
; i
< number
+current_entry
; ++i
)
340 if (i
< used_entries
)
341 tmp_vlc_bits
[i
] = current_length
;
343 current_entry
+=number
;
345 if (current_entry
>used_entries
) {
346 av_log(vc
->avctx
, AV_LOG_ERROR
, " More codelengths than codes in codebook. \n");
347 ret
= AVERROR_INVALIDDATA
;
352 codebook_setup
->lookup_type
= get_bits(gb
, 4);
354 av_dlog(NULL
, " lookup type: %d : %s \n", codebook_setup
->lookup_type
,
355 codebook_setup
->lookup_type
? "vq" : "no lookup");
357 // If the codebook is used for (inverse) VQ, calculate codevectors.
359 if (codebook_setup
->lookup_type
== 1) {
361 unsigned codebook_lookup_values
= ff_vorbis_nth_root(entries
, codebook_setup
->dimensions
);
363 float codebook_minimum_value
= vorbisfloat2float(get_bits_long(gb
, 32));
364 float codebook_delta_value
= vorbisfloat2float(get_bits_long(gb
, 32));
365 unsigned codebook_value_bits
= get_bits(gb
, 4) + 1;
366 unsigned codebook_sequence_p
= get_bits1(gb
);
368 av_dlog(NULL
, " We expect %d numbers for building the codevectors. \n",
369 codebook_lookup_values
);
370 av_dlog(NULL
, " delta %f minmum %f \n",
371 codebook_delta_value
, codebook_minimum_value
);
373 for (i
= 0; i
< codebook_lookup_values
; ++i
) {
374 codebook_multiplicands
[i
] = get_bits(gb
, codebook_value_bits
);
376 av_dlog(NULL
, " multiplicands*delta+minmum : %e \n",
377 (float)codebook_multiplicands
[i
] * codebook_delta_value
+ codebook_minimum_value
);
378 av_dlog(NULL
, " multiplicand %u\n", codebook_multiplicands
[i
]);
381 // Weed out unused vlcs and build codevector vector
382 codebook_setup
->codevectors
= used_entries
? av_mallocz_array(used_entries
,
383 codebook_setup
->dimensions
*
384 sizeof(*codebook_setup
->codevectors
))
386 for (j
= 0, i
= 0; i
< entries
; ++i
) {
387 unsigned dim
= codebook_setup
->dimensions
;
389 if (tmp_vlc_bits
[i
]) {
391 unsigned lookup_offset
= i
;
393 av_dlog(vc
->avctx
, "Lookup offset %u ,", i
);
395 for (k
= 0; k
< dim
; ++k
) {
396 unsigned multiplicand_offset
= lookup_offset
% codebook_lookup_values
;
397 codebook_setup
->codevectors
[j
* dim
+ k
] = codebook_multiplicands
[multiplicand_offset
] * codebook_delta_value
+ codebook_minimum_value
+ last
;
398 if (codebook_sequence_p
)
399 last
= codebook_setup
->codevectors
[j
* dim
+ k
];
400 lookup_offset
/=codebook_lookup_values
;
402 tmp_vlc_bits
[j
] = tmp_vlc_bits
[i
];
404 av_dlog(vc
->avctx
, "real lookup offset %u, vector: ", j
);
405 for (k
= 0; k
< dim
; ++k
)
406 av_dlog(vc
->avctx
, " %f ",
407 codebook_setup
->codevectors
[j
* dim
+ k
]);
408 av_dlog(vc
->avctx
, "\n");
413 if (j
!= used_entries
) {
414 av_log(vc
->avctx
, AV_LOG_ERROR
, "Bug in codevector vector building code. \n");
415 ret
= AVERROR_INVALIDDATA
;
418 entries
= used_entries
;
419 } else if (codebook_setup
->lookup_type
>= 2) {
420 av_log(vc
->avctx
, AV_LOG_ERROR
, "Codebook lookup type not supported. \n");
421 ret
= AVERROR_INVALIDDATA
;
425 // Initialize VLC table
426 if (ff_vorbis_len2vlc(tmp_vlc_bits
, tmp_vlc_codes
, entries
)) {
427 av_log(vc
->avctx
, AV_LOG_ERROR
, " Invalid code lengths while generating vlcs. \n");
428 ret
= AVERROR_INVALIDDATA
;
431 codebook_setup
->maxdepth
= 0;
432 for (t
= 0; t
< entries
; ++t
)
433 if (tmp_vlc_bits
[t
] >= codebook_setup
->maxdepth
)
434 codebook_setup
->maxdepth
= tmp_vlc_bits
[t
];
436 if (codebook_setup
->maxdepth
> 3 * V_NB_BITS
)
437 codebook_setup
->nb_bits
= V_NB_BITS2
;
439 codebook_setup
->nb_bits
= V_NB_BITS
;
441 codebook_setup
->maxdepth
= (codebook_setup
->maxdepth
+codebook_setup
->nb_bits
- 1) / codebook_setup
->nb_bits
;
443 if ((ret
= init_vlc(&codebook_setup
->vlc
, codebook_setup
->nb_bits
,
444 entries
, tmp_vlc_bits
, sizeof(*tmp_vlc_bits
),
445 sizeof(*tmp_vlc_bits
), tmp_vlc_codes
,
446 sizeof(*tmp_vlc_codes
), sizeof(*tmp_vlc_codes
),
448 av_log(vc
->avctx
, AV_LOG_ERROR
, " Error generating vlc tables. \n");
453 av_free(tmp_vlc_bits
);
454 av_free(tmp_vlc_codes
);
455 av_free(codebook_multiplicands
);
460 av_free(tmp_vlc_bits
);
461 av_free(tmp_vlc_codes
);
462 av_free(codebook_multiplicands
);
466 // Process time domain transforms part (unused in Vorbis I)
468 static int vorbis_parse_setup_hdr_tdtransforms(vorbis_context
*vc
)
470 GetBitContext
*gb
= &vc
->gb
;
471 unsigned i
, vorbis_time_count
= get_bits(gb
, 6) + 1;
473 for (i
= 0; i
< vorbis_time_count
; ++i
) {
474 unsigned vorbis_tdtransform
= get_bits(gb
, 16);
476 av_dlog(NULL
, " Vorbis time domain transform %u: %u\n",
477 vorbis_time_count
, vorbis_tdtransform
);
479 if (vorbis_tdtransform
) {
480 av_log(vc
->avctx
, AV_LOG_ERROR
, "Vorbis time domain transform data nonzero. \n");
481 return AVERROR_INVALIDDATA
;
487 // Process floors part
489 static int vorbis_floor0_decode(vorbis_context
*vc
,
490 vorbis_floor_data
*vfu
, float *vec
);
491 static int create_map(vorbis_context
*vc
, unsigned floor_number
);
492 static int vorbis_floor1_decode(vorbis_context
*vc
,
493 vorbis_floor_data
*vfu
, float *vec
);
494 static int vorbis_parse_setup_hdr_floors(vorbis_context
*vc
)
496 GetBitContext
*gb
= &vc
->gb
;
499 vc
->floor_count
= get_bits(gb
, 6) + 1;
501 vc
->floors
= av_mallocz(vc
->floor_count
* sizeof(*vc
->floors
));
503 return AVERROR(ENOMEM
);
505 for (i
= 0; i
< vc
->floor_count
; ++i
) {
506 vorbis_floor
*floor_setup
= &vc
->floors
[i
];
508 floor_setup
->floor_type
= get_bits(gb
, 16);
510 av_dlog(NULL
, " %d. floor type %d \n", i
, floor_setup
->floor_type
);
512 if (floor_setup
->floor_type
== 1) {
513 int maximum_class
= -1;
514 unsigned rangebits
, rangemax
, floor1_values
= 2;
516 floor_setup
->decode
= vorbis_floor1_decode
;
518 floor_setup
->data
.t1
.partitions
= get_bits(gb
, 5);
520 av_dlog(NULL
, " %d.floor: %d partitions \n",
521 i
, floor_setup
->data
.t1
.partitions
);
523 for (j
= 0; j
< floor_setup
->data
.t1
.partitions
; ++j
) {
524 floor_setup
->data
.t1
.partition_class
[j
] = get_bits(gb
, 4);
525 if (floor_setup
->data
.t1
.partition_class
[j
] > maximum_class
)
526 maximum_class
= floor_setup
->data
.t1
.partition_class
[j
];
528 av_dlog(NULL
, " %d. floor %d partition class %d \n",
529 i
, j
, floor_setup
->data
.t1
.partition_class
[j
]);
533 av_dlog(NULL
, " maximum class %d \n", maximum_class
);
535 for (j
= 0; j
<= maximum_class
; ++j
) {
536 floor_setup
->data
.t1
.class_dimensions
[j
] = get_bits(gb
, 3) + 1;
537 floor_setup
->data
.t1
.class_subclasses
[j
] = get_bits(gb
, 2);
539 av_dlog(NULL
, " %d floor %d class dim: %d subclasses %d \n", i
, j
,
540 floor_setup
->data
.t1
.class_dimensions
[j
],
541 floor_setup
->data
.t1
.class_subclasses
[j
]);
543 if (floor_setup
->data
.t1
.class_subclasses
[j
]) {
544 GET_VALIDATED_INDEX(floor_setup
->data
.t1
.class_masterbook
[j
], 8, vc
->codebook_count
)
546 av_dlog(NULL
, " masterbook: %d \n", floor_setup
->data
.t1
.class_masterbook
[j
]);
549 for (k
= 0; k
< (1 << floor_setup
->data
.t1
.class_subclasses
[j
]); ++k
) {
550 int16_t bits
= get_bits(gb
, 8) - 1;
552 VALIDATE_INDEX(bits
, vc
->codebook_count
)
553 floor_setup
->data
.t1
.subclass_books
[j
][k
] = bits
;
555 av_dlog(NULL
, " book %d. : %d \n", k
, floor_setup
->data
.t1
.subclass_books
[j
][k
]);
559 floor_setup
->data
.t1
.multiplier
= get_bits(gb
, 2) + 1;
560 floor_setup
->data
.t1
.x_list_dim
= 2;
562 for (j
= 0; j
< floor_setup
->data
.t1
.partitions
; ++j
)
563 floor_setup
->data
.t1
.x_list_dim
+=floor_setup
->data
.t1
.class_dimensions
[floor_setup
->data
.t1
.partition_class
[j
]];
565 floor_setup
->data
.t1
.list
= av_mallocz_array(floor_setup
->data
.t1
.x_list_dim
,
566 sizeof(*floor_setup
->data
.t1
.list
));
567 if (!floor_setup
->data
.t1
.list
)
568 return AVERROR(ENOMEM
);
570 rangebits
= get_bits(gb
, 4);
571 rangemax
= (1 << rangebits
);
572 if (rangemax
> vc
->blocksize
[1] / 2) {
573 av_log(vc
->avctx
, AV_LOG_ERROR
,
574 "Floor value is too large for blocksize: %u (%"PRIu32
")\n",
575 rangemax
, vc
->blocksize
[1] / 2);
576 return AVERROR_INVALIDDATA
;
578 floor_setup
->data
.t1
.list
[0].x
= 0;
579 floor_setup
->data
.t1
.list
[1].x
= rangemax
;
581 for (j
= 0; j
< floor_setup
->data
.t1
.partitions
; ++j
) {
582 for (k
= 0; k
< floor_setup
->data
.t1
.class_dimensions
[floor_setup
->data
.t1
.partition_class
[j
]]; ++k
, ++floor1_values
) {
583 floor_setup
->data
.t1
.list
[floor1_values
].x
= get_bits(gb
, rangebits
);
585 av_dlog(NULL
, " %u. floor1 Y coord. %d\n", floor1_values
,
586 floor_setup
->data
.t1
.list
[floor1_values
].x
);
590 // Precalculate order of x coordinates - needed for decode
591 if (ff_vorbis_ready_floor1_list(vc
->avctx
,
592 floor_setup
->data
.t1
.list
,
593 floor_setup
->data
.t1
.x_list_dim
)) {
594 return AVERROR_INVALIDDATA
;
596 } else if (floor_setup
->floor_type
== 0) {
597 unsigned max_codebook_dim
= 0;
599 floor_setup
->decode
= vorbis_floor0_decode
;
601 floor_setup
->data
.t0
.order
= get_bits(gb
, 8);
602 if (!floor_setup
->data
.t0
.order
) {
603 av_log(vc
->avctx
, AV_LOG_ERROR
, "Floor 0 order is 0.\n");
604 return AVERROR_INVALIDDATA
;
606 floor_setup
->data
.t0
.rate
= get_bits(gb
, 16);
607 if (!floor_setup
->data
.t0
.rate
) {
608 av_log(vc
->avctx
, AV_LOG_ERROR
, "Floor 0 rate is 0.\n");
609 return AVERROR_INVALIDDATA
;
611 floor_setup
->data
.t0
.bark_map_size
= get_bits(gb
, 16);
612 if (!floor_setup
->data
.t0
.bark_map_size
) {
613 av_log(vc
->avctx
, AV_LOG_ERROR
,
614 "Floor 0 bark map size is 0.\n");
615 return AVERROR_INVALIDDATA
;
617 floor_setup
->data
.t0
.amplitude_bits
= get_bits(gb
, 6);
618 floor_setup
->data
.t0
.amplitude_offset
= get_bits(gb
, 8);
619 floor_setup
->data
.t0
.num_books
= get_bits(gb
, 4) + 1;
621 /* allocate mem for booklist */
622 floor_setup
->data
.t0
.book_list
=
623 av_malloc(floor_setup
->data
.t0
.num_books
);
624 if (!floor_setup
->data
.t0
.book_list
)
625 return AVERROR(ENOMEM
);
626 /* read book indexes */
630 for (idx
= 0; idx
< floor_setup
->data
.t0
.num_books
; ++idx
) {
631 GET_VALIDATED_INDEX(book_idx
, 8, vc
->codebook_count
)
632 floor_setup
->data
.t0
.book_list
[idx
] = book_idx
;
633 if (vc
->codebooks
[book_idx
].dimensions
> max_codebook_dim
)
634 max_codebook_dim
= vc
->codebooks
[book_idx
].dimensions
;
638 if ((ret
= create_map(vc
, i
)) < 0)
641 /* codebook dim is for padding if codebook dim doesn't *
642 * divide order+1 then we need to read more data */
643 floor_setup
->data
.t0
.lsp
=
644 av_malloc_array((floor_setup
->data
.t0
.order
+ 1 + max_codebook_dim
),
645 sizeof(*floor_setup
->data
.t0
.lsp
));
646 if (!floor_setup
->data
.t0
.lsp
)
647 return AVERROR(ENOMEM
);
649 /* debug output parsed headers */
650 av_dlog(NULL
, "floor0 order: %u\n", floor_setup
->data
.t0
.order
);
651 av_dlog(NULL
, "floor0 rate: %u\n", floor_setup
->data
.t0
.rate
);
652 av_dlog(NULL
, "floor0 bark map size: %u\n",
653 floor_setup
->data
.t0
.bark_map_size
);
654 av_dlog(NULL
, "floor0 amplitude bits: %u\n",
655 floor_setup
->data
.t0
.amplitude_bits
);
656 av_dlog(NULL
, "floor0 amplitude offset: %u\n",
657 floor_setup
->data
.t0
.amplitude_offset
);
658 av_dlog(NULL
, "floor0 number of books: %u\n",
659 floor_setup
->data
.t0
.num_books
);
660 av_dlog(NULL
, "floor0 book list pointer: %p\n",
661 floor_setup
->data
.t0
.book_list
);
664 for (idx
= 0; idx
< floor_setup
->data
.t0
.num_books
; ++idx
) {
665 av_dlog(NULL
, " Book %d: %u\n", idx
+ 1,
666 floor_setup
->data
.t0
.book_list
[idx
]);
670 av_log(vc
->avctx
, AV_LOG_ERROR
, "Invalid floor type!\n");
671 return AVERROR_INVALIDDATA
;
677 // Process residues part
679 static int vorbis_parse_setup_hdr_residues(vorbis_context
*vc
)
681 GetBitContext
*gb
= &vc
->gb
;
684 vc
->residue_count
= get_bits(gb
, 6)+1;
685 vc
->residues
= av_mallocz(vc
->residue_count
* sizeof(*vc
->residues
));
687 return AVERROR(ENOMEM
);
689 av_dlog(NULL
, " There are %d residues. \n", vc
->residue_count
);
691 for (i
= 0; i
< vc
->residue_count
; ++i
) {
692 vorbis_residue
*res_setup
= &vc
->residues
[i
];
694 unsigned high_bits
, low_bits
;
696 res_setup
->type
= get_bits(gb
, 16);
698 av_dlog(NULL
, " %u. residue type %d\n", i
, res_setup
->type
);
700 res_setup
->begin
= get_bits(gb
, 24);
701 res_setup
->end
= get_bits(gb
, 24);
702 res_setup
->partition_size
= get_bits(gb
, 24) + 1;
703 /* Validations to prevent a buffer overflow later. */
704 if (res_setup
->begin
>res_setup
->end
||
705 (res_setup
->end
-res_setup
->begin
) / res_setup
->partition_size
> FFMIN(V_MAX_PARTITIONS
, 65535)) {
706 av_log(vc
->avctx
, AV_LOG_ERROR
,
707 "partition out of bounds: type, begin, end, size, blocksize: %"PRIu16
", %"PRIu32
", %"PRIu32
", %u, %"PRIu32
"\n",
708 res_setup
->type
, res_setup
->begin
, res_setup
->end
,
709 res_setup
->partition_size
, vc
->blocksize
[1] / 2);
710 return AVERROR_INVALIDDATA
;
713 res_setup
->classifications
= get_bits(gb
, 6) + 1;
714 GET_VALIDATED_INDEX(res_setup
->classbook
, 8, vc
->codebook_count
)
716 res_setup
->ptns_to_read
=
717 (res_setup
->end
- res_setup
->begin
) / res_setup
->partition_size
;
718 res_setup
->classifs
= av_malloc_array(res_setup
->ptns_to_read
,
720 sizeof(*res_setup
->classifs
));
721 if (!res_setup
->classifs
)
722 return AVERROR(ENOMEM
);
724 av_dlog(NULL
, " begin %d end %d part.size %d classif.s %d classbook %d \n",
725 res_setup
->begin
, res_setup
->end
, res_setup
->partition_size
,
726 res_setup
->classifications
, res_setup
->classbook
);
728 for (j
= 0; j
< res_setup
->classifications
; ++j
) {
730 low_bits
= get_bits(gb
, 3);
732 high_bits
= get_bits(gb
, 5);
733 cascade
[j
] = (high_bits
<< 3) + low_bits
;
735 av_dlog(NULL
, " %u class cascade depth: %d\n", j
, ilog(cascade
[j
]));
738 res_setup
->maxpass
= 0;
739 for (j
= 0; j
< res_setup
->classifications
; ++j
) {
740 for (k
= 0; k
< 8; ++k
) {
741 if (cascade
[j
]&(1 << k
)) {
742 GET_VALIDATED_INDEX(res_setup
->books
[j
][k
], 8, vc
->codebook_count
)
744 av_dlog(NULL
, " %u class cascade depth %u book: %d\n",
745 j
, k
, res_setup
->books
[j
][k
]);
747 if (k
>res_setup
->maxpass
)
748 res_setup
->maxpass
= k
;
750 res_setup
->books
[j
][k
] = -1;
758 // Process mappings part
760 static int vorbis_parse_setup_hdr_mappings(vorbis_context
*vc
)
762 GetBitContext
*gb
= &vc
->gb
;
765 vc
->mapping_count
= get_bits(gb
, 6)+1;
766 vc
->mappings
= av_mallocz(vc
->mapping_count
* sizeof(*vc
->mappings
));
768 return AVERROR(ENOMEM
);
770 av_dlog(NULL
, " There are %d mappings. \n", vc
->mapping_count
);
772 for (i
= 0; i
< vc
->mapping_count
; ++i
) {
773 vorbis_mapping
*mapping_setup
= &vc
->mappings
[i
];
775 if (get_bits(gb
, 16)) {
776 av_log(vc
->avctx
, AV_LOG_ERROR
, "Other mappings than type 0 are not compliant with the Vorbis I specification. \n");
777 return AVERROR_INVALIDDATA
;
780 mapping_setup
->submaps
= get_bits(gb
, 4) + 1;
782 mapping_setup
->submaps
= 1;
786 mapping_setup
->coupling_steps
= get_bits(gb
, 8) + 1;
787 mapping_setup
->magnitude
= av_mallocz(mapping_setup
->coupling_steps
*
788 sizeof(*mapping_setup
->magnitude
));
789 mapping_setup
->angle
= av_mallocz(mapping_setup
->coupling_steps
*
790 sizeof(*mapping_setup
->angle
));
791 if (!mapping_setup
->angle
|| !mapping_setup
->magnitude
)
792 return AVERROR(ENOMEM
);
794 for (j
= 0; j
< mapping_setup
->coupling_steps
; ++j
) {
795 GET_VALIDATED_INDEX(mapping_setup
->magnitude
[j
], ilog(vc
->audio_channels
- 1), vc
->audio_channels
)
796 GET_VALIDATED_INDEX(mapping_setup
->angle
[j
], ilog(vc
->audio_channels
- 1), vc
->audio_channels
)
799 mapping_setup
->coupling_steps
= 0;
802 av_dlog(NULL
, " %u mapping coupling steps: %d\n",
803 i
, mapping_setup
->coupling_steps
);
805 if (get_bits(gb
, 2)) {
806 av_log(vc
->avctx
, AV_LOG_ERROR
, "%u. mapping setup data invalid.\n", i
);
807 return AVERROR_INVALIDDATA
; // following spec.
810 if (mapping_setup
->submaps
>1) {
811 mapping_setup
->mux
= av_mallocz_array(vc
->audio_channels
,
812 sizeof(*mapping_setup
->mux
));
813 if (!mapping_setup
->mux
)
814 return AVERROR(ENOMEM
);
816 for (j
= 0; j
< vc
->audio_channels
; ++j
)
817 mapping_setup
->mux
[j
] = get_bits(gb
, 4);
820 for (j
= 0; j
< mapping_setup
->submaps
; ++j
) {
821 skip_bits(gb
, 8); // FIXME check?
822 GET_VALIDATED_INDEX(mapping_setup
->submap_floor
[j
], 8, vc
->floor_count
)
823 GET_VALIDATED_INDEX(mapping_setup
->submap_residue
[j
], 8, vc
->residue_count
)
825 av_dlog(NULL
, " %u mapping %u submap : floor %d, residue %d\n", i
, j
,
826 mapping_setup
->submap_floor
[j
],
827 mapping_setup
->submap_residue
[j
]);
833 // Process modes part
835 static int create_map(vorbis_context
*vc
, unsigned floor_number
)
837 vorbis_floor
*floors
= vc
->floors
;
843 for (blockflag
= 0; blockflag
< 2; ++blockflag
) {
844 n
= vc
->blocksize
[blockflag
] / 2;
845 floors
[floor_number
].data
.t0
.map
[blockflag
] =
846 av_malloc_array(n
+ 1, sizeof(int32_t)); // n + sentinel
847 if (!floors
[floor_number
].data
.t0
.map
[blockflag
])
848 return AVERROR(ENOMEM
);
850 map
= floors
[floor_number
].data
.t0
.map
[blockflag
];
851 vf
= &floors
[floor_number
].data
.t0
;
853 for (idx
= 0; idx
< n
; ++idx
) {
854 map
[idx
] = floor(BARK((vf
->rate
* idx
) / (2.0f
* n
)) *
855 (vf
->bark_map_size
/ BARK(vf
->rate
/ 2.0f
)));
856 if (vf
->bark_map_size
-1 < map
[idx
])
857 map
[idx
] = vf
->bark_map_size
- 1;
860 vf
->map_size
[blockflag
] = n
;
863 for (idx
= 0; idx
<= n
; ++idx
) {
864 av_dlog(NULL
, "floor0 map: map at pos %d is %d\n", idx
, map
[idx
]);
870 static int vorbis_parse_setup_hdr_modes(vorbis_context
*vc
)
872 GetBitContext
*gb
= &vc
->gb
;
875 vc
->mode_count
= get_bits(gb
, 6) + 1;
876 vc
->modes
= av_mallocz(vc
->mode_count
* sizeof(*vc
->modes
));
878 return AVERROR(ENOMEM
);
880 av_dlog(NULL
, " There are %d modes.\n", vc
->mode_count
);
882 for (i
= 0; i
< vc
->mode_count
; ++i
) {
883 vorbis_mode
*mode_setup
= &vc
->modes
[i
];
885 mode_setup
->blockflag
= get_bits1(gb
);
886 mode_setup
->windowtype
= get_bits(gb
, 16); //FIXME check
887 mode_setup
->transformtype
= get_bits(gb
, 16); //FIXME check
888 GET_VALIDATED_INDEX(mode_setup
->mapping
, 8, vc
->mapping_count
);
890 av_dlog(NULL
, " %u mode: blockflag %d, windowtype %d, transformtype %d, mapping %d\n",
891 i
, mode_setup
->blockflag
, mode_setup
->windowtype
,
892 mode_setup
->transformtype
, mode_setup
->mapping
);
897 // Process the whole setup header using the functions above
899 static int vorbis_parse_setup_hdr(vorbis_context
*vc
)
901 GetBitContext
*gb
= &vc
->gb
;
904 if ((get_bits(gb
, 8) != 'v') || (get_bits(gb
, 8) != 'o') ||
905 (get_bits(gb
, 8) != 'r') || (get_bits(gb
, 8) != 'b') ||
906 (get_bits(gb
, 8) != 'i') || (get_bits(gb
, 8) != 's')) {
907 av_log(vc
->avctx
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (no vorbis signature). \n");
908 return AVERROR_INVALIDDATA
;
911 if ((ret
= vorbis_parse_setup_hdr_codebooks(vc
))) {
912 av_log(vc
->avctx
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (codebooks). \n");
915 if ((ret
= vorbis_parse_setup_hdr_tdtransforms(vc
))) {
916 av_log(vc
->avctx
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (time domain transforms). \n");
919 if ((ret
= vorbis_parse_setup_hdr_floors(vc
))) {
920 av_log(vc
->avctx
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (floors). \n");
923 if ((ret
= vorbis_parse_setup_hdr_residues(vc
))) {
924 av_log(vc
->avctx
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (residues). \n");
927 if ((ret
= vorbis_parse_setup_hdr_mappings(vc
))) {
928 av_log(vc
->avctx
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (mappings). \n");
931 if ((ret
= vorbis_parse_setup_hdr_modes(vc
))) {
932 av_log(vc
->avctx
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (modes). \n");
935 if (!get_bits1(gb
)) {
936 av_log(vc
->avctx
, AV_LOG_ERROR
, " Vorbis setup header packet corrupt (framing flag). \n");
937 return AVERROR_INVALIDDATA
; // framing flag bit unset error
943 // Process the identification header
945 static int vorbis_parse_id_hdr(vorbis_context
*vc
)
947 GetBitContext
*gb
= &vc
->gb
;
950 if ((get_bits(gb
, 8) != 'v') || (get_bits(gb
, 8) != 'o') ||
951 (get_bits(gb
, 8) != 'r') || (get_bits(gb
, 8) != 'b') ||
952 (get_bits(gb
, 8) != 'i') || (get_bits(gb
, 8) != 's')) {
953 av_log(vc
->avctx
, AV_LOG_ERROR
, " Vorbis id header packet corrupt (no vorbis signature). \n");
954 return AVERROR_INVALIDDATA
;
957 vc
->version
= get_bits_long(gb
, 32); //FIXME check 0
958 vc
->audio_channels
= get_bits(gb
, 8);
959 if (vc
->audio_channels
<= 0) {
960 av_log(vc
->avctx
, AV_LOG_ERROR
, "Invalid number of channels\n");
961 return AVERROR_INVALIDDATA
;
963 vc
->audio_samplerate
= get_bits_long(gb
, 32);
964 if (vc
->audio_samplerate
<= 0) {
965 av_log(vc
->avctx
, AV_LOG_ERROR
, "Invalid samplerate\n");
966 return AVERROR_INVALIDDATA
;
968 vc
->bitrate_maximum
= get_bits_long(gb
, 32);
969 vc
->bitrate_nominal
= get_bits_long(gb
, 32);
970 vc
->bitrate_minimum
= get_bits_long(gb
, 32);
971 bl0
= get_bits(gb
, 4);
972 bl1
= get_bits(gb
, 4);
973 if (bl0
> 13 || bl0
< 6 || bl1
> 13 || bl1
< 6 || bl1
< bl0
) {
974 av_log(vc
->avctx
, AV_LOG_ERROR
, " Vorbis id header packet corrupt (illegal blocksize). \n");
975 return AVERROR_INVALIDDATA
;
977 vc
->blocksize
[0] = (1 << bl0
);
978 vc
->blocksize
[1] = (1 << bl1
);
979 vc
->win
[0] = ff_vorbis_vwin
[bl0
- 6];
980 vc
->win
[1] = ff_vorbis_vwin
[bl1
- 6];
982 if ((get_bits1(gb
)) == 0) {
983 av_log(vc
->avctx
, AV_LOG_ERROR
, " Vorbis id header packet corrupt (framing flag not set). \n");
984 return AVERROR_INVALIDDATA
;
987 vc
->channel_residues
= av_malloc_array(vc
->blocksize
[1] / 2, vc
->audio_channels
* sizeof(*vc
->channel_residues
));
988 vc
->saved
= av_mallocz_array(vc
->blocksize
[1] / 4, vc
->audio_channels
* sizeof(*vc
->saved
));
989 if (!vc
->channel_residues
|| !vc
->saved
)
990 return AVERROR(ENOMEM
);
992 vc
->previous_window
= -1;
994 ff_mdct_init(&vc
->mdct
[0], bl0
, 1, -1.0);
995 ff_mdct_init(&vc
->mdct
[1], bl1
, 1, -1.0);
996 vc
->fdsp
= avpriv_float_dsp_alloc(vc
->avctx
->flags
& CODEC_FLAG_BITEXACT
);
998 return AVERROR(ENOMEM
);
1000 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 ",
1001 vc
->version
, vc
->audio_channels
, vc
->audio_samplerate
, vc
->bitrate_maximum
, vc
->bitrate_nominal
, vc
->bitrate_minimum
, vc
->blocksize
[0], vc
->blocksize
[1]);
1004 BLK = vc->blocksize[0];
1005 for (i = 0; i < BLK / 2; ++i) {
1006 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)));
1013 // Process the extradata using the functions above (identification header, setup header)
1015 static av_cold
int vorbis_decode_init(AVCodecContext
*avctx
)
1017 vorbis_context
*vc
= avctx
->priv_data
;
1018 uint8_t *headers
= avctx
->extradata
;
1019 int headers_len
= avctx
->extradata_size
;
1020 uint8_t *header_start
[3];
1022 GetBitContext
*gb
= &vc
->gb
;
1026 ff_vorbisdsp_init(&vc
->dsp
);
1027 ff_fmt_convert_init(&vc
->fmt_conv
, avctx
);
1029 avctx
->sample_fmt
= AV_SAMPLE_FMT_FLTP
;
1032 av_log(avctx
, AV_LOG_ERROR
, "Extradata missing.\n");
1033 return AVERROR_INVALIDDATA
;
1036 if ((ret
= avpriv_split_xiph_headers(headers
, headers_len
, 30, header_start
, header_len
)) < 0) {
1037 av_log(avctx
, AV_LOG_ERROR
, "Extradata corrupt.\n");
1041 init_get_bits(gb
, header_start
[0], header_len
[0]*8);
1042 hdr_type
= get_bits(gb
, 8);
1043 if (hdr_type
!= 1) {
1044 av_log(avctx
, AV_LOG_ERROR
, "First header is not the id header.\n");
1045 return AVERROR_INVALIDDATA
;
1047 if ((ret
= vorbis_parse_id_hdr(vc
))) {
1048 av_log(avctx
, AV_LOG_ERROR
, "Id header corrupt.\n");
1053 init_get_bits(gb
, header_start
[2], header_len
[2]*8);
1054 hdr_type
= get_bits(gb
, 8);
1055 if (hdr_type
!= 5) {
1056 av_log(avctx
, AV_LOG_ERROR
, "Third header is not the setup header.\n");
1058 return AVERROR_INVALIDDATA
;
1060 if ((ret
= vorbis_parse_setup_hdr(vc
))) {
1061 av_log(avctx
, AV_LOG_ERROR
, "Setup header corrupt.\n");
1066 if (vc
->audio_channels
> 8)
1067 avctx
->channel_layout
= 0;
1069 avctx
->channel_layout
= ff_vorbis_channel_layouts
[vc
->audio_channels
- 1];
1071 avctx
->channels
= vc
->audio_channels
;
1072 avctx
->sample_rate
= vc
->audio_samplerate
;
1077 // Decode audiopackets -------------------------------------------------
1079 // Read and decode floor
1081 static int vorbis_floor0_decode(vorbis_context
*vc
,
1082 vorbis_floor_data
*vfu
, float *vec
)
1084 vorbis_floor0
*vf
= &vfu
->t0
;
1085 float *lsp
= vf
->lsp
;
1086 unsigned amplitude
, book_idx
;
1087 unsigned blockflag
= vc
->modes
[vc
->mode_number
].blockflag
;
1089 if (!vf
->amplitude_bits
)
1092 amplitude
= get_bits(&vc
->gb
, vf
->amplitude_bits
);
1093 if (amplitude
> 0) {
1095 unsigned idx
, lsp_len
= 0;
1096 vorbis_codebook codebook
;
1098 book_idx
= get_bits(&vc
->gb
, ilog(vf
->num_books
));
1099 if (book_idx
>= vf
->num_books
) {
1100 av_log(vc
->avctx
, AV_LOG_ERROR
, "floor0 dec: booknumber too high!\n");
1103 av_dlog(NULL
, "floor0 dec: booknumber: %u\n", book_idx
);
1104 codebook
= vc
->codebooks
[vf
->book_list
[book_idx
]];
1105 /* Invalid codebook! */
1106 if (!codebook
.codevectors
)
1107 return AVERROR_INVALIDDATA
;
1109 while (lsp_len
<vf
->order
) {
1112 av_dlog(NULL
, "floor0 dec: book dimension: %d\n", codebook
.dimensions
);
1113 av_dlog(NULL
, "floor0 dec: maximum depth: %d\n", codebook
.maxdepth
);
1114 /* read temp vector */
1115 vec_off
= get_vlc2(&vc
->gb
, codebook
.vlc
.table
,
1116 codebook
.nb_bits
, codebook
.maxdepth
)
1117 * codebook
.dimensions
;
1118 av_dlog(NULL
, "floor0 dec: vector offset: %d\n", vec_off
);
1119 /* copy each vector component and add last to it */
1120 for (idx
= 0; idx
< codebook
.dimensions
; ++idx
)
1121 lsp
[lsp_len
+idx
] = codebook
.codevectors
[vec_off
+idx
] + last
;
1122 last
= lsp
[lsp_len
+idx
-1]; /* set last to last vector component */
1124 lsp_len
+= codebook
.dimensions
;
1126 /* DEBUG: output lsp coeffs */
1129 for (idx
= 0; idx
< lsp_len
; ++idx
)
1130 av_dlog(NULL
, "floor0 dec: coeff at %d is %f\n", idx
, lsp
[idx
]);
1133 /* synthesize floor output vector */
1136 int order
= vf
->order
;
1137 float wstep
= M_PI
/ vf
->bark_map_size
;
1139 for (i
= 0; i
< order
; i
++)
1140 lsp
[i
] = 2.0f
* cos(lsp
[i
]);
1142 av_dlog(NULL
, "floor0 synth: map_size = %"PRIu32
"; m = %d; wstep = %f\n",
1143 vf
->map_size
[blockflag
], order
, wstep
);
1146 while (i
< vf
->map_size
[blockflag
]) {
1147 int j
, iter_cond
= vf
->map
[blockflag
][i
];
1150 float two_cos_w
= 2.0f
* cos(wstep
* iter_cond
); // needed all times
1152 /* similar part for the q and p products */
1153 for (j
= 0; j
+ 1 < order
; j
+= 2) {
1154 q
*= lsp
[j
] - two_cos_w
;
1155 p
*= lsp
[j
+ 1] - two_cos_w
;
1157 if (j
== order
) { // even order
1158 p
*= p
* (2.0f
- two_cos_w
);
1159 q
*= q
* (2.0f
+ two_cos_w
);
1160 } else { // odd order
1161 q
*= two_cos_w
-lsp
[j
]; // one more time for q
1163 /* final step and square */
1164 p
*= p
* (4.f
- two_cos_w
* two_cos_w
);
1168 /* calculate linear floor value */
1169 q
= exp((((amplitude
*vf
->amplitude_offset
) /
1170 (((1 << vf
->amplitude_bits
) - 1) * sqrt(p
+ q
)))
1171 - vf
->amplitude_offset
) * .11512925f
);
1176 } while (vf
->map
[blockflag
][i
] == iter_cond
);
1180 /* this channel is unused */
1184 av_dlog(NULL
, " Floor0 decoded\n");
1189 static int vorbis_floor1_decode(vorbis_context
*vc
,
1190 vorbis_floor_data
*vfu
, float *vec
)
1192 vorbis_floor1
*vf
= &vfu
->t1
;
1193 GetBitContext
*gb
= &vc
->gb
;
1194 uint16_t range_v
[4] = { 256, 128, 86, 64 };
1195 unsigned range
= range_v
[vf
->multiplier
- 1];
1196 uint16_t floor1_Y
[258];
1197 uint16_t floor1_Y_final
[258];
1198 int floor1_flag
[258];
1199 unsigned partition_class
, cdim
, cbits
, csub
, cval
, offset
, i
, j
;
1200 int book
, adx
, ady
, dy
, off
, predicted
, err
;
1203 if (!get_bits1(gb
)) // silence
1206 // Read values (or differences) for the floor's points
1208 floor1_Y
[0] = get_bits(gb
, ilog(range
- 1));
1209 floor1_Y
[1] = get_bits(gb
, ilog(range
- 1));
1211 av_dlog(NULL
, "floor 0 Y %d floor 1 Y %d \n", floor1_Y
[0], floor1_Y
[1]);
1214 for (i
= 0; i
< vf
->partitions
; ++i
) {
1215 partition_class
= vf
->partition_class
[i
];
1216 cdim
= vf
->class_dimensions
[partition_class
];
1217 cbits
= vf
->class_subclasses
[partition_class
];
1218 csub
= (1 << cbits
) - 1;
1221 av_dlog(NULL
, "Cbits %u\n", cbits
);
1223 if (cbits
) // this reads all subclasses for this partition's class
1224 cval
= get_vlc2(gb
, vc
->codebooks
[vf
->class_masterbook
[partition_class
]].vlc
.table
,
1225 vc
->codebooks
[vf
->class_masterbook
[partition_class
]].nb_bits
, 3);
1227 for (j
= 0; j
< cdim
; ++j
) {
1228 book
= vf
->subclass_books
[partition_class
][cval
& csub
];
1230 av_dlog(NULL
, "book %d Cbits %u cval %u bits:%d\n",
1231 book
, cbits
, cval
, get_bits_count(gb
));
1233 cval
= cval
>> cbits
;
1235 int v
= get_vlc2(gb
, vc
->codebooks
[book
].vlc
.table
,
1236 vc
->codebooks
[book
].nb_bits
, 3);
1238 return AVERROR_INVALIDDATA
;
1239 floor1_Y
[offset
+j
] = v
;
1241 floor1_Y
[offset
+j
] = 0;
1244 av_dlog(NULL
, " floor(%d) = %d \n",
1245 vf
->list
[offset
+j
].x
, floor1_Y
[offset
+j
]);
1250 // Amplitude calculation from the differences
1254 floor1_Y_final
[0] = floor1_Y
[0];
1255 floor1_Y_final
[1] = floor1_Y
[1];
1257 for (i
= 2; i
< vf
->x_list_dim
; ++i
) {
1258 unsigned val
, highroom
, lowroom
, room
, high_neigh_offs
, low_neigh_offs
;
1260 low_neigh_offs
= vf
->list
[i
].low
;
1261 high_neigh_offs
= vf
->list
[i
].high
;
1262 dy
= floor1_Y_final
[high_neigh_offs
] - floor1_Y_final
[low_neigh_offs
]; // render_point begin
1263 adx
= vf
->list
[high_neigh_offs
].x
- vf
->list
[low_neigh_offs
].x
;
1265 err
= ady
* (vf
->list
[i
].x
- vf
->list
[low_neigh_offs
].x
);
1268 predicted
= floor1_Y_final
[low_neigh_offs
] - off
;
1270 predicted
= floor1_Y_final
[low_neigh_offs
] + off
;
1271 } // render_point end
1274 highroom
= range
-predicted
;
1275 lowroom
= predicted
;
1276 if (highroom
< lowroom
) {
1277 room
= highroom
* 2;
1279 room
= lowroom
* 2; // SPEC misspelling
1282 floor1_flag
[low_neigh_offs
] = 1;
1283 floor1_flag
[high_neigh_offs
] = 1;
1286 if (highroom
> lowroom
) {
1287 floor1_Y_final
[i
] = av_clip_uint16(val
- lowroom
+ predicted
);
1289 floor1_Y_final
[i
] = av_clip_uint16(predicted
- val
+ highroom
- 1);
1293 floor1_Y_final
[i
] = av_clip_uint16(predicted
- (val
+ 1) / 2);
1295 floor1_Y_final
[i
] = av_clip_uint16(predicted
+ val
/ 2);
1300 floor1_Y_final
[i
] = av_clip_uint16(predicted
);
1303 av_dlog(NULL
, " Decoded floor(%d) = %u / val %u\n",
1304 vf
->list
[i
].x
, floor1_Y_final
[i
], val
);
1307 // Curve synth - connect the calculated dots and convert from dB scale FIXME optimize ?
1309 ff_vorbis_floor1_render_list(vf
->list
, vf
->x_list_dim
, floor1_Y_final
, floor1_flag
, vf
->multiplier
, vec
, vf
->list
[1].x
);
1311 av_dlog(NULL
, " Floor decoded\n");
1316 static av_always_inline
int setup_classifs(vorbis_context
*vc
,
1318 uint8_t *do_not_decode
,
1320 int partition_count
,
1325 unsigned c_p_c
= vc
->codebooks
[vr
->classbook
].dimensions
;
1326 unsigned inverse_class
= ff_inverse
[vr
->classifications
];
1327 unsigned temp
, temp2
;
1328 for (p
= 0, j
= 0; j
< ch_used
; ++j
) {
1329 if (!do_not_decode
[j
]) {
1330 temp
= get_vlc2(&vc
->gb
, vc
->codebooks
[vr
->classbook
].vlc
.table
,
1331 vc
->codebooks
[vr
->classbook
].nb_bits
, 3);
1333 av_dlog(NULL
, "Classword: %u\n", temp
);
1338 av_assert0(vr
->classifications
> 1); //needed for inverse[]
1340 if (temp
<= 65536) {
1341 for (i
= partition_count
+ c_p_c
- 1; i
>= partition_count
; i
--) {
1342 temp2
= (((uint64_t)temp
) * inverse_class
) >> 32;
1344 if (i
< ptns_to_read
)
1345 vr
->classifs
[p
+ i
] = temp
- temp2
* vr
->classifications
;
1349 for (i
= partition_count
+ c_p_c
- 1; i
>= partition_count
; i
--) {
1350 temp2
= temp
/ vr
->classifications
;
1352 if (i
< ptns_to_read
)
1353 vr
->classifs
[p
+ i
] = temp
- temp2
* vr
->classifications
;
1362 // Read and decode residue
1364 static av_always_inline
int vorbis_residue_decode_internal(vorbis_context
*vc
,
1367 uint8_t *do_not_decode
,
1373 GetBitContext
*gb
= &vc
->gb
;
1374 unsigned c_p_c
= vc
->codebooks
[vr
->classbook
].dimensions
;
1375 uint8_t *classifs
= vr
->classifs
;
1376 unsigned pass
, ch_used
, i
, j
, k
, l
;
1377 unsigned max_output
= (ch
- 1) * vlen
;
1378 int ptns_to_read
= vr
->ptns_to_read
;
1379 int libvorbis_bug
= 0;
1382 for (j
= 1; j
< ch
; ++j
)
1383 do_not_decode
[0] &= do_not_decode
[j
]; // FIXME - clobbering input
1384 if (do_not_decode
[0])
1387 max_output
+= vr
->end
/ ch
;
1390 max_output
+= vr
->end
;
1393 if (max_output
> ch_left
* vlen
) {
1394 if (max_output
<= ch_left
* vlen
+ vr
->partition_size
*ch_used
/ch
) {
1398 av_log(vc
->avctx
, AV_LOG_ERROR
, "Insufficient output buffer\n");
1399 return AVERROR_INVALIDDATA
;
1403 av_dlog(NULL
, " residue type 0/1/2 decode begin, ch: %d cpc %d \n", ch
, c_p_c
);
1405 for (pass
= 0; pass
<= vr
->maxpass
; ++pass
) { // FIXME OPTIMIZE?
1406 int voffset
, partition_count
, j_times_ptns_to_read
;
1408 voffset
= vr
->begin
;
1409 for (partition_count
= 0; partition_count
< ptns_to_read
;) { // SPEC error
1412 if ((ret
= setup_classifs(vc
, vr
, do_not_decode
, ch_used
, partition_count
, ptns_to_read
)) < 0)
1415 for (i
= 0; (i
< c_p_c
) && (partition_count
< ptns_to_read
); ++i
) {
1416 for (j_times_ptns_to_read
= 0, j
= 0; j
< ch_used
; ++j
) {
1419 if (!do_not_decode
[j
]) {
1420 unsigned vqclass
= classifs
[j_times_ptns_to_read
+ partition_count
];
1421 int vqbook
= vr
->books
[vqclass
][pass
];
1423 if (vqbook
>= 0 && vc
->codebooks
[vqbook
].codevectors
) {
1425 unsigned dim
= vc
->codebooks
[vqbook
].dimensions
;
1426 unsigned step
= FASTDIV(vr
->partition_size
<< 1, dim
<< 1);
1427 vorbis_codebook codebook
= vc
->codebooks
[vqbook
];
1431 voffs
= voffset
+j
*vlen
;
1432 for (k
= 0; k
< step
; ++k
) {
1433 coffs
= get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * dim
;
1434 for (l
= 0; l
< dim
; ++l
)
1435 vec
[voffs
+ k
+ l
* step
] += codebook
.codevectors
[coffs
+ l
];
1437 } else if (vr_type
== 1) {
1438 voffs
= voffset
+ j
* vlen
;
1439 for (k
= 0; k
< step
; ++k
) {
1440 coffs
= get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * dim
;
1441 for (l
= 0; l
< dim
; ++l
, ++voffs
) {
1442 vec
[voffs
]+=codebook
.codevectors
[coffs
+l
];
1444 av_dlog(NULL
, " pass %d offs: %d curr: %f change: %f cv offs.: %d \n",
1445 pass
, voffs
, vec
[voffs
], codebook
.codevectors
[coffs
+l
], coffs
);
1448 } else if (vr_type
== 2 && ch
== 2 && (voffset
& 1) == 0 && (dim
& 1) == 0) { // most frequent case optimized
1449 voffs
= voffset
>> 1;
1452 for (k
= 0; k
< step
; ++k
) {
1453 coffs
= get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * 2;
1454 vec
[voffs
+ k
] += codebook
.codevectors
[coffs
];
1455 vec
[voffs
+ k
+ vlen
] += codebook
.codevectors
[coffs
+ 1];
1457 } else if (dim
== 4) {
1458 for (k
= 0; k
< step
; ++k
, voffs
+= 2) {
1459 coffs
= get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * 4;
1460 vec
[voffs
] += codebook
.codevectors
[coffs
];
1461 vec
[voffs
+ 1 ] += codebook
.codevectors
[coffs
+ 2];
1462 vec
[voffs
+ vlen
] += codebook
.codevectors
[coffs
+ 1];
1463 vec
[voffs
+ vlen
+ 1] += codebook
.codevectors
[coffs
+ 3];
1466 for (k
= 0; k
< step
; ++k
) {
1467 coffs
= get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * dim
;
1468 for (l
= 0; l
< dim
; l
+= 2, voffs
++) {
1469 vec
[voffs
] += codebook
.codevectors
[coffs
+ l
];
1470 vec
[voffs
+ vlen
] += codebook
.codevectors
[coffs
+ l
+ 1];
1472 av_dlog(NULL
, " pass %d offs: %d curr: %f change: %f cv offs.: %d+%d \n",
1473 pass
, voffset
/ ch
+ (voffs
% ch
) * vlen
,
1474 vec
[voffset
/ ch
+ (voffs
% ch
) * vlen
],
1475 codebook
.codevectors
[coffs
+ l
], coffs
, l
);
1479 } else if (vr_type
== 2) {
1480 unsigned voffs_div
= FASTDIV(voffset
<< 1, ch
<<1);
1481 unsigned voffs_mod
= voffset
- voffs_div
* ch
;
1483 for (k
= 0; k
< step
; ++k
) {
1484 coffs
= get_vlc2(gb
, codebook
.vlc
.table
, codebook
.nb_bits
, 3) * dim
;
1485 for (l
= 0; l
< dim
; ++l
) {
1486 vec
[voffs_div
+ voffs_mod
* vlen
] +=
1487 codebook
.codevectors
[coffs
+ l
];
1489 av_dlog(NULL
, " pass %d offs: %d curr: %f change: %f cv offs.: %d+%d \n",
1490 pass
, voffs_div
+ voffs_mod
* vlen
,
1491 vec
[voffs_div
+ voffs_mod
* vlen
],
1492 codebook
.codevectors
[coffs
+ l
], coffs
, l
);
1494 if (++voffs_mod
== ch
) {
1503 j_times_ptns_to_read
+= ptns_to_read
;
1506 voffset
+= vr
->partition_size
;
1509 if (libvorbis_bug
&& !pass
) {
1510 for (j
= 0; j
< ch_used
; ++j
) {
1511 if (!do_not_decode
[j
]) {
1512 get_vlc2(&vc
->gb
, vc
->codebooks
[vr
->classbook
].vlc
.table
,
1513 vc
->codebooks
[vr
->classbook
].nb_bits
, 3);
1521 static inline int vorbis_residue_decode(vorbis_context
*vc
, vorbis_residue
*vr
,
1523 uint8_t *do_not_decode
,
1524 float *vec
, unsigned vlen
,
1528 return vorbis_residue_decode_internal(vc
, vr
, ch
, do_not_decode
, vec
, vlen
, ch_left
, 2);
1529 else if (vr
->type
== 1)
1530 return vorbis_residue_decode_internal(vc
, vr
, ch
, do_not_decode
, vec
, vlen
, ch_left
, 1);
1531 else if (vr
->type
== 0)
1532 return vorbis_residue_decode_internal(vc
, vr
, ch
, do_not_decode
, vec
, vlen
, ch_left
, 0);
1534 av_log(vc
->avctx
, AV_LOG_ERROR
, " Invalid residue type while residue decode?! \n");
1535 return AVERROR_INVALIDDATA
;
1539 void ff_vorbis_inverse_coupling(float *mag
, float *ang
, intptr_t blocksize
)
1542 for (i
= 0; i
< blocksize
; i
++) {
1545 ang
[i
] = mag
[i
] - ang
[i
];
1547 float temp
= ang
[i
];
1555 float temp
= ang
[i
];
1563 // Decode the audio packet using the functions above
1565 static int vorbis_parse_audio_packet(vorbis_context
*vc
, float **floor_ptr
)
1567 GetBitContext
*gb
= &vc
->gb
;
1569 int previous_window
= vc
->previous_window
;
1570 unsigned mode_number
, blockflag
, blocksize
;
1572 uint8_t no_residue
[255];
1573 uint8_t do_not_decode
[255];
1574 vorbis_mapping
*mapping
;
1575 float *ch_res_ptr
= vc
->channel_residues
;
1576 uint8_t res_chan
[255];
1577 unsigned res_num
= 0;
1579 unsigned ch_left
= vc
->audio_channels
;
1582 if (get_bits1(gb
)) {
1583 av_log(vc
->avctx
, AV_LOG_ERROR
, "Not a Vorbis I audio packet.\n");
1584 return AVERROR_INVALIDDATA
; // packet type not audio
1587 if (vc
->mode_count
== 1) {
1590 GET_VALIDATED_INDEX(mode_number
, ilog(vc
->mode_count
-1), vc
->mode_count
)
1592 vc
->mode_number
= mode_number
;
1593 mapping
= &vc
->mappings
[vc
->modes
[mode_number
].mapping
];
1595 av_dlog(NULL
, " Mode number: %u , mapping: %d , blocktype %d\n", mode_number
,
1596 vc
->modes
[mode_number
].mapping
, vc
->modes
[mode_number
].blockflag
);
1598 blockflag
= vc
->modes
[mode_number
].blockflag
;
1599 blocksize
= vc
->blocksize
[blockflag
];
1600 vlen
= blocksize
/ 2;
1602 int code
= get_bits(gb
, 2);
1603 if (previous_window
< 0)
1604 previous_window
= code
>>1;
1605 } else if (previous_window
< 0)
1606 previous_window
= 0;
1608 memset(ch_res_ptr
, 0, sizeof(float) * vc
->audio_channels
* vlen
); //FIXME can this be removed ?
1609 for (i
= 0; i
< vc
->audio_channels
; ++i
)
1610 memset(floor_ptr
[i
], 0, vlen
* sizeof(floor_ptr
[0][0])); //FIXME can this be removed ?
1614 for (i
= 0; i
< vc
->audio_channels
; ++i
) {
1615 vorbis_floor
*floor
;
1617 if (mapping
->submaps
> 1) {
1618 floor
= &vc
->floors
[mapping
->submap_floor
[mapping
->mux
[i
]]];
1620 floor
= &vc
->floors
[mapping
->submap_floor
[0]];
1623 ret
= floor
->decode(vc
, &floor
->data
, floor_ptr
[i
]);
1626 av_log(vc
->avctx
, AV_LOG_ERROR
, "Invalid codebook in vorbis_floor_decode.\n");
1627 return AVERROR_INVALIDDATA
;
1629 no_residue
[i
] = ret
;
1632 // Nonzero vector propagate
1634 for (i
= mapping
->coupling_steps
- 1; i
>= 0; --i
) {
1635 if (!(no_residue
[mapping
->magnitude
[i
]] & no_residue
[mapping
->angle
[i
]])) {
1636 no_residue
[mapping
->magnitude
[i
]] = 0;
1637 no_residue
[mapping
->angle
[i
]] = 0;
1643 for (i
= 0; i
< mapping
->submaps
; ++i
) {
1644 vorbis_residue
*residue
;
1648 for (j
= 0; j
< vc
->audio_channels
; ++j
) {
1649 if ((mapping
->submaps
== 1) || (i
== mapping
->mux
[j
])) {
1650 res_chan
[j
] = res_num
;
1651 if (no_residue
[j
]) {
1652 do_not_decode
[ch
] = 1;
1654 do_not_decode
[ch
] = 0;
1660 residue
= &vc
->residues
[mapping
->submap_residue
[i
]];
1662 av_log(vc
->avctx
, AV_LOG_ERROR
, "Too many channels in vorbis_floor_decode.\n");
1663 return AVERROR_INVALIDDATA
;
1666 ret
= vorbis_residue_decode(vc
, residue
, ch
, do_not_decode
, ch_res_ptr
, vlen
, ch_left
);
1671 ch_res_ptr
+= ch
* vlen
;
1676 return AVERROR_INVALIDDATA
;
1680 for (i
= mapping
->coupling_steps
- 1; i
>= 0; --i
) { //warning: i has to be signed
1683 mag
= vc
->channel_residues
+res_chan
[mapping
->magnitude
[i
]] * blocksize
/ 2;
1684 ang
= vc
->channel_residues
+res_chan
[mapping
->angle
[i
]] * blocksize
/ 2;
1685 vc
->dsp
.vorbis_inverse_coupling(mag
, ang
, blocksize
/ 2);
1690 mdct
= &vc
->mdct
[blockflag
];
1692 for (j
= vc
->audio_channels
-1;j
>= 0; j
--) {
1693 ch_res_ptr
= vc
->channel_residues
+ res_chan
[j
] * blocksize
/ 2;
1694 vc
->fdsp
->vector_fmul(floor_ptr
[j
], floor_ptr
[j
], ch_res_ptr
, blocksize
/ 2);
1695 mdct
->imdct_half(mdct
, ch_res_ptr
, floor_ptr
[j
]);
1698 // Overlap/add, save data for next overlapping
1700 retlen
= (blocksize
+ vc
->blocksize
[previous_window
]) / 4;
1701 for (j
= 0; j
< vc
->audio_channels
; j
++) {
1702 unsigned bs0
= vc
->blocksize
[0];
1703 unsigned bs1
= vc
->blocksize
[1];
1704 float *residue
= vc
->channel_residues
+ res_chan
[j
] * blocksize
/ 2;
1705 float *saved
= vc
->saved
+ j
* bs1
/ 4;
1706 float *ret
= floor_ptr
[j
];
1707 float *buf
= residue
;
1708 const float *win
= vc
->win
[blockflag
& previous_window
];
1710 if (blockflag
== previous_window
) {
1711 vc
->fdsp
->vector_fmul_window(ret
, saved
, buf
, win
, blocksize
/ 4);
1712 } else if (blockflag
> previous_window
) {
1713 vc
->fdsp
->vector_fmul_window(ret
, saved
, buf
, win
, bs0
/ 4);
1714 memcpy(ret
+bs0
/2, buf
+bs0
/4, ((bs1
-bs0
)/4) * sizeof(float));
1716 memcpy(ret
, saved
, ((bs1
- bs0
) / 4) * sizeof(float));
1717 vc
->fdsp
->vector_fmul_window(ret
+ (bs1
- bs0
) / 4, saved
+ (bs1
- bs0
) / 4, buf
, win
, bs0
/ 4);
1719 memcpy(saved
, buf
+ blocksize
/ 4, blocksize
/ 4 * sizeof(float));
1722 vc
->previous_window
= blockflag
;
1726 // Return the decoded audio packet through the standard api
1728 static int vorbis_decode_frame(AVCodecContext
*avctx
, void *data
,
1729 int *got_frame_ptr
, AVPacket
*avpkt
)
1731 const uint8_t *buf
= avpkt
->data
;
1732 int buf_size
= avpkt
->size
;
1733 vorbis_context
*vc
= avctx
->priv_data
;
1734 AVFrame
*frame
= data
;
1735 GetBitContext
*gb
= &vc
->gb
;
1736 float *channel_ptrs
[255];
1739 av_dlog(NULL
, "packet length %d \n", buf_size
);
1741 if (*buf
== 1 && buf_size
> 7) {
1742 init_get_bits(gb
, buf
+1, buf_size
*8 - 8);
1744 if ((ret
= vorbis_parse_id_hdr(vc
))) {
1745 av_log(avctx
, AV_LOG_ERROR
, "Id header corrupt.\n");
1750 if (vc
->audio_channels
> 8)
1751 avctx
->channel_layout
= 0;
1753 avctx
->channel_layout
= ff_vorbis_channel_layouts
[vc
->audio_channels
- 1];
1755 avctx
->channels
= vc
->audio_channels
;
1756 avctx
->sample_rate
= vc
->audio_samplerate
;
1760 if (*buf
== 3 && buf_size
> 7) {
1761 av_log(avctx
, AV_LOG_DEBUG
, "Ignoring comment header\n");
1765 if (*buf
== 5 && buf_size
> 7 && vc
->channel_residues
&& !vc
->modes
) {
1766 init_get_bits(gb
, buf
+1, buf_size
*8 - 8);
1767 if ((ret
= vorbis_parse_setup_hdr(vc
))) {
1768 av_log(avctx
, AV_LOG_ERROR
, "Setup header corrupt.\n");
1775 if (!vc
->channel_residues
|| !vc
->modes
) {
1776 av_log(avctx
, AV_LOG_ERROR
, "Data packet before valid headers\n");
1777 return AVERROR_INVALIDDATA
;
1780 /* get output buffer */
1781 frame
->nb_samples
= vc
->blocksize
[1] / 2;
1782 if ((ret
= ff_get_buffer(avctx
, frame
, 0)) < 0)
1785 if (vc
->audio_channels
> 8) {
1786 for (i
= 0; i
< vc
->audio_channels
; i
++)
1787 channel_ptrs
[i
] = (float *)frame
->extended_data
[i
];
1789 for (i
= 0; i
< vc
->audio_channels
; i
++) {
1790 int ch
= ff_vorbis_channel_layout_offsets
[vc
->audio_channels
- 1][i
];
1791 channel_ptrs
[ch
] = (float *)frame
->extended_data
[i
];
1795 init_get_bits(gb
, buf
, buf_size
*8);
1797 if ((len
= vorbis_parse_audio_packet(vc
, channel_ptrs
)) <= 0)
1800 if (!vc
->first_frame
) {
1801 vc
->first_frame
= 1;
1803 av_frame_unref(frame
);
1807 av_dlog(NULL
, "parsed %d bytes %d bits, returned %d samples (*ch*bits) \n",
1808 get_bits_count(gb
) / 8, get_bits_count(gb
) % 8, len
);
1810 frame
->nb_samples
= len
;
1818 static av_cold
int vorbis_decode_close(AVCodecContext
*avctx
)
1820 vorbis_context
*vc
= avctx
->priv_data
;
1827 static av_cold
void vorbis_decode_flush(AVCodecContext
*avctx
)
1829 vorbis_context
*vc
= avctx
->priv_data
;
1832 memset(vc
->saved
, 0, (vc
->blocksize
[1] / 4) * vc
->audio_channels
*
1833 sizeof(*vc
->saved
));
1835 vc
->previous_window
= -1;
1836 vc
->first_frame
= 0;
1839 AVCodec ff_vorbis_decoder
= {
1841 .long_name
= NULL_IF_CONFIG_SMALL("Vorbis"),
1842 .type
= AVMEDIA_TYPE_AUDIO
,
1843 .id
= AV_CODEC_ID_VORBIS
,
1844 .priv_data_size
= sizeof(vorbis_context
),
1845 .init
= vorbis_decode_init
,
1846 .close
= vorbis_decode_close
,
1847 .decode
= vorbis_decode_frame
,
1848 .flush
= vorbis_decode_flush
,
1849 .capabilities
= CODEC_CAP_DR1
,
1850 .channel_layouts
= ff_vorbis_channel_layouts
,
1851 .sample_fmts
= (const enum AVSampleFormat
[]) { AV_SAMPLE_FMT_FLTP
,
1852 AV_SAMPLE_FMT_NONE
},