OverlapAdd.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 OVERLAPADD_H_
#define OVERLAPADD_H_

#ifndef _MSC_VER
#include "Sox.H"
#else
// Note : Microsoft doesn't understand the different between upper and lower case in file names.
// on microsoft, you have to manually rename Sox.H to SoxWindows.H
#include "SoxWindows.H"
#endif

#define OVERLAP_DEFAULT 0.5
#define WINDOWSIZE_DEFAULT 2048

#include "Debug.H"
#define OVERLAPADD_CHCNT_ERROR OVERLAPADD_ERROR_OFFSET-1 
#define OVERLAPADD_FILESIZE_MISMATCH_ERROR OVERLAPADD_ERROR_OFFSET-2 
#define OVERLAPADD_FACTOR_TOO_LARGE_ERROR OVERLAPADD_ERROR_OFFSET-3 


class OverlapAddDebug : public SoxDebug {
public:
    OverlapAddDebug() {
#ifndef NDEBUG
        errors[OVERLAPADD_CHCNT_ERROR]=string("OverlapAdd: The requested channel is larger then the number available in the input audio file. If in the last window, this error will not be thrown. ");
        errors[OVERLAPADD_FILESIZE_MISMATCH_ERROR]=string("OverlapAdd: The requested number of audio samples can't be read from the input audio file. ");
#endif
    }
};

template<class TYPE>
class OverlapAdd {
    float overlapFactor; 

    void init(float factor) {
        if (factor >= 1.) {
            cerr<<"OverlapAdd::init The specified factor "<<factor<<" is >= 1. This is not allowed : ERROR : exiting."<<endl;
            exit(OVERLAPADD_FACTOR_TOO_LARGE_ERROR);
        }
        overlapFactor=factor;
        data.resize(WINDOWSIZE_DEFAULT,2); // ensure that the default window size is reasonable
    }

protected:
    Eigen::Matrix<TYPE, Eigen::Dynamic, Eigen::Dynamic> data;

public:

    OverlapAdd(void) {
        init(OVERLAP_DEFAULT);
    }

    OverlapAdd(float factor) {
        init(factor);
    }

    virtual ~OverlapAdd() {
    }
//
//    template<class TYPE>
//    void loadData(const Eigen::Matrix<TYPE, Eigen::Dynamic, 1> &dataIn, uint windowSize){
//        uint windowCnt=(int)floor((float)dataIn.rows()/(float)windowSize); // find the number of full segments
//        uint rem=dataIn.rows()-windowCnt*windowSize; // find the remainder
//        uint totalWindowCnt=windowCnt+((rem)?1:0);
//        if (data.rows()!=windowSize || data.columns()!=totalWindowCnt)
//            data.resize(windowSize,totalWindowCnt);
//        data.block(0,0,windowSize, windowCnt)=dataIn.block(0,0,windowCnt*windowSize,1).reshape(windowSize,windowCnt);
//        if (totalWindowCnt!=windowCnt){
//            data.block(0,totalWindowCnt-1,windowSize, 1)=Eigen::Matrix<TYPE, Eigen::Dynamic, 1>::Zeros(windowSize,1);
//            data.block(0,totalWindowCnt-1,rem, 1)=dataIn.block(windowSize*windowCnt, 0, rem, 1);
//        }
//    }

    int loadData(Sox<float> &sox, uint windowSize, uint sampleCount, int whichCh=0) {
        int ret=NO_ERROR;
        if ((ret=sox.getChCntIn())<0) // check whether the file is opened
            return ret;
        if (whichCh+1>sox.getChCntIn())
            return OVERLAPADD_CHCNT_ERROR;

        uint N=(uint)floor((float)windowSize*overlapFactor); // the number of samples in the overlap region
        uint M=windowSize-N; // the number of samples to load in each time the audio file is read

//        cout<<"N="<<N<<endl;
//        cout<<"M="<<M<<endl;

        //cout<<15.-(float)sampleCount/(float)windowSize/(1.-overlapFactor)<<endl;
        uint windowCnt=(int)(ceil((float)((float)sampleCount/(float)windowSize/(1.-overlapFactor)))); // find the number of full segments
        cout<<"sampleCount="<<sampleCount<<endl;
        cout<<"windowCnt="<<windowCnt<<'\t'<<15.-windowCnt<<endl;
        cout<<"windowSize="<<windowSize<<endl;

        if (data.cols()!=windowSize || data.rows()!=windowCnt)
            data.resize(windowSize, windowCnt);
        data=Eigen::Matrix<TYPE, Eigen::Dynamic, Eigen::Dynamic>::Zero(windowSize, windowCnt);

        ret=NO_ERROR;
        Eigen::Matrix<TYPE, Eigen::Dynamic, Eigen::Dynamic> audioData;
        for (int i=0; i<windowCnt; i++) {
            int toRead=M;
            (i==0) ? toRead=windowSize : toRead=M;
            if (i==windowCnt-1) toRead+=N; // if this is the last window, then try to read an extra overlap region
            if (toRead>sampleCount+N)
                toRead=sampleCount+N; // make sure not to read too many samples
            //cout<<"toRead "<<toRead<<'\t';
            if (toRead>0) {
                int cnt=sox.read(audioData, toRead);
                //cout<<"read "<<audioData.rows()<<endl;
                if (cnt<0 && cnt!=SOX_EOF_OR_ERROR)
                    return SoxDebug().evaluateError(cnt);
                if (audioData.rows()!=toRead) {
                    ret=windowCnt-toRead;
                    if (i!=windowCnt-1)
                        ret=OVERLAPADD_FILESIZE_MISMATCH_ERROR;
                }
            } else
                audioData=Eigen::Matrix<TYPE, Eigen::Dynamic, Eigen::Dynamic>::Zero(M, whichCh+1);
            //cout<<audioData.transpose()<<endl;
            sampleCount-=audioData.rows(); // keep track of the number read
            if (i==0) // The first window contains a full window of data
                data.block(0, i, audioData.rows(), 1)=audioData.block(0, whichCh, audioData.rows(), 1); // load in the new samples to the end of the window
            else
                data.block(N, i, audioData.rows(), 1)=audioData.block(0, whichCh, audioData.rows(), 1); // load in the new samples to the end of the window
            if (i<windowCnt-1) // copy the overlap to the beginning of the next window - except the last window, in which case, don't copy as there are no more subsequent windows.
                data.block(0, i+1, N, 1)=data.block(windowSize-N, i, N, 1);
        }

        //cout<<data.transpose()<<endl;
        return ret;
    }

    int unloadData(Sox<float> &sox) {
        cout<<"OverlapAdd::unloadData"<<endl;
        int ret=NO_ERROR;
        if ((ret=sox.getChCntOut())<0) // check whether the file is opened
            return ret;
        uint windowSize=data.rows();
        uint N=(uint)floor((float)windowSize*overlapFactor); // the number of samples in the overlap region
        uint M=windowSize-N; // the number of samples to write out each time the audio file is written to.

//        cout<<"N="<<N<<endl;
//        cout<<"M="<<M<<endl;

        uint windowCnt=data.cols(); // find the number of output segments
//        cout<<"sampleCount="<<sampleCount<<endl;
//        cout<<"windowCnt="<<windowCnt<<endl;
//        cout<<"windowSize="<<windowSize<<endl;

        ret=NO_ERROR;
        Eigen::Matrix<TYPE, Eigen::Dynamic, Eigen::Dynamic> audioData(M,1); // the audio data is written out N+M samples at a time
        // create the windowing data using wndData as a temporary buffer.
        Eigen::Array<TYPE, Eigen::Dynamic, Eigen::Dynamic> wndFront, wndBack, wndData=Eigen::Array<TYPE, 1, Eigen::Dynamic>::LinSpaced(2*N,0.,M_PI-M_PI/(2*N)).sin().square().transpose();
        wndFront=wndData.block(0, 0, N, 1); // ramp up window
        wndBack=wndData.block(N, 0, N, 1); // ramp down window
        //cout<<wndFront<<"\n\n"<<wndBack<<endl;
        for (int i=0; i<windowCnt; i++) {
            int toWrite=M;
            (i==0) ? toWrite=N: toWrite=M;

//            cout<<"wndData = "<<wndData<<endl;
            if (i==0) // The first output
                wndData=data.block(0, i, N, 1); // simply copy the first N samples to the output buffer
            else
                wndData+=data.block(0, i, N, 1).array()*wndFront;
//            cout<<"wndData = "<<wndData<<endl;
//            cout<<endl;
            audioData.block(0, 0, N, 1)=wndData; // copy the windowed data into the first N samples
            if (windowSize-2*N > 0) // if we are underlapping, copy any extra unwindowed data over (NOTE: windowSize-2N = M-N)
                audioData.block(N, 0, M-N, 1)=data.block(N, i, M-N, 1); // copy the

            cout<<audioData.transpose()<<endl;

            wndData=data.block(windowSize-N, i, N, 1).array()*wndBack;

//                data.block(0, i, audioData.rows(), 1)=audioData.block(0, whichCh, audioData.rows(), 1); // load in the new samples to the end of the window
//            else
//                data.block(N, i, audioData.rows(), 1)=audioData.block(0, whichCh, audioData.rows(), 1); // load in the new samples to the end of the window
//            if (i<windowCnt-1) // copy the overlap to the beginning of the next window - except the last window, in which case, don't copy as there are no more subsequent windows.
//                data.block(0, i+1, N, 1)=data.block(windowSize-N, i, N, 1);

//            cout<<audioData<<endl;

            int cnt=sox.write(audioData);
            //cout<<"written "<<audioData.rows()<<endl;
            if (cnt!=audioData.rows())
                return SoxDebug().evaluateError(cnt);

            if (i==windowCnt-1) { // last window so copy the last block out.
                audioData=data.block(windowSize-N, i, N, 1);
            cout<<audioData.transpose()<<endl;
                cnt=sox.write(audioData);
                if (cnt!=audioData.rows())
                    return SoxDebug().evaluateError(cnt);
            }
        }

        //cout<<data.transpose()<<endl;
        return ret;
    }

    float getOverlapFactor() {
        return overlapFactor;
    }

    float getWindowSize() {
        return data.rows();
    }

    float getWindowCount() {
        return data.cols();
    }

    void dump(void) {
        cout<<data.transpose()<<endl;
    }

    TYPE getMaxVal(){
        //cout<<"getMaxVal "<<data.cwiseAbs().maxCoeff()<<endl;
        return data.cwiseAbs().maxCoeff();
    }
};
#endif // OVERLAPADD_H_