信号全体に対して再帰的ダウンサンプリングを行う
- x: 入力信号
- xd_raw:
  - xをダウンサンプリングした信号
  - [ダウンサンプリング1回の信号，ダウンサンプリング2回の信号，…，ダウンサンプリングN回目の信号]を格納するリスト
ダウンサンプリングされた信号からスペクトル算出に使う信号を切り出す
- xd:
  - xd = np.zeros((self.n_octave, n_frames, self.n_fft_1oct))
  - xd_rawから各オクターブk で hop_length_ds = hop_length // 2 ** kずらしながら格納していく
- xd_fftは xdの各ベクトルをFFTした信号
- 高速化のため numba を利用
スペクトルカーネルを使ってCQTスペクトルを計算

再帰的ダウンサンプリング法の実装し始めは、xd_rawとxdの違いが分かりにくかったです。
xdはxd_rawの一部を切り出していることに注意してください。

    def stcqt_batch(self, x):
        n_frames = len(x) // self.hop_length
        
        n_x_adjust = 2 ** (self.n_octave-1)
        n_pad = n_x_adjust - (len(x) + self.n_fft) % n_x_adjust
        len_x = len(x) + self.n_fft + n_pad

        # 1. recursive downsampling
        xd_raw = np.zeros((self.n_octave, len_x))
        tmp_x  = np.zeros(len_x)
        xd_raw[0, 0:len(x)] = x[:]
        for k in range(1, self.n_octave):
            idx1 = len_x  // 2 ** (k-1)
            idx2 = idx1 // 2
            tmp_x[0:idx1]     = filtfilt(self.lpf_b, self.lpf_a, xd_raw[k-1, 0:idx1]) #lfilter
            xd_raw[k, 0:idx2] = tmp_x[0:idx1][::2]
            #xd_raw[k, 0:idx2] =  resampy.resample(xd_raw[k-1, 0:idx1], self.sr/ 2**(k-1), self.sr/ 2**k, filter='kaiser_fast')
           
        # 2. make xd
        xd     = np.zeros((self.n_octave, n_frames, self.n_fft_1oct))
        _batch_make_xd(xd_raw, xd, 
                       self.n_octave, self.n_bpo, n_frames,
                       self.n_fft, self.n_fft_1oct, self.hop_length)
        del xd_raw, tmp_x 
                          
        # 3. calc. cqt-spec using spectral kernel by each octave
        spec = np.zeros([self.n_pitch, n_frames], dtype=np.complex128)
        xd_fft = np.zeros(self.n_fft_1oct, dtype=np.complex128)
        
        for k in range(0, self.n_octave):  
            st = self.n_bpo * (self.n_octave-k-1)           
            en = st + self.n_bpo
            
            for n in range(n_frames):
                xd_fft[:] = np.fft.fft(xd[k, n, :]) 
                spec[st:en, n] = np.dot(self.spectral_kernel, xd_fft)
                
        return spec

@jit('void(f8[:,:], f8[:,:,:], i8, i8, i8, i8, i8, i8)', nopython=True, nogil=True)
def _batch_make_xd(
        xd_raw, xd, 
        n_octave, n_bpo, n_frames,
        n_fft, n_fft_1oct, hop_length,
    ):
       
    for k in range(0, n_octave): 
        center_init = n_fft // 2 ** (k + 1)
        hop_length_ds = hop_length // 2 ** k
        
        for n in range(n_frames):
            center = center_init + n * hop_length_ds
            st = center - n_fft_1oct//2
            en = center + n_fft_1oct//2
            xd[k, n, :] = xd_raw[k, st:en]