1/** 2 * @file 3 * Vorbis I decoder 4 * @author Denes Balatoni ( dbalatoni programozo hu ) 5 * 6 * This file is part of FFmpeg. 7 * 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. 12 * 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. 17 * 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 21 */ 22 23#undef V_DEBUG 24//#define V_DEBUG 25//#define AV_DEBUG(...) av_log(NULL, AV_LOG_INFO, __VA_ARGS__) 26 27#include <math.h> 28 29#define ALT_BITSTREAM_READER_LE 30#include "avcodec.h" 31#include "get_bits.h" 32#include "dsputil.h" 33#include "fft.h" 34 35#include "vorbis.h" 36#include "xiph.h" 37 38#define V_NB_BITS 8 39#define V_NB_BITS2 11 40#define V_MAX_VLCS (1 << 16) 41#define V_MAX_PARTITIONS (1 << 20) 42 43#ifndef V_DEBUG 44#define AV_DEBUG(...) 45#endif 46 47#undef NDEBUG 48#include <assert.h> 49 50typedef struct { 51 uint_fast8_t dimensions; 52 uint_fast8_t lookup_type; 53 uint_fast8_t maxdepth; 54 VLC vlc; 55 float *codevectors; 56 unsigned int nb_bits; 57} vorbis_codebook; 58 59typedef union vorbis_floor_u vorbis_floor_data; 60typedef struct vorbis_floor0_s vorbis_floor0; 61typedef struct vorbis_floor1_s vorbis_floor1; 62struct vorbis_context_s; 63typedef 64uint_fast8_t (* vorbis_floor_decode_func) 65 (struct vorbis_context_s *, vorbis_floor_data *, float *); 66typedef struct { 67 uint_fast8_t floor_type; 68 vorbis_floor_decode_func decode; 69 union vorbis_floor_u { 70 struct vorbis_floor0_s { 71 uint_fast8_t order; 72 uint_fast16_t rate; 73 uint_fast16_t bark_map_size; 74 int_fast32_t *map[2]; 75 uint_fast32_t map_size[2]; 76 uint_fast8_t amplitude_bits; 77 uint_fast8_t amplitude_offset; 78 uint_fast8_t num_books; 79 uint_fast8_t *book_list; 80 float *lsp; 81 } t0; 82 struct vorbis_floor1_s { 83 uint_fast8_t partitions; 84 uint_fast8_t maximum_class; 85 uint_fast8_t partition_class[32]; 86 uint_fast8_t class_dimensions[16]; 87 uint_fast8_t class_subclasses[16]; 88 uint_fast8_t class_masterbook[16]; 89 int_fast16_t subclass_books[16][8]; 90 uint_fast8_t multiplier; 91 uint_fast16_t x_list_dim; 92 vorbis_floor1_entry *list; 93 } t1; 94 } data; 95} vorbis_floor; 96 97typedef struct { 98 uint_fast16_t type; 99 uint_fast32_t begin; 100 uint_fast32_t end; 101 uint_fast32_t partition_size; 102 uint_fast8_t classifications; 103 uint_fast8_t classbook; 104 int_fast16_t books[64][8]; 105 uint_fast8_t maxpass; 106} vorbis_residue; 107 108typedef struct { 109 uint_fast8_t submaps; 110 uint_fast16_t coupling_steps; 111 uint_fast8_t *magnitude; 112 uint_fast8_t *angle; 113 uint_fast8_t *mux; 114 uint_fast8_t submap_floor[16]; 115 uint_fast8_t submap_residue[16]; 116} vorbis_mapping; 117 118typedef struct { 119 uint_fast8_t blockflag; 120 uint_fast16_t windowtype; 121 uint_fast16_t transformtype; 122 uint_fast8_t mapping; 123} vorbis_mode; 124 125typedef struct vorbis_context_s { 126 AVCodecContext *avccontext; 127 GetBitContext gb; 128 DSPContext dsp; 129 130 FFTContext mdct[2]; 131 uint_fast8_t first_frame; 132 uint_fast32_t version; 133 uint_fast8_t audio_channels; 134 uint_fast32_t audio_samplerate; 135 uint_fast32_t bitrate_maximum; 136 uint_fast32_t bitrate_nominal; 137 uint_fast32_t bitrate_minimum; 138 uint_fast32_t blocksize[2]; 139 const float *win[2]; 140 uint_fast16_t codebook_count; 141 vorbis_codebook *codebooks; 142 uint_fast8_t floor_count; 143 vorbis_floor *floors; 144 uint_fast8_t residue_count; 145 vorbis_residue *residues; 146 uint_fast8_t mapping_count; 147 vorbis_mapping *mappings; 148 uint_fast8_t mode_count; 149 vorbis_mode *modes; 150 uint_fast8_t mode_number; // mode number for the current packet 151 uint_fast8_t previous_window; 152 float *channel_residues; 153 float *channel_floors; 154 float *saved; 155 uint_fast32_t add_bias; // for float->int conversion 156 uint_fast32_t exp_bias; 157} vorbis_context; 158 159/* Helper functions */ 160 161#define BARK(x) \ 162 (13.1f * atan(0.00074f * (x)) + 2.24f * atan(1.85e-8f * (x) * (x)) + 1e-4f * (x)) 163 164static 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) \ 166 if (idx >= limit) {\ 167 av_log(vc->avccontext, AV_LOG_ERROR,\ 168 idx_err_str,\ 169 (int)(idx), (int)(limit - 1), #idx, __FILE__, __LINE__);\ 170 return -1;\ 171 } 172#define GET_VALIDATED_INDEX(idx, bits, limit) \ 173 {\ 174 idx = get_bits(gb, bits);\ 175 VALIDATE_INDEX(idx, limit)\ 176 } 177 178static float vorbisfloat2float(uint_fast32_t val) 179{ 180 double mant = val & 0x1fffff; 181 long exp = (val & 0x7fe00000L) >> 21; 182 if (val & 0x80000000) 183 mant = -mant; 184 return ldexp(mant, exp - 20 - 768); 185} 186 187 188// Free all allocated memory ----------------------------------------- 189 190static void vorbis_free(vorbis_context *vc) 191{ 192 int_fast16_t i; 193 194 av_freep(&vc->channel_residues); 195 av_freep(&vc->channel_floors); 196 av_freep(&vc->saved); 197 198 av_freep(&vc->residues); 199 av_freep(&vc->modes); 200 201 ff_mdct_end(&vc->mdct[0]); 202 ff_mdct_end(&vc->mdct[1]); 203 204 for (i = 0; i < vc->codebook_count; ++i) { 205 av_free(vc->codebooks[i].codevectors); 206 free_vlc(&vc->codebooks[i].vlc); 207 } 208 av_freep(&vc->codebooks); 209 210 for (i = 0; i < vc->floor_count; ++i) { 211 if (vc->floors[i].floor_type == 0) { 212 av_free(vc->floors[i].data.t0.map[0]); 213 av_free(vc->floors[i].data.t0.map[1]); 214 av_free(vc->floors[i].data.t0.book_list); 215 av_free(vc->floors[i].data.t0.lsp); 216 } else { 217 av_free(vc->floors[i].data.t1.list); 218 } 219 } 220 av_freep(&vc->floors); 221 222 for (i = 0; i < vc->mapping_count; ++i) { 223 av_free(vc->mappings[i].magnitude); 224 av_free(vc->mappings[i].angle); 225 av_free(vc->mappings[i].mux); 226 } 227 av_freep(&vc->mappings); 228} 229 230// Parse setup header ------------------------------------------------- 231 232// Process codebooks part 233 234static int vorbis_parse_setup_hdr_codebooks(vorbis_context *vc) 235{ 236 uint_fast16_t cb; 237 uint8_t *tmp_vlc_bits; 238 uint32_t *tmp_vlc_codes; 239 GetBitContext *gb = &vc->gb; 240 241 vc->codebook_count = get_bits(gb, 8) + 1; 242 243 AV_DEBUG(" Codebooks: %d \n", vc->codebook_count); 244 245 vc->codebooks = av_mallocz(vc->codebook_count * sizeof(vorbis_codebook)); 246 tmp_vlc_bits = av_mallocz(V_MAX_VLCS * sizeof(uint8_t)); 247 tmp_vlc_codes = av_mallocz(V_MAX_VLCS * sizeof(uint32_t)); 248 249 for (cb = 0; cb < vc->codebook_count; ++cb) { 250 vorbis_codebook *codebook_setup = &vc->codebooks[cb]; 251 uint_fast8_t ordered; 252 uint_fast32_t t, used_entries = 0; 253 uint_fast32_t entries; 254 255 AV_DEBUG(" %d. Codebook \n", cb); 256 257 if (get_bits(gb, 24) != 0x564342) { 258 av_log(vc->avccontext, AV_LOG_ERROR, " %"PRIdFAST16". Codebook setup data corrupt. \n", cb); 259 goto error; 260 } 261 262 codebook_setup->dimensions=get_bits(gb, 16); 263 if (codebook_setup->dimensions > 16 || codebook_setup->dimensions == 0) { 264 av_log(vc->avccontext, AV_LOG_ERROR, " %"PRIdFAST16". Codebook's dimension is invalid (%d). \n", cb, codebook_setup->dimensions); 265 goto error; 266 } 267 entries = get_bits(gb, 24); 268 if (entries > V_MAX_VLCS) { 269 av_log(vc->avccontext, AV_LOG_ERROR, " %"PRIdFAST16". Codebook has too many entries (%"PRIdFAST32"). \n", cb, entries); 270 goto error; 271 } 272 273 ordered = get_bits1(gb); 274 275 AV_DEBUG(" codebook_dimensions %d, codebook_entries %d \n", codebook_setup->dimensions, entries); 276 277 if (!ordered) { 278 uint_fast16_t ce; 279 uint_fast8_t flag; 280 uint_fast8_t sparse = get_bits1(gb); 281 282 AV_DEBUG(" not ordered \n"); 283 284 if (sparse) { 285 AV_DEBUG(" sparse \n"); 286 287 used_entries = 0; 288 for (ce = 0; ce < entries; ++ce) { 289 flag = get_bits1(gb); 290 if (flag) { 291 tmp_vlc_bits[ce] = get_bits(gb, 5) + 1; 292 ++used_entries; 293 } else 294 tmp_vlc_bits[ce] = 0; 295 } 296 } else { 297 AV_DEBUG(" not sparse \n"); 298 299 used_entries = entries; 300 for (ce = 0; ce < entries; ++ce) 301 tmp_vlc_bits[ce] = get_bits(gb, 5) + 1; 302 } 303 } else { 304 uint_fast16_t current_entry = 0; 305 uint_fast8_t current_length = get_bits(gb, 5)+1; 306 307 AV_DEBUG(" ordered, current length: %d \n", current_length); //FIXME 308 309 used_entries = entries; 310 for (; current_entry < used_entries && current_length <= 32; ++current_length) { 311 uint_fast16_t i, number; 312 313 AV_DEBUG(" number bits: %d ", ilog(entries - current_entry)); 314 315 number = get_bits(gb, ilog(entries - current_entry)); 316 317 AV_DEBUG(" number: %d \n", number); 318 319 for (i = current_entry; i < number+current_entry; ++i) 320 if (i < used_entries) 321 tmp_vlc_bits[i] = current_length; 322 323 current_entry+=number; 324 } 325 if (current_entry>used_entries) { 326 av_log(vc->avccontext, AV_LOG_ERROR, " More codelengths than codes in codebook. \n"); 327 goto error; 328 } 329 } 330 331 codebook_setup->lookup_type = get_bits(gb, 4); 332 333 AV_DEBUG(" lookup type: %d : %s \n", codebook_setup->lookup_type, codebook_setup->lookup_type ? "vq" : "no lookup"); 334 335// If the codebook is used for (inverse) VQ, calculate codevectors. 336 337 if (codebook_setup->lookup_type == 1) { 338 uint_fast16_t i, j, k; 339 uint_fast16_t codebook_lookup_values = ff_vorbis_nth_root(entries, codebook_setup->dimensions); 340 uint_fast16_t codebook_multiplicands[codebook_lookup_values]; 341 342 float codebook_minimum_value = vorbisfloat2float(get_bits_long(gb, 32)); 343 float codebook_delta_value = vorbisfloat2float(get_bits_long(gb, 32)); 344 uint_fast8_t codebook_value_bits = get_bits(gb, 4)+1; 345 uint_fast8_t codebook_sequence_p = get_bits1(gb); 346 347 AV_DEBUG(" We expect %d numbers for building the codevectors. \n", codebook_lookup_values); 348 AV_DEBUG(" delta %f minmum %f \n", codebook_delta_value, codebook_minimum_value); 349 350 for (i = 0; i < codebook_lookup_values; ++i) { 351 codebook_multiplicands[i] = get_bits(gb, codebook_value_bits); 352 353 AV_DEBUG(" multiplicands*delta+minmum : %e \n", (float)codebook_multiplicands[i]*codebook_delta_value+codebook_minimum_value); 354 AV_DEBUG(" multiplicand %d \n", codebook_multiplicands[i]); 355 } 356 357// Weed out unused vlcs and build codevector vector 358 codebook_setup->codevectors = used_entries ? av_mallocz(used_entries*codebook_setup->dimensions * sizeof(float)) : NULL; 359 for (j = 0, i = 0; i < entries; ++i) { 360 uint_fast8_t dim = codebook_setup->dimensions; 361 362 if (tmp_vlc_bits[i]) { 363 float last = 0.0; 364 uint_fast32_t lookup_offset = i; 365 366#ifdef V_DEBUG 367 av_log(vc->avccontext, AV_LOG_INFO, "Lookup offset %d ,", i); 368#endif 369 370 for (k = 0; k < dim; ++k) { 371 uint_fast32_t multiplicand_offset = lookup_offset % codebook_lookup_values; 372 codebook_setup->codevectors[j * dim + k] = codebook_multiplicands[multiplicand_offset] * codebook_delta_value + codebook_minimum_value + last; 373 if (codebook_sequence_p) 374 last = codebook_setup->codevectors[j * dim + k]; 375 lookup_offset/=codebook_lookup_values; 376 } 377 tmp_vlc_bits[j] = tmp_vlc_bits[i]; 378 379#ifdef V_DEBUG 380 av_log(vc->avccontext, AV_LOG_INFO, "real lookup offset %d, vector: ", j); 381 for (k = 0; k < dim; ++k) 382 av_log(vc->avccontext, AV_LOG_INFO, " %f ", codebook_setup->codevectors[j * dim + k]); 383 av_log(vc->avccontext, AV_LOG_INFO, "\n"); 384#endif 385 386 ++j; 387 } 388 } 389 if (j != used_entries) { 390 av_log(vc->avccontext, AV_LOG_ERROR, "Bug in codevector vector building code. \n"); 391 goto error; 392 } 393 entries = used_entries; 394 } else if (codebook_setup->lookup_type >= 2) { 395 av_log(vc->avccontext, AV_LOG_ERROR, "Codebook lookup type not supported. \n"); 396 goto error; 397 } 398 399// Initialize VLC table 400 if (ff_vorbis_len2vlc(tmp_vlc_bits, tmp_vlc_codes, entries)) { 401 av_log(vc->avccontext, AV_LOG_ERROR, " Invalid code lengths while generating vlcs. \n"); 402 goto error; 403 } 404 codebook_setup->maxdepth = 0; 405 for (t = 0; t < entries; ++t) 406 if (tmp_vlc_bits[t] >= codebook_setup->maxdepth) 407 codebook_setup->maxdepth = tmp_vlc_bits[t]; 408 409 if (codebook_setup->maxdepth > 3 * V_NB_BITS) 410 codebook_setup->nb_bits = V_NB_BITS2; 411 else 412 codebook_setup->nb_bits = V_NB_BITS; 413 414 codebook_setup->maxdepth = (codebook_setup->maxdepth+codebook_setup->nb_bits - 1) / codebook_setup->nb_bits; 415 416 if (init_vlc(&codebook_setup->vlc, codebook_setup->nb_bits, entries, tmp_vlc_bits, sizeof(*tmp_vlc_bits), sizeof(*tmp_vlc_bits), tmp_vlc_codes, sizeof(*tmp_vlc_codes), sizeof(*tmp_vlc_codes), INIT_VLC_LE)) { 417 av_log(vc->avccontext, AV_LOG_ERROR, " Error generating vlc tables. \n"); 418 goto error; 419 } 420 } 421 422 av_free(tmp_vlc_bits); 423 av_free(tmp_vlc_codes); 424 return 0; 425 426// Error: 427error: 428 av_free(tmp_vlc_bits); 429 av_free(tmp_vlc_codes); 430 return -1; 431} 432 433// Process time domain transforms part (unused in Vorbis I) 434 435static int vorbis_parse_setup_hdr_tdtransforms(vorbis_context *vc) 436{ 437 GetBitContext *gb = &vc->gb; 438 uint_fast8_t i; 439 uint_fast8_t vorbis_time_count = get_bits(gb, 6) + 1; 440 441 for (i = 0; i < vorbis_time_count; ++i) { 442 uint_fast16_t vorbis_tdtransform = get_bits(gb, 16); 443 444 AV_DEBUG(" Vorbis time domain transform %d: %d \n", vorbis_time_count, vorbis_tdtransform); 445 446 if (vorbis_tdtransform) { 447 av_log(vc->avccontext, AV_LOG_ERROR, "Vorbis time domain transform data nonzero. \n"); 448 return -1; 449 } 450 } 451 return 0; 452} 453 454// Process floors part 455 456static uint_fast8_t vorbis_floor0_decode(vorbis_context *vc, 457 vorbis_floor_data *vfu, float *vec); 458static void create_map(vorbis_context *vc, uint_fast8_t floor_number); 459static uint_fast8_t vorbis_floor1_decode(vorbis_context *vc, 460 vorbis_floor_data *vfu, float *vec); 461static int vorbis_parse_setup_hdr_floors(vorbis_context *vc) 462{ 463 GetBitContext *gb = &vc->gb; 464 uint_fast16_t i,j,k; 465 466 vc->floor_count = get_bits(gb, 6) + 1; 467 468 vc->floors = av_mallocz(vc->floor_count * sizeof(vorbis_floor)); 469 470 for (i = 0; i < vc->floor_count; ++i) { 471 vorbis_floor *floor_setup = &vc->floors[i]; 472 473 floor_setup->floor_type = get_bits(gb, 16); 474 475 AV_DEBUG(" %d. floor type %d \n", i, floor_setup->floor_type); 476 477 if (floor_setup->floor_type == 1) { 478 uint_fast8_t maximum_class = 0; 479 uint_fast8_t rangebits; 480 uint_fast16_t floor1_values = 2; 481 482 floor_setup->decode = vorbis_floor1_decode; 483 484 floor_setup->data.t1.partitions = get_bits(gb, 5); 485 486 AV_DEBUG(" %d.floor: %d partitions \n", i, floor_setup->data.t1.partitions); 487 488 for (j = 0; j < floor_setup->data.t1.partitions; ++j) { 489 floor_setup->data.t1.partition_class[j] = get_bits(gb, 4); 490 if (floor_setup->data.t1.partition_class[j] > maximum_class) 491 maximum_class = floor_setup->data.t1.partition_class[j]; 492 493 AV_DEBUG(" %d. floor %d partition class %d \n", i, j, floor_setup->data.t1.partition_class[j]); 494 495 } 496 497 AV_DEBUG(" maximum class %d \n", maximum_class); 498 499 floor_setup->data.t1.maximum_class = maximum_class; 500 501 for (j = 0; j <= maximum_class; ++j) { 502 floor_setup->data.t1.class_dimensions[j] = get_bits(gb, 3) + 1; 503 floor_setup->data.t1.class_subclasses[j] = get_bits(gb, 2); 504 505 AV_DEBUG(" %d floor %d class dim: %d subclasses %d \n", i, j, floor_setup->data.t1.class_dimensions[j], floor_setup->data.t1.class_subclasses[j]); 506 507 if (floor_setup->data.t1.class_subclasses[j]) { 508 GET_VALIDATED_INDEX(floor_setup->data.t1.class_masterbook[j], 8, vc->codebook_count) 509 510 AV_DEBUG(" masterbook: %d \n", floor_setup->data.t1.class_masterbook[j]); 511 } 512 513 for (k = 0; k < (1 << floor_setup->data.t1.class_subclasses[j]); ++k) { 514 int16_t bits = get_bits(gb, 8) - 1; 515 if (bits != -1) 516 VALIDATE_INDEX(bits, vc->codebook_count) 517 floor_setup->data.t1.subclass_books[j][k] = bits; 518 519 AV_DEBUG(" book %d. : %d \n", k, floor_setup->data.t1.subclass_books[j][k]); 520 } 521 } 522 523 floor_setup->data.t1.multiplier = get_bits(gb, 2) + 1; 524 floor_setup->data.t1.x_list_dim = 2; 525 526 for (j = 0; j < floor_setup->data.t1.partitions; ++j) 527 floor_setup->data.t1.x_list_dim+=floor_setup->data.t1.class_dimensions[floor_setup->data.t1.partition_class[j]]; 528 529 floor_setup->data.t1.list = av_mallocz(floor_setup->data.t1.x_list_dim * sizeof(vorbis_floor1_entry)); 530 531 532 rangebits = get_bits(gb, 4); 533 floor_setup->data.t1.list[0].x = 0; 534 floor_setup->data.t1.list[1].x = (1 << rangebits); 535 536 for (j = 0; j < floor_setup->data.t1.partitions; ++j) { 537 for (k = 0; k < floor_setup->data.t1.class_dimensions[floor_setup->data.t1.partition_class[j]]; ++k, ++floor1_values) { 538 floor_setup->data.t1.list[floor1_values].x = get_bits(gb, rangebits); 539 540 AV_DEBUG(" %d. floor1 Y coord. %d \n", floor1_values, floor_setup->data.t1.list[floor1_values].x); 541 } 542 } 543 544// Precalculate order of x coordinates - needed for decode 545 ff_vorbis_ready_floor1_list(floor_setup->data.t1.list, floor_setup->data.t1.x_list_dim); 546 } else if (floor_setup->floor_type == 0) { 547 uint_fast8_t max_codebook_dim = 0; 548 549 floor_setup->decode = vorbis_floor0_decode; 550 551 floor_setup->data.t0.order = get_bits(gb, 8); 552 floor_setup->data.t0.rate = get_bits(gb, 16); 553 floor_setup->data.t0.bark_map_size = get_bits(gb, 16); 554 floor_setup->data.t0.amplitude_bits = get_bits(gb, 6); 555 /* zero would result in a div by zero later * 556 * 2^0 - 1 == 0 */ 557 if (floor_setup->data.t0.amplitude_bits == 0) { 558 av_log(vc->avccontext, AV_LOG_ERROR, 559 "Floor 0 amplitude bits is 0.\n"); 560 return -1; 561 } 562 floor_setup->data.t0.amplitude_offset = get_bits(gb, 8); 563 floor_setup->data.t0.num_books = get_bits(gb, 4) + 1; 564 565 /* allocate mem for booklist */ 566 floor_setup->data.t0.book_list = 567 av_malloc(floor_setup->data.t0.num_books); 568 if (!floor_setup->data.t0.book_list) 569 return -1; 570 /* read book indexes */ 571 { 572 int idx; 573 uint_fast8_t book_idx; 574 for (idx = 0; idx < floor_setup->data.t0.num_books; ++idx) { 575 GET_VALIDATED_INDEX(floor_setup->data.t0.book_list[idx], 8, vc->codebook_count) 576 if (vc->codebooks[book_idx].dimensions > max_codebook_dim) 577 max_codebook_dim = vc->codebooks[book_idx].dimensions; 578 } 579 } 580 581 create_map(vc, i); 582 583 /* allocate mem for lsp coefficients */ 584 { 585 /* codebook dim is for padding if codebook dim doesn't * 586 * divide order+1 then we need to read more data */ 587 floor_setup->data.t0.lsp = 588 av_malloc((floor_setup->data.t0.order+1 + max_codebook_dim) 589 * sizeof(float)); 590 if (!floor_setup->data.t0.lsp) 591 return -1; 592 } 593 594#ifdef V_DEBUG /* debug output parsed headers */ 595 AV_DEBUG("floor0 order: %u\n", floor_setup->data.t0.order); 596 AV_DEBUG("floor0 rate: %u\n", floor_setup->data.t0.rate); 597 AV_DEBUG("floor0 bark map size: %u\n", 598 floor_setup->data.t0.bark_map_size); 599 AV_DEBUG("floor0 amplitude bits: %u\n", 600 floor_setup->data.t0.amplitude_bits); 601 AV_DEBUG("floor0 amplitude offset: %u\n", 602 floor_setup->data.t0.amplitude_offset); 603 AV_DEBUG("floor0 number of books: %u\n", 604 floor_setup->data.t0.num_books); 605 AV_DEBUG("floor0 book list pointer: %p\n", 606 floor_setup->data.t0.book_list); 607 { 608 int idx; 609 for (idx = 0; idx < floor_setup->data.t0.num_books; ++idx) { 610 AV_DEBUG(" Book %d: %u\n", 611 idx+1, 612 floor_setup->data.t0.book_list[idx]); 613 } 614 } 615#endif 616 } else { 617 av_log(vc->avccontext, AV_LOG_ERROR, "Invalid floor type!\n"); 618 return -1; 619 } 620 } 621 return 0; 622} 623 624// Process residues part 625 626static int vorbis_parse_setup_hdr_residues(vorbis_context *vc) 627{ 628 GetBitContext *gb = &vc->gb; 629 uint_fast8_t i, j, k; 630 631 vc->residue_count = get_bits(gb, 6)+1; 632 vc->residues = av_mallocz(vc->residue_count * sizeof(vorbis_residue)); 633 634 AV_DEBUG(" There are %d residues. \n", vc->residue_count); 635 636 for (i = 0; i < vc->residue_count; ++i) { 637 vorbis_residue *res_setup = &vc->residues[i]; 638 uint_fast8_t cascade[64]; 639 uint_fast8_t high_bits; 640 uint_fast8_t low_bits; 641 642 res_setup->type = get_bits(gb, 16); 643 644 AV_DEBUG(" %d. residue type %d \n", i, res_setup->type); 645 646 res_setup->begin = get_bits(gb, 24); 647 res_setup->end = get_bits(gb, 24); 648 res_setup->partition_size = get_bits(gb, 24) + 1; 649 /* Validations to prevent a buffer overflow later. */ 650 if (res_setup->begin>res_setup->end || 651 res_setup->end>vc->blocksize[1] / (res_setup->type == 2 ? 1 : 2) || 652 (res_setup->end-res_setup->begin) / res_setup->partition_size > V_MAX_PARTITIONS) { 653 av_log(vc->avccontext, AV_LOG_ERROR, "partition out of bounds: type, begin, end, size, blocksize: %"PRIdFAST16", %"PRIdFAST32", %"PRIdFAST32", %"PRIdFAST32", %"PRIdFAST32"\n", res_setup->type, res_setup->begin, res_setup->end, res_setup->partition_size, vc->blocksize[1] / 2); 654 return -1; 655 } 656 657 res_setup->classifications = get_bits(gb, 6) + 1; 658 GET_VALIDATED_INDEX(res_setup->classbook, 8, vc->codebook_count) 659 660 AV_DEBUG(" begin %d end %d part.size %d classif.s %d classbook %d \n", res_setup->begin, res_setup->end, res_setup->partition_size, 661 res_setup->classifications, res_setup->classbook); 662 663 for (j = 0; j < res_setup->classifications; ++j) { 664 high_bits = 0; 665 low_bits = get_bits(gb, 3); 666 if (get_bits1(gb)) 667 high_bits = get_bits(gb, 5); 668 cascade[j] = (high_bits << 3) + low_bits; 669 670 AV_DEBUG(" %d class casscade depth: %d \n", j, ilog(cascade[j])); 671 } 672 673 res_setup->maxpass = 0; 674 for (j = 0; j < res_setup->classifications; ++j) { 675 for (k = 0; k < 8; ++k) { 676 if (cascade[j]&(1 << k)) { 677 GET_VALIDATED_INDEX(res_setup->books[j][k], 8, vc->codebook_count) 678 679 AV_DEBUG(" %d class casscade depth %d book: %d \n", j, k, res_setup->books[j][k]); 680 681 if (k>res_setup->maxpass) 682 res_setup->maxpass = k; 683 } else { 684 res_setup->books[j][k] = -1; 685 } 686 } 687 } 688 } 689 return 0; 690} 691 692// Process mappings part 693 694static int vorbis_parse_setup_hdr_mappings(vorbis_context *vc) 695{ 696 GetBitContext *gb = &vc->gb; 697 uint_fast8_t i, j; 698 699 vc->mapping_count = get_bits(gb, 6)+1; 700 vc->mappings = av_mallocz(vc->mapping_count * sizeof(vorbis_mapping)); 701 702 AV_DEBUG(" There are %d mappings. \n", vc->mapping_count); 703 704 for (i = 0; i < vc->mapping_count; ++i) { 705 vorbis_mapping *mapping_setup = &vc->mappings[i]; 706 707 if (get_bits(gb, 16)) { 708 av_log(vc->avccontext, AV_LOG_ERROR, "Other mappings than type 0 are not compliant with the Vorbis I specification. \n"); 709 return -1; 710 } 711 if (get_bits1(gb)) { 712 mapping_setup->submaps = get_bits(gb, 4) + 1; 713 } else { 714 mapping_setup->submaps = 1; 715 } 716 717 if (get_bits1(gb)) { 718 mapping_setup->coupling_steps = get_bits(gb, 8) + 1; 719 mapping_setup->magnitude = av_mallocz(mapping_setup->coupling_steps * sizeof(uint_fast8_t)); 720 mapping_setup->angle = av_mallocz(mapping_setup->coupling_steps * sizeof(uint_fast8_t)); 721 for (j = 0; j < mapping_setup->coupling_steps; ++j) { 722 GET_VALIDATED_INDEX(mapping_setup->magnitude[j], ilog(vc->audio_channels - 1), vc->audio_channels) 723 GET_VALIDATED_INDEX(mapping_setup->angle[j], ilog(vc->audio_channels - 1), vc->audio_channels) 724 } 725 } else { 726 mapping_setup->coupling_steps = 0; 727 } 728 729 AV_DEBUG(" %d mapping coupling steps: %d \n", i, mapping_setup->coupling_steps); 730 731 if (get_bits(gb, 2)) { 732 av_log(vc->avccontext, AV_LOG_ERROR, "%d. mapping setup data invalid. \n", i); 733 return -1; // following spec. 734 } 735 736 if (mapping_setup->submaps>1) { 737 mapping_setup->mux = av_mallocz(vc->audio_channels * sizeof(uint_fast8_t)); 738 for (j = 0; j < vc->audio_channels; ++j) 739 mapping_setup->mux[j] = get_bits(gb, 4); 740 } 741 742 for (j = 0; j < mapping_setup->submaps; ++j) { 743 skip_bits(gb, 8); // FIXME check? 744 GET_VALIDATED_INDEX(mapping_setup->submap_floor[j], 8, vc->floor_count) 745 GET_VALIDATED_INDEX(mapping_setup->submap_residue[j], 8, vc->residue_count) 746 747 AV_DEBUG(" %d mapping %d submap : floor %d, residue %d \n", i, j, mapping_setup->submap_floor[j], mapping_setup->submap_residue[j]); 748 } 749 } 750 return 0; 751} 752 753// Process modes part 754 755static void create_map(vorbis_context *vc, uint_fast8_t floor_number) 756{ 757 vorbis_floor *floors = vc->floors; 758 vorbis_floor0 *vf; 759 int idx; 760 int_fast8_t blockflag; 761 int_fast32_t *map; 762 int_fast32_t n; //TODO: could theoretically be smaller? 763 764 for (blockflag = 0; blockflag < 2; ++blockflag) { 765 n = vc->blocksize[blockflag] / 2; 766 floors[floor_number].data.t0.map[blockflag] = 767 av_malloc((n+1) * sizeof(int_fast32_t)); // n + sentinel 768 769 map = floors[floor_number].data.t0.map[blockflag]; 770 vf = &floors[floor_number].data.t0; 771 772 for (idx = 0; idx < n; ++idx) { 773 map[idx] = floor(BARK((vf->rate * idx) / (2.0f * n)) * 774 ((vf->bark_map_size) / 775 BARK(vf->rate / 2.0f))); 776 if (vf->bark_map_size-1 < map[idx]) 777 map[idx] = vf->bark_map_size - 1; 778 } 779 map[n] = -1; 780 vf->map_size[blockflag] = n; 781 } 782 783# ifdef V_DEBUG 784 for (idx = 0; idx <= n; ++idx) { 785 AV_DEBUG("floor0 map: map at pos %d is %d\n", 786 idx, map[idx]); 787 } 788# endif 789} 790 791static int vorbis_parse_setup_hdr_modes(vorbis_context *vc) 792{ 793 GetBitContext *gb = &vc->gb; 794 uint_fast8_t i; 795 796 vc->mode_count = get_bits(gb, 6) + 1; 797 vc->modes = av_mallocz(vc->mode_count * sizeof(vorbis_mode)); 798 799 AV_DEBUG(" There are %d modes.\n", vc->mode_count); 800 801 for (i = 0; i < vc->mode_count; ++i) { 802 vorbis_mode *mode_setup = &vc->modes[i]; 803 804 mode_setup->blockflag = get_bits1(gb); 805 mode_setup->windowtype = get_bits(gb, 16); //FIXME check 806 mode_setup->transformtype = get_bits(gb, 16); //FIXME check 807 GET_VALIDATED_INDEX(mode_setup->mapping, 8, vc->mapping_count); 808 809 AV_DEBUG(" %d mode: blockflag %d, windowtype %d, transformtype %d, mapping %d \n", i, mode_setup->blockflag, mode_setup->windowtype, mode_setup->transformtype, mode_setup->mapping); 810 } 811 return 0; 812} 813 814// Process the whole setup header using the functions above 815 816static int vorbis_parse_setup_hdr(vorbis_context *vc) 817{ 818 GetBitContext *gb = &vc->gb; 819 820 if ((get_bits(gb, 8) != 'v') || (get_bits(gb, 8) != 'o') || 821 (get_bits(gb, 8) != 'r') || (get_bits(gb, 8) != 'b') || 822 (get_bits(gb, 8) != 'i') || (get_bits(gb, 8) != 's')) { 823 av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (no vorbis signature). \n"); 824 return -1; 825 } 826 827 if (vorbis_parse_setup_hdr_codebooks(vc)) { 828 av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (codebooks). \n"); 829 return -2; 830 } 831 if (vorbis_parse_setup_hdr_tdtransforms(vc)) { 832 av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (time domain transforms). \n"); 833 return -3; 834 } 835 if (vorbis_parse_setup_hdr_floors(vc)) { 836 av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (floors). \n"); 837 return -4; 838 } 839 if (vorbis_parse_setup_hdr_residues(vc)) { 840 av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (residues). \n"); 841 return -5; 842 } 843 if (vorbis_parse_setup_hdr_mappings(vc)) { 844 av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (mappings). \n"); 845 return -6; 846 } 847 if (vorbis_parse_setup_hdr_modes(vc)) { 848 av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (modes). \n"); 849 return -7; 850 } 851 if (!get_bits1(gb)) { 852 av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (framing flag). \n"); 853 return -8; // framing flag bit unset error 854 } 855 856 return 0; 857} 858 859// Process the identification header 860 861static int vorbis_parse_id_hdr(vorbis_context *vc) 862{ 863 GetBitContext *gb = &vc->gb; 864 uint_fast8_t bl0, bl1; 865 866 if ((get_bits(gb, 8) != 'v') || (get_bits(gb, 8) != 'o') || 867 (get_bits(gb, 8) != 'r') || (get_bits(gb, 8) != 'b') || 868 (get_bits(gb, 8) != 'i') || (get_bits(gb, 8) != 's')) { 869 av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis id header packet corrupt (no vorbis signature). \n"); 870 return -1; 871 } 872 873 vc->version = get_bits_long(gb, 32); //FIXME check 0 874 vc->audio_channels = get_bits(gb, 8); 875 if (vc->audio_channels <= 0) { 876 av_log(vc->avccontext, AV_LOG_ERROR, "Invalid number of channels\n"); 877 return -1; 878 } 879 vc->audio_samplerate = get_bits_long(gb, 32); 880 if (vc->audio_samplerate <= 0) { 881 av_log(vc->avccontext, AV_LOG_ERROR, "Invalid samplerate\n"); 882 return -1; 883 } 884 vc->bitrate_maximum = get_bits_long(gb, 32); 885 vc->bitrate_nominal = get_bits_long(gb, 32); 886 vc->bitrate_minimum = get_bits_long(gb, 32); 887 bl0 = get_bits(gb, 4); 888 bl1 = get_bits(gb, 4); 889 vc->blocksize[0] = (1 << bl0); 890 vc->blocksize[1] = (1 << bl1); 891 if (bl0 > 13 || bl0 < 6 || bl1 > 13 || bl1 < 6 || bl1 < bl0) { 892 av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis id header packet corrupt (illegal blocksize). \n"); 893 return -3; 894 } 895 // output format int16 896 if (vc->blocksize[1] / 2 * vc->audio_channels * 2 > AVCODEC_MAX_AUDIO_FRAME_SIZE) { 897 av_log(vc->avccontext, AV_LOG_ERROR, "Vorbis channel count makes " 898 "output packets too large.\n"); 899 return -4; 900 } 901 vc->win[0] = ff_vorbis_vwin[bl0 - 6]; 902 vc->win[1] = ff_vorbis_vwin[bl1 - 6]; 903 904 if ((get_bits1(gb)) == 0) { 905 av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis id header packet corrupt (framing flag not set). \n"); 906 return -2; 907 } 908 909 vc->channel_residues = av_malloc((vc->blocksize[1] / 2) * vc->audio_channels * sizeof(float)); 910 vc->channel_floors = av_malloc((vc->blocksize[1] / 2) * vc->audio_channels * sizeof(float)); 911 vc->saved = av_mallocz((vc->blocksize[1] / 4) * vc->audio_channels * sizeof(float)); 912 vc->previous_window = 0; 913 914 ff_mdct_init(&vc->mdct[0], bl0, 1, vc->exp_bias ? -(1 << 15) : -1.0); 915 ff_mdct_init(&vc->mdct[1], bl1, 1, vc->exp_bias ? -(1 << 15) : -1.0); 916 917 AV_DEBUG(" vorbis version %d \n audio_channels %d \n audio_samplerate %d \n bitrate_max %d \n bitrate_nom %d \n bitrate_min %d \n blk_0 %d blk_1 %d \n ", 918 vc->version, vc->audio_channels, vc->audio_samplerate, vc->bitrate_maximum, vc->bitrate_nominal, vc->bitrate_minimum, vc->blocksize[0], vc->blocksize[1]); 919 920/* 921 BLK = vc->blocksize[0]; 922 for (i = 0; i < BLK / 2; ++i) { 923 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))); 924 } 925*/ 926 927 return 0; 928} 929 930// Process the extradata using the functions above (identification header, setup header) 931 932static av_cold int vorbis_decode_init(AVCodecContext *avccontext) 933{ 934 vorbis_context *vc = avccontext->priv_data ; 935 uint8_t *headers = avccontext->extradata; 936 int headers_len = avccontext->extradata_size; 937 uint8_t *header_start[3]; 938 int header_len[3]; 939 GetBitContext *gb = &(vc->gb); 940 int hdr_type; 941 942 vc->avccontext = avccontext; 943 dsputil_init(&vc->dsp, avccontext); 944 945 if (vc->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) { 946 vc->add_bias = 385; 947 vc->exp_bias = 0; 948 } else { 949 vc->add_bias = 0; 950 vc->exp_bias = 15 << 23; 951 } 952 953 if (!headers_len) { 954 av_log(avccontext, AV_LOG_ERROR, "Extradata missing.\n"); 955 return -1; 956 } 957 958 if (ff_split_xiph_headers(headers, headers_len, 30, header_start, header_len) < 0) { 959 av_log(avccontext, AV_LOG_ERROR, "Extradata corrupt.\n"); 960 return -1; 961 } 962 963 init_get_bits(gb, header_start[0], header_len[0]*8); 964 hdr_type = get_bits(gb, 8); 965 if (hdr_type != 1) { 966 av_log(avccontext, AV_LOG_ERROR, "First header is not the id header.\n"); 967 return -1; 968 } 969 if (vorbis_parse_id_hdr(vc)) { 970 av_log(avccontext, AV_LOG_ERROR, "Id header corrupt.\n"); 971 vorbis_free(vc); 972 return -1; 973 } 974 975 init_get_bits(gb, header_start[2], header_len[2]*8); 976 hdr_type = get_bits(gb, 8); 977 if (hdr_type != 5) { 978 av_log(avccontext, AV_LOG_ERROR, "Third header is not the setup header.\n"); 979 vorbis_free(vc); 980 return -1; 981 } 982 if (vorbis_parse_setup_hdr(vc)) { 983 av_log(avccontext, AV_LOG_ERROR, "Setup header corrupt.\n"); 984 vorbis_free(vc); 985 return -1; 986 } 987 988 if (vc->audio_channels > 8) 989 avccontext->channel_layout = 0; 990 else 991 avccontext->channel_layout = ff_vorbis_channel_layouts[vc->audio_channels - 1]; 992 993 avccontext->channels = vc->audio_channels; 994 avccontext->sample_rate = vc->audio_samplerate; 995 avccontext->frame_size = FFMIN(vc->blocksize[0], vc->blocksize[1]) >> 2; 996 avccontext->sample_fmt = SAMPLE_FMT_S16; 997 998 return 0 ; 999} 1000 1001// Decode audiopackets ------------------------------------------------- 1002 1003// Read and decode floor 1004 1005static uint_fast8_t vorbis_floor0_decode(vorbis_context *vc, 1006 vorbis_floor_data *vfu, float *vec) 1007{ 1008 vorbis_floor0 *vf = &vfu->t0; 1009 float *lsp = vf->lsp; 1010 uint_fast32_t amplitude; 1011 uint_fast32_t book_idx; 1012 uint_fast8_t blockflag = vc->modes[vc->mode_number].blockflag; 1013 1014 amplitude = get_bits(&vc->gb, vf->amplitude_bits); 1015 if (amplitude > 0) { 1016 float last = 0; 1017 uint_fast16_t lsp_len = 0; 1018 uint_fast16_t idx; 1019 vorbis_codebook codebook; 1020 1021 book_idx = get_bits(&vc->gb, ilog(vf->num_books)); 1022 if (book_idx >= vf->num_books) { 1023 av_log(vc->avccontext, AV_LOG_ERROR, 1024 "floor0 dec: booknumber too high!\n"); 1025 book_idx = 0; 1026 //FIXME: look above 1027 } 1028 AV_DEBUG("floor0 dec: booknumber: %u\n", book_idx); 1029 codebook = vc->codebooks[vf->book_list[book_idx]]; 1030 1031 while (lsp_len<vf->order) { 1032 int vec_off; 1033 1034 AV_DEBUG("floor0 dec: book dimension: %d\n", codebook.dimensions); 1035 AV_DEBUG("floor0 dec: maximum depth: %d\n", codebook.maxdepth); 1036 /* read temp vector */ 1037 vec_off = get_vlc2(&vc->gb, codebook.vlc.table, 1038 codebook.nb_bits, codebook.maxdepth) 1039 * codebook.dimensions; 1040 AV_DEBUG("floor0 dec: vector offset: %d\n", vec_off); 1041 /* copy each vector component and add last to it */ 1042 for (idx = 0; idx < codebook.dimensions; ++idx) 1043 lsp[lsp_len+idx] = codebook.codevectors[vec_off+idx] + last; 1044 last = lsp[lsp_len+idx-1]; /* set last to last vector component */ 1045 1046 lsp_len += codebook.dimensions; 1047 } 1048#ifdef V_DEBUG 1049 /* DEBUG: output lsp coeffs */ 1050 { 1051 int idx; 1052 for (idx = 0; idx < lsp_len; ++idx) 1053 AV_DEBUG("floor0 dec: coeff at %d is %f\n", idx, lsp[idx]); 1054 } 1055#endif 1056 1057 /* synthesize floor output vector */ 1058 { 1059 int i; 1060 int order = vf->order; 1061 float wstep = M_PI / vf->bark_map_size; 1062 1063 for (i = 0; i < order; i++) 1064 lsp[i] = 2.0f * cos(lsp[i]); 1065 1066 AV_DEBUG("floor0 synth: map_size = %d; m = %d; wstep = %f\n", 1067 vf->map_size, order, wstep); 1068 1069 i = 0; 1070 while (i < vf->map_size[blockflag]) { 1071 int j, iter_cond = vf->map[blockflag][i]; 1072 float p = 0.5f; 1073 float q = 0.5f; 1074 float two_cos_w = 2.0f * cos(wstep * iter_cond); // needed all times 1075 1076 /* similar part for the q and p products */ 1077 for (j = 0; j + 1 < order; j += 2) { 1078 q *= lsp[j] - two_cos_w; 1079 p *= lsp[j + 1] - two_cos_w; 1080 } 1081 if (j == order) { // even order 1082 p *= p * (2.0f - two_cos_w); 1083 q *= q * (2.0f + two_cos_w); 1084 } else { // odd order 1085 q *= two_cos_w-lsp[j]; // one more time for q 1086 1087 /* final step and square */ 1088 p *= p * (4.f - two_cos_w * two_cos_w); 1089 q *= q; 1090 } 1091 1092 /* calculate linear floor value */ 1093 { 1094 q = exp((((amplitude*vf->amplitude_offset) / 1095 (((1 << vf->amplitude_bits) - 1) * sqrt(p + q))) 1096 - vf->amplitude_offset) * .11512925f); 1097 } 1098 1099 /* fill vector */ 1100 do { 1101 vec[i] = q; ++i; 1102 } while (vf->map[blockflag][i] == iter_cond); 1103 } 1104 } 1105 } else { 1106 /* this channel is unused */ 1107 return 1; 1108 } 1109 1110 AV_DEBUG(" Floor0 decoded\n"); 1111 1112 return 0; 1113} 1114 1115static uint_fast8_t vorbis_floor1_decode(vorbis_context *vc, 1116 vorbis_floor_data *vfu, float *vec) 1117{ 1118 vorbis_floor1 *vf = &vfu->t1; 1119 GetBitContext *gb = &vc->gb; 1120 uint_fast16_t range_v[4] = { 256, 128, 86, 64 }; 1121 uint_fast16_t range = range_v[vf->multiplier-1]; 1122 uint_fast16_t floor1_Y[vf->x_list_dim]; 1123 uint_fast16_t floor1_Y_final[vf->x_list_dim]; 1124 int floor1_flag[vf->x_list_dim]; 1125 uint_fast8_t class_; 1126 uint_fast8_t cdim; 1127 uint_fast8_t cbits; 1128 uint_fast8_t csub; 1129 uint_fast8_t cval; 1130 int_fast16_t book; 1131 uint_fast16_t offset; 1132 uint_fast16_t i,j; 1133 /*u*/int_fast16_t adx, ady, off, predicted; // WTF ? dy/adx = (unsigned)dy/adx ? 1134 int_fast16_t dy, err; 1135 1136 1137 if (!get_bits1(gb)) // silence 1138 return 1; 1139 1140// Read values (or differences) for the floor's points 1141 1142 floor1_Y[0] = get_bits(gb, ilog(range - 1)); 1143 floor1_Y[1] = get_bits(gb, ilog(range - 1)); 1144 1145 AV_DEBUG("floor 0 Y %d floor 1 Y %d \n", floor1_Y[0], floor1_Y[1]); 1146 1147 offset = 2; 1148 for (i = 0; i < vf->partitions; ++i) { 1149 class_ = vf->partition_class[i]; 1150 cdim = vf->class_dimensions[class_]; 1151 cbits = vf->class_subclasses[class_]; 1152 csub = (1 << cbits) - 1; 1153 cval = 0; 1154 1155 AV_DEBUG("Cbits %d \n", cbits); 1156 1157 if (cbits) // this reads all subclasses for this partition's class 1158 cval = get_vlc2(gb, vc->codebooks[vf->class_masterbook[class_]].vlc.table, 1159 vc->codebooks[vf->class_masterbook[class_]].nb_bits, 3); 1160 1161 for (j = 0; j < cdim; ++j) { 1162 book = vf->subclass_books[class_][cval & csub]; 1163 1164 AV_DEBUG("book %d Cbits %d cval %d bits:%d \n", book, cbits, cval, get_bits_count(gb)); 1165 1166 cval = cval >> cbits; 1167 if (book > -1) { 1168 floor1_Y[offset+j] = get_vlc2(gb, vc->codebooks[book].vlc.table, 1169 vc->codebooks[book].nb_bits, 3); 1170 } else { 1171 floor1_Y[offset+j] = 0; 1172 } 1173 1174 AV_DEBUG(" floor(%d) = %d \n", vf->list[offset+j].x, floor1_Y[offset+j]); 1175 } 1176 offset+=cdim; 1177 } 1178 1179// Amplitude calculation from the differences 1180 1181 floor1_flag[0] = 1; 1182 floor1_flag[1] = 1; 1183 floor1_Y_final[0] = floor1_Y[0]; 1184 floor1_Y_final[1] = floor1_Y[1]; 1185 1186 for (i = 2; i < vf->x_list_dim; ++i) { 1187 uint_fast16_t val, highroom, lowroom, room; 1188 uint_fast16_t high_neigh_offs; 1189 uint_fast16_t low_neigh_offs; 1190 1191 low_neigh_offs = vf->list[i].low; 1192 high_neigh_offs = vf->list[i].high; 1193 dy = floor1_Y_final[high_neigh_offs] - floor1_Y_final[low_neigh_offs]; // render_point begin 1194 adx = vf->list[high_neigh_offs].x - vf->list[low_neigh_offs].x; 1195 ady = FFABS(dy); 1196 err = ady * (vf->list[i].x - vf->list[low_neigh_offs].x); 1197 off = (int16_t)err / (int16_t)adx; 1198 if (dy < 0) { 1199 predicted = floor1_Y_final[low_neigh_offs] - off; 1200 } else { 1201 predicted = floor1_Y_final[low_neigh_offs] + off; 1202 } // render_point end 1203 1204 val = floor1_Y[i]; 1205 highroom = range-predicted; 1206 lowroom = predicted; 1207 if (highroom < lowroom) { 1208 room = highroom * 2; 1209 } else { 1210 room = lowroom * 2; // SPEC mispelling 1211 } 1212 if (val) { 1213 floor1_flag[low_neigh_offs] = 1; 1214 floor1_flag[high_neigh_offs] = 1; 1215 floor1_flag[i] = 1; 1216 if (val >= room) { 1217 if (highroom > lowroom) { 1218 floor1_Y_final[i] = val - lowroom + predicted; 1219 } else { 1220 floor1_Y_final[i] = predicted - val + highroom - 1; 1221 } 1222 } else { 1223 if (val & 1) { 1224 floor1_Y_final[i] = predicted - (val + 1) / 2; 1225 } else { 1226 floor1_Y_final[i] = predicted + val / 2; 1227 } 1228 } 1229 } else { 1230 floor1_flag[i] = 0; 1231 floor1_Y_final[i] = predicted; 1232 } 1233 1234 AV_DEBUG(" Decoded floor(%d) = %d / val %d \n", vf->list[i].x, floor1_Y_final[i], val); 1235 } 1236 1237// Curve synth - connect the calculated dots and convert from dB scale FIXME optimize ? 1238 1239 ff_vorbis_floor1_render_list(vf->list, vf->x_list_dim, floor1_Y_final, floor1_flag, vf->multiplier, vec, vf->list[1].x); 1240 1241 AV_DEBUG(" Floor decoded\n"); 1242 1243 return 0; 1244} 1245 1246// Read and decode residue 1247 1248static av_always_inline int vorbis_residue_decode_internal(vorbis_context *vc, 1249 vorbis_residue *vr, 1250 uint_fast8_t ch, 1251 uint_fast8_t *do_not_decode, 1252 float *vec, 1253 uint_fast16_t vlen, 1254 int vr_type) 1255{ 1256 GetBitContext *gb = &vc->gb; 1257 uint_fast8_t c_p_c = vc->codebooks[vr->classbook].dimensions; 1258 uint_fast16_t n_to_read = vr->end-vr->begin; 1259 uint_fast16_t ptns_to_read = n_to_read/vr->partition_size; 1260 uint_fast8_t classifs[ptns_to_read*vc->audio_channels]; 1261 uint_fast8_t pass; 1262 uint_fast8_t ch_used; 1263 uint_fast8_t i,j,l; 1264 uint_fast16_t k; 1265 1266 if (vr_type == 2) { 1267 for (j = 1; j < ch; ++j) 1268 do_not_decode[0] &= do_not_decode[j]; // FIXME - clobbering input 1269 if (do_not_decode[0]) 1270 return 0; 1271 ch_used = 1; 1272 } else { 1273 ch_used = ch; 1274 } 1275 1276 AV_DEBUG(" residue type 0/1/2 decode begin, ch: %d cpc %d \n", ch, c_p_c); 1277 1278 for (pass = 0; pass <= vr->maxpass; ++pass) { // FIXME OPTIMIZE? 1279 uint_fast16_t voffset; 1280 uint_fast16_t partition_count; 1281 uint_fast16_t j_times_ptns_to_read; 1282 1283 voffset = vr->begin; 1284 for (partition_count = 0; partition_count < ptns_to_read;) { // SPEC error 1285 if (!pass) { 1286 uint_fast32_t inverse_class = ff_inverse[vr->classifications]; 1287 for (j_times_ptns_to_read = 0, j = 0; j < ch_used; ++j) { 1288 if (!do_not_decode[j]) { 1289 uint_fast32_t temp = get_vlc2(gb, vc->codebooks[vr->classbook].vlc.table, 1290 vc->codebooks[vr->classbook].nb_bits, 3); 1291 1292 AV_DEBUG("Classword: %d \n", temp); 1293 1294 assert(vr->classifications > 1 && temp <= 65536); //needed for inverse[] 1295 for (i = 0; i < c_p_c; ++i) { 1296 uint_fast32_t temp2; 1297 1298 temp2 = (((uint_fast64_t)temp) * inverse_class) >> 32; 1299 if (partition_count + c_p_c - 1 - i < ptns_to_read) 1300 classifs[j_times_ptns_to_read + partition_count + c_p_c - 1 - i] = temp - temp2 * vr->classifications; 1301 temp = temp2; 1302 } 1303 } 1304 j_times_ptns_to_read += ptns_to_read; 1305 } 1306 } 1307 for (i = 0; (i < c_p_c) && (partition_count < ptns_to_read); ++i) { 1308 for (j_times_ptns_to_read = 0, j = 0; j < ch_used; ++j) { 1309 uint_fast16_t voffs; 1310 1311 if (!do_not_decode[j]) { 1312 uint_fast8_t vqclass = classifs[j_times_ptns_to_read+partition_count]; 1313 int_fast16_t vqbook = vr->books[vqclass][pass]; 1314 1315 if (vqbook >= 0 && vc->codebooks[vqbook].codevectors) { 1316 uint_fast16_t coffs; 1317 unsigned dim = vc->codebooks[vqbook].dimensions; // not uint_fast8_t: 64bit is slower here on amd64 1318 uint_fast16_t step = dim == 1 ? vr->partition_size 1319 : FASTDIV(vr->partition_size, dim); 1320 vorbis_codebook codebook = vc->codebooks[vqbook]; 1321 1322 if (vr_type == 0) { 1323 1324 voffs = voffset+j*vlen; 1325 for (k = 0; k < step; ++k) { 1326 coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * dim; 1327 for (l = 0; l < dim; ++l) 1328 vec[voffs + k + l * step] += codebook.codevectors[coffs + l]; // FPMATH 1329 } 1330 } else if (vr_type == 1) { 1331 voffs = voffset + j * vlen; 1332 for (k = 0; k < step; ++k) { 1333 coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * dim; 1334 for (l = 0; l < dim; ++l, ++voffs) { 1335 vec[voffs]+=codebook.codevectors[coffs+l]; // FPMATH 1336 1337 AV_DEBUG(" pass %d offs: %d curr: %f change: %f cv offs.: %d \n", pass, voffs, vec[voffs], codebook.codevectors[coffs+l], coffs); 1338 } 1339 } 1340 } else if (vr_type == 2 && ch == 2 && (voffset & 1) == 0 && (dim & 1) == 0) { // most frequent case optimized 1341 voffs = voffset >> 1; 1342 1343 if (dim == 2) { 1344 for (k = 0; k < step; ++k) { 1345 coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * 2; 1346 vec[voffs + k ] += codebook.codevectors[coffs ]; // FPMATH 1347 vec[voffs + k + vlen] += codebook.codevectors[coffs + 1]; // FPMATH 1348 } 1349 } else if (dim == 4) { 1350 for (k = 0; k < step; ++k, voffs += 2) { 1351 coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * 4; 1352 vec[voffs ] += codebook.codevectors[coffs ]; // FPMATH 1353 vec[voffs + 1 ] += codebook.codevectors[coffs + 2]; // FPMATH 1354 vec[voffs + vlen ] += codebook.codevectors[coffs + 1]; // FPMATH 1355 vec[voffs + vlen + 1] += codebook.codevectors[coffs + 3]; // FPMATH 1356 } 1357 } else 1358 for (k = 0; k < step; ++k) { 1359 coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * dim; 1360 for (l = 0; l < dim; l += 2, voffs++) { 1361 vec[voffs ] += codebook.codevectors[coffs + l ]; // FPMATH 1362 vec[voffs + vlen] += codebook.codevectors[coffs + l + 1]; // FPMATH 1363 1364 AV_DEBUG(" pass %d offs: %d curr: %f change: %f cv offs.: %d+%d \n", pass, voffset / ch + (voffs % ch) * vlen, vec[voffset / ch + (voffs % ch) * vlen], codebook.codevectors[coffs + l], coffs, l); 1365 } 1366 } 1367 1368 } else if (vr_type == 2) { 1369 voffs = voffset; 1370 1371 for (k = 0; k < step; ++k) { 1372 coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * dim; 1373 for (l = 0; l < dim; ++l, ++voffs) { 1374 vec[voffs / ch + (voffs % ch) * vlen] += codebook.codevectors[coffs + l]; // FPMATH FIXME use if and counter instead of / and % 1375 1376 AV_DEBUG(" pass %d offs: %d curr: %f change: %f cv offs.: %d+%d \n", pass, voffset / ch + (voffs % ch) * vlen, vec[voffset / ch + (voffs % ch) * vlen], codebook.codevectors[coffs + l], coffs, l); 1377 } 1378 } 1379 } 1380 } 1381 } 1382 j_times_ptns_to_read += ptns_to_read; 1383 } 1384 ++partition_count; 1385 voffset += vr->partition_size; 1386 } 1387 } 1388 } 1389 return 0; 1390} 1391 1392static inline int vorbis_residue_decode(vorbis_context *vc, vorbis_residue *vr, 1393 uint_fast8_t ch, 1394 uint_fast8_t *do_not_decode, 1395 float *vec, uint_fast16_t vlen) 1396{ 1397 if (vr->type == 2) 1398 return vorbis_residue_decode_internal(vc, vr, ch, do_not_decode, vec, vlen, 2); 1399 else if (vr->type == 1) 1400 return vorbis_residue_decode_internal(vc, vr, ch, do_not_decode, vec, vlen, 1); 1401 else if (vr->type == 0) 1402 return vorbis_residue_decode_internal(vc, vr, ch, do_not_decode, vec, vlen, 0); 1403 else { 1404 av_log(vc->avccontext, AV_LOG_ERROR, " Invalid residue type while residue decode?! \n"); 1405 return -1; 1406 } 1407} 1408 1409void vorbis_inverse_coupling(float *mag, float *ang, int blocksize) 1410{ 1411 int i; 1412 for (i = 0; i < blocksize; i++) { 1413 if (mag[i] > 0.0) { 1414 if (ang[i] > 0.0) { 1415 ang[i] = mag[i] - ang[i]; 1416 } else { 1417 float temp = ang[i]; 1418 ang[i] = mag[i]; 1419 mag[i] += temp; 1420 } 1421 } else { 1422 if (ang[i] > 0.0) { 1423 ang[i] += mag[i]; 1424 } else { 1425 float temp = ang[i]; 1426 ang[i] = mag[i]; 1427 mag[i] -= temp; 1428 } 1429 } 1430 } 1431} 1432 1433static void copy_normalize(float *dst, float *src, int len, int exp_bias, 1434 float add_bias) 1435{ 1436 int i; 1437 if (exp_bias) { 1438 memcpy(dst, src, len * sizeof(float)); 1439 } else { 1440 for (i = 0; i < len; i++) 1441 dst[i] = src[i] + add_bias; 1442 } 1443} 1444 1445// Decode the audio packet using the functions above 1446 1447static int vorbis_parse_audio_packet(vorbis_context *vc) 1448{ 1449 GetBitContext *gb = &vc->gb; 1450 1451 uint_fast8_t previous_window = vc->previous_window; 1452 uint_fast8_t mode_number; 1453 uint_fast8_t blockflag; 1454 uint_fast16_t blocksize; 1455 int_fast32_t i,j; 1456 uint_fast8_t no_residue[vc->audio_channels]; 1457 uint_fast8_t do_not_decode[vc->audio_channels]; 1458 vorbis_mapping *mapping; 1459 float *ch_res_ptr = vc->channel_residues; 1460 float *ch_floor_ptr = vc->channel_floors; 1461 uint_fast8_t res_chan[vc->audio_channels]; 1462 uint_fast8_t res_num = 0; 1463 int_fast16_t retlen = 0; 1464 float fadd_bias = vc->add_bias; 1465 1466 if (get_bits1(gb)) { 1467 av_log(vc->avccontext, AV_LOG_ERROR, "Not a Vorbis I audio packet.\n"); 1468 return -1; // packet type not audio 1469 } 1470 1471 if (vc->mode_count == 1) { 1472 mode_number = 0; 1473 } else { 1474 GET_VALIDATED_INDEX(mode_number, ilog(vc->mode_count-1), vc->mode_count) 1475 } 1476 vc->mode_number = mode_number; 1477 mapping = &vc->mappings[vc->modes[mode_number].mapping]; 1478 1479 AV_DEBUG(" Mode number: %d , mapping: %d , blocktype %d \n", mode_number, vc->modes[mode_number].mapping, vc->modes[mode_number].blockflag); 1480 1481 blockflag = vc->modes[mode_number].blockflag; 1482 blocksize = vc->blocksize[blockflag]; 1483 if (blockflag) 1484 skip_bits(gb, 2); // previous_window, next_window 1485 1486 memset(ch_res_ptr, 0, sizeof(float) * vc->audio_channels * blocksize / 2); //FIXME can this be removed ? 1487 memset(ch_floor_ptr, 0, sizeof(float) * vc->audio_channels * blocksize / 2); //FIXME can this be removed ? 1488 1489// Decode floor 1490 1491 for (i = 0; i < vc->audio_channels; ++i) { 1492 vorbis_floor *floor; 1493 if (mapping->submaps > 1) { 1494 floor = &vc->floors[mapping->submap_floor[mapping->mux[i]]]; 1495 } else { 1496 floor = &vc->floors[mapping->submap_floor[0]]; 1497 } 1498 1499 no_residue[i] = floor->decode(vc, &floor->data, ch_floor_ptr); 1500 ch_floor_ptr += blocksize / 2; 1501 } 1502 1503// Nonzero vector propagate 1504 1505 for (i = mapping->coupling_steps - 1; i >= 0; --i) { 1506 if (!(no_residue[mapping->magnitude[i]] & no_residue[mapping->angle[i]])) { 1507 no_residue[mapping->magnitude[i]] = 0; 1508 no_residue[mapping->angle[i]] = 0; 1509 } 1510 } 1511 1512// Decode residue 1513 1514 for (i = 0; i < mapping->submaps; ++i) { 1515 vorbis_residue *residue; 1516 uint_fast8_t ch = 0; 1517 1518 for (j = 0; j < vc->audio_channels; ++j) { 1519 if ((mapping->submaps == 1) || (i == mapping->mux[j])) { 1520 res_chan[j] = res_num; 1521 if (no_residue[j]) { 1522 do_not_decode[ch] = 1; 1523 } else { 1524 do_not_decode[ch] = 0; 1525 } 1526 ++ch; 1527 ++res_num; 1528 } 1529 } 1530 residue = &vc->residues[mapping->submap_residue[i]]; 1531 vorbis_residue_decode(vc, residue, ch, do_not_decode, ch_res_ptr, blocksize/2); 1532 1533 ch_res_ptr += ch * blocksize / 2; 1534 } 1535 1536// Inverse coupling 1537 1538 for (i = mapping->coupling_steps - 1; i >= 0; --i) { //warning: i has to be signed 1539 float *mag, *ang; 1540 1541 mag = vc->channel_residues+res_chan[mapping->magnitude[i]] * blocksize / 2; 1542 ang = vc->channel_residues+res_chan[mapping->angle[i]] * blocksize / 2; 1543 vc->dsp.vorbis_inverse_coupling(mag, ang, blocksize / 2); 1544 } 1545 1546// Dotproduct, MDCT 1547 1548 for (j = vc->audio_channels-1;j >= 0; j--) { 1549 ch_floor_ptr = vc->channel_floors + j * blocksize / 2; 1550 ch_res_ptr = vc->channel_residues + res_chan[j] * blocksize / 2; 1551 vc->dsp.vector_fmul(ch_floor_ptr, ch_res_ptr, blocksize / 2); 1552 ff_imdct_half(&vc->mdct[blockflag], ch_res_ptr, ch_floor_ptr); 1553 } 1554 1555// Overlap/add, save data for next overlapping FPMATH 1556 1557 retlen = (blocksize + vc->blocksize[previous_window]) / 4; 1558 for (j = 0; j < vc->audio_channels; j++) { 1559 uint_fast16_t bs0 = vc->blocksize[0]; 1560 uint_fast16_t bs1 = vc->blocksize[1]; 1561 float *residue = vc->channel_residues + res_chan[j] * blocksize / 2; 1562 float *saved = vc->saved + j * bs1 / 4; 1563 float *ret = vc->channel_floors + j * retlen; 1564 float *buf = residue; 1565 const float *win = vc->win[blockflag & previous_window]; 1566 1567 if (blockflag == previous_window) { 1568 vc->dsp.vector_fmul_window(ret, saved, buf, win, fadd_bias, blocksize / 4); 1569 } else if (blockflag > previous_window) { 1570 vc->dsp.vector_fmul_window(ret, saved, buf, win, fadd_bias, bs0 / 4); 1571 copy_normalize(ret+bs0/2, buf+bs0/4, (bs1-bs0)/4, vc->exp_bias, fadd_bias); 1572 } else { 1573 copy_normalize(ret, saved, (bs1 - bs0) / 4, vc->exp_bias, fadd_bias); 1574 vc->dsp.vector_fmul_window(ret + (bs1 - bs0) / 4, saved + (bs1 - bs0) / 4, buf, win, fadd_bias, bs0 / 4); 1575 } 1576 memcpy(saved, buf + blocksize / 4, blocksize / 4 * sizeof(float)); 1577 } 1578 1579 vc->previous_window = blockflag; 1580 return retlen; 1581} 1582 1583// Return the decoded audio packet through the standard api 1584 1585static int vorbis_decode_frame(AVCodecContext *avccontext, 1586 void *data, int *data_size, 1587 AVPacket *avpkt) 1588{ 1589 const uint8_t *buf = avpkt->data; 1590 int buf_size = avpkt->size; 1591 vorbis_context *vc = avccontext->priv_data ; 1592 GetBitContext *gb = &(vc->gb); 1593 const float *channel_ptrs[vc->audio_channels]; 1594 int i; 1595 1596 int_fast16_t len; 1597 1598 if (!buf_size) 1599 return 0; 1600 1601 AV_DEBUG("packet length %d \n", buf_size); 1602 1603 init_get_bits(gb, buf, buf_size*8); 1604 1605 len = vorbis_parse_audio_packet(vc); 1606 1607 if (len <= 0) { 1608 *data_size = 0; 1609 return buf_size; 1610 } 1611 1612 if (!vc->first_frame) { 1613 vc->first_frame = 1; 1614 *data_size = 0; 1615 return buf_size ; 1616 } 1617 1618 AV_DEBUG("parsed %d bytes %d bits, returned %d samples (*ch*bits) \n", get_bits_count(gb)/8, get_bits_count(gb)%8, len); 1619 1620 if (vc->audio_channels > 8) { 1621 for (i = 0; i < vc->audio_channels; i++) 1622 channel_ptrs[i] = vc->channel_floors + i * len; 1623 } else { 1624 for (i = 0; i < vc->audio_channels; i++) 1625 channel_ptrs[i] = vc->channel_floors + 1626 len * ff_vorbis_channel_layout_offsets[vc->audio_channels - 1][i]; 1627 } 1628 1629 vc->dsp.float_to_int16_interleave(data, channel_ptrs, len, vc->audio_channels); 1630 *data_size = len * 2 * vc->audio_channels; 1631 1632 return buf_size ; 1633} 1634 1635// Close decoder 1636 1637static av_cold int vorbis_decode_close(AVCodecContext *avccontext) 1638{ 1639 vorbis_context *vc = avccontext->priv_data; 1640 1641 vorbis_free(vc); 1642 1643 return 0 ; 1644} 1645 1646AVCodec vorbis_decoder = { 1647 "vorbis", 1648 AVMEDIA_TYPE_AUDIO, 1649 CODEC_ID_VORBIS, 1650 sizeof(vorbis_context), 1651 vorbis_decode_init, 1652 NULL, 1653 vorbis_decode_close, 1654 vorbis_decode_frame, 1655 .long_name = NULL_IF_CONFIG_SMALL("Vorbis"), 1656 .channel_layouts = ff_vorbis_channel_layouts, 1657}; 1658 1659