精华内容
下载资源
问答
  • PYTHON 声音文件 频谱分析 FFT

    千次阅读 2019-06-13 09:23:25
    import os import time import wave import numpy as np import numpy.core._dtype_ctypes import multiprocessing import matplotlib.pylab as pl ...def fft_show(wavdata, Fr, figure_num, cmap0): N = Fr ...

    import os
    import time
    import wave
    import numpy as np
    import numpy.core._dtype_ctypes
    import multiprocessing
    import matplotlib.pylab as pl

    def fft_show(wavdata, Fr, figure_num, cmap0):
        N = Fr
        df = 1
        freq =[df*n for n in range(0, N)]
        c = np.fft.fft(wavdata[:N])
        print('len: {0}:{1}{2}{3}'.format(len(c), c[0], c[1], c[2]))

        d = int(len(c)/2)
        for index in range(d):
            print("freq:{0}, value:{1}".format(freq[index], abs(c[index])))

        fig, ax = pl.plt.subplots(1, 1)
        ax.plot(freq[:d-1], abs(c[:d-1]), color='red')
        ax.set_xlabel('Freq(HZ)')
        ax.set_ylabel('Y(freq)')
        pl.plt.show()

    def creat_figure(waveData, Fs, figure_num, cmap0):
        pl.plt.figure(figsize=(8, 4.0))
        print('Child process {0} {1} Running {2} '.format(figure_num, os.getpid(), time.time()))
        pl.specgram(waveData, NFFT=512, Fs=Fs, noverlap=256, pad_to=8192, mode='magnitude', scale='dB' \
                      , vmin=0, cmap=cmap0)
        print('Child process {0} {1} specgram {2} '.format(figure_num, os.getpid(), time.time()))
        #pl.plt.savefig('fft\\mono_%d.png'%(figure_num+1))
        #pl.plt.savefig('fft\\mono_%d.png'% (figure_num+1), dpi=100)
        pl.plt.savefig('fft\\mono_%d.png'% (figure_num+1), bbox_inches='tight')
        pl.plt.cla()
        print('Child process {0} {1} end {2} '.format(figure_num, os.getpid(), time.time()))

    if __name__ == '__main__':
        multiprocessing.freeze_support()
        time0 = time.time()
        wavefile = wave.open("d:\\1k.wav", 'rb')
        params = wavefile.getparams()
        nchannels, sample_width, framerate, numframe = params[:4]
        print("framerate:", framerate)
        print("sample_width:", sample_width)
        print("nchannels:", nchannels)
        print("numframe:", numframe)
        strData = wavefile.readframes(numframe)
        waveData = np.frombuffer(strData, dtype=np.int16)
        waveData = np.reshape(waveData, [numframe, nchannels])
        wavefile.close()
        # pl.plt.figure(figsize=(6.4, 4.0))
        cmap_fft = pl.plt.get_cmap('plasma')
        fft_show(waveData[:, 0], framerate, 0, cmap_fft)


        #p = multiprocessing.Pool(processes=4)
        #for num in range(nchannels):
            #p.apply_async(creat_figure, args=(waveData[:,num], numframe, num, cmap_fft))
            #p.apply_async(fft_show, args=(waveData[:, num], framerate, num, cmap_fft))
        #p.close()
        #p.join()
        print('Running time: %s Seconds' % (time.time() - time0))
     

    展开全文
  • 英尺声波 图形化快速傅立叶变换和声音文件的互相关 用您自己的两个声音文件替换/ app中的两个mp3文件 在根目录中启动一个简单的python服务器 转到localhost:portnum / app /查看比较
  • python读取wav文件并进行FFT变换

    千次阅读 2019-10-11 15:32:55
    WAV为微软公司(Microsoft)开发的一种声音文件格式,它符合RIFF(Resource Interchange File Format)文件规范,用于保存Windows平台的音频信息资源,被Windows平台及其应用程序所广泛支持,该格式也支持MSADPCM,...

    一、wav格式文件

    WAV为微软公司(Microsoft)开发的一种声音文件格式,它符合RIFF(Resource Interchange File Format)文件规范,用于保存Windows平台的音频信息资源,被Windows平台及其应用程序所广泛支持,该格式也支持MSADPCM,CCITT A LAW等多种压缩运算法,支持多种音频数字,取样频率和声道,标准格式化的WAV文件和CD格式一样,也是44.1K的取样频率,16位量化数字,因此在声音文件质量和CD相差无几! WAV打开工具是WINDOWS的媒体播放器。
      通常使用三个参数来表示声音,量化位数,取样频率和采样点振幅。量化位数分为8位,16位,24位三种,声道有单声道和立体声之分,单声道振幅数据为n1矩阵点,立体声为n2矩阵点,取样频率一般有11025Hz(11kHz) ,22050Hz(22kHz)和44100Hz(44kHz) 三种,不过尽管音质出色,但在压缩后的文件体积过大!相对其他音频格式而言是一个缺点,其文件大小的计算方式为:WAV格式文件所占容量(B) = (取样频率 X量化位数X 声道) X 时间 / 8 (字节= 8bit) 每一分钟WAV格式的音频文件的大小为10MB,其大小不随音量大小及清晰度的变化而变化。
      WAV是最接近无损的音乐格式,所以文件大小相对也比较大。

    二、python代码

    import wave
    from scipy.fftpack import fft,ifft
    import matplotlib.pyplot as plt
    import numpy as np
    
    def wave_read(path):
        '''#打开wav文件 ,open返回一个的是一个Wave_read类的实例,
        通过调用它的方法读取WAV文件的格式和数据'''
        f=wave.open(path,"rb")
        #一次性返回所有的WAV文件的格式信息,它返回的是一个组元(tuple):声道数, 量化位数(byte单位),
        # 采
        # 样频率, 采样点数, 压缩类型, 压缩类型的描述。wave模块只支持非压缩的数据,因此可以忽略最后两个信息'''
        params=f.getparams()
        # 读取波形数据
        nchannels, sampwidth, framerate, nframes=params[:4]
        # 读取声音数据,传递一个参数指定需要读取的长度(以取样点为单位)
        str_date=f.readframes(nframes)
        f.close()
        # 需要根据声道数和量化单位,将读取的二进制数据转换为一个可以计算的数组
        wave_date=np.frombuffer(str_date,dtype=np.short)
        # 将wave_data数组改为2列,行数自动匹配。在修改shape的属性时,需使得数组的总长度不变。
        wave_date.shape=-1,2
        # 转置数据,使成为2行的数据,方便下面时间匹配
        wave_date=wave_date.T
        #通过取样点数和取样频率计算出每个取样的时间,也就是周期T=采样单数/采样率
        time=np.arange(0,nframes)* (1.0/framerate)
        return wave_date,time
    
    def date_fft(data,time,start,end):
        #wavedata, wavetime = wave_read(path)
        t=[]
        y=[]
        for i in range(time.size):
            if ((time[i]>=start) & (time[i]<=end)):
                t=np.append(t,time[i])
                y=np.append(y,data[0][i])#取左声道
        n=len(t)# 信号长度
        yy=fft(y)
        yf=abs(yy)#取绝对值
        yf1=abs(fft(y))/n#归一化处理
        yf2=yf1[range(int(n/2))]##由于对称性,只取一半区间
    
        xf=np.arange(len(y))#频率
        xf1=xf
        xf2=xf[range(int(n/2))]#取一半区间
    
        #显示原始序列
        plt.figure()
        plt.subplot(221)
        plt.plot(t,y,'g')
        plt.xlabel("Time")
        plt.ylabel("Amplitude")
        plt.title("Original wave")
    
        #显示取绝对值后的序列
        plt.subplot(222)
        plt.plot(xf, yf)
        plt.xlabel("Freq (Hz)")
        plt.ylabel("|Y(freq)|")
        plt.title("FFT of Mixed wave(two sides frequency range",fontsize=7,color='#7A378B')
        # 注意这里的颜色可以查询颜色代码表
    
        #显示归一化处理后双边序列
        plt.subplot(223)
        plt.plot(xf1, yf1)
        # 注意这里的颜色可以查询颜色代码表
        plt.xlabel("Freq (Hz)")
        plt.ylabel("|Y(freq)|")
        plt.title('FFT of Mixed wave(Normalized processing)',fontsize=10,color='#F08080')
    
        # 显示归一化处理后单边序列
        plt.subplot(224)
        plt.plot(xf2, yf2, 'b')
        # 注意这里的颜色可以查询颜色代码表
        plt.xlabel("Freq (Hz)")
        plt.ylabel("|Y(freq)|")
        plt.title('FFT of Mixed wave',fontsize=10,color='#F08080')
    
        plt.show()
    
    
    wave_date, time=wave_read("01.wav")
    date_fft(wave_date,time,1,2)
    
    #左右声道的显示
    plt.figure()
    plt.subplot(211)
    plt.plot(time, wave_date[0])
    plt.title("Left channel")
    plt.subplot(212)
    plt.plot(time, wave_date[1], c="g")
    plt.title("Right channel")
    plt.show()
    
    

    三、图像显示

    1.左右声道的显示

    在这里插入图片描述

    2.FFT变换显示

    在这里插入图片描述

    四、参考文章

    1.Python读取麦克风保存成文件并进行FFT
    2.https://blog.csdn.net/weixin_32393347/article/details/85273820
    3.https://blog.csdn.net/qq_39516859/article/details/79819276
    4.https://blog.csdn.net/jeffrey2010/article/details/77427451

    展开全文
  • FFT功率谱可视化仪 可以在以下位置找到该应用程序的高质量演示。 该程序利用离散傅立叶变换获得音频文件的时频域。 结果可以解释如下: 在程序的顶部,我们可以看到原始时间振幅数据,因为它可以在任何WAV文件中...
  • 对声音信号进行加密,将声音文件在时间轴上分割成几段,分别将段的秩序及某些段内的秩序颠倒,从而实现了对声音文件的加密。首先,先读取一个声音信号,对信号做1024点FFT变换,取完点之后,分成四个向量,四个向量...
  • audio-to-midi接收声音文件,并将其转换为多通道MIDI文件。 它通过以用户指定的时间步长在音频数据的所有通道上执行FFT来实现此目的。 然后将得到的频率分析分为与十二个音阶相对应的等效类; 每个类别的音量是其...
  • 保存wave文件-&gt;打开wave并进行FFT。 当时用Spectrogram 16这款软件达到了演示的目的。 想继续往下做,应该要参考这篇文。   ------------------------------------------------------- 这是本人在csdn...

    FFT的结果是跟窗口有关的。我目的是想实时读取麦克风的,但目前只做到读取麦克风录音->保存wave文件->打开wave并进行FFT。

    当时用Spectrogram 16这款软件达到了演示的目的。

    想继续往下做,应该要参考这篇文

     

    -------------------------------------------------------

    这是本人在csdn的第一篇博文,以前的博客是http://kken0206.blog.163.com/

    旧博客基本上是自己玩的,163博客圈十分窄。今天发现系统还会自动删评论,一怒之下,决定要换了。

    在此慢慢积累和互联网有关的知识。。

     

     

    一、环境

    XP Python 3.4

    二、安装必须包:
    1、安装python3.4
    2、https://pypi.org搜索pyaudio并pip install whl
    3、pip install numpy scipy matlablib
    4、参考http://www.squirrel-electronics.com/zai-pythonxia-shi-shi-xian-shi-mai-ke-feng-bo-xing-yu-pin-pu.html run demo: https://github.com/licheegh/dig_sig_py_study/tree/master/Analyse_Microphone

     

    三、Python 上FFT例子

    https://blog.csdn.net/ouening/article/details/71079535

     

    四、Python--pyaudio声卡录音

    https://blog.csdn.net/xsc_c/article/details/8944655

     

    五、Python--pyAudio播放wav格式声音

    https://blog.csdn.net/xsc_c/article/details/8944077

     

    六、TODO: 打开wav文件并进行FFT分析

    #!usr/bin/env python
    #coding=utf-8
     
    from tkinter import *
    import wave
    from scipy.fftpack import fft,ifft
    import matplotlib.pyplot as plt
    import numpy as np
     
    def read_wave_data(file_path):
    	#open a wave file, and return a Wave_read object
    	f = wave.open(file_path,"rb")
    	#read the wave's format infomation,and return a tuple
    	params = f.getparams()
    	#get the info
    	nchannels, sampwidth, framerate, nframes = params[:4]
    	#Reads and returns nframes of audio, as a string of bytes. 
    	str_data = f.readframes(nframes)
    	#close the stream
    	f.close()
    	#turn the wave's data to array
    	wave_data = np.fromstring(str_data, dtype = np.short)
    	#for the data is stereo,and format is LRLRLR...
    	#shape the array to n*2(-1 means fit the y coordinate)
    	wave_data.shape = -1, 2
    	#transpose the data
    	wave_data = wave_data.T
    	#calculate the time bar
    	time = np.arange(0, nframes) * (1.0/framerate)
    	return wave_data, time
    
    def data_fft(data, time, time_start, time_end):
            #短时fft。截取一段时间内的数据先
            #time_start是开始时间,time_end是结束时间
            t = []
            y = []
            count = 0
            #for i in time:
            for i in range(time.size):
                    if((time[i] >= time_start) & (time[i] <= time_end)):
                            count = count + 1
                            t = np.append(t, time[i])
                            y = np.append(y, data[0][i])    #只提取左声道
            #print (count)
                            
            yy=fft(y)                  #快速傅里叶变换
            yreal = yy.real               # 获取实数部分
            yimag = yy.imag               # 获取虚数部分
    
                    
            yf=abs(fft(y))                # 取绝对值
            yf1=abs(fft(y))/len(t)           #归一化处理
            yf2 = yf1[range(int(len(t)/2))]  #由于对称性,只取一半区间
    
            xf = np.arange(len(y))        # 频率
            xf1 = xf
            xf2 = xf[range(int(len(t)/2))]  #取一半区间
    
            plt.figure()
            
            plt.subplot(221)
            plt.plot(t, y)   
            plt.title('Original wave')
    
            plt.subplot(222)
            plt.plot(xf,yf,'r')
            plt.title('FFT of Mixed wave(two sides frequency range)',fontsize=7,color='#7A378B')  #注意这里的颜色可以查询颜色代码表
    
            plt.subplot(223)
            plt.plot(xf1,yf1,'g')
            plt.title('FFT of Mixed wave(normalization)',fontsize=9,color='r')
    
            plt.subplot(224)
            plt.plot(xf2,yf2,'b')
            plt.title('FFT of Mixed wave)',fontsize=10,color='#F08080')
    
    
            plt.show()
            
            
    def main():
    	wave_data, time = read_wave_data('D:\Python34\myCode\\file1.wav')
    	
    	data_fft(wave_data, time, 1, 2)
    	
    	plt.figure()
    	#draw the wave
    	plt.subplot(211)
    	plt.plot(time, wave_data[0])
    	plt.subplot(212)
    	plt.plot(time, wave_data[1], c = "g")
    	plt.show()
    	
     
    if __name__ == "__main__":
    	main()
    

     

    展开全文
  • 声音信号编码和FFT解码

    千次阅读 2014-11-14 12:44:44
    队长是我们专业里的大牛,把这个开源软件改写了,但是发现声音传送的的速度无法满足要求,于是转而研究音频传输文件。好了,我说了队长是大牛,可是在研究的时候遇到一个问题,就是要将声音信号采集,然后将声音的...

            最近我在一个队伍里参加SOLVEFOR TOMORROM探知未来2014年全国青年科普创新实践暨作品大赛。从广州赛区毫无悬念地进入到北京赛区决赛,然后决赛的规则更加恶心,这个时候队长提出要使用声音传递信号,网上是有个开源的软件:https://github.com/JesseGu/SinVoice

             队长是我们专业里的大牛,把这个开源软件改写了,但是发现声音传送的的速度无法满足要求,于是转而研究音频传输文件。好了,我说了队长是大牛,可是在研究的时候遇到一个问题,就是要将声音信号采集,然后将声音的时域信号转化为频域信号,这个时候就要用到FFT(快速傅里叶变换),队长见我一直在打酱油,就把这个任务交给了我。

           我当时心里就一个靠,哥去年的高数都差点挂了,傅里叶我去你大爷的,爷们儿不会啊。于是乎便上百度,找到的FFT算法采样点都特么要是2的整数次方,队长给我的却是4410个采样点,这尼玛我在百度里一番捣腾,要么就是写得太渣,要我自己去研究高数还不如弄死我。最后翻墙谷歌找到一个不错的FFT的Java算法,之后对其进行了修改。

           好的,现在来谈谈,我解决的问题。我要在0.1秒钟里用声音传输2个字节的数据,首先要对这段两个字节进行编码,例如我要传送的是0x31,0xA7,首先将其编码,片段如下:

    private final static double sampling_rate = 4410;
    	private static double[] encode = new double[4410];           //定义编码数组
    	private static boolean[] single = new boolean[16];       //定义标记数组
    	private static double[] t = new double[4410];
    
    public static double[] t_encode(){                     //初始化t
    		for(int i = 0; i < t.length; i++){
    			t[i] = (double) (1.0/sampling_rate*i);
    		}
    		return t;
    	}
    public static boolean[] single_encode(byte[] message){                 //编码single	
    		String ZERO="00000000";
    		String[] s_ = new String[2];
    		for(int i = 0; i < message.length; i++){
    			String s = Integer.toBinaryString(message[i]);
    			if(s.length() > 8){
    				s = s.substring(s.length() - 8);
    			}
    			else if(s.length() < 8){
    				s = ZERO.substring(s.length()) + s;
    			}
    //			System.out.println(s);
    			s_[i] = s;
    		}		
    		
    	    char[] c = new char[16];
    	    String se = s_[0] + s_[1];
    	    c = se.toCharArray();
    //	    System.out.println(c);
    	    for(int i = 0; i < 16; i++){
    	    	if( c[i] == '1'){
    	    		single[i] = true; 
    	    	}
    	    	else{
    	    		single[i] = false;
    	    	}
    	    }
    	    return single;
    	}
    	
    	public static double[] encode_(boolean[] single){                                 //初始化encode
    		for(int i = 0; i < encode.length; i++){
    			for(int j = 0; j < single.length; j++){
    				if(!single[j]) continue;
    				int rate = 4000 + 1000 * j;
    				encode[i] += 8 * Math.sin(2 * Math.PI * rate * t[i]);
    			}
    		}
    		return encode;
    	}
           上面的三个方法完成了对byte数组的编码,然后再通过声音发射出去,然后重点来了,下一个问题就是对采集的声音信号经过FFT处理,将频率散布在0 -- 44100HZ之间,在3000HZ到20000HZ之间取1000HZ为间隔设立信号点,3000HZ有峰值就代表start,4000HZ,5000HZ,6000HZ,......19000HZ刚好构成了两个字节,20000HZ代表end。FFT经过变换后是一个对称的图形,我们去前面2205个点判断峰值,并进行解码得到数组。废话不多说,上代码。

    FFT:

    public class FFT {
    	
    	
    	public static Complex[] fft(Complex[] x){
    		int N = x.length;
    		Complex[] y = new Complex[N];
    		y = x;
    		double[] real = new double[N];
    		double[] imag = new double[N];
    		for(int i = 0; i < N; i++){
    			real[i] = x[i].re;
    			imag[i] = x[i].im;
    		}
    		transform(real,imag);
    		for(int i = 0; i < N; i++){
    			y[i].re = real[i];
    			y[i].im = imag[i];
    		}
    		return y;
    	}
    	/* 
    	 * Computes the discrete Fourier transform (DFT) of the given complex vector, storing the result back into the vector.
    	 * The vector can have any length. This is a wrapper function.
    	 */
    	public static void transform(double[] real, double[] imag) {
    		if (real.length != imag.length)
    			throw new IllegalArgumentException("Mismatched lengths");
    		
    		int n = real.length;
    		if (n == 0)
    			return;
    		else if ((n & (n - 1)) == 0)  //N是2的整数次方
    			transformRadix2(real, imag);
    		else  //N不是2的整数次方,跳转到更为复杂的计算方法
    			transformBluestein(real, imag);
    	}
    	
    	
    	/* 
    	 * Computes the inverse discrete Fourier transform (IDFT) of the given complex vector, storing the result back into the vector.
    	 * The vector can have any length. This is a wrapper function. This transform does not perform scaling, so the inverse is not a true inverse.
    	 */
    	public static void inverseTransform(double[] real, double[] imag) {
    		transform(imag, real);
    	}
    	
    	
    	/* 
    	 * Computes the discrete Fourier transform (DFT) of the given complex vector, storing the result back into the vector.
    	 * The vector's length must be a power of 2. Uses the Cooley-Tukey decimation-in-time radix-2 algorithm.
    	 */
    	public static void transformRadix2(double[] real, double[] imag) {
    		// Initialization
    		if (real.length != imag.length)
    			throw new IllegalArgumentException("Mismatched lengths");
    		int n = real.length;
    		int levels = 31 - Integer.numberOfLeadingZeros(n);  // Equal to floor(log2(n))
    		if (1 << levels != n)
    			throw new IllegalArgumentException("Length is not a power of 2");
    		double[] cosTable = new double[n / 2];
    		double[] sinTable = new double[n / 2];
    		for (int i = 0; i < n / 2; i++) {
    			cosTable[i] = Math.cos(2 * Math.PI * i / n);
    			sinTable[i] = Math.sin(2 * Math.PI * i / n);
    		}
    		
    		// Bit-reversed addressing permutation
    		for (int i = 0; i < n; i++) {
    			int j = Integer.reverse(i) >>> (32 - levels);
    			if (j > i) {
    				double temp = real[i];
    				real[i] = real[j];
    				real[j] = temp;
    				temp = imag[i];
    				imag[i] = imag[j];
    				imag[j] = temp;
    			}
    		}
    		
    		// Cooley-Tukey decimation-in-time radix-2 FFT
    		for (int size = 2; size <= n; size *= 2) {
    			int halfsize = size / 2;
    			int tablestep = n / size;
    			for (int i = 0; i < n; i += size) {
    				for (int j = i, k = 0; j < i + halfsize; j++, k += tablestep) {
    					double tpre =  real[j+halfsize] * cosTable[k] + imag[j+halfsize] * sinTable[k];
    					double tpim = -real[j+halfsize] * sinTable[k] + imag[j+halfsize] * cosTable[k];
    					real[j + halfsize] = real[j] - tpre;
    					imag[j + halfsize] = imag[j] - tpim;
    					real[j] += tpre;
    					imag[j] += tpim;
    				}
    			}
    			if (size == n)  // Prevent overflow in 'size *= 2'
    				break;
    		}
    	}
    	
    	
    	/* 
    	 * Computes the discrete Fourier transform (DFT) of the given complex vector, storing the result back into the vector.
    	 * The vector can have any length. This requires the convolution function, which in turn requires the radix-2 FFT function.
    	 * Uses Bluestein's chirp z-transform algorithm.
    	 */
    	public static void transformBluestein(double[] real, double[] imag) {
    		// Find a power-of-2 convolution length m such that m >= n * 2 + 1
    		if (real.length != imag.length)
    			throw new IllegalArgumentException("Mismatched lengths");
    		int n = real.length;
    		if (n >= 0x20000000)
    			throw new IllegalArgumentException("Array too large");
    		int m = Integer.highestOneBit(n * 2 + 1) << 1;
    		
    		// Trignometric tables
    		double[] cosTable = new double[n];
    		double[] sinTable = new double[n];
    		for (int i = 0; i < n; i++) {
    			int j = (int)((long)i * i % (n * 2));  // This is more accurate than j = i * i
    			cosTable[i] = Math.cos(Math.PI * j / n);
    			sinTable[i] = Math.sin(Math.PI * j / n);
    		}
    		
    		// Temporary vectors and preprocessing
    		double[] areal = new double[m];
    		double[] aimag = new double[m];
    		for (int i = 0; i < n; i++) {
    			areal[i] =  real[i] * cosTable[i] + imag[i] * sinTable[i];
    			aimag[i] = -real[i] * sinTable[i] + imag[i] * cosTable[i];
    		}
    		double[] breal = new double[m];
    		double[] bimag = new double[m];
    		breal[0] = cosTable[0];
    		bimag[0] = sinTable[0];
    		for (int i = 1; i < n; i++) {
    			breal[i] = breal[m - i] = cosTable[i];
    			bimag[i] = bimag[m - i] = sinTable[i];
    		}
    		
    		// Convolution
    		double[] creal = new double[m];
    		double[] cimag = new double[m];
    		convolve(areal, aimag, breal, bimag, creal, cimag);
    		
    		// Postprocessing
    		for (int i = 0; i < n; i++) {
    			real[i] =  creal[i] * cosTable[i] + cimag[i] * sinTable[i];
    			imag[i] = -creal[i] * sinTable[i] + cimag[i] * cosTable[i];
    		}
    	}
    	
    	
    	/* 
    	 * Computes the circular convolution of the given real vectors. Each vector's length must be the same.
    	 */
    	public static void convolve(double[] x, double[] y, double[] out) {
    		if (x.length != y.length || x.length != out.length)
    			throw new IllegalArgumentException("Mismatched lengths");
    		int n = x.length;
    		convolve(x, new double[n], y, new double[n], out, new double[n]);
    	}
    	
    	
    	/* 
    	 * Computes the circular convolution of the given complex vectors. Each vector's length must be the same.
    	 */
    	public static void convolve(double[] xreal, double[] ximag, double[] yreal, double[] yimag, double[] outreal, double[] outimag) {
    		if (xreal.length != ximag.length || xreal.length != yreal.length || yreal.length != yimag.length || xreal.length != outreal.length || outreal.length != outimag.length)
    			throw new IllegalArgumentException("Mismatched lengths");
    		
    		int n = xreal.length;
    		xreal = (double[]) xreal.clone();
    		ximag = (double[]) ximag.clone();
    		yreal = (double[]) yreal.clone();
    		yimag = (double[]) yimag.clone();
    		
    		transform(xreal, ximag);
    		transform(yreal, yimag);
    		for (int i = 0; i < n; i++) {
    			double temp = xreal[i] * yreal[i] - ximag[i] * yimag[i];
    			ximag[i] = ximag[i] * yreal[i] + xreal[i] * yimag[i];
    			xreal[i] = temp;
    		}
    		inverseTransform(xreal, ximag);
    		for (int i = 0; i < n; i++) {  // Scaling (because this FFT implementation omits it)
    			outreal[i] = xreal[i] / n;
    			outimag[i] = ximag[i] / n;
    		}
    	}
    	
        // display an array of Complex numbers to standard output
        public static void show(Complex[] x, String title) {
            System.out.println(title);
            System.out.println("-------------------");
            for (int i = 0; i < x.length; i++) {
                System.out.println(x[i]);
            }
            System.out.println();
        }
        
        public static void main(String[] args) { 
            int N = Integer.parseInt("5");
            Complex[] x = new Complex[N];
    
            // original data
            for (int i = 0; i < N; i++) {
                x[i] = new Complex(i, 0);
                x[i] = new Complex(-2*Math.random() + 1, 0);
            }
            show(x, "x");
    
            // FFT of original data
            Complex[] y = fft(x);
            show(y, "y = fft(x)");
        }
    	
    }
    接下来是Complex:

    
    /*************************************************************************
     *  Compilation:  javac Complex.java
     *  Execution:    java Complex
     *
     *  Data type for complex numbers.
     *
     *  The data type is "immutable" so once you create and initialize
     *  a Complex object, you cannot change it. The "final" keyword
     *  when declaring re and im enforces this rule, making it a
     *  compile-time error to change the .re or .im fields after
     *  they've been initialized.
     *
     *  % java Complex
     *  a            = 5.0 + 6.0i
     *  b            = -3.0 + 4.0i
     *  Re(a)        = 5.0
     *  Im(a)        = 6.0
     *  b + a        = 2.0 + 10.0i
     *  a - b        = 8.0 + 2.0i
     *  a * b        = -39.0 + 2.0i
     *  b * a        = -39.0 + 2.0i
     *  a / b        = 0.36 - 1.52i
     *  (a / b) * b  = 5.0 + 6.0i
     *  conj(a)      = 5.0 - 6.0i
     *  |a|          = 7.810249675906654
     *  tan(a)       = -6.685231390246571E-6 + 1.0000103108981198i
     *
     *************************************************************************/
    
    public class Complex {
        public double re;   // the real part
        public double im;   // the imaginary part
    
        // create a new object with the given real and imaginary parts
        public Complex(double real, double imag) {
            re = real;
            im = imag;
        }
    
        // return a string representation of the invoking Complex object
        public String toString() {
            if (im == 0) return re + "";
            if (re == 0) return im + "i";
            if (im <  0) return re + " - " + (-im) + "i";
            return re + " + " + im + "i";
        }
    
        // return abs/modulus/magnitude and angle/phase/argument
        public double abs()   { return Math.hypot(re, im); }  // Math.sqrt(re*re + im*im)
        public double phase() { return Math.atan2(im, re); }  // between -pi and pi
    
        // return a new Complex object whose value is (this + b)
        public Complex plus(Complex b) {
            Complex a = this;             // invoking object
            double real = a.re + b.re;
            double imag = a.im + b.im;
            return new Complex(real, imag);
        }
    
        // return a new Complex object whose value is (this - b)
        public Complex minus(Complex b) {
            Complex a = this;
            double real = a.re - b.re;
            double imag = a.im - b.im;
            return new Complex(real, imag);
        }
    
        // return a new Complex object whose value is (this * b)
        public Complex times(Complex b) {
            Complex a = this;
            double real = a.re * b.re - a.im * b.im;
            double imag = a.re * b.im + a.im * b.re;
            return new Complex(real, imag);
        }
    
        // scalar multiplication
        // return a new object whose value is (this * alpha)
        public Complex times(double alpha) {
            return new Complex(alpha * re, alpha * im);
        }
    
        // return a new Complex object whose value is the conjugate of this
        public Complex conjugate() {  return new Complex(re, -im); }
    
        // return a new Complex object whose value is the reciprocal of this
        public Complex reciprocal() {
            double scale = re*re + im*im;
            return new Complex(re / scale, -im / scale);
        }
    
        // return the real or imaginary part
        public double re() { return re; }
        public double im() { return im; }
    
        // return a / b
        public Complex divides(Complex b) {
            Complex a = this;
            return a.times(b.reciprocal());
        }
    
        // return a new Complex object whose value is the complex exponential of this
        public Complex exp() {
            return new Complex(Math.exp(re) * Math.cos(im), Math.exp(re) * Math.sin(im));
        }
    
        // return a new Complex object whose value is the complex sine of this
        public Complex sin() {
            return new Complex(Math.sin(re) * Math.cosh(im), Math.cos(re) * Math.sinh(im));
        }
    
        // return a new Complex object whose value is the complex cosine of this
        public Complex cos() {
            return new Complex(Math.cos(re) * Math.cosh(im), -Math.sin(re) * Math.sinh(im));
        }
    
        // return a new Complex object whose value is the complex tangent of this
        public Complex tan() {
            return sin().divides(cos());
        }
        
    
    
        // a static version of plus
        public static Complex plus(Complex a, Complex b) {
            double real = a.re + b.re;
            double imag = a.im + b.im;
            Complex sum = new Complex(real, imag);
            return sum;
        }
    }
           最后求峰值我是直接设定一个高度,将FFT变换后的点取模值,然后设定一个高度,比如90000,大于10000的为1,就是峰值,其他的为0。这样就解码出来了。

          如果考虑到杂音的干扰,可以调高0bit的峰值,比如讲0bit的峰值改成1bit峰值的三分之一。

    展开全文
  • **功能实现:**读取音频文件的数据,取其中一部分数据,生成幅度谱,相位谱。 import numpy as np import pylab as plt import librosa from math import * import wave import time time_start=time.time() def ...
  • MATLAB 声音文件处理

    2019-10-06 05:47:30
    由于最近的Project要做声音分析,需要用到MATLAB,之前一直...言归正传,我们来讨论下用MATLAB做声音文件处理。 1. 读取WAV声音文件 % wavread(filename) 读取一个WAVE文件,并返回采样数据到向量y中,Fs表示采样...
  • FFT原理详解

    万次阅读 2016-01-18 19:29:37
    FFT是离散傅立叶变换的快速算法,可以将一个信号变换到频域。有些信号在时域上是很难看出什么特征的,但是如果变换到 频域之后,就很容易看出特征了。这就是很多信号分析采用FFT变换的原因。另外,FFT可以将一个...
  • 声音文件到频谱图/频谱实用程序 上图:频谱图显示0-22050 Hz频率扫描 上图:2khz方波的频谱 用法 sndspec filename [filename2 ...] [选项] Usage: sndspec filename [filename2 ...] [options] --dyn-range <n>...
  • 声音的时域、频域(FFT)波形实时可视化绘制 爱国者 发表于 2007年08月17日 浏览:1378 评论:4 源代码附件:1C#,.NET 1.0,.NET 2.0文章包含源代码1个,成功下载206次(请点击本文附件链接下载) <!--google_ad_client =...
  • 音频实时显示 FFT转换

    热门讨论 2012-11-16 23:25:26
    这是很久之前做的一个音频采集显示程序,只要你的电脑带MIC都能使用,打开以后,按信号采集然,可以选择原生模式或者FFT模式,停止采集后可以按播放播放采集的声音,可以根据自己的爱好加个文件保存(由于没有研究过...
  • 关于声音文件的波形图和频谱图

    万次阅读 2008-08-29 01:16:00
    我也想在界面上加上这样的些东西,经过几天的努力,声音文件的波形图已经会画了,原理也弄得很清楚,可是对于频谱图 的绘图却没有一点头绪,关键是对于FFT(快速傅立叶变换)弄不清楚,不知道FFT到底怎么对音频文件...
  • MATLAB对一段音频进行FFT处理,可以绘制出原声音信号的时域波形,可以比较出直接运算和蝶形运算的语音信号FFT频谱特性
  • 【STM32】使用STM32提供的DSP库进行FFT(附详细代码)

    万次阅读 多人点赞 2019-05-12 15:42:41
    最近,因为项目需要在STM32F103系列处理器上,对采集的音频信号进行FFT运算,然而STM32F103毕竟不是STM32F4系列的处理器,对于一般的FFT运算程序还是比较缓慢的。 幸亏官方提供了针对FFT的官方库,但是去官网找了...
  • matlab解析出声音文件的频率

    千次阅读 2019-09-29 16:59:44
    ff.wav 是一段频率为17640HZ的已知声音文件 贴上代码: 1 %1、%[X,Fs,Bit]=wavread('d:\\ff.wav'); 2 %2、然后进行特征提取 3 %3、然后分类器识别 4 %4、输出识别结果 5 %close all; 6 %clear all;.....
  • 输入可以是原始数据或 WAV 格式的声音文件,同样适用于输出。 安装 下载 git 存储库后,只需编写: make 为了绘制图形,您还需要在系统上安装 gnuplot(请参阅官方网页部分中的 gnuplot)。 用法 Usage: ./befft...
  • 该程序将读取经过校准的.wav文件,并允许用户对其进行分析,就像使用声级计分析声场一样。 该软件实现了快速,慢速,脉冲和LEQ。 A,C和单位加权; Ln和噪声剂量分析; 倍频程和1/3倍频程带分析; 高分辨率FFT分析和...
  • lf, rf = np.fft.rfft(left), np.fft.rfft(right) Roll the array to increase the pitch. lf, rf = np.roll(lf, shift), np.roll(rf, shift) The highest frequencies roll over to the lowest ones. That's not ...
  • STM32 FFT 音频处理

    千次阅读 2018-11-15 16:55:34
    制作过程: 1.准备材料: stm32f103核心板 1块 OLED12864显示屏 1块(SPI接口) ...声音检测传感器 1块 (咪头+放大电路 可以网上买现成的模块,也可根据后文提供的原理图自己做) 2.硬件连接...
  • mfcc中的fft操作What we should know about sound. Sound is produced when there’s an object that vibrates and those vibrations determine the oscillation of air molecules which creates an alternation of ...
  • STM32 FFT算法实现

    千次阅读 多人点赞 2020-08-21 12:08:16
    1, 添加文件。 首先,我们在例程工程目录下新建:DSP_LIB 文件夹,存放我们将要添加的文件: arm_cortexM4lf_math.lib 和相关头文件(文件由官方提供),如图: 然后,打开工程,新建 DSP_LIB 分组,并将 arm_...
  • MATLAB 声音文件分析、处理。

    万次阅读 2014-08-20 17:04:26
    言归正传,我们来讨论下用MATLAB做声音文件处理。 1. 读取WAV声音文件 [plain]   view plain copy % wavread(filename) 读取一个WAVE文件,并返回采样数据到向量y中...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,841
精华内容 736
关键字:

声音文件fft