WSOLA4Audiere.H

/* Copyright 2001-2005 Matt Flax <flatmax@ieee.org>
   This file is part of MFFM Time Scale Modification for Audio.

   MFFM Time Scale Modification for Audio 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.
   
   MFFM Time Scale Modification for Audio 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 MFFM Time Scale Modification for Audio
 */
#ifndef WSOLA4AUDIERE_H
#define WSOLA4AUDIERE_H


#include <audiere.h>
#include "WSOLA.H"

using namespace audiere;

#define DEF_TAU 1.0

namespace audiere {

  class WSOLA4Audiere : public RefImplementation<SampleSource> {
    
    int WSOLARead(int frame_count){
      int lastFrame=0;
      int framesProcessed=(int)((double)windowSize/2.0/(double)channels);
      //exit strategy
      if ((wsola->getSourceIndex()/channels+framesProcessed)>input.getEnd()){
        std::cout<<"last frame : exit as you wish"<<endl;
        lastFrame=1;
        //input-=framesProcessed;
        //setPosition(getLength());
        //              reset();
        //      return 0;
        std::cout<<"input.getEnd() "<<input.getEnd()<<"wsola->getSourceIndex()/channels "<<wsola->getSourceIndex()/channels<<endl;
        framesProcessed=input.getEnd()-wsola->getSourceIndex()/channels;
        std::cout<<"last frame : "<<framesProcessed<<" frames dropped"<<endl;
        if (lastFrameCallback)
          lastFrameCallback(callBackData);
        //                              if (callBackData)
        //                                      ::SendMessage((HWND)callBackData, WM_MESSAGETOAMIS, amis::AUDIO_CLIP_FINISHED, 0);
        return 0;
      }
      
      if (firstFrame){
        std::cout<<"firstFrame"<<endl;
        //load the input data to the buffer and then to wsola
        m_source->setPosition(wsola->getSourceIndex()/channels);//seek to the correct location
        int readCnt=m_source->read(wsola->getSourceLength()/channels, &(*input.window)[0]);
        //std::cout<<"read "<<readCnt<<" frames from the source : wanted "<<wsola->getSourceLength()/channels<<" frames"<<endl;
        wsola->initProcess(&(*input.window)[0], tau);
        //std::cout<<"wsola->getSourceLength() "<<wsola->getSourceLength()<<endl;
        //std::cout<<"readCnt="<<readCnt<<endl;
        firstFrame=0;
      }
      
      //load the input data to the buffer and then to wsola
      m_source->setPosition(wsola->getSourceIndex()/channels);//seek to the correct location
      //std::cout<<"here"<<endl;
      int readCnt;
      readCnt=m_source->read(wsola->getSourceLength()/channels, &(*input.window)[0]);
      //std::cout<<"read "<<readCnt<<" frames from the source : wanted "<<wsola->getSourceLength()/channels<<" frames"<<endl;
      wsola->loadSourceInput(&(*input.window)[0]);
      
      //Load desired input data
      m_source->setPosition(wsola->getDesiredIndex()/channels);//seek to the correct location
      readCnt=m_source->read(wsola->getDesiredLength()/channels, &(*input.window)[0]);
      
      wsola->loadDesiredInput(&(*input.window)[0]);
      
      //Process outputting to the local memory buffer 
      int ret=wsola->processFrame(output, tau); //process halfWindow
      if (ret<0){
        if (ret==WSOLA::INPUT_READ2DF_ERR)
          std::cout<<"Destination frame read error, most probably using a factor >=1.0 and at the end of the input file"<<endl;
        else if (ret==WSOLA::INPUT_READ2SF_ERR)
          std::cout<<"Source frame read error, most probably using a factor <1.0, and at the end of the input file"<<endl;
        else if (ret==WSOLA::WRITE_ERR)
          std::cout<<"Is your disk full, we encountered a write error"<<endl;
        else if (ret==WSOLA::PROCFFT_ERR)
          std::cout<<"Please contact the author - this error shouldn't occur."<<endl;
        else if (ret==WSOLA::DEFAULT_ERR)
          std::cout<<"Un-known default error encountered"<<endl;
        else //Handle other errors here
          std::cout<<"Unknown error - unreliable failure"<<endl;
      }
      
      if (lastFrame)
        reset();
      //        return WSOLA::FINISHED_NORMALLY;
      
      //std::cout<<input<<endl;
      return framesProcessed;
    }
  public:
    
    WSOLA4Audiere(SampleSourcePtr source, double ta=DEF_TAU, int startPoint=0, int endPoint=0, void (*lastFrameCallback_in)(void *)=NULL, void *callBackData_in=NULL) {
      m_source=source;
      if(source){
        source->getFormat(channels,fs,mSampleFormat);
        std::cout<<"file length is : "<<source->getLength()<<endl;
      } else {
        std::cout<<"WSOLA4Audiere(SampleSourcePtr source) : source doesn't exist !"<<endl;
        exit(-1);
      }
      
      //check source is seekable
      if (!m_source->isSeekable()){
        std::cout<<"WSOLA4Audiere(SampleSourcePtr source) : source is not seekable.\nspeed change may not work !"<<endl;
      }
      
      windowSize =channels*HANNING_LENGTH(fs);
      std::cout<<"windowSize="<<windowSize<<endl;
      // Make sure that the half window size is an integer number of channels
      while (remainder((double)windowSize /2.0/(double)channels, floor((double)windowSize /2.0/(double)channels)) != 0.0){
        windowSize ++;
      }
      std::cout<<"windowSize="<<windowSize<<endl;
      tau = ta;
      firstFrame = 1;
      wsola=0;
      wsola = new WSOLA (windowSize, fs, channels);//Version 2 instantiation;   
      if (!wsola){
        std::cout<<"WSOLA4Audiere(SampleSourcePtr source) : couldn't instantiate WSOLA"<<endl;
        exit(-1);
      }
      
      output=NULL; //Null the input / output buffers
      
      //Reserve local memory stores
      
      //set the input time code which holds the length of the audio
      // as well as the beginning, current and end locations
      // as well as a window for the input data
      input.init(startPoint,m_source->getLength()+1); //the point we want to start from
      setPosition(startPoint);
      (*input.window)=wsola->getSourceLength(); //Set the window size
      input.setFinish(m_source->getLength()+1); //Set the absolute length
      //std::cout<<input<<endl;
      //std::cout<<"endpoint "<<endPoint<<endl;
      if (endPoint!=0)//Guard against dummy entry
        if (endPoint<=input.getFinish()-1)
          input.setEnd(endPoint); //the point we want to end at
        else
          input.setEnd(input.getFinish()-1); //Force end at end of stream
      //This is default ...
      //input.setBeginning(0); //starts at zero time
      std::cout<<"input:\n"<<input<<endl;
      
      //Set up the output array
      output = new ATYPE[windowSize]; //The output store
      if (output==NULL){
        std::cout<<"error defining output memory"<<endl;
        exit(-2);
      }
      
      //set up the callback funciton
      lastFrameCallback=lastFrameCallback_in;
      callBackData=callBackData_in;
    }
    
    ~WSOLA4Audiere(){
      if (wsola) delete wsola; wsola=NULL;
      if (output) delete [] output; output=NULL;
    }
    
    void ADR_CALL getFormat(int& channel_count, int& sample_rate, SampleFormat& sample_format){
      m_source->getFormat(channel_count,sample_rate,sample_format);
      std::cout<<"channel_count,sample_rate,sample_format"<<channel_count<<'\t'<<sample_rate<<'\t'<<sample_format<<endl;
      if (GetSampleSize(sample_format)!=wsola->getFrameSize())
        printf("Difference between Audiere (%d bytes) and WSOLA (%d bytes) frame sizes ... should be OK as long as WSOLA > Audiere",GetSampleSize(sample_format),wsola->getFrameSize());
    }
    
    int ADR_CALL read(int frame_count, void* buffer) {
      //std::cout<<"request frame_count "<<frame_count<<endl;
      int framesProcessed=0, realSize=(int)((double)windowSize/2.0/(double)channels);
      //std::cout<<"framesProcessed "<<framesProcessed<<" realSize "<<realSize<<endl;
      while ((framesProcessed+realSize)<frame_count){
        int oneCycleCnt=WSOLARead(realSize);
        if (oneCycleCnt>0){
          memcpy(&((ATYPE*)buffer)[framesProcessed*channels], output,oneCycleCnt*channels*sizeof(ATYPE));
          framesProcessed+=oneCycleCnt;
        } else
          break;
      }
      //std::cout<<"returning "<<framesProcessed<<" wanted "<<frame_count<<endl;
      return framesProcessed;
    }
    
    void ADR_CALL reset() {
      m_source->reset();
      wsola->reset();
    }
    
    bool ADR_CALL isSeekable() {
      return m_source->isSeekable();
    }
    int  ADR_CALL getLength() {
      return m_source->getLength();
    }
    
    void ADR_CALL setPosition(int position){
      m_source->setPosition(position);
      wsola->setPosition(position*channels);
      input=position;
    }
    
    int  ADR_CALL getPosition(){
      std::cout<<"getpos"<<endl;
      //return input.getCount();
      return m_source->getPosition();
    }
    
    bool ADR_CALL getRepeat() {
      return m_source->getRepeat();
    }
    void ADR_CALL setRepeat(bool repeat){
      m_source->setRepeat(repeat);
    }
    void  setTau(float ta) {
      std::cout<<"setTau "<<ta<<endl;
      this->tau = ta;
      std::cout<<"tau is now "<<this->tau<<endl;
    }
    float getTau(){
      return tau;
    }
    
    int getTagCount() {return m_source->getTagCount();}
    const char* getTagKey(int i) {return m_source->getTagKey(i);}
    const char* getTagValue(int i) {return m_source->getTagValue(i);}
    const char* getTagType(int i) {return m_source->getTagType(i);}
    
  private:
    SampleSourcePtr m_source;
    
    WSOLA *wsola;
    
    int channels;
    int fs;
    SampleFormat mSampleFormat;
    int windowSize;
    
    float tau;
    int firstFrame;
    
    TIMECODETYPE_W input;
    ATYPE *output;
    
  public:
    void (*lastFrameCallback)(void *);
    void *callBackData;
  };
}
#endif

---