Lines Matching defs:vc
166 av_log(vc->avctx, AV_LOG_ERROR,\
189 static void vorbis_free(vorbis_context *vc)
193 av_freep(&vc->channel_residues);
194 av_freep(&vc->saved);
195 av_freep(&vc->fdsp);
197 if (vc->residues)
198 for (i = 0; i < vc->residue_count; i++)
199 av_freep(&vc->residues[i].classifs);
200 av_freep(&vc->residues);
201 av_freep(&vc->modes);
203 ff_mdct_end(&vc->mdct[0]);
204 ff_mdct_end(&vc->mdct[1]);
206 if (vc->codebooks)
207 for (i = 0; i < vc->codebook_count; ++i) {
208 av_freep(&vc->codebooks[i].codevectors);
209 ff_free_vlc(&vc->codebooks[i].vlc);
211 av_freep(&vc->codebooks);
213 if (vc->floors)
214 for (i = 0; i < vc->floor_count; ++i) {
215 if (vc->floors[i].floor_type == 0) {
216 av_freep(&vc->floors[i].data.t0.map[0]);
217 av_freep(&vc->floors[i].data.t0.map[1]);
218 av_freep(&vc->floors[i].data.t0.book_list);
219 av_freep(&vc->floors[i].data.t0.lsp);
221 av_freep(&vc->floors[i].data.t1.list);
224 av_freep(&vc->floors);
226 if (vc->mappings)
227 for (i = 0; i < vc->mapping_count; ++i) {
228 av_freep(&vc->mappings[i].magnitude);
229 av_freep(&vc->mappings[i].angle);
230 av_freep(&vc->mappings[i].mux);
232 av_freep(&vc->mappings);
239 static int vorbis_parse_setup_hdr_codebooks(vorbis_context *vc)
244 GetBitContext *gb = &vc->gb;
248 vc->codebook_count = get_bits(gb, 8) + 1;
250 ff_dlog(NULL, " Codebooks: %d \n", vc->codebook_count);
252 vc->codebooks = av_mallocz(vc->codebook_count * sizeof(*vc->codebooks));
256 if (!vc->codebooks ||
262 for (cb = 0; cb < vc->codebook_count; ++cb) {
263 vorbis_codebook *codebook_setup = &vc->codebooks[cb];
269 av_log(vc->avctx, AV_LOG_ERROR,
277 av_log(vc->avctx, AV_LOG_ERROR,
285 av_log(vc->avctx, AV_LOG_ERROR,
345 av_log(vc->avctx, AV_LOG_ERROR, " More codelengths than codes in codebook. \n");
403 ff_dlog(vc->avctx, "Lookup offset %u ,", i);
414 ff_dlog(vc->avctx, "real lookup offset %u, vector: ", j);
416 ff_dlog(vc->avctx, " %f ",
418 ff_dlog(vc->avctx, "\n");
424 av_log(vc->avctx, AV_LOG_ERROR, "Bug in codevector vector building code. \n");
430 av_log(vc->avctx, AV_LOG_ERROR, "Codebook lookup type not supported. \n");
437 av_log(vc->avctx, AV_LOG_ERROR, " Invalid code lengths while generating vlcs. \n");
458 av_log(vc->avctx, AV_LOG_ERROR, " Error generating vlc tables. \n");
478 static int vorbis_parse_setup_hdr_tdtransforms(vorbis_context *vc)
480 GetBitContext *gb = &vc->gb;
490 av_log(vc->avctx, AV_LOG_ERROR, "Vorbis time domain transform data nonzero. \n");
499 static int vorbis_floor0_decode(vorbis_context *vc,
501 static int create_map(vorbis_context *vc, unsigned floor_number);
502 static int vorbis_floor1_decode(vorbis_context *vc,
504 static int vorbis_parse_setup_hdr_floors(vorbis_context *vc)
506 GetBitContext *gb = &vc->gb;
509 vc->floor_count = get_bits(gb, 6) + 1;
511 vc->floors = av_mallocz(vc->floor_count * sizeof(*vc->floors));
512 if (!vc->floors)
515 for (i = 0; i < vc->floor_count; ++i) {
516 vorbis_floor *floor_setup = &vc->floors[i];
554 GET_VALIDATED_INDEX(floor_setup->data.t1.class_masterbook[j], 8, vc->codebook_count)
562 VALIDATE_INDEX(bits, vc->codebook_count)
582 av_log(vc->avctx, AV_LOG_ERROR,
587 if (rangemax > vc->blocksize[1] / 2) {
588 av_log(vc->avctx, AV_LOG_ERROR,
590 rangemax, vc->blocksize[1] / 2);
606 if (ff_vorbis_ready_floor1_list(vc->avctx,
618 av_log(vc->avctx, AV_LOG_ERROR, "Floor 0 order is 0.\n");
623 av_log(vc->avctx, AV_LOG_ERROR, "Floor 0 rate is 0.\n");
628 av_log(vc->avctx, AV_LOG_ERROR,
646 GET_VALIDATED_INDEX(book_idx, 8, vc->codebook_count)
648 if (vc->codebooks[book_idx].dimensions > max_codebook_dim)
649 max_codebook_dim = vc->codebooks[book_idx].dimensions;
653 if ((ret = create_map(vc, i)) < 0)
685 av_log(vc->avctx, AV_LOG_ERROR, "Invalid floor type!\n");
694 static int vorbis_parse_setup_hdr_residues(vorbis_context *vc)
696 GetBitContext *gb = &vc->gb;
699 vc->residue_count = get_bits(gb, 6)+1;
700 vc->residues = av_mallocz(vc->residue_count * sizeof(*vc->residues));
701 if (!vc->residues)
704 ff_dlog(NULL, " There are %d residues. \n", vc->residue_count);
706 for (i = 0; i < vc->residue_count; ++i) {
707 vorbis_residue *res_setup = &vc->residues[i];
721 av_log(vc->avctx, AV_LOG_ERROR,
724 res_setup->partition_size, vc->blocksize[1] / 2);
729 GET_VALIDATED_INDEX(res_setup->classbook, 8, vc->codebook_count)
734 vc->audio_channels *
757 GET_VALIDATED_INDEX(res_setup->books[j][k], 8, vc->codebook_count)
775 static int vorbis_parse_setup_hdr_mappings(vorbis_context *vc)
777 GetBitContext *gb = &vc->gb;
780 vc->mapping_count = get_bits(gb, 6)+1;
781 vc->mappings = av_mallocz(vc->mapping_count * sizeof(*vc->mappings));
782 if (!vc->mappings)
785 ff_dlog(NULL, " There are %d mappings. \n", vc->mapping_count);
787 for (i = 0; i < vc->mapping_count; ++i) {
788 vorbis_mapping *mapping_setup = &vc->mappings[i];
791 av_log(vc->avctx, AV_LOG_ERROR, "Other mappings than type 0 are not compliant with the Vorbis I specification. \n");
802 if (vc->audio_channels < 2) {
803 av_log(vc->avctx, AV_LOG_ERROR,
815 GET_VALIDATED_INDEX(mapping_setup->magnitude[j], ilog(vc->audio_channels - 1), vc->audio_channels)
816 GET_VALIDATED_INDEX(mapping_setup->angle[j], ilog(vc->audio_channels - 1), vc->audio_channels)
826 av_log(vc->avctx, AV_LOG_ERROR, "%u. mapping setup data invalid.\n", i);
831 mapping_setup->mux = av_calloc(vc->audio_channels,
836 for (j = 0; j < vc->audio_channels; ++j)
842 GET_VALIDATED_INDEX(mapping_setup->submap_floor[j], 8, vc->floor_count)
843 GET_VALIDATED_INDEX(mapping_setup->submap_residue[j], 8, vc->residue_count)
855 static int create_map(vorbis_context *vc, unsigned floor_number)
857 vorbis_floor *floors = vc->floors;
864 n = vc->blocksize[blockflag] / 2;
890 static int vorbis_parse_setup_hdr_modes(vorbis_context *vc)
892 GetBitContext *gb = &vc->gb;
895 vc->mode_count = get_bits(gb, 6) + 1;
896 vc->modes = av_mallocz(vc->mode_count * sizeof(*vc->modes));
897 if (!vc->modes)
900 ff_dlog(NULL, " There are %d modes.\n", vc->mode_count);
902 for (i = 0; i < vc->mode_count; ++i) {
903 vorbis_mode *mode_setup = &vc->modes[i];
908 GET_VALIDATED_INDEX(mode_setup->mapping, 8, vc->mapping_count);
919 static int vorbis_parse_setup_hdr(vorbis_context *vc)
921 GetBitContext *gb = &vc->gb;
927 av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (no vorbis signature). \n");
931 if ((ret = vorbis_parse_setup_hdr_codebooks(vc))) {
932 av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (codebooks). \n");
935 if ((ret = vorbis_parse_setup_hdr_tdtransforms(vc))) {
936 av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (time domain transforms). \n");
939 if ((ret = vorbis_parse_setup_hdr_floors(vc))) {
940 av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (floors). \n");
943 if ((ret = vorbis_parse_setup_hdr_residues(vc))) {
944 av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (residues). \n");
947 if ((ret = vorbis_parse_setup_hdr_mappings(vc))) {
948 av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (mappings). \n");
951 if ((ret = vorbis_parse_setup_hdr_modes(vc))) {
952 av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (modes). \n");
956 av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (framing flag). \n");
965 static int vorbis_parse_id_hdr(vorbis_context *vc)
967 GetBitContext *gb = &vc->gb;
973 av_log(vc->avctx, AV_LOG_ERROR, " Vorbis id header packet corrupt (no vorbis signature). \n");
977 vc->version = get_bits_long(gb, 32); //FIXME check 0
978 vc->audio_channels = get_bits(gb, 8);
979 if (vc->audio_channels <= 0) {
980 av_log(vc->avctx, AV_LOG_ERROR, "Invalid number of channels\n");
983 vc->audio_samplerate = get_bits_long(gb, 32);
984 if (vc->audio_samplerate <= 0) {
985 av_log(vc->avctx, AV_LOG_ERROR, "Invalid samplerate\n");
988 vc->bitrate_maximum = get_bits_long(gb, 32);
989 vc->bitrate_nominal = get_bits_long(gb, 32);
990 vc->bitrate_minimum = get_bits_long(gb, 32);
994 av_log(vc->avctx, AV_LOG_ERROR, " Vorbis id header packet corrupt (illegal blocksize). \n");
997 vc->blocksize[0] = (1 << bl0);
998 vc->blocksize[1] = (1 << bl1);
999 vc->win[0] = ff_vorbis_vwin[bl0 - 6];
1000 vc->win[1] = ff_vorbis_vwin[bl1 - 6];
1003 av_log(vc->avctx, AV_LOG_ERROR, " Vorbis id header packet corrupt (framing flag not set). \n");
1007 vc->channel_residues = av_malloc_array(vc->blocksize[1] / 2, vc->audio_channels * sizeof(*vc->channel_residues));
1008 vc->saved = av_calloc(vc->blocksize[1] / 4, vc->audio_channels * sizeof(*vc->saved));
1009 if (!vc->channel_residues || !vc->saved)
1012 vc->previous_window = -1;
1014 ff_mdct_init(&vc->mdct[0], bl0, 1, -1.0);
1015 ff_mdct_init(&vc->mdct[1], bl1, 1, -1.0);
1016 vc->fdsp = avpriv_float_dsp_alloc(vc->avctx->flags & AV_CODEC_FLAG_BITEXACT);
1017 if (!vc->fdsp)
1021 vc->version, vc->audio_channels, vc->audio_samplerate, vc->bitrate_maximum, vc->bitrate_nominal, vc->bitrate_minimum, vc->blocksize[0], vc->blocksize[1]);
1024 BLK = vc->blocksize[0];
1026 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)));
1037 vorbis_context *vc = avctx->priv_data;
1042 GetBitContext *gb = &vc->gb;
1045 vc->avctx = avctx;
1046 ff_vorbisdsp_init(&vc->dsp);
1066 if ((ret = vorbis_parse_id_hdr(vc))) {
1068 vorbis_free(vc);
1076 vorbis_free(vc);
1079 if ((ret = vorbis_parse_setup_hdr(vc))) {
1081 vorbis_free(vc);
1086 if (vc->audio_channels > 8) {
1088 avctx->ch_layout.nb_channels = vc->audio_channels;
1090 av_channel_layout_copy(&avctx->ch_layout, &ff_vorbis_ch_layouts[vc->audio_channels - 1]);
1093 avctx->sample_rate = vc->audio_samplerate;
1102 static int vorbis_floor0_decode(vorbis_context *vc,
1109 unsigned blockflag = vc->modes[vc->mode_number].blockflag;
1114 amplitude = get_bits64(&vc->gb, vf->amplitude_bits);
1120 book_idx = get_bits(&vc->gb, ilog(vf->num_books));
1122 av_log(vc->avctx, AV_LOG_ERROR, "floor0 dec: booknumber too high!\n");
1126 codebook = vc->codebooks[vf->book_list[book_idx]];
1137 vec_off = get_vlc2(&vc->gb, codebook.vlc.table,
1216 static int vorbis_floor1_decode(vorbis_context *vc,
1220 GetBitContext *gb = &vc->gb;
1251 cval = get_vlc2(gb, vc->codebooks[vf->class_masterbook[partition_class]].vlc.table,
1252 vc->codebooks[vf->class_masterbook[partition_class]].nb_bits, 3);
1262 int v = get_vlc2(gb, vc->codebooks[book].vlc.table,
1263 vc->codebooks[book].nb_bits, 3);
1343 static av_always_inline int setup_classifs(vorbis_context *vc,
1351 vorbis_codebook *codebook = vc->codebooks + vr->classbook;
1358 temp = get_vlc2(&vc->gb, codebook->vlc.table,
1366 av_log(vc->avctx, AV_LOG_ERROR,
1392 static av_always_inline int vorbis_residue_decode_internal(vorbis_context *vc,
1401 GetBitContext *gb = &vc->gb;
1402 unsigned c_p_c = vc->codebooks[vr->classbook].dimensions;
1426 av_log(vc->avctx, AV_LOG_ERROR, "Insufficient output buffer\n");
1439 int ret = setup_classifs(vc, vr, do_not_decode, ch_used, partition_count, ptns_to_read);
1451 if (vqbook >= 0 && vc->codebooks[vqbook].codevectors) {
1453 unsigned dim = vc->codebooks[vqbook].dimensions;
1455 vorbis_codebook codebook = vc->codebooks[vqbook];
1558 get_vlc2(&vc->gb, vc->codebooks[vr->classbook].vlc.table,
1559 vc->codebooks[vr->classbook].nb_bits, 3);
1567 static inline int vorbis_residue_decode(vorbis_context *vc, vorbis_residue *vr,
1574 return vorbis_residue_decode_internal(vc, vr, ch, do_not_decode, vec, vlen, ch_left, 2);
1576 return vorbis_residue_decode_internal(vc, vr, ch, do_not_decode, vec, vlen, ch_left, 1);
1578 return vorbis_residue_decode_internal(vc, vr, ch, do_not_decode, vec, vlen, ch_left, 0);
1580 av_log(vc->avctx, AV_LOG_ERROR, " Invalid residue type while residue decode?! \n");
1611 static int vorbis_parse_audio_packet(vorbis_context *vc, float **floor_ptr)
1613 GetBitContext *gb = &vc->gb;
1615 int previous_window = vc->previous_window;
1621 float *ch_res_ptr = vc->channel_residues;
1625 unsigned ch_left = vc->audio_channels;
1629 av_log(vc->avctx, AV_LOG_ERROR, "Not a Vorbis I audio packet.\n");
1633 if (vc->mode_count == 1) {
1636 GET_VALIDATED_INDEX(mode_number, ilog(vc->mode_count-1), vc->mode_count)
1638 vc->mode_number = mode_number;
1639 mapping = &vc->mappings[vc->modes[mode_number].mapping];
1642 vc->modes[mode_number].mapping, vc->modes[mode_number].blockflag);
1644 blockflag = vc->modes[mode_number].blockflag;
1645 blocksize = vc->blocksize[blockflag];
1654 memset(ch_res_ptr, 0, sizeof(float) * vc->audio_channels * vlen); //FIXME can this be removed ?
1655 for (i = 0; i < vc->audio_channels; ++i)
1660 for (i = 0; i < vc->audio_channels; ++i) {
1664 floor = &vc->floors[mapping->submap_floor[mapping->mux[i]]];
1666 floor = &vc->floors[mapping->submap_floor[0]];
1669 ret = floor->decode(vc, &floor->data, floor_ptr[i]);
1672 av_log(vc->avctx, AV_LOG_ERROR, "Invalid codebook in vorbis_floor_decode.\n");
1694 for (j = 0; j < vc->audio_channels; ++j) {
1706 residue = &vc->residues[mapping->submap_residue[i]];
1708 av_log(vc->avctx, AV_LOG_ERROR, "Too many channels in vorbis_floor_decode.\n");
1712 ret = vorbis_residue_decode(vc, residue, ch, do_not_decode, ch_res_ptr, vlen, ch_left);
1729 mag = vc->channel_residues+res_chan[mapping->magnitude[i]] * blocksize / 2;
1730 ang = vc->channel_residues+res_chan[mapping->angle[i]] * blocksize / 2;
1731 vc->dsp.vorbis_inverse_coupling(mag, ang, blocksize / 2);
1736 mdct = &vc->mdct[blockflag];
1738 for (j = vc->audio_channels-1;j >= 0; j--) {
1739 ch_res_ptr = vc->channel_residues + res_chan[j] * blocksize / 2;
1740 vc->fdsp->vector_fmul(floor_ptr[j], floor_ptr[j], ch_res_ptr, blocksize / 2);
1746 retlen = (blocksize + vc->blocksize[previous_window]) / 4;
1747 for (j = 0; j < vc->audio_channels; j++) {
1748 unsigned bs0 = vc->blocksize[0];
1749 unsigned bs1 = vc->blocksize[1];
1750 float *residue = vc->channel_residues + res_chan[j] * blocksize / 2;
1751 float *saved = vc->saved + j * bs1 / 4;
1754 const float *win = vc->win[blockflag & previous_window];
1757 vc->fdsp->vector_fmul_window(ret, saved, buf, win, blocksize / 4);
1759 vc->fdsp->vector_fmul_window(ret, saved, buf, win, bs0 / 4);
1763 vc->fdsp->vector_fmul_window(ret + (bs1 - bs0) / 4, saved + (bs1 - bs0) / 4, buf, win, bs0 / 4);
1768 vc->previous_window = blockflag;
1779 vorbis_context *vc = avctx->priv_data;
1780 GetBitContext *gb = &vc->gb;
1790 vorbis_free(vc);
1791 if ((ret = vorbis_parse_id_hdr(vc))) {
1793 vorbis_free(vc);
1798 if (vc->audio_channels > 8) {
1800 avctx->ch_layout.nb_channels = vc->audio_channels;
1802 av_channel_layout_copy(&avctx->ch_layout, &ff_vorbis_ch_layouts[vc->audio_channels - 1]);
1805 avctx->sample_rate = vc->audio_samplerate;
1814 if (*buf == 5 && buf_size > 7 && vc->channel_residues && !vc->modes) {
1818 if ((ret = vorbis_parse_setup_hdr(vc))) {
1820 vorbis_free(vc);
1826 if (!vc->channel_residues || !vc->modes) {
1832 frame->nb_samples = vc->blocksize[1] / 2;
1836 if (vc->audio_channels > 8) {
1837 for (i = 0; i < vc->audio_channels; i++)
1840 for (i = 0; i < vc->audio_channels; i++) {
1841 int ch = ff_vorbis_channel_layout_offsets[vc->audio_channels - 1][i];
1849 if ((len = vorbis_parse_audio_packet(vc, channel_ptrs)) <= 0)
1852 if (!vc->first_frame) {
1853 vc->first_frame = 1;
1872 vorbis_context *vc = avctx->priv_data;
1874 vorbis_free(vc);
1881 vorbis_context *vc = avctx->priv_data;
1883 if (vc->saved) {
1884 memset(vc->saved, 0, (vc->blocksize[1] / 4) * vc->audio_channels *
1885 sizeof(*vc->saved));
1887 vc->previous_window = -1;
1888 vc->first_frame = 0;