Mercurial > libavcodec.hg
comparison vorbis.c @ 3571:3bfe36a9db73 libavcodec
vorbis cosmetics: mdct0,mdct1 => mdct[2]
author | lorenm |
---|---|
date | Thu, 10 Aug 2006 21:57:30 +0000 |
parents | 991ef6ade276 |
children | f549d1e685f7 |
comparison
equal
deleted
inserted
replaced
3570:991ef6ade276 | 3571:3bfe36a9db73 |
---|---|
159 av_freep(&vc->buf_tmp); | 159 av_freep(&vc->buf_tmp); |
160 | 160 |
161 av_freep(&vc->residues); | 161 av_freep(&vc->residues); |
162 av_freep(&vc->modes); | 162 av_freep(&vc->modes); |
163 | 163 |
164 ff_mdct_end(&vc->mdct0); | 164 ff_mdct_end(&vc->mdct[0]); |
165 ff_mdct_end(&vc->mdct1); | 165 ff_mdct_end(&vc->mdct[1]); |
166 | 166 |
167 for(i=0;i<vc->codebook_count;++i) { | 167 for(i=0;i<vc->codebook_count;++i) { |
168 av_free(vc->codebooks[i].codevectors); | 168 av_free(vc->codebooks[i].codevectors); |
169 free_vlc(&vc->codebooks[i].vlc); | 169 free_vlc(&vc->codebooks[i].vlc); |
170 } | 170 } |
192 av_free(vc->mappings[i].mux); | 192 av_free(vc->mappings[i].mux); |
193 } | 193 } |
194 av_freep(&vc->mappings); | 194 av_freep(&vc->mappings); |
195 | 195 |
196 if(vc->exp_bias){ | 196 if(vc->exp_bias){ |
197 av_freep(&vc->swin); | 197 av_freep(&vc->win[0]); |
198 av_freep(&vc->lwin); | 198 av_freep(&vc->win[1]); |
199 } | 199 } |
200 } | 200 } |
201 | 201 |
202 // Parse setup header ------------------------------------------------- | 202 // Parse setup header ------------------------------------------------- |
203 | 203 |
760 int_fast32_t * map; | 760 int_fast32_t * map; |
761 int_fast32_t n; //TODO: could theoretically be smaller? | 761 int_fast32_t n; //TODO: could theoretically be smaller? |
762 | 762 |
763 for (blockflag=0;blockflag<2;++blockflag) | 763 for (blockflag=0;blockflag<2;++blockflag) |
764 { | 764 { |
765 n=(blockflag ? vc->blocksize_1 : vc->blocksize_0) / 2; | 765 n=(blockflag ? vc->blocksize[1] : vc->blocksize[0]) / 2; |
766 floors[floor_number].data.t0.map[blockflag]= | 766 floors[floor_number].data.t0.map[blockflag]= |
767 av_malloc((n+1) * sizeof(int_fast32_t)); // n+sentinel | 767 av_malloc((n+1) * sizeof(int_fast32_t)); // n+sentinel |
768 | 768 |
769 map=floors[floor_number].data.t0.map[blockflag]; | 769 map=floors[floor_number].data.t0.map[blockflag]; |
770 vf=&floors[floor_number].data.t0; | 770 vf=&floors[floor_number].data.t0; |
875 vc->bitrate_maximum=get_bits_long_le(gb, 32); | 875 vc->bitrate_maximum=get_bits_long_le(gb, 32); |
876 vc->bitrate_nominal=get_bits_long_le(gb, 32); | 876 vc->bitrate_nominal=get_bits_long_le(gb, 32); |
877 vc->bitrate_minimum=get_bits_long_le(gb, 32); | 877 vc->bitrate_minimum=get_bits_long_le(gb, 32); |
878 bl0=get_bits(gb, 4); | 878 bl0=get_bits(gb, 4); |
879 bl1=get_bits(gb, 4); | 879 bl1=get_bits(gb, 4); |
880 vc->blocksize_0=(1<<bl0); | 880 vc->blocksize[0]=(1<<bl0); |
881 vc->blocksize_1=(1<<bl1); | 881 vc->blocksize[1]=(1<<bl1); |
882 if (bl0>13 || bl0<6 || bl1>13 || bl1<6 || bl1<bl0) { | 882 if (bl0>13 || bl0<6 || bl1>13 || bl1<6 || bl1<bl0) { |
883 av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis id header packet corrupt (illegal blocksize). \n"); | 883 av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis id header packet corrupt (illegal blocksize). \n"); |
884 return 3; | 884 return 3; |
885 } | 885 } |
886 // output format int16 | 886 // output format int16 |
887 if (vc->blocksize_1/2 * vc->audio_channels * 2 > | 887 if (vc->blocksize[1]/2 * vc->audio_channels * 2 > |
888 AVCODEC_MAX_AUDIO_FRAME_SIZE) { | 888 AVCODEC_MAX_AUDIO_FRAME_SIZE) { |
889 av_log(vc->avccontext, AV_LOG_ERROR, "Vorbis channel count makes " | 889 av_log(vc->avccontext, AV_LOG_ERROR, "Vorbis channel count makes " |
890 "output packets too large.\n"); | 890 "output packets too large.\n"); |
891 return 4; | 891 return 4; |
892 } | 892 } |
893 vc->swin=vwin[bl0-6]; | 893 vc->win[0]=vwin[bl0-6]; |
894 vc->lwin=vwin[bl1-6]; | 894 vc->win[1]=vwin[bl1-6]; |
895 | 895 |
896 if(vc->exp_bias){ | 896 if(vc->exp_bias){ |
897 int i; | 897 int i, j; |
898 float *win; | 898 for(j=0; j<2; j++){ |
899 win = av_malloc(vc->blocksize_0/2 * sizeof(float)); | 899 float *win = av_malloc(vc->blocksize[j]/2 * sizeof(float)); |
900 for(i=0; i<vc->blocksize_0/2; i++) | 900 for(i=0; i<vc->blocksize[j]/2; i++) |
901 win[i] = vc->swin[i] * (1<<15); | 901 win[i] = vc->win[j][i] * (1<<15); |
902 vc->swin = win; | 902 vc->win[j] = win; |
903 win = av_malloc(vc->blocksize_1/2 * sizeof(float)); | 903 } |
904 for(i=0; i<vc->blocksize_1/2; i++) | |
905 win[i] = vc->lwin[i] * (1<<15); | |
906 vc->lwin = win; | |
907 } | 904 } |
908 | 905 |
909 if ((get_bits1(gb)) == 0) { | 906 if ((get_bits1(gb)) == 0) { |
910 av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis id header packet corrupt (framing flag not set). \n"); | 907 av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis id header packet corrupt (framing flag not set). \n"); |
911 return 2; | 908 return 2; |
912 } | 909 } |
913 | 910 |
914 vc->channel_residues=(float *)av_malloc((vc->blocksize_1/2)*vc->audio_channels * sizeof(float)); | 911 vc->channel_residues=(float *)av_malloc((vc->blocksize[1]/2)*vc->audio_channels * sizeof(float)); |
915 vc->channel_floors=(float *)av_malloc((vc->blocksize_1/2)*vc->audio_channels * sizeof(float)); | 912 vc->channel_floors=(float *)av_malloc((vc->blocksize[1]/2)*vc->audio_channels * sizeof(float)); |
916 vc->saved=(float *)av_malloc((vc->blocksize_1/2)*vc->audio_channels * sizeof(float)); | 913 vc->saved=(float *)av_malloc((vc->blocksize[1]/2)*vc->audio_channels * sizeof(float)); |
917 vc->ret=(float *)av_malloc((vc->blocksize_1/2)*vc->audio_channels * sizeof(float)); | 914 vc->ret=(float *)av_malloc((vc->blocksize[1]/2)*vc->audio_channels * sizeof(float)); |
918 vc->buf=(float *)av_malloc(vc->blocksize_1 * sizeof(float)); | 915 vc->buf=(float *)av_malloc(vc->blocksize[1] * sizeof(float)); |
919 vc->buf_tmp=(float *)av_malloc(vc->blocksize_1 * sizeof(float)); | 916 vc->buf_tmp=(float *)av_malloc(vc->blocksize[1] * sizeof(float)); |
920 vc->saved_start=0; | 917 vc->saved_start=0; |
921 | 918 |
922 ff_mdct_init(&vc->mdct0, bl0, 1); | 919 ff_mdct_init(&vc->mdct[0], bl0, 1); |
923 ff_mdct_init(&vc->mdct1, bl1, 1); | 920 ff_mdct_init(&vc->mdct[1], bl1, 1); |
924 | 921 |
925 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 ", | 922 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 ", |
926 vc->version, vc->audio_channels, vc->audio_samplerate, vc->bitrate_maximum, vc->bitrate_nominal, vc->bitrate_minimum, vc->blocksize_0, vc->blocksize_1); | 923 vc->version, vc->audio_channels, vc->audio_samplerate, vc->bitrate_maximum, vc->bitrate_nominal, vc->bitrate_minimum, vc->blocksize[0], vc->blocksize[1]); |
927 | 924 |
928 /* | 925 /* |
929 BLK=vc->blocksize_0; | 926 BLK=vc->blocksize[0]; |
930 for(i=0;i<BLK/2;++i) { | 927 for(i=0;i<BLK/2;++i) { |
931 vc->swin[i]=sin(0.5*3.14159265358*(sin(((float)i+0.5)/(float)BLK*3.14159265358))*(sin(((float)i+0.5)/(float)BLK*3.14159265358))); | 928 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))); |
932 } | 929 } |
933 */ | 930 */ |
934 | 931 |
935 return 0; | 932 return 0; |
936 } | 933 } |
1543 if (vc->modes[mode_number].blockflag) { | 1540 if (vc->modes[mode_number].blockflag) { |
1544 previous_window=get_bits1(gb); | 1541 previous_window=get_bits1(gb); |
1545 next_window=get_bits1(gb); | 1542 next_window=get_bits1(gb); |
1546 } | 1543 } |
1547 | 1544 |
1548 blocksize=vc->modes[mode_number].blockflag ? vc->blocksize_1 : vc->blocksize_0; | 1545 blocksize=vc->blocksize[vc->modes[mode_number].blockflag]; |
1549 memset(ch_res_ptr, 0, sizeof(float)*vc->audio_channels*blocksize/2); //FIXME can this be removed ? | 1546 memset(ch_res_ptr, 0, sizeof(float)*vc->audio_channels*blocksize/2); //FIXME can this be removed ? |
1550 memset(ch_floor_ptr, 0, sizeof(float)*vc->audio_channels*blocksize/2); //FIXME can this be removed ? | 1547 memset(ch_floor_ptr, 0, sizeof(float)*vc->audio_channels*blocksize/2); //FIXME can this be removed ? |
1551 | 1548 |
1552 // Decode floor | 1549 // Decode floor |
1553 | 1550 |
1616 // MDCT, overlap/add, save data for next overlapping FPMATH | 1613 // MDCT, overlap/add, save data for next overlapping FPMATH |
1617 | 1614 |
1618 for(j=0;j<vc->audio_channels;++j) { | 1615 for(j=0;j<vc->audio_channels;++j) { |
1619 uint_fast8_t step=vc->audio_channels; | 1616 uint_fast8_t step=vc->audio_channels; |
1620 uint_fast16_t k; | 1617 uint_fast16_t k; |
1621 float *saved=vc->saved+j*vc->blocksize_1/2; | 1618 float *saved=vc->saved+j*vc->blocksize[1]/2; |
1622 float *ret=vc->ret; | 1619 float *ret=vc->ret; |
1623 const float *lwin=vc->lwin; | 1620 const float *lwin=vc->win[1]; |
1624 const float *swin=vc->swin; | 1621 const float *swin=vc->win[0]; |
1625 float *buf=vc->buf; | 1622 float *buf=vc->buf; |
1626 float *buf_tmp=vc->buf_tmp; | 1623 float *buf_tmp=vc->buf_tmp; |
1627 | 1624 |
1628 ch_floor_ptr=vc->channel_floors+j*blocksize/2; | 1625 ch_floor_ptr=vc->channel_floors+j*blocksize/2; |
1629 | 1626 |
1630 saved_start=vc->saved_start; | 1627 saved_start=vc->saved_start; |
1631 | 1628 |
1632 vc->mdct0.fft.imdct_calc(vc->modes[mode_number].blockflag ? &vc->mdct1 : &vc->mdct0, buf, ch_floor_ptr, buf_tmp); | 1629 vc->mdct[0].fft.imdct_calc(&vc->mdct[vc->modes[mode_number].blockflag], buf, ch_floor_ptr, buf_tmp); |
1633 | 1630 |
1634 //FIXME process channels together, to allow faster simd vector_fmul_add_add? | 1631 //FIXME process channels together, to allow faster simd vector_fmul_add_add? |
1635 if (vc->modes[mode_number].blockflag) { | 1632 if (vc->modes[mode_number].blockflag) { |
1636 // -- overlap/add | 1633 // -- overlap/add |
1637 if (previous_window) { | 1634 if (previous_window) { |
1638 vc->dsp.vector_fmul_add_add(ret+j, buf, lwin, saved, vc->add_bias, vc->blocksize_1/2, step); | 1635 vc->dsp.vector_fmul_add_add(ret+j, buf, lwin, saved, vc->add_bias, vc->blocksize[1]/2, step); |
1639 retlen=vc->blocksize_1/2; | 1636 retlen=vc->blocksize[1]/2; |
1640 } else { | 1637 } else { |
1641 int len = (vc->blocksize_1-vc->blocksize_0)/4; | 1638 int len = (vc->blocksize[1]-vc->blocksize[0])/4; |
1642 buf += len; | 1639 buf += len; |
1643 vc->dsp.vector_fmul_add_add(ret+j, buf, swin, saved, vc->add_bias, vc->blocksize_0/2, step); | 1640 vc->dsp.vector_fmul_add_add(ret+j, buf, swin, saved, vc->add_bias, vc->blocksize[0]/2, step); |
1644 k = vc->blocksize_0/2*step + j; | 1641 k = vc->blocksize[0]/2*step + j; |
1645 buf += vc->blocksize_0/2; | 1642 buf += vc->blocksize[0]/2; |
1646 if(vc->exp_bias){ | 1643 if(vc->exp_bias){ |
1647 for(i=0; i<len; i++, k+=step) | 1644 for(i=0; i<len; i++, k+=step) |
1648 ((uint32_t*)ret)[k] = ((uint32_t*)buf)[i] + vc->exp_bias; // ret[k]=buf[i]*(1<<bias) | 1645 ((uint32_t*)ret)[k] = ((uint32_t*)buf)[i] + vc->exp_bias; // ret[k]=buf[i]*(1<<bias) |
1649 } else { | 1646 } else { |
1650 for(i=0; i<len; i++, k+=step) | 1647 for(i=0; i<len; i++, k+=step) |
1651 ret[k] = buf[i] + fadd_bias; | 1648 ret[k] = buf[i] + fadd_bias; |
1652 } | 1649 } |
1653 buf=vc->buf; | 1650 buf=vc->buf; |
1654 retlen=vc->blocksize_0/2+len; | 1651 retlen=vc->blocksize[0]/2+len; |
1655 } | 1652 } |
1656 // -- save | 1653 // -- save |
1657 if (next_window) { | 1654 if (next_window) { |
1658 buf += vc->blocksize_1/2; | 1655 buf += vc->blocksize[1]/2; |
1659 vc->dsp.vector_fmul_reverse(saved, buf, lwin, vc->blocksize_1/2); | 1656 vc->dsp.vector_fmul_reverse(saved, buf, lwin, vc->blocksize[1]/2); |
1660 saved_start=0; | 1657 saved_start=0; |
1661 } else { | 1658 } else { |
1662 saved_start=(vc->blocksize_1-vc->blocksize_0)/4; | 1659 saved_start=(vc->blocksize[1]-vc->blocksize[0])/4; |
1663 buf += vc->blocksize_1/2; | 1660 buf += vc->blocksize[1]/2; |
1664 for(i=0; i<saved_start; i++) | 1661 for(i=0; i<saved_start; i++) |
1665 ((uint32_t*)saved)[i] = ((uint32_t*)buf)[i] + vc->exp_bias; | 1662 ((uint32_t*)saved)[i] = ((uint32_t*)buf)[i] + vc->exp_bias; |
1666 vc->dsp.vector_fmul_reverse(saved+saved_start, buf+saved_start, swin, vc->blocksize_0/2); | 1663 vc->dsp.vector_fmul_reverse(saved+saved_start, buf+saved_start, swin, vc->blocksize[0]/2); |
1667 } | 1664 } |
1668 } else { | 1665 } else { |
1669 // --overlap/add | 1666 // --overlap/add |
1670 if(vc->add_bias) { | 1667 if(vc->add_bias) { |
1671 for(k=j, i=0;i<saved_start;++i, k+=step) | 1668 for(k=j, i=0;i<saved_start;++i, k+=step) |
1672 ret[k] = saved[i] + fadd_bias; | 1669 ret[k] = saved[i] + fadd_bias; |
1673 } else { | 1670 } else { |
1674 for(k=j, i=0;i<saved_start;++i, k+=step) | 1671 for(k=j, i=0;i<saved_start;++i, k+=step) |
1675 ret[k] = saved[i]; | 1672 ret[k] = saved[i]; |
1676 } | 1673 } |
1677 vc->dsp.vector_fmul_add_add(ret+k, buf, swin, saved+saved_start, vc->add_bias, vc->blocksize_0/2, step); | 1674 vc->dsp.vector_fmul_add_add(ret+k, buf, swin, saved+saved_start, vc->add_bias, vc->blocksize[0]/2, step); |
1678 retlen=saved_start+vc->blocksize_0/2; | 1675 retlen=saved_start+vc->blocksize[0]/2; |
1679 // -- save | 1676 // -- save |
1680 buf += vc->blocksize_0/2; | 1677 buf += vc->blocksize[0]/2; |
1681 vc->dsp.vector_fmul_reverse(saved, buf, swin, vc->blocksize_0/2); | 1678 vc->dsp.vector_fmul_reverse(saved, buf, swin, vc->blocksize[0]/2); |
1682 saved_start=0; | 1679 saved_start=0; |
1683 } | 1680 } |
1684 } | 1681 } |
1685 vc->saved_start=saved_start; | 1682 vc->saved_start=saved_start; |
1686 | 1683 |