WSOLA.H

Go to the documentation of this file.

/* Copyright 2000-2018 Matt Flax <flatmax@flatmax.org>
   This file is part of GTK+ IOStream class set

   GTK+ IOStream is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GTK+ IOStream is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You have received a copy of the GNU General Public License
   along with GTK+ IOStream
 */
#ifndef WSOLA_H_
#define WSOLA_H_

#include "config.h"
#ifdef HAVE_EMSCRIPTEN
#include <emscripten/bind.h>
#endif

#ifdef _MSC_VER
#define MS_ROUND
#ifdef _MSC_VER
#define _USE_MATH_DEFINES
#endif
#include <math.h>

double round(double number) {
    return number < 0.0 ? ceil(number - 0.5) : floor(number + 0.5);
}
#endif

#include <Debug.H> 

#define WSOLA_MOD2_ERROR -10+WSOLA_ERROR_OFFSET 
#define WSOLA_NFRAMES_JACK_ERROR -11+WSOLA_ERROR_OFFSET 
#define WSOLA_ROWS_ERROR -12+WSOLA_ERROR_OFFSET 
#define WSOLA_COLS_ERROR -13+WSOLA_ERROR_OFFSET 


class WSOLADebug : virtual public Debug {
public:
    WSOLADebug() {
#ifndef NDEBUG
        errors[WSOLA_MOD2_ERROR]=std::string("Developer error : BUFF_SIZE must be divisible by 2. ");
        errors[WSOLA_NFRAMES_JACK_ERROR]=std::string("Jack nframes request error : Jack wants to process a number of frames which WSOLA can't handle. ");
        errors[WSOLA_ROWS_ERROR]=std::string("Row request error : You are trying to access beyond the end of the array. ");
        errors[WSOLA_COLS_ERROR]=std::string("Col request error : You are trying to access beyond the end of the array. ");
#endif
    }

    virtual ~WSOLADebug() {}
};

#include <Eigen/Dense>
using namespace Eigen;

typedef float FP_TYPE; 

#define FS_DEFAULT 48000. 
#define TAU 0.02 

#define DEFAULT_CH_CNT 1 

#define M_DEFAULT 3; 


class WSOLA {

    float fs; 

    int N; 
    int NO2; 
    int M; 
    int m; 
    double rem; 

    Array<FP_TYPE, Dynamic , Dynamic> buffer; 

    Array<FP_TYPE, Dynamic, Dynamic> wnd; 

    Array<FP_TYPE, Dynamic, Dynamic> nextOutput; 

    Array<FP_TYPE, Dynamic, Dynamic> simComp; 

    template<typename Derived>
    int findSimilarityInBuffer(const DenseBase<Derived> &buffer);

    template<typename Derived>
    FP_TYPE findSimilarity(const ArrayBase<Derived> &outputIn) {
        simComp=outputIn;
        simComp*=wnd;
        return rms(nextOutput-simComp);
    }

    template<typename Derived>
    FP_TYPE rms(const ArrayBase<Derived> &s) {
        //r=sqrt(mean(s.^2));
//        cout<<"norm"<<endl;
//        cout<<s.matrix().norm()<<endl;
        return s.matrix().norm();
    }

    void OLAWnd(void);

    int inputSamplesRequired; 

    void init(void);
public:

    Array<FP_TYPE, Dynamic, Dynamic> output; 
    Array<FP_TYPE, Dynamic, Dynamic> input; 

    WSOLA();

    WSOLA(int chCnt);

    virtual ~WSOLA(); 

#ifdef HAVE_EMSCRIPTEN
    int processOurInput(FP_TYPE timeScale) {
        return process(timeScale, input);
    }
#endif

    template<typename Derived>
    int process(FP_TYPE timeScale, const DenseBase<Derived> &input) {
//        cout<<"input : "<<endl;
//        cout<<input<<endl;
//        cout<<"buffer pre shift : "<<endl;
//        cout<<buffer<<endl;
        // shift the buffer on
        int chCnt=buffer.rows();
        buffer.block(0,0,chCnt,buffer.cols()-inputSamplesRequired)=buffer.block(0,inputSamplesRequired,chCnt,buffer.cols()-inputSamplesRequired);
//        cout<<"buffer post shift : "<<endl;
//        cout<<buffer<<endl;
        // load the required input samples into the buffer
        buffer.block(0,buffer.cols()-inputSamplesRequired,chCnt,inputSamplesRequired)=input.block(0,0,chCnt,inputSamplesRequired);
//        cout<<"buffer with input : "<<endl;
//        cout<<buffer<<endl;

        processInner(); // do the inner processing

        // shift on by the ratio of N/2
//        cout<<"rem "<<rem<<endl;
        double shiftOn=timeScale*NO2+rem;
//        cout<<"shiftOn "<<shiftOn<<endl;
        inputSamplesRequired=static_cast<int>(round(shiftOn));
//        cout<<"inputSamplesRequired "<<inputSamplesRequired<<endl;
        rem=shiftOn-(double)inputSamplesRequired;
//        cout<<"rem "<<rem<<endl;
        return inputSamplesRequired;
    }

    void processInner(void);

//    template<typename Derived>
//    int loadBuffer(, const DenseBase<Derived> &input);

    int getMaxInputSamplesRequired(void) {
        return NO2*(M+2);
    }

    int getSamplesRequired(void) {
        return inputSamplesRequired;
    }

    int getOutputSize(void){
        return NO2;
    }

    void reset(int chCnt);

    int noMoreAudio(){
        return inputSamplesRequired-=NO2;
    }

    int loadInput(int n, int m, FP_TYPE val);

    FP_TYPE unloadOutput(int n, int m);

    void setFS(float fsIn);

};

#endif // WSOLA_H_