00001
00023 #undef V_DEBUG
00024
00025
00026
00027 #include <math.h>
00028
00029 #define ALT_BITSTREAM_READER_LE
00030 #include "avcodec.h"
00031 #include "get_bits.h"
00032 #include "dsputil.h"
00033 #include "fft.h"
00034
00035 #include "vorbis.h"
00036 #include "xiph.h"
00037
00038 #define V_NB_BITS 8
00039 #define V_NB_BITS2 11
00040 #define V_MAX_VLCS (1 << 16)
00041 #define V_MAX_PARTITIONS (1 << 20)
00042
00043 #ifndef V_DEBUG
00044 #define AV_DEBUG(...)
00045 #endif
00046
00047 #undef NDEBUG
00048 #include <assert.h>
00049
00050 typedef struct {
00051 uint_fast8_t dimensions;
00052 uint_fast8_t lookup_type;
00053 uint_fast8_t maxdepth;
00054 VLC vlc;
00055 float *codevectors;
00056 unsigned int nb_bits;
00057 } vorbis_codebook;
00058
00059 typedef union vorbis_floor_u vorbis_floor_data;
00060 typedef struct vorbis_floor0_s vorbis_floor0;
00061 typedef struct vorbis_floor1_s vorbis_floor1;
00062 struct vorbis_context_s;
00063 typedef
00064 uint_fast8_t (* vorbis_floor_decode_func)
00065 (struct vorbis_context_s *, vorbis_floor_data *, float *);
00066 typedef struct {
00067 uint_fast8_t floor_type;
00068 vorbis_floor_decode_func decode;
00069 union vorbis_floor_u {
00070 struct vorbis_floor0_s {
00071 uint_fast8_t order;
00072 uint_fast16_t rate;
00073 uint_fast16_t bark_map_size;
00074 int_fast32_t *map[2];
00075 uint_fast32_t map_size[2];
00076 uint_fast8_t amplitude_bits;
00077 uint_fast8_t amplitude_offset;
00078 uint_fast8_t num_books;
00079 uint_fast8_t *book_list;
00080 float *lsp;
00081 } t0;
00082 struct vorbis_floor1_s {
00083 uint_fast8_t partitions;
00084 uint_fast8_t maximum_class;
00085 uint_fast8_t partition_class[32];
00086 uint_fast8_t class_dimensions[16];
00087 uint_fast8_t class_subclasses[16];
00088 uint_fast8_t class_masterbook[16];
00089 int_fast16_t subclass_books[16][8];
00090 uint_fast8_t multiplier;
00091 uint_fast16_t x_list_dim;
00092 vorbis_floor1_entry *list;
00093 } t1;
00094 } data;
00095 } vorbis_floor;
00096
00097 typedef struct {
00098 uint_fast16_t type;
00099 uint_fast32_t begin;
00100 uint_fast32_t end;
00101 uint_fast32_t partition_size;
00102 uint_fast8_t classifications;
00103 uint_fast8_t classbook;
00104 int_fast16_t books[64][8];
00105 uint_fast8_t maxpass;
00106 } vorbis_residue;
00107
00108 typedef struct {
00109 uint_fast8_t submaps;
00110 uint_fast16_t coupling_steps;
00111 uint_fast8_t *magnitude;
00112 uint_fast8_t *angle;
00113 uint_fast8_t *mux;
00114 uint_fast8_t submap_floor[16];
00115 uint_fast8_t submap_residue[16];
00116 } vorbis_mapping;
00117
00118 typedef struct {
00119 uint_fast8_t blockflag;
00120 uint_fast16_t windowtype;
00121 uint_fast16_t transformtype;
00122 uint_fast8_t mapping;
00123 } vorbis_mode;
00124
00125 typedef struct vorbis_context_s {
00126 AVCodecContext *avccontext;
00127 GetBitContext gb;
00128 DSPContext dsp;
00129
00130 FFTContext mdct[2];
00131 uint_fast8_t first_frame;
00132 uint_fast32_t version;
00133 uint_fast8_t audio_channels;
00134 uint_fast32_t audio_samplerate;
00135 uint_fast32_t bitrate_maximum;
00136 uint_fast32_t bitrate_nominal;
00137 uint_fast32_t bitrate_minimum;
00138 uint_fast32_t blocksize[2];
00139 const float *win[2];
00140 uint_fast16_t codebook_count;
00141 vorbis_codebook *codebooks;
00142 uint_fast8_t floor_count;
00143 vorbis_floor *floors;
00144 uint_fast8_t residue_count;
00145 vorbis_residue *residues;
00146 uint_fast8_t mapping_count;
00147 vorbis_mapping *mappings;
00148 uint_fast8_t mode_count;
00149 vorbis_mode *modes;
00150 uint_fast8_t mode_number;
00151 uint_fast8_t previous_window;
00152 float *channel_residues;
00153 float *channel_floors;
00154 float *saved;
00155 uint_fast32_t add_bias;
00156 uint_fast32_t exp_bias;
00157 } vorbis_context;
00158
00159
00160
00161 #define BARK(x) \
00162 (13.1f * atan(0.00074f * (x)) + 2.24f * atan(1.85e-8f * (x) * (x)) + 1e-4f * (x))
00163
00164 static const char idx_err_str[] = "Index value %d out of range (0 - %d) for %s at %s:%i\n";
00165 #define VALIDATE_INDEX(idx, limit) \
00166 if (idx >= limit) {\
00167 av_log(vc->avccontext, AV_LOG_ERROR,\
00168 idx_err_str,\
00169 (int)(idx), (int)(limit - 1), #idx, __FILE__, __LINE__);\
00170 return -1;\
00171 }
00172 #define GET_VALIDATED_INDEX(idx, bits, limit) \
00173 {\
00174 idx = get_bits(gb, bits);\
00175 VALIDATE_INDEX(idx, limit)\
00176 }
00177
00178 static float vorbisfloat2float(uint_fast32_t val)
00179 {
00180 double mant = val & 0x1fffff;
00181 long exp = (val & 0x7fe00000L) >> 21;
00182 if (val & 0x80000000)
00183 mant = -mant;
00184 return ldexp(mant, exp - 20 - 768);
00185 }
00186
00187
00188
00189
00190 static void vorbis_free(vorbis_context *vc)
00191 {
00192 int_fast16_t i;
00193
00194 av_freep(&vc->channel_residues);
00195 av_freep(&vc->channel_floors);
00196 av_freep(&vc->saved);
00197
00198 av_freep(&vc->residues);
00199 av_freep(&vc->modes);
00200
00201 ff_mdct_end(&vc->mdct[0]);
00202 ff_mdct_end(&vc->mdct[1]);
00203
00204 for (i = 0; i < vc->codebook_count; ++i) {
00205 av_free(vc->codebooks[i].codevectors);
00206 free_vlc(&vc->codebooks[i].vlc);
00207 }
00208 av_freep(&vc->codebooks);
00209
00210 for (i = 0; i < vc->floor_count; ++i) {
00211 if (vc->floors[i].floor_type == 0) {
00212 av_free(vc->floors[i].data.t0.map[0]);
00213 av_free(vc->floors[i].data.t0.map[1]);
00214 av_free(vc->floors[i].data.t0.book_list);
00215 av_free(vc->floors[i].data.t0.lsp);
00216 } else {
00217 av_free(vc->floors[i].data.t1.list);
00218 }
00219 }
00220 av_freep(&vc->floors);
00221
00222 for (i = 0; i < vc->mapping_count; ++i) {
00223 av_free(vc->mappings[i].magnitude);
00224 av_free(vc->mappings[i].angle);
00225 av_free(vc->mappings[i].mux);
00226 }
00227 av_freep(&vc->mappings);
00228 }
00229
00230
00231
00232
00233
00234 static int vorbis_parse_setup_hdr_codebooks(vorbis_context *vc)
00235 {
00236 uint_fast16_t cb;
00237 uint8_t *tmp_vlc_bits;
00238 uint32_t *tmp_vlc_codes;
00239 GetBitContext *gb = &vc->gb;
00240
00241 vc->codebook_count = get_bits(gb, 8) + 1;
00242
00243 AV_DEBUG(" Codebooks: %d \n", vc->codebook_count);
00244
00245 vc->codebooks = av_mallocz(vc->codebook_count * sizeof(vorbis_codebook));
00246 tmp_vlc_bits = av_mallocz(V_MAX_VLCS * sizeof(uint8_t));
00247 tmp_vlc_codes = av_mallocz(V_MAX_VLCS * sizeof(uint32_t));
00248
00249 for (cb = 0; cb < vc->codebook_count; ++cb) {
00250 vorbis_codebook *codebook_setup = &vc->codebooks[cb];
00251 uint_fast8_t ordered;
00252 uint_fast32_t t, used_entries = 0;
00253 uint_fast32_t entries;
00254
00255 AV_DEBUG(" %d. Codebook \n", cb);
00256
00257 if (get_bits(gb, 24) != 0x564342) {
00258 av_log(vc->avccontext, AV_LOG_ERROR, " %"PRIdFAST16". Codebook setup data corrupt. \n", cb);
00259 goto error;
00260 }
00261
00262 codebook_setup->dimensions=get_bits(gb, 16);
00263 if (codebook_setup->dimensions > 16 || codebook_setup->dimensions == 0) {
00264 av_log(vc->avccontext, AV_LOG_ERROR, " %"PRIdFAST16". Codebook's dimension is invalid (%d). \n", cb, codebook_setup->dimensions);
00265 goto error;
00266 }
00267 entries = get_bits(gb, 24);
00268 if (entries > V_MAX_VLCS) {
00269 av_log(vc->avccontext, AV_LOG_ERROR, " %"PRIdFAST16". Codebook has too many entries (%"PRIdFAST32"). \n", cb, entries);
00270 goto error;
00271 }
00272
00273 ordered = get_bits1(gb);
00274
00275 AV_DEBUG(" codebook_dimensions %d, codebook_entries %d \n", codebook_setup->dimensions, entries);
00276
00277 if (!ordered) {
00278 uint_fast16_t ce;
00279 uint_fast8_t flag;
00280 uint_fast8_t sparse = get_bits1(gb);
00281
00282 AV_DEBUG(" not ordered \n");
00283
00284 if (sparse) {
00285 AV_DEBUG(" sparse \n");
00286
00287 used_entries = 0;
00288 for (ce = 0; ce < entries; ++ce) {
00289 flag = get_bits1(gb);
00290 if (flag) {
00291 tmp_vlc_bits[ce] = get_bits(gb, 5) + 1;
00292 ++used_entries;
00293 } else
00294 tmp_vlc_bits[ce] = 0;
00295 }
00296 } else {
00297 AV_DEBUG(" not sparse \n");
00298
00299 used_entries = entries;
00300 for (ce = 0; ce < entries; ++ce)
00301 tmp_vlc_bits[ce] = get_bits(gb, 5) + 1;
00302 }
00303 } else {
00304 uint_fast16_t current_entry = 0;
00305 uint_fast8_t current_length = get_bits(gb, 5)+1;
00306
00307 AV_DEBUG(" ordered, current length: %d \n", current_length);
00308
00309 used_entries = entries;
00310 for (; current_entry < used_entries && current_length <= 32; ++current_length) {
00311 uint_fast16_t i, number;
00312
00313 AV_DEBUG(" number bits: %d ", ilog(entries - current_entry));
00314
00315 number = get_bits(gb, ilog(entries - current_entry));
00316
00317 AV_DEBUG(" number: %d \n", number);
00318
00319 for (i = current_entry; i < number+current_entry; ++i)
00320 if (i < used_entries)
00321 tmp_vlc_bits[i] = current_length;
00322
00323 current_entry+=number;
00324 }
00325 if (current_entry>used_entries) {
00326 av_log(vc->avccontext, AV_LOG_ERROR, " More codelengths than codes in codebook. \n");
00327 goto error;
00328 }
00329 }
00330
00331 codebook_setup->lookup_type = get_bits(gb, 4);
00332
00333 AV_DEBUG(" lookup type: %d : %s \n", codebook_setup->lookup_type, codebook_setup->lookup_type ? "vq" : "no lookup");
00334
00335
00336
00337 if (codebook_setup->lookup_type == 1) {
00338 uint_fast16_t i, j, k;
00339 uint_fast16_t codebook_lookup_values = ff_vorbis_nth_root(entries, codebook_setup->dimensions);
00340 uint_fast16_t codebook_multiplicands[codebook_lookup_values];
00341
00342 float codebook_minimum_value = vorbisfloat2float(get_bits_long(gb, 32));
00343 float codebook_delta_value = vorbisfloat2float(get_bits_long(gb, 32));
00344 uint_fast8_t codebook_value_bits = get_bits(gb, 4)+1;
00345 uint_fast8_t codebook_sequence_p = get_bits1(gb);
00346
00347 AV_DEBUG(" We expect %d numbers for building the codevectors. \n", codebook_lookup_values);
00348 AV_DEBUG(" delta %f minmum %f \n", codebook_delta_value, codebook_minimum_value);
00349
00350 for (i = 0; i < codebook_lookup_values; ++i) {
00351 codebook_multiplicands[i] = get_bits(gb, codebook_value_bits);
00352
00353 AV_DEBUG(" multiplicands*delta+minmum : %e \n", (float)codebook_multiplicands[i]*codebook_delta_value+codebook_minimum_value);
00354 AV_DEBUG(" multiplicand %d \n", codebook_multiplicands[i]);
00355 }
00356
00357
00358 codebook_setup->codevectors = used_entries ? av_mallocz(used_entries*codebook_setup->dimensions * sizeof(float)) : NULL;
00359 for (j = 0, i = 0; i < entries; ++i) {
00360 uint_fast8_t dim = codebook_setup->dimensions;
00361
00362 if (tmp_vlc_bits[i]) {
00363 float last = 0.0;
00364 uint_fast32_t lookup_offset = i;
00365
00366 #ifdef V_DEBUG
00367 av_log(vc->avccontext, AV_LOG_INFO, "Lookup offset %d ,", i);
00368 #endif
00369
00370 for (k = 0; k < dim; ++k) {
00371 uint_fast32_t multiplicand_offset = lookup_offset % codebook_lookup_values;
00372 codebook_setup->codevectors[j * dim + k] = codebook_multiplicands[multiplicand_offset] * codebook_delta_value + codebook_minimum_value + last;
00373 if (codebook_sequence_p)
00374 last = codebook_setup->codevectors[j * dim + k];
00375 lookup_offset/=codebook_lookup_values;
00376 }
00377 tmp_vlc_bits[j] = tmp_vlc_bits[i];
00378
00379 #ifdef V_DEBUG
00380 av_log(vc->avccontext, AV_LOG_INFO, "real lookup offset %d, vector: ", j);
00381 for (k = 0; k < dim; ++k)
00382 av_log(vc->avccontext, AV_LOG_INFO, " %f ", codebook_setup->codevectors[j * dim + k]);
00383 av_log(vc->avccontext, AV_LOG_INFO, "\n");
00384 #endif
00385
00386 ++j;
00387 }
00388 }
00389 if (j != used_entries) {
00390 av_log(vc->avccontext, AV_LOG_ERROR, "Bug in codevector vector building code. \n");
00391 goto error;
00392 }
00393 entries = used_entries;
00394 } else if (codebook_setup->lookup_type >= 2) {
00395 av_log(vc->avccontext, AV_LOG_ERROR, "Codebook lookup type not supported. \n");
00396 goto error;
00397 }
00398
00399
00400 if (ff_vorbis_len2vlc(tmp_vlc_bits, tmp_vlc_codes, entries)) {
00401 av_log(vc->avccontext, AV_LOG_ERROR, " Invalid code lengths while generating vlcs. \n");
00402 goto error;
00403 }
00404 codebook_setup->maxdepth = 0;
00405 for (t = 0; t < entries; ++t)
00406 if (tmp_vlc_bits[t] >= codebook_setup->maxdepth)
00407 codebook_setup->maxdepth = tmp_vlc_bits[t];
00408
00409 if (codebook_setup->maxdepth > 3 * V_NB_BITS)
00410 codebook_setup->nb_bits = V_NB_BITS2;
00411 else
00412 codebook_setup->nb_bits = V_NB_BITS;
00413
00414 codebook_setup->maxdepth = (codebook_setup->maxdepth+codebook_setup->nb_bits - 1) / codebook_setup->nb_bits;
00415
00416 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)) {
00417 av_log(vc->avccontext, AV_LOG_ERROR, " Error generating vlc tables. \n");
00418 goto error;
00419 }
00420 }
00421
00422 av_free(tmp_vlc_bits);
00423 av_free(tmp_vlc_codes);
00424 return 0;
00425
00426
00427 error:
00428 av_free(tmp_vlc_bits);
00429 av_free(tmp_vlc_codes);
00430 return -1;
00431 }
00432
00433
00434
00435 static int vorbis_parse_setup_hdr_tdtransforms(vorbis_context *vc)
00436 {
00437 GetBitContext *gb = &vc->gb;
00438 uint_fast8_t i;
00439 uint_fast8_t vorbis_time_count = get_bits(gb, 6) + 1;
00440
00441 for (i = 0; i < vorbis_time_count; ++i) {
00442 uint_fast16_t vorbis_tdtransform = get_bits(gb, 16);
00443
00444 AV_DEBUG(" Vorbis time domain transform %d: %d \n", vorbis_time_count, vorbis_tdtransform);
00445
00446 if (vorbis_tdtransform) {
00447 av_log(vc->avccontext, AV_LOG_ERROR, "Vorbis time domain transform data nonzero. \n");
00448 return -1;
00449 }
00450 }
00451 return 0;
00452 }
00453
00454
00455
00456 static uint_fast8_t vorbis_floor0_decode(vorbis_context *vc,
00457 vorbis_floor_data *vfu, float *vec);
00458 static void create_map(vorbis_context *vc, uint_fast8_t floor_number);
00459 static uint_fast8_t vorbis_floor1_decode(vorbis_context *vc,
00460 vorbis_floor_data *vfu, float *vec);
00461 static int vorbis_parse_setup_hdr_floors(vorbis_context *vc)
00462 {
00463 GetBitContext *gb = &vc->gb;
00464 uint_fast16_t i,j,k;
00465
00466 vc->floor_count = get_bits(gb, 6) + 1;
00467
00468 vc->floors = av_mallocz(vc->floor_count * sizeof(vorbis_floor));
00469
00470 for (i = 0; i < vc->floor_count; ++i) {
00471 vorbis_floor *floor_setup = &vc->floors[i];
00472
00473 floor_setup->floor_type = get_bits(gb, 16);
00474
00475 AV_DEBUG(" %d. floor type %d \n", i, floor_setup->floor_type);
00476
00477 if (floor_setup->floor_type == 1) {
00478 uint_fast8_t maximum_class = 0;
00479 uint_fast8_t rangebits;
00480 uint_fast16_t floor1_values = 2;
00481
00482 floor_setup->decode = vorbis_floor1_decode;
00483
00484 floor_setup->data.t1.partitions = get_bits(gb, 5);
00485
00486 AV_DEBUG(" %d.floor: %d partitions \n", i, floor_setup->data.t1.partitions);
00487
00488 for (j = 0; j < floor_setup->data.t1.partitions; ++j) {
00489 floor_setup->data.t1.partition_class[j] = get_bits(gb, 4);
00490 if (floor_setup->data.t1.partition_class[j] > maximum_class)
00491 maximum_class = floor_setup->data.t1.partition_class[j];
00492
00493 AV_DEBUG(" %d. floor %d partition class %d \n", i, j, floor_setup->data.t1.partition_class[j]);
00494
00495 }
00496
00497 AV_DEBUG(" maximum class %d \n", maximum_class);
00498
00499 floor_setup->data.t1.maximum_class = maximum_class;
00500
00501 for (j = 0; j <= maximum_class; ++j) {
00502 floor_setup->data.t1.class_dimensions[j] = get_bits(gb, 3) + 1;
00503 floor_setup->data.t1.class_subclasses[j] = get_bits(gb, 2);
00504
00505 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]);
00506
00507 if (floor_setup->data.t1.class_subclasses[j]) {
00508 GET_VALIDATED_INDEX(floor_setup->data.t1.class_masterbook[j], 8, vc->codebook_count)
00509
00510 AV_DEBUG(" masterbook: %d \n", floor_setup->data.t1.class_masterbook[j]);
00511 }
00512
00513 for (k = 0; k < (1 << floor_setup->data.t1.class_subclasses[j]); ++k) {
00514 int16_t bits = get_bits(gb, 8) - 1;
00515 if (bits != -1)
00516 VALIDATE_INDEX(bits, vc->codebook_count)
00517 floor_setup->data.t1.subclass_books[j][k] = bits;
00518
00519 AV_DEBUG(" book %d. : %d \n", k, floor_setup->data.t1.subclass_books[j][k]);
00520 }
00521 }
00522
00523 floor_setup->data.t1.multiplier = get_bits(gb, 2) + 1;
00524 floor_setup->data.t1.x_list_dim = 2;
00525
00526 for (j = 0; j < floor_setup->data.t1.partitions; ++j)
00527 floor_setup->data.t1.x_list_dim+=floor_setup->data.t1.class_dimensions[floor_setup->data.t1.partition_class[j]];
00528
00529 floor_setup->data.t1.list = av_mallocz(floor_setup->data.t1.x_list_dim * sizeof(vorbis_floor1_entry));
00530
00531
00532 rangebits = get_bits(gb, 4);
00533 floor_setup->data.t1.list[0].x = 0;
00534 floor_setup->data.t1.list[1].x = (1 << rangebits);
00535
00536 for (j = 0; j < floor_setup->data.t1.partitions; ++j) {
00537 for (k = 0; k < floor_setup->data.t1.class_dimensions[floor_setup->data.t1.partition_class[j]]; ++k, ++floor1_values) {
00538 floor_setup->data.t1.list[floor1_values].x = get_bits(gb, rangebits);
00539
00540 AV_DEBUG(" %d. floor1 Y coord. %d \n", floor1_values, floor_setup->data.t1.list[floor1_values].x);
00541 }
00542 }
00543
00544
00545 ff_vorbis_ready_floor1_list(floor_setup->data.t1.list, floor_setup->data.t1.x_list_dim);
00546 } else if (floor_setup->floor_type == 0) {
00547 uint_fast8_t max_codebook_dim = 0;
00548
00549 floor_setup->decode = vorbis_floor0_decode;
00550
00551 floor_setup->data.t0.order = get_bits(gb, 8);
00552 floor_setup->data.t0.rate = get_bits(gb, 16);
00553 floor_setup->data.t0.bark_map_size = get_bits(gb, 16);
00554 floor_setup->data.t0.amplitude_bits = get_bits(gb, 6);
00555
00556
00557 if (floor_setup->data.t0.amplitude_bits == 0) {
00558 av_log(vc->avccontext, AV_LOG_ERROR,
00559 "Floor 0 amplitude bits is 0.\n");
00560 return -1;
00561 }
00562 floor_setup->data.t0.amplitude_offset = get_bits(gb, 8);
00563 floor_setup->data.t0.num_books = get_bits(gb, 4) + 1;
00564
00565
00566 floor_setup->data.t0.book_list =
00567 av_malloc(floor_setup->data.t0.num_books);
00568 if (!floor_setup->data.t0.book_list)
00569 return -1;
00570
00571 {
00572 int idx;
00573 uint_fast8_t book_idx;
00574 for (idx = 0; idx < floor_setup->data.t0.num_books; ++idx) {
00575 GET_VALIDATED_INDEX(floor_setup->data.t0.book_list[idx], 8, vc->codebook_count)
00576 if (vc->codebooks[book_idx].dimensions > max_codebook_dim)
00577 max_codebook_dim = vc->codebooks[book_idx].dimensions;
00578 }
00579 }
00580
00581 create_map(vc, i);
00582
00583
00584 {
00585
00586
00587 floor_setup->data.t0.lsp =
00588 av_malloc((floor_setup->data.t0.order+1 + max_codebook_dim)
00589 * sizeof(float));
00590 if (!floor_setup->data.t0.lsp)
00591 return -1;
00592 }
00593
00594 #ifdef V_DEBUG
00595 AV_DEBUG("floor0 order: %u\n", floor_setup->data.t0.order);
00596 AV_DEBUG("floor0 rate: %u\n", floor_setup->data.t0.rate);
00597 AV_DEBUG("floor0 bark map size: %u\n",
00598 floor_setup->data.t0.bark_map_size);
00599 AV_DEBUG("floor0 amplitude bits: %u\n",
00600 floor_setup->data.t0.amplitude_bits);
00601 AV_DEBUG("floor0 amplitude offset: %u\n",
00602 floor_setup->data.t0.amplitude_offset);
00603 AV_DEBUG("floor0 number of books: %u\n",
00604 floor_setup->data.t0.num_books);
00605 AV_DEBUG("floor0 book list pointer: %p\n",
00606 floor_setup->data.t0.book_list);
00607 {
00608 int idx;
00609 for (idx = 0; idx < floor_setup->data.t0.num_books; ++idx) {
00610 AV_DEBUG(" Book %d: %u\n",
00611 idx+1,
00612 floor_setup->data.t0.book_list[idx]);
00613 }
00614 }
00615 #endif
00616 } else {
00617 av_log(vc->avccontext, AV_LOG_ERROR, "Invalid floor type!\n");
00618 return -1;
00619 }
00620 }
00621 return 0;
00622 }
00623
00624
00625
00626 static int vorbis_parse_setup_hdr_residues(vorbis_context *vc)
00627 {
00628 GetBitContext *gb = &vc->gb;
00629 uint_fast8_t i, j, k;
00630
00631 vc->residue_count = get_bits(gb, 6)+1;
00632 vc->residues = av_mallocz(vc->residue_count * sizeof(vorbis_residue));
00633
00634 AV_DEBUG(" There are %d residues. \n", vc->residue_count);
00635
00636 for (i = 0; i < vc->residue_count; ++i) {
00637 vorbis_residue *res_setup = &vc->residues[i];
00638 uint_fast8_t cascade[64];
00639 uint_fast8_t high_bits;
00640 uint_fast8_t low_bits;
00641
00642 res_setup->type = get_bits(gb, 16);
00643
00644 AV_DEBUG(" %d. residue type %d \n", i, res_setup->type);
00645
00646 res_setup->begin = get_bits(gb, 24);
00647 res_setup->end = get_bits(gb, 24);
00648 res_setup->partition_size = get_bits(gb, 24) + 1;
00649
00650 if (res_setup->begin>res_setup->end ||
00651 res_setup->end>vc->blocksize[1] / (res_setup->type == 2 ? 1 : 2) ||
00652 (res_setup->end-res_setup->begin) / res_setup->partition_size > V_MAX_PARTITIONS) {
00653 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);
00654 return -1;
00655 }
00656
00657 res_setup->classifications = get_bits(gb, 6) + 1;
00658 GET_VALIDATED_INDEX(res_setup->classbook, 8, vc->codebook_count)
00659
00660 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,
00661 res_setup->classifications, res_setup->classbook);
00662
00663 for (j = 0; j < res_setup->classifications; ++j) {
00664 high_bits = 0;
00665 low_bits = get_bits(gb, 3);
00666 if (get_bits1(gb))
00667 high_bits = get_bits(gb, 5);
00668 cascade[j] = (high_bits << 3) + low_bits;
00669
00670 AV_DEBUG(" %d class casscade depth: %d \n", j, ilog(cascade[j]));
00671 }
00672
00673 res_setup->maxpass = 0;
00674 for (j = 0; j < res_setup->classifications; ++j) {
00675 for (k = 0; k < 8; ++k) {
00676 if (cascade[j]&(1 << k)) {
00677 GET_VALIDATED_INDEX(res_setup->books[j][k], 8, vc->codebook_count)
00678
00679 AV_DEBUG(" %d class casscade depth %d book: %d \n", j, k, res_setup->books[j][k]);
00680
00681 if (k>res_setup->maxpass)
00682 res_setup->maxpass = k;
00683 } else {
00684 res_setup->books[j][k] = -1;
00685 }
00686 }
00687 }
00688 }
00689 return 0;
00690 }
00691
00692
00693
00694 static int vorbis_parse_setup_hdr_mappings(vorbis_context *vc)
00695 {
00696 GetBitContext *gb = &vc->gb;
00697 uint_fast8_t i, j;
00698
00699 vc->mapping_count = get_bits(gb, 6)+1;
00700 vc->mappings = av_mallocz(vc->mapping_count * sizeof(vorbis_mapping));
00701
00702 AV_DEBUG(" There are %d mappings. \n", vc->mapping_count);
00703
00704 for (i = 0; i < vc->mapping_count; ++i) {
00705 vorbis_mapping *mapping_setup = &vc->mappings[i];
00706
00707 if (get_bits(gb, 16)) {
00708 av_log(vc->avccontext, AV_LOG_ERROR, "Other mappings than type 0 are not compliant with the Vorbis I specification. \n");
00709 return -1;
00710 }
00711 if (get_bits1(gb)) {
00712 mapping_setup->submaps = get_bits(gb, 4) + 1;
00713 } else {
00714 mapping_setup->submaps = 1;
00715 }
00716
00717 if (get_bits1(gb)) {
00718 mapping_setup->coupling_steps = get_bits(gb, 8) + 1;
00719 mapping_setup->magnitude = av_mallocz(mapping_setup->coupling_steps * sizeof(uint_fast8_t));
00720 mapping_setup->angle = av_mallocz(mapping_setup->coupling_steps * sizeof(uint_fast8_t));
00721 for (j = 0; j < mapping_setup->coupling_steps; ++j) {
00722 GET_VALIDATED_INDEX(mapping_setup->magnitude[j], ilog(vc->audio_channels - 1), vc->audio_channels)
00723 GET_VALIDATED_INDEX(mapping_setup->angle[j], ilog(vc->audio_channels - 1), vc->audio_channels)
00724 }
00725 } else {
00726 mapping_setup->coupling_steps = 0;
00727 }
00728
00729 AV_DEBUG(" %d mapping coupling steps: %d \n", i, mapping_setup->coupling_steps);
00730
00731 if (get_bits(gb, 2)) {
00732 av_log(vc->avccontext, AV_LOG_ERROR, "%d. mapping setup data invalid. \n", i);
00733 return -1;
00734 }
00735
00736 if (mapping_setup->submaps>1) {
00737 mapping_setup->mux = av_mallocz(vc->audio_channels * sizeof(uint_fast8_t));
00738 for (j = 0; j < vc->audio_channels; ++j)
00739 mapping_setup->mux[j] = get_bits(gb, 4);
00740 }
00741
00742 for (j = 0; j < mapping_setup->submaps; ++j) {
00743 skip_bits(gb, 8);
00744 GET_VALIDATED_INDEX(mapping_setup->submap_floor[j], 8, vc->floor_count)
00745 GET_VALIDATED_INDEX(mapping_setup->submap_residue[j], 8, vc->residue_count)
00746
00747 AV_DEBUG(" %d mapping %d submap : floor %d, residue %d \n", i, j, mapping_setup->submap_floor[j], mapping_setup->submap_residue[j]);
00748 }
00749 }
00750 return 0;
00751 }
00752
00753
00754
00755 static void create_map(vorbis_context *vc, uint_fast8_t floor_number)
00756 {
00757 vorbis_floor *floors = vc->floors;
00758 vorbis_floor0 *vf;
00759 int idx;
00760 int_fast8_t blockflag;
00761 int_fast32_t *map;
00762 int_fast32_t n;
00763
00764 for (blockflag = 0; blockflag < 2; ++blockflag) {
00765 n = vc->blocksize[blockflag] / 2;
00766 floors[floor_number].data.t0.map[blockflag] =
00767 av_malloc((n+1) * sizeof(int_fast32_t));
00768
00769 map = floors[floor_number].data.t0.map[blockflag];
00770 vf = &floors[floor_number].data.t0;
00771
00772 for (idx = 0; idx < n; ++idx) {
00773 map[idx] = floor(BARK((vf->rate * idx) / (2.0f * n)) *
00774 ((vf->bark_map_size) /
00775 BARK(vf->rate / 2.0f)));
00776 if (vf->bark_map_size-1 < map[idx])
00777 map[idx] = vf->bark_map_size - 1;
00778 }
00779 map[n] = -1;
00780 vf->map_size[blockflag] = n;
00781 }
00782
00783 # ifdef V_DEBUG
00784 for (idx = 0; idx <= n; ++idx) {
00785 AV_DEBUG("floor0 map: map at pos %d is %d\n",
00786 idx, map[idx]);
00787 }
00788 # endif
00789 }
00790
00791 static int vorbis_parse_setup_hdr_modes(vorbis_context *vc)
00792 {
00793 GetBitContext *gb = &vc->gb;
00794 uint_fast8_t i;
00795
00796 vc->mode_count = get_bits(gb, 6) + 1;
00797 vc->modes = av_mallocz(vc->mode_count * sizeof(vorbis_mode));
00798
00799 AV_DEBUG(" There are %d modes.\n", vc->mode_count);
00800
00801 for (i = 0; i < vc->mode_count; ++i) {
00802 vorbis_mode *mode_setup = &vc->modes[i];
00803
00804 mode_setup->blockflag = get_bits1(gb);
00805 mode_setup->windowtype = get_bits(gb, 16);
00806 mode_setup->transformtype = get_bits(gb, 16);
00807 GET_VALIDATED_INDEX(mode_setup->mapping, 8, vc->mapping_count);
00808
00809 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);
00810 }
00811 return 0;
00812 }
00813
00814
00815
00816 static int vorbis_parse_setup_hdr(vorbis_context *vc)
00817 {
00818 GetBitContext *gb = &vc->gb;
00819
00820 if ((get_bits(gb, 8) != 'v') || (get_bits(gb, 8) != 'o') ||
00821 (get_bits(gb, 8) != 'r') || (get_bits(gb, 8) != 'b') ||
00822 (get_bits(gb, 8) != 'i') || (get_bits(gb, 8) != 's')) {
00823 av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (no vorbis signature). \n");
00824 return -1;
00825 }
00826
00827 if (vorbis_parse_setup_hdr_codebooks(vc)) {
00828 av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (codebooks). \n");
00829 return -2;
00830 }
00831 if (vorbis_parse_setup_hdr_tdtransforms(vc)) {
00832 av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (time domain transforms). \n");
00833 return -3;
00834 }
00835 if (vorbis_parse_setup_hdr_floors(vc)) {
00836 av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (floors). \n");
00837 return -4;
00838 }
00839 if (vorbis_parse_setup_hdr_residues(vc)) {
00840 av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (residues). \n");
00841 return -5;
00842 }
00843 if (vorbis_parse_setup_hdr_mappings(vc)) {
00844 av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (mappings). \n");
00845 return -6;
00846 }
00847 if (vorbis_parse_setup_hdr_modes(vc)) {
00848 av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (modes). \n");
00849 return -7;
00850 }
00851 if (!get_bits1(gb)) {
00852 av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (framing flag). \n");
00853 return -8;
00854 }
00855
00856 return 0;
00857 }
00858
00859
00860
00861 static int vorbis_parse_id_hdr(vorbis_context *vc)
00862 {
00863 GetBitContext *gb = &vc->gb;
00864 uint_fast8_t bl0, bl1;
00865
00866 if ((get_bits(gb, 8) != 'v') || (get_bits(gb, 8) != 'o') ||
00867 (get_bits(gb, 8) != 'r') || (get_bits(gb, 8) != 'b') ||
00868 (get_bits(gb, 8) != 'i') || (get_bits(gb, 8) != 's')) {
00869 av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis id header packet corrupt (no vorbis signature). \n");
00870 return -1;
00871 }
00872
00873 vc->version = get_bits_long(gb, 32);
00874 vc->audio_channels = get_bits(gb, 8);
00875 if (vc->audio_channels <= 0) {
00876 av_log(vc->avccontext, AV_LOG_ERROR, "Invalid number of channels\n");
00877 return -1;
00878 }
00879 vc->audio_samplerate = get_bits_long(gb, 32);
00880 if (vc->audio_samplerate <= 0) {
00881 av_log(vc->avccontext, AV_LOG_ERROR, "Invalid samplerate\n");
00882 return -1;
00883 }
00884 vc->bitrate_maximum = get_bits_long(gb, 32);
00885 vc->bitrate_nominal = get_bits_long(gb, 32);
00886 vc->bitrate_minimum = get_bits_long(gb, 32);
00887 bl0 = get_bits(gb, 4);
00888 bl1 = get_bits(gb, 4);
00889 vc->blocksize[0] = (1 << bl0);
00890 vc->blocksize[1] = (1 << bl1);
00891 if (bl0 > 13 || bl0 < 6 || bl1 > 13 || bl1 < 6 || bl1 < bl0) {
00892 av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis id header packet corrupt (illegal blocksize). \n");
00893 return -3;
00894 }
00895
00896 if (vc->blocksize[1] / 2 * vc->audio_channels * 2 > AVCODEC_MAX_AUDIO_FRAME_SIZE) {
00897 av_log(vc->avccontext, AV_LOG_ERROR, "Vorbis channel count makes "
00898 "output packets too large.\n");
00899 return -4;
00900 }
00901 vc->win[0] = ff_vorbis_vwin[bl0 - 6];
00902 vc->win[1] = ff_vorbis_vwin[bl1 - 6];
00903
00904 if ((get_bits1(gb)) == 0) {
00905 av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis id header packet corrupt (framing flag not set). \n");
00906 return -2;
00907 }
00908
00909 vc->channel_residues = av_malloc((vc->blocksize[1] / 2) * vc->audio_channels * sizeof(float));
00910 vc->channel_floors = av_malloc((vc->blocksize[1] / 2) * vc->audio_channels * sizeof(float));
00911 vc->saved = av_mallocz((vc->blocksize[1] / 4) * vc->audio_channels * sizeof(float));
00912 vc->previous_window = 0;
00913
00914 ff_mdct_init(&vc->mdct[0], bl0, 1, vc->exp_bias ? -(1 << 15) : -1.0);
00915 ff_mdct_init(&vc->mdct[1], bl1, 1, vc->exp_bias ? -(1 << 15) : -1.0);
00916
00917 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 ",
00918 vc->version, vc->audio_channels, vc->audio_samplerate, vc->bitrate_maximum, vc->bitrate_nominal, vc->bitrate_minimum, vc->blocksize[0], vc->blocksize[1]);
00919
00920
00921
00922
00923
00924
00925
00926
00927 return 0;
00928 }
00929
00930
00931
00932 static av_cold int vorbis_decode_init(AVCodecContext *avccontext)
00933 {
00934 vorbis_context *vc = avccontext->priv_data ;
00935 uint8_t *headers = avccontext->extradata;
00936 int headers_len = avccontext->extradata_size;
00937 uint8_t *header_start[3];
00938 int header_len[3];
00939 GetBitContext *gb = &(vc->gb);
00940 int hdr_type;
00941
00942 vc->avccontext = avccontext;
00943 dsputil_init(&vc->dsp, avccontext);
00944
00945 if (vc->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
00946 vc->add_bias = 385;
00947 vc->exp_bias = 0;
00948 } else {
00949 vc->add_bias = 0;
00950 vc->exp_bias = 15 << 23;
00951 }
00952
00953 if (!headers_len) {
00954 av_log(avccontext, AV_LOG_ERROR, "Extradata missing.\n");
00955 return -1;
00956 }
00957
00958 if (ff_split_xiph_headers(headers, headers_len, 30, header_start, header_len) < 0) {
00959 av_log(avccontext, AV_LOG_ERROR, "Extradata corrupt.\n");
00960 return -1;
00961 }
00962
00963 init_get_bits(gb, header_start[0], header_len[0]*8);
00964 hdr_type = get_bits(gb, 8);
00965 if (hdr_type != 1) {
00966 av_log(avccontext, AV_LOG_ERROR, "First header is not the id header.\n");
00967 return -1;
00968 }
00969 if (vorbis_parse_id_hdr(vc)) {
00970 av_log(avccontext, AV_LOG_ERROR, "Id header corrupt.\n");
00971 vorbis_free(vc);
00972 return -1;
00973 }
00974
00975 init_get_bits(gb, header_start[2], header_len[2]*8);
00976 hdr_type = get_bits(gb, 8);
00977 if (hdr_type != 5) {
00978 av_log(avccontext, AV_LOG_ERROR, "Third header is not the setup header.\n");
00979 vorbis_free(vc);
00980 return -1;
00981 }
00982 if (vorbis_parse_setup_hdr(vc)) {
00983 av_log(avccontext, AV_LOG_ERROR, "Setup header corrupt.\n");
00984 vorbis_free(vc);
00985 return -1;
00986 }
00987
00988 if (vc->audio_channels > 8)
00989 avccontext->channel_layout = 0;
00990 else
00991 avccontext->channel_layout = ff_vorbis_channel_layouts[vc->audio_channels - 1];
00992
00993 avccontext->channels = vc->audio_channels;
00994 avccontext->sample_rate = vc->audio_samplerate;
00995 avccontext->frame_size = FFMIN(vc->blocksize[0], vc->blocksize[1]) >> 2;
00996 avccontext->sample_fmt = SAMPLE_FMT_S16;
00997
00998 return 0 ;
00999 }
01000
01001
01002
01003
01004
01005 static uint_fast8_t vorbis_floor0_decode(vorbis_context *vc,
01006 vorbis_floor_data *vfu, float *vec)
01007 {
01008 vorbis_floor0 *vf = &vfu->t0;
01009 float *lsp = vf->lsp;
01010 uint_fast32_t amplitude;
01011 uint_fast32_t book_idx;
01012 uint_fast8_t blockflag = vc->modes[vc->mode_number].blockflag;
01013
01014 amplitude = get_bits(&vc->gb, vf->amplitude_bits);
01015 if (amplitude > 0) {
01016 float last = 0;
01017 uint_fast16_t lsp_len = 0;
01018 uint_fast16_t idx;
01019 vorbis_codebook codebook;
01020
01021 book_idx = get_bits(&vc->gb, ilog(vf->num_books));
01022 if (book_idx >= vf->num_books) {
01023 av_log(vc->avccontext, AV_LOG_ERROR,
01024 "floor0 dec: booknumber too high!\n");
01025 book_idx = 0;
01026
01027 }
01028 AV_DEBUG("floor0 dec: booknumber: %u\n", book_idx);
01029 codebook = vc->codebooks[vf->book_list[book_idx]];
01030
01031 while (lsp_len<vf->order) {
01032 int vec_off;
01033
01034 AV_DEBUG("floor0 dec: book dimension: %d\n", codebook.dimensions);
01035 AV_DEBUG("floor0 dec: maximum depth: %d\n", codebook.maxdepth);
01036
01037 vec_off = get_vlc2(&vc->gb, codebook.vlc.table,
01038 codebook.nb_bits, codebook.maxdepth)
01039 * codebook.dimensions;
01040 AV_DEBUG("floor0 dec: vector offset: %d\n", vec_off);
01041
01042 for (idx = 0; idx < codebook.dimensions; ++idx)
01043 lsp[lsp_len+idx] = codebook.codevectors[vec_off+idx] + last;
01044 last = lsp[lsp_len+idx-1];
01045
01046 lsp_len += codebook.dimensions;
01047 }
01048 #ifdef V_DEBUG
01049
01050 {
01051 int idx;
01052 for (idx = 0; idx < lsp_len; ++idx)
01053 AV_DEBUG("floor0 dec: coeff at %d is %f\n", idx, lsp[idx]);
01054 }
01055 #endif
01056
01057
01058 {
01059 int i;
01060 int order = vf->order;
01061 float wstep = M_PI / vf->bark_map_size;
01062
01063 for (i = 0; i < order; i++)
01064 lsp[i] = 2.0f * cos(lsp[i]);
01065
01066 AV_DEBUG("floor0 synth: map_size = %d; m = %d; wstep = %f\n",
01067 vf->map_size, order, wstep);
01068
01069 i = 0;
01070 while (i < vf->map_size[blockflag]) {
01071 int j, iter_cond = vf->map[blockflag][i];
01072 float p = 0.5f;
01073 float q = 0.5f;
01074 float two_cos_w = 2.0f * cos(wstep * iter_cond);
01075
01076
01077 for (j = 0; j + 1 < order; j += 2) {
01078 q *= lsp[j] - two_cos_w;
01079 p *= lsp[j + 1] - two_cos_w;
01080 }
01081 if (j == order) {
01082 p *= p * (2.0f - two_cos_w);
01083 q *= q * (2.0f + two_cos_w);
01084 } else {
01085 q *= two_cos_w-lsp[j];
01086
01087
01088 p *= p * (4.f - two_cos_w * two_cos_w);
01089 q *= q;
01090 }
01091
01092
01093 {
01094 q = exp((((amplitude*vf->amplitude_offset) /
01095 (((1 << vf->amplitude_bits) - 1) * sqrt(p + q)))
01096 - vf->amplitude_offset) * .11512925f);
01097 }
01098
01099
01100 do {
01101 vec[i] = q; ++i;
01102 } while (vf->map[blockflag][i] == iter_cond);
01103 }
01104 }
01105 } else {
01106
01107 return 1;
01108 }
01109
01110 AV_DEBUG(" Floor0 decoded\n");
01111
01112 return 0;
01113 }
01114
01115 static uint_fast8_t vorbis_floor1_decode(vorbis_context *vc,
01116 vorbis_floor_data *vfu, float *vec)
01117 {
01118 vorbis_floor1 *vf = &vfu->t1;
01119 GetBitContext *gb = &vc->gb;
01120 uint_fast16_t range_v[4] = { 256, 128, 86, 64 };
01121 uint_fast16_t range = range_v[vf->multiplier-1];
01122 uint_fast16_t floor1_Y[vf->x_list_dim];
01123 uint_fast16_t floor1_Y_final[vf->x_list_dim];
01124 int floor1_flag[vf->x_list_dim];
01125 uint_fast8_t class_;
01126 uint_fast8_t cdim;
01127 uint_fast8_t cbits;
01128 uint_fast8_t csub;
01129 uint_fast8_t cval;
01130 int_fast16_t book;
01131 uint_fast16_t offset;
01132 uint_fast16_t i,j;
01133 int_fast16_t adx, ady, off, predicted;
01134 int_fast16_t dy, err;
01135
01136
01137 if (!get_bits1(gb))
01138 return 1;
01139
01140
01141
01142 floor1_Y[0] = get_bits(gb, ilog(range - 1));
01143 floor1_Y[1] = get_bits(gb, ilog(range - 1));
01144
01145 AV_DEBUG("floor 0 Y %d floor 1 Y %d \n", floor1_Y[0], floor1_Y[1]);
01146
01147 offset = 2;
01148 for (i = 0; i < vf->partitions; ++i) {
01149 class_ = vf->partition_class[i];
01150 cdim = vf->class_dimensions[class_];
01151 cbits = vf->class_subclasses[class_];
01152 csub = (1 << cbits) - 1;
01153 cval = 0;
01154
01155 AV_DEBUG("Cbits %d \n", cbits);
01156
01157 if (cbits)
01158 cval = get_vlc2(gb, vc->codebooks[vf->class_masterbook[class_]].vlc.table,
01159 vc->codebooks[vf->class_masterbook[class_]].nb_bits, 3);
01160
01161 for (j = 0; j < cdim; ++j) {
01162 book = vf->subclass_books[class_][cval & csub];
01163
01164 AV_DEBUG("book %d Cbits %d cval %d bits:%d \n", book, cbits, cval, get_bits_count(gb));
01165
01166 cval = cval >> cbits;
01167 if (book > -1) {
01168 floor1_Y[offset+j] = get_vlc2(gb, vc->codebooks[book].vlc.table,
01169 vc->codebooks[book].nb_bits, 3);
01170 } else {
01171 floor1_Y[offset+j] = 0;
01172 }
01173
01174 AV_DEBUG(" floor(%d) = %d \n", vf->list[offset+j].x, floor1_Y[offset+j]);
01175 }
01176 offset+=cdim;
01177 }
01178
01179
01180
01181 floor1_flag[0] = 1;
01182 floor1_flag[1] = 1;
01183 floor1_Y_final[0] = floor1_Y[0];
01184 floor1_Y_final[1] = floor1_Y[1];
01185
01186 for (i = 2; i < vf->x_list_dim; ++i) {
01187 uint_fast16_t val, highroom, lowroom, room;
01188 uint_fast16_t high_neigh_offs;
01189 uint_fast16_t low_neigh_offs;
01190
01191 low_neigh_offs = vf->list[i].low;
01192 high_neigh_offs = vf->list[i].high;
01193 dy = floor1_Y_final[high_neigh_offs] - floor1_Y_final[low_neigh_offs];
01194 adx = vf->list[high_neigh_offs].x - vf->list[low_neigh_offs].x;
01195 ady = FFABS(dy);
01196 err = ady * (vf->list[i].x - vf->list[low_neigh_offs].x);
01197 off = (int16_t)err / (int16_t)adx;
01198 if (dy < 0) {
01199 predicted = floor1_Y_final[low_neigh_offs] - off;
01200 } else {
01201 predicted = floor1_Y_final[low_neigh_offs] + off;
01202 }
01203
01204 val = floor1_Y[i];
01205 highroom = range-predicted;
01206 lowroom = predicted;
01207 if (highroom < lowroom) {
01208 room = highroom * 2;
01209 } else {
01210 room = lowroom * 2;
01211 }
01212 if (val) {
01213 floor1_flag[low_neigh_offs] = 1;
01214 floor1_flag[high_neigh_offs] = 1;
01215 floor1_flag[i] = 1;
01216 if (val >= room) {
01217 if (highroom > lowroom) {
01218 floor1_Y_final[i] = val - lowroom + predicted;
01219 } else {
01220 floor1_Y_final[i] = predicted - val + highroom - 1;
01221 }
01222 } else {
01223 if (val & 1) {
01224 floor1_Y_final[i] = predicted - (val + 1) / 2;
01225 } else {
01226 floor1_Y_final[i] = predicted + val / 2;
01227 }
01228 }
01229 } else {
01230 floor1_flag[i] = 0;
01231 floor1_Y_final[i] = predicted;
01232 }
01233
01234 AV_DEBUG(" Decoded floor(%d) = %d / val %d \n", vf->list[i].x, floor1_Y_final[i], val);
01235 }
01236
01237
01238
01239 ff_vorbis_floor1_render_list(vf->list, vf->x_list_dim, floor1_Y_final, floor1_flag, vf->multiplier, vec, vf->list[1].x);
01240
01241 AV_DEBUG(" Floor decoded\n");
01242
01243 return 0;
01244 }
01245
01246
01247
01248 static av_always_inline int vorbis_residue_decode_internal(vorbis_context *vc,
01249 vorbis_residue *vr,
01250 uint_fast8_t ch,
01251 uint_fast8_t *do_not_decode,
01252 float *vec,
01253 uint_fast16_t vlen,
01254 int vr_type)
01255 {
01256 GetBitContext *gb = &vc->gb;
01257 uint_fast8_t c_p_c = vc->codebooks[vr->classbook].dimensions;
01258 uint_fast16_t n_to_read = vr->end-vr->begin;
01259 uint_fast16_t ptns_to_read = n_to_read/vr->partition_size;
01260 uint_fast8_t classifs[ptns_to_read*vc->audio_channels];
01261 uint_fast8_t pass;
01262 uint_fast8_t ch_used;
01263 uint_fast8_t i,j,l;
01264 uint_fast16_t k;
01265
01266 if (vr_type == 2) {
01267 for (j = 1; j < ch; ++j)
01268 do_not_decode[0] &= do_not_decode[j];
01269 if (do_not_decode[0])
01270 return 0;
01271 ch_used = 1;
01272 } else {
01273 ch_used = ch;
01274 }
01275
01276 AV_DEBUG(" residue type 0/1/2 decode begin, ch: %d cpc %d \n", ch, c_p_c);
01277
01278 for (pass = 0; pass <= vr->maxpass; ++pass) {
01279 uint_fast16_t voffset;
01280 uint_fast16_t partition_count;
01281 uint_fast16_t j_times_ptns_to_read;
01282
01283 voffset = vr->begin;
01284 for (partition_count = 0; partition_count < ptns_to_read;) {
01285 if (!pass) {
01286 uint_fast32_t inverse_class = ff_inverse[vr->classifications];
01287 for (j_times_ptns_to_read = 0, j = 0; j < ch_used; ++j) {
01288 if (!do_not_decode[j]) {
01289 uint_fast32_t temp = get_vlc2(gb, vc->codebooks[vr->classbook].vlc.table,
01290 vc->codebooks[vr->classbook].nb_bits, 3);
01291
01292 AV_DEBUG("Classword: %d \n", temp);
01293
01294 assert(vr->classifications > 1 && temp <= 65536);
01295 for (i = 0; i < c_p_c; ++i) {
01296 uint_fast32_t temp2;
01297
01298 temp2 = (((uint_fast64_t)temp) * inverse_class) >> 32;
01299 if (partition_count + c_p_c - 1 - i < ptns_to_read)
01300 classifs[j_times_ptns_to_read + partition_count + c_p_c - 1 - i] = temp - temp2 * vr->classifications;
01301 temp = temp2;
01302 }
01303 }
01304 j_times_ptns_to_read += ptns_to_read;
01305 }
01306 }
01307 for (i = 0; (i < c_p_c) && (partition_count < ptns_to_read); ++i) {
01308 for (j_times_ptns_to_read = 0, j = 0; j < ch_used; ++j) {
01309 uint_fast16_t voffs;
01310
01311 if (!do_not_decode[j]) {
01312 uint_fast8_t vqclass = classifs[j_times_ptns_to_read+partition_count];
01313 int_fast16_t vqbook = vr->books[vqclass][pass];
01314
01315 if (vqbook >= 0 && vc->codebooks[vqbook].codevectors) {
01316 uint_fast16_t coffs;
01317 unsigned dim = vc->codebooks[vqbook].dimensions;
01318 uint_fast16_t step = dim == 1 ? vr->partition_size
01319 : FASTDIV(vr->partition_size, dim);
01320 vorbis_codebook codebook = vc->codebooks[vqbook];
01321
01322 if (vr_type == 0) {
01323
01324 voffs = voffset+j*vlen;
01325 for (k = 0; k < step; ++k) {
01326 coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * dim;
01327 for (l = 0; l < dim; ++l)
01328 vec[voffs + k + l * step] += codebook.codevectors[coffs + l];
01329 }
01330 } else if (vr_type == 1) {
01331 voffs = voffset + j * vlen;
01332 for (k = 0; k < step; ++k) {
01333 coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * dim;
01334 for (l = 0; l < dim; ++l, ++voffs) {
01335 vec[voffs]+=codebook.codevectors[coffs+l];
01336
01337 AV_DEBUG(" pass %d offs: %d curr: %f change: %f cv offs.: %d \n", pass, voffs, vec[voffs], codebook.codevectors[coffs+l], coffs);
01338 }
01339 }
01340 } else if (vr_type == 2 && ch == 2 && (voffset & 1) == 0 && (dim & 1) == 0) {
01341 voffs = voffset >> 1;
01342
01343 if (dim == 2) {
01344 for (k = 0; k < step; ++k) {
01345 coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * 2;
01346 vec[voffs + k ] += codebook.codevectors[coffs ];
01347 vec[voffs + k + vlen] += codebook.codevectors[coffs + 1];
01348 }
01349 } else if (dim == 4) {
01350 for (k = 0; k < step; ++k, voffs += 2) {
01351 coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * 4;
01352 vec[voffs ] += codebook.codevectors[coffs ];
01353 vec[voffs + 1 ] += codebook.codevectors[coffs + 2];
01354 vec[voffs + vlen ] += codebook.codevectors[coffs + 1];
01355 vec[voffs + vlen + 1] += codebook.codevectors[coffs + 3];
01356 }
01357 } else
01358 for (k = 0; k < step; ++k) {
01359 coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * dim;
01360 for (l = 0; l < dim; l += 2, voffs++) {
01361 vec[voffs ] += codebook.codevectors[coffs + l ];
01362 vec[voffs + vlen] += codebook.codevectors[coffs + l + 1];
01363
01364 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);
01365 }
01366 }
01367
01368 } else if (vr_type == 2) {
01369 voffs = voffset;
01370
01371 for (k = 0; k < step; ++k) {
01372 coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * dim;
01373 for (l = 0; l < dim; ++l, ++voffs) {
01374 vec[voffs / ch + (voffs % ch) * vlen] += codebook.codevectors[coffs + l];
01375
01376 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);
01377 }
01378 }
01379 }
01380 }
01381 }
01382 j_times_ptns_to_read += ptns_to_read;
01383 }
01384 ++partition_count;
01385 voffset += vr->partition_size;
01386 }
01387 }
01388 }
01389 return 0;
01390 }
01391
01392 static inline int vorbis_residue_decode(vorbis_context *vc, vorbis_residue *vr,
01393 uint_fast8_t ch,
01394 uint_fast8_t *do_not_decode,
01395 float *vec, uint_fast16_t vlen)
01396 {
01397 if (vr->type == 2)
01398 return vorbis_residue_decode_internal(vc, vr, ch, do_not_decode, vec, vlen, 2);
01399 else if (vr->type == 1)
01400 return vorbis_residue_decode_internal(vc, vr, ch, do_not_decode, vec, vlen, 1);
01401 else if (vr->type == 0)
01402 return vorbis_residue_decode_internal(vc, vr, ch, do_not_decode, vec, vlen, 0);
01403 else {
01404 av_log(vc->avccontext, AV_LOG_ERROR, " Invalid residue type while residue decode?! \n");
01405 return -1;
01406 }
01407 }
01408
01409 void vorbis_inverse_coupling(float *mag, float *ang, int blocksize)
01410 {
01411 int i;
01412 for (i = 0; i < blocksize; i++) {
01413 if (mag[i] > 0.0) {
01414 if (ang[i] > 0.0) {
01415 ang[i] = mag[i] - ang[i];
01416 } else {
01417 float temp = ang[i];
01418 ang[i] = mag[i];
01419 mag[i] += temp;
01420 }
01421 } else {
01422 if (ang[i] > 0.0) {
01423 ang[i] += mag[i];
01424 } else {
01425 float temp = ang[i];
01426 ang[i] = mag[i];
01427 mag[i] -= temp;
01428 }
01429 }
01430 }
01431 }
01432
01433 static void copy_normalize(float *dst, float *src, int len, int exp_bias,
01434 float add_bias)
01435 {
01436 int i;
01437 if (exp_bias) {
01438 memcpy(dst, src, len * sizeof(float));
01439 } else {
01440 for (i = 0; i < len; i++)
01441 dst[i] = src[i] + add_bias;
01442 }
01443 }
01444
01445
01446
01447 static int vorbis_parse_audio_packet(vorbis_context *vc)
01448 {
01449 GetBitContext *gb = &vc->gb;
01450
01451 uint_fast8_t previous_window = vc->previous_window;
01452 uint_fast8_t mode_number;
01453 uint_fast8_t blockflag;
01454 uint_fast16_t blocksize;
01455 int_fast32_t i,j;
01456 uint_fast8_t no_residue[vc->audio_channels];
01457 uint_fast8_t do_not_decode[vc->audio_channels];
01458 vorbis_mapping *mapping;
01459 float *ch_res_ptr = vc->channel_residues;
01460 float *ch_floor_ptr = vc->channel_floors;
01461 uint_fast8_t res_chan[vc->audio_channels];
01462 uint_fast8_t res_num = 0;
01463 int_fast16_t retlen = 0;
01464 float fadd_bias = vc->add_bias;
01465
01466 if (get_bits1(gb)) {
01467 av_log(vc->avccontext, AV_LOG_ERROR, "Not a Vorbis I audio packet.\n");
01468 return -1;
01469 }
01470
01471 if (vc->mode_count == 1) {
01472 mode_number = 0;
01473 } else {
01474 GET_VALIDATED_INDEX(mode_number, ilog(vc->mode_count-1), vc->mode_count)
01475 }
01476 vc->mode_number = mode_number;
01477 mapping = &vc->mappings[vc->modes[mode_number].mapping];
01478
01479 AV_DEBUG(" Mode number: %d , mapping: %d , blocktype %d \n", mode_number, vc->modes[mode_number].mapping, vc->modes[mode_number].blockflag);
01480
01481 blockflag = vc->modes[mode_number].blockflag;
01482 blocksize = vc->blocksize[blockflag];
01483 if (blockflag)
01484 skip_bits(gb, 2);
01485
01486 memset(ch_res_ptr, 0, sizeof(float) * vc->audio_channels * blocksize / 2);
01487 memset(ch_floor_ptr, 0, sizeof(float) * vc->audio_channels * blocksize / 2);
01488
01489
01490
01491 for (i = 0; i < vc->audio_channels; ++i) {
01492 vorbis_floor *floor;
01493 if (mapping->submaps > 1) {
01494 floor = &vc->floors[mapping->submap_floor[mapping->mux[i]]];
01495 } else {
01496 floor = &vc->floors[mapping->submap_floor[0]];
01497 }
01498
01499 no_residue[i] = floor->decode(vc, &floor->data, ch_floor_ptr);
01500 ch_floor_ptr += blocksize / 2;
01501 }
01502
01503
01504
01505 for (i = mapping->coupling_steps - 1; i >= 0; --i) {
01506 if (!(no_residue[mapping->magnitude[i]] & no_residue[mapping->angle[i]])) {
01507 no_residue[mapping->magnitude[i]] = 0;
01508 no_residue[mapping->angle[i]] = 0;
01509 }
01510 }
01511
01512
01513
01514 for (i = 0; i < mapping->submaps; ++i) {
01515 vorbis_residue *residue;
01516 uint_fast8_t ch = 0;
01517
01518 for (j = 0; j < vc->audio_channels; ++j) {
01519 if ((mapping->submaps == 1) || (i == mapping->mux[j])) {
01520 res_chan[j] = res_num;
01521 if (no_residue[j]) {
01522 do_not_decode[ch] = 1;
01523 } else {
01524 do_not_decode[ch] = 0;
01525 }
01526 ++ch;
01527 ++res_num;
01528 }
01529 }
01530 residue = &vc->residues[mapping->submap_residue[i]];
01531 vorbis_residue_decode(vc, residue, ch, do_not_decode, ch_res_ptr, blocksize/2);
01532
01533 ch_res_ptr += ch * blocksize / 2;
01534 }
01535
01536
01537
01538 for (i = mapping->coupling_steps - 1; i >= 0; --i) {
01539 float *mag, *ang;
01540
01541 mag = vc->channel_residues+res_chan[mapping->magnitude[i]] * blocksize / 2;
01542 ang = vc->channel_residues+res_chan[mapping->angle[i]] * blocksize / 2;
01543 vc->dsp.vorbis_inverse_coupling(mag, ang, blocksize / 2);
01544 }
01545
01546
01547
01548 for (j = vc->audio_channels-1;j >= 0; j--) {
01549 ch_floor_ptr = vc->channel_floors + j * blocksize / 2;
01550 ch_res_ptr = vc->channel_residues + res_chan[j] * blocksize / 2;
01551 vc->dsp.vector_fmul(ch_floor_ptr, ch_res_ptr, blocksize / 2);
01552 ff_imdct_half(&vc->mdct[blockflag], ch_res_ptr, ch_floor_ptr);
01553 }
01554
01555
01556
01557 retlen = (blocksize + vc->blocksize[previous_window]) / 4;
01558 for (j = 0; j < vc->audio_channels; j++) {
01559 uint_fast16_t bs0 = vc->blocksize[0];
01560 uint_fast16_t bs1 = vc->blocksize[1];
01561 float *residue = vc->channel_residues + res_chan[j] * blocksize / 2;
01562 float *saved = vc->saved + j * bs1 / 4;
01563 float *ret = vc->channel_floors + j * retlen;
01564 float *buf = residue;
01565 const float *win = vc->win[blockflag & previous_window];
01566
01567 if (blockflag == previous_window) {
01568 vc->dsp.vector_fmul_window(ret, saved, buf, win, fadd_bias, blocksize / 4);
01569 } else if (blockflag > previous_window) {
01570 vc->dsp.vector_fmul_window(ret, saved, buf, win, fadd_bias, bs0 / 4);
01571 copy_normalize(ret+bs0/2, buf+bs0/4, (bs1-bs0)/4, vc->exp_bias, fadd_bias);
01572 } else {
01573 copy_normalize(ret, saved, (bs1 - bs0) / 4, vc->exp_bias, fadd_bias);
01574 vc->dsp.vector_fmul_window(ret + (bs1 - bs0) / 4, saved + (bs1 - bs0) / 4, buf, win, fadd_bias, bs0 / 4);
01575 }
01576 memcpy(saved, buf + blocksize / 4, blocksize / 4 * sizeof(float));
01577 }
01578
01579 vc->previous_window = blockflag;
01580 return retlen;
01581 }
01582
01583
01584
01585 static int vorbis_decode_frame(AVCodecContext *avccontext,
01586 void *data, int *data_size,
01587 AVPacket *avpkt)
01588 {
01589 const uint8_t *buf = avpkt->data;
01590 int buf_size = avpkt->size;
01591 vorbis_context *vc = avccontext->priv_data ;
01592 GetBitContext *gb = &(vc->gb);
01593 const float *channel_ptrs[vc->audio_channels];
01594 int i;
01595
01596 int_fast16_t len;
01597
01598 if (!buf_size)
01599 return 0;
01600
01601 AV_DEBUG("packet length %d \n", buf_size);
01602
01603 init_get_bits(gb, buf, buf_size*8);
01604
01605 len = vorbis_parse_audio_packet(vc);
01606
01607 if (len <= 0) {
01608 *data_size = 0;
01609 return buf_size;
01610 }
01611
01612 if (!vc->first_frame) {
01613 vc->first_frame = 1;
01614 *data_size = 0;
01615 return buf_size ;
01616 }
01617
01618 AV_DEBUG("parsed %d bytes %d bits, returned %d samples (*ch*bits) \n", get_bits_count(gb)/8, get_bits_count(gb)%8, len);
01619
01620 if (vc->audio_channels > 8) {
01621 for (i = 0; i < vc->audio_channels; i++)
01622 channel_ptrs[i] = vc->channel_floors + i * len;
01623 } else {
01624 for (i = 0; i < vc->audio_channels; i++)
01625 channel_ptrs[i] = vc->channel_floors +
01626 len * ff_vorbis_channel_layout_offsets[vc->audio_channels - 1][i];
01627 }
01628
01629 vc->dsp.float_to_int16_interleave(data, channel_ptrs, len, vc->audio_channels);
01630 *data_size = len * 2 * vc->audio_channels;
01631
01632 return buf_size ;
01633 }
01634
01635
01636
01637 static av_cold int vorbis_decode_close(AVCodecContext *avccontext)
01638 {
01639 vorbis_context *vc = avccontext->priv_data;
01640
01641 vorbis_free(vc);
01642
01643 return 0 ;
01644 }
01645
01646 AVCodec vorbis_decoder = {
01647 "vorbis",
01648 AVMEDIA_TYPE_AUDIO,
01649 CODEC_ID_VORBIS,
01650 sizeof(vorbis_context),
01651 vorbis_decode_init,
01652 NULL,
01653 vorbis_decode_close,
01654 vorbis_decode_frame,
01655 .long_name = NULL_IF_CONFIG_SMALL("Vorbis"),
01656 .channel_layouts = ff_vorbis_channel_layouts,
01657 };
01658