JointMap修正

kss.py

@@ -5,13 +5,13 @@
 import math
 from util import read_signal, get_frame,separate_channels,add_signal,uniting_channles,write_signal
 from vad.ltsd import LTSD
-from voice_enhancement import SupectralSubtruction,MMSE_STSA
+from voice_enhancement import SupectralSubtruction,MMSE_STSA,JointMap
 
 WINSIZE=4096
 VADOFFSET = 1
-songfile='railgun.wav'
-karaokefile="railgun_offv.wav"
-outfile='railgun_ss.wav'
+songfile='sky.wav'
+karaokefile="sky_offv.wav"
+outfile='sky_jm.wav'
 
 class KaraokeFileLoader():
     def __init__(self,winsize):
@@ -64,11 +64,13 @@ def _alignment(self,ssignal,ksignal):
                 small=score
         return  start,index
 
+
 def subtruction(ssignal,ksignal,window,winsize):
     nf = len(ssignal_l)/(winsize/2) - 1
     out=sp.zeros(len(ssignal),sp.float32)
-    ss = SupectralSubtruction(winsize,window)
+    #ss = SupectralSubtruction(winsize,window)
     #ss = MMSE_STSA(winsize,window)
+    ss = JointMap(winsize,window)
     for no in xrange(nf):
         s = get_frame(ssignal, winsize, no)
         k = get_frame(ksignal, winsize, no)
@@ -149,7 +151,7 @@ def vad(vas,signal,winsize,window):
     #                               noverlap=WINSIZE/2, window=window)
     #plt.show()
 
-
+    """
     ltsd = LTSD(WINSIZE,window,5,lambda0=40)
     res_l,ltsds_l =  ltsd.compute_without_noise(sig_out_l)
     ltsd = LTSD(WINSIZE,window,5,lambda0=40)
@@ -167,7 +169,7 @@ def vad(vas,signal,winsize,window):
     sig_out_l = vad(res_l,sig_out_l,WINSIZE,window)
     sig_out_r = vad(res_l,sig_out_r,WINSIZE,window)
     print "vad is Done"
-
+    """
 
     result = uniting_channles(sig_out_l, sig_out_r)
     write_signal(outfile, params, result)

voice_enhancement.py

@@ -20,8 +20,23 @@ def compute(self,signal,noise):
         SY = SYr * sp.exp(SYp*1j)
         return sp.real(sp.ifft(SY))
 
+class SpectrumReconstruction():
+    def __init__(self,winsize,window,alpha=0.98):
+        self._window=window
+        self._G = sp.zeros(winsize,sp.float32)
+        self._prevGamma = sp.zeros(winsize,sp.float32)
+        self._alpha = alpha
+
+    def compute(self,signal,noise):
+        return signal
+
+    def _calc_aposteriori_snr(self,syr,nyr):
+        return syr**2.0/nyr**2.0
+
+    def _calc_apriori_snr(self,gamma):
+        return self._alpha*self._G**2 * self._prevGamma + (1.0-self._alpha)*sp.maximum(gamma-1.0, 0)#a priori s/n ratio
 
-class MMSE_STSA():
+class MMSE_STSA(SpectrumReconstruction):
     def __init__(self,winsize,window,alpha=0.98):
         self._window=window
         self._G = sp.zeros(winsize,sp.float32)
@@ -34,24 +49,26 @@ def compute(self,signal,noise):
         SYr = sp.absolute(SY)
         SYp = sp.angle(SY)
         NY = sp.fft(noise*self._window)
-        nlambda = sp.absolute(NY)
-        gamma = SYr**2.0/nlambda**2.0 #a-posteriori s/n ratio
-        xi = self._alpha*self._G**2 * self._prevGamma + (1.0-self._alpha)*sp.maximum(gamma-1.0, 0)#a priori s/n ratio
+        NYr = sp.absolute(NY)
+        gamma = self._calc_aposteriori_snr(SYr,NYr)
+        xi = self._calc_apriori_snr(gamma)
         self._prevGamma = gamma
         nu = gamma * xi / (1+xi)
         self._G = (self._gamma15*sp.sqrt(nu)/gamma)*sp.exp(-nu/2)*((1+nu)*spc.i0(nu/2)+nu*spc.i1(nu/2))
         idx = sp.isnan(self._G) + sp.isinf(self._G)
-        self._G[idx] = xi[idx] / ( xi[idx] + 1)
+        #self._G[idx] = xi[idx] / ( xi[idx] + 1)
+        self._G[idx] = 0.0
         Yr = self._G * SYr
         Yr = sp.maximum(Yr,0)
         Y = Yr * sp.exp(SYp*1j)
         return sp.real(sp.ifft(Y))
 
-class JointMap():
-    def __init__(self,winsize,window,mu=0.76,tau=1.92):
+class JointMap(SpectrumReconstruction):
+    def __init__(self,winsize,window,alpha=0.99,mu=1.74,tau=0.126):
         self._window=window
         self._G = sp.zeros(winsize,sp.float32)
         self._prevGamma = sp.zeros(winsize,sp.float32)
+        self._alpha = alpha
         self._mu = mu
         self._tau = tau
 
@@ -60,11 +77,15 @@ def compute(self,signal,noise):
         SYr = sp.absolute(SY)
         SYp = sp.angle(SY)
         NY = sp.fft(noise*self._window)
-        nlambda = sp.absolute(NY)
-        gamma = SYr**2.0/nlambda**2.0 #a-posteriori s/n ratio
-        xi = self._alpha*self._G**2 * self._prevGamma + (1.0-self._alpha)*sp.maximum(gamma-1.0, 0)#a priori s/n ratio
+        NYr = sp.absolute(NY)
+        gamma = self._calc_aposteriori_snr(SYr,NYr)
+        xi = self._calc_apriori_snr(gamma)
+        self._prevGamma = gamma
         u = 0.5 - self._mu/(4.0*sp.sqrt(gamma*xi))
         self._G = u + sp.sqrt(u**2.0 + self._tau/(gamma*2.0))
+        idx = sp.isnan(self._G) + sp.isinf(self._G)
+        #self._G[idx] = xi[idx] / ( xi[idx] + 1)
+        self._G[idx] = 0.0
         Yr = self._G * SYr
         Y = Yr * sp.exp(SYp*1j)
         return sp.real(sp.ifft(Y))