Sox.H

Go to the documentation of this file.

/* This file was contributed by Deqx.com
   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 SOX_H_
#define SOX_H_

#if defined(_MSC_VER) || defined(__CYGWIN__)
#error On microsoft, please rename this file to SoxWindows.H and delete this line.
#endif

#include <Debug.H>
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wignored-attributes"
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#include <Eigen/Dense>
#pragma GCC diagnostic pop

#define SOX_READ_FILE_OPEN_ERROR SOX_ERROR_OFFSET-1 
#define SOX_CLOSE_FILE_ERROR SOX_ERROR_OFFSET-2 
#define SOX_READ_FILE_NOT_OPENED_ERROR SOX_ERROR_OFFSET-3 
#define SOX_EOF_OR_ERROR SOX_ERROR_OFFSET-4 
#define SOX_READ_MAXSCALE_ERROR SOX_ERROR_OFFSET-6 
#define SOX_WRITE_FILE_OPEN_ERROR SOX_ERROR_OFFSET-7 
#define SOX_WRITE_FILE_NOT_OPENED_ERROR SOX_ERROR_OFFSET-8 
#define SOX_WRITE_OUT_CHANNEL_MISMATCH SOX_ERROR_OFFSET-9 
#define SOX_WRITE_SAMPLES_WRITTEN_MISMATCH_ERROR SOX_ERROR_OFFSET-10 
#define SOX_ROW_BOUNDS_ERROR SOX_ERROR_OFFSET-11 
#define SOX_COL_BOUNDS_ERROR SOX_ERROR_OFFSET-12 

#include <sox.h>

#include <limits> // for NaN
#include <vector>
using namespace std;

#include "config.h"

class SoxDebug : virtual public Debug {
public:
    SoxDebug() {
#ifndef NDEBUG
                        errors[SOX_READ_FILE_OPEN_ERROR]=string("SOX: Couldn't open the input file");
                        errors[SOX_CLOSE_FILE_ERROR]=string("SOX: Couldn't open the output file");
                        errors[SOX_READ_FILE_NOT_OPENED_ERROR]=string("SOX: Couldn't read from file as the input file hasn't been opened yet");
                        errors[SOX_EOF_OR_ERROR]=string("SOX: Either an error or the EOF was hit whilst operating on the file");
                        errors[SOX_READ_MAXSCALE_ERROR]=string("SOX: couldn't open the max file to find the value to rescale the maximum to, if you continue the audio file will not be re-scaled correctly");
                        errors[SOX_WRITE_FILE_OPEN_ERROR]=string("SOX: Couldn't write to file as the output file hasn't been opened yet");
                        errors[SOX_WRITE_FILE_NOT_OPENED_ERROR]=string("SOX: Couldn't write to the file as the output file hasn't been opened yet");
                        errors[SOX_WRITE_OUT_CHANNEL_MISMATCH]=string("SOX: you provided data to write out which doesn't match the number of channels specified during openWrite for the output file");
      errors[SOX_WRITE_SAMPLES_WRITTEN_MISMATCH_ERROR]=string("SOX: The incorrect number of samples were written to file. ");
      errors[SOX_ROW_BOUNDS_ERROR]=string("SOX: Row larger then the matrix size error. ");
      errors[SOX_COL_BOUNDS_ERROR]=string("SOX: Col larger then the matrix size error. ");
#endif
    }

    virtual ~SoxDebug() {}
};

template<typename FP_TYPE_>
class Sox {
    sox_format_t *in; 
    double maxVal; 
    sox_format_t *out; 

    double outputMaxVal; 
    vector<sox_sample_t> outputBuffer; 

    int close(bool inputFile);

    static void output_message(unsigned level, const char *filename, const char *fmt, va_list ap);

public:
    Sox(); 
    virtual ~Sox(); 

    int openRead(string fileName);

    int openRead(intptr_t buffer, size_t len);

    template <typename Derived>
    int read(Eigen::DenseBase<Derived> &audioData, int count=0){
        typedef typename Derived::Scalar Scalar;
        int retVal=NO_ERROR; // start assuming no error
        if (in) { // if the input file has been opened...
            if (count==0) // if we want everything
                count = in->signal.length/in->signal.channels;
            Eigen::Array<sox_sample_t, Eigen::Dynamic, Eigen::Dynamic> readData(count*in->signal.channels,1); // generate the necessary data store to read into.
            size_t readCount=sox_read(in, readData.data(), count*in->signal.channels); // try to read
            if (readCount==SOX_EOF) { // if we hit the end of file or have an error
                retVal=SOX_EOF_OR_ERROR;
                audioData.resize(0,0);
            } else { // all requested audio has been read, now resize the readData and
                // ensure the audioData matrix is the correct size
                if (audioData.cols()!= in->signal.channels | audioData.rows()!=readCount/in->signal.channels)
                     audioData.derived().resize(readCount/in->signal.channels, in->signal.channels);
                if (!(maxVal != maxVal)) // if we know our desired maxval
                  for (int i=0; i<readCount; i++)
                      audioData(i/in->signal.channels,i%in->signal.channels)=(Scalar)(maxVal*(double)readData(i)/(double)numeric_limits<sox_sample_t>::max());
                else  {// scale to fullscale for the type
                  double scaleFact=(double)pow(2.,(double)sizeof(Scalar)*8.-1.);
                  for (int i=0; i<readCount; i++)
                      audioData(i/in->signal.channels,i%in->signal.channels)=(Scalar)(scaleFact*(double)readData(i)/(double)numeric_limits<sox_sample_t>::max());
                }
            }
        } else
            retVal=SOX_READ_FILE_NOT_OPENED_ERROR;
        return retVal;
    }

    virtual int openWrite(const string &fileName, double fs, int channels, double maxVal){
        return openWrite(fileName, fs, channels, maxVal, sizeof(FP_TYPE_)*CHAR_BIT, false, sox_option_default, sox_option_default, sox_option_default);
    }

    virtual int openWrite(const string &fileName, double fs, int channels, double maxVal, unsigned int wordSize, bool switchEndian, int revBytes, int revNibbles, int revBits);

    int openMemWrite(void *buffer, size_t len, double fs, int channels, double maxVal){
        return openMemWrite(buffer, len, fs, channels, maxVal, sizeof(FP_TYPE_)*CHAR_BIT, false, sox_option_default, sox_option_default, sox_option_default);
    }

    virtual int openMemWrite(void *buffer, size_t len, double fs, int channels, double maxVal, unsigned int wordSize, bool switchEndian, int revBytes, int revNibbles, int revBits);

    virtual int write(const vector<vector<FP_TYPE_> > &audioData);

    template <typename Derived>
    int write(const Eigen::DenseBase<Derived> &audioData) {
        int retVal=NO_ERROR; // start assuming no error
        if (out) { // if the output file has been opened...
            if (out->signal.channels!=audioData.cols())
                retVal=SOX_WRITE_OUT_CHANNEL_MISMATCH;
            else {
                int ch=out->signal.channels;
                int len=audioData.rows();
                int total=ch*len;
                if (outputBuffer.size()<total)
                    outputBuffer.resize(total);
                for (int i=0; i<audioData.cols(); i++) // stride the interleaved outputBuffer with each channel
                    for (int j=0; j<len; j++)
                        outputBuffer[j*ch+i]=(sox_sample_t)((double)audioData(j,i)*((double)numeric_limits<sox_sample_t>::max()/outputMaxVal));
                size_t writeCount=sox_write(out, &outputBuffer[0], total);
                retVal=writeCount;
            }
        } else
            retVal=SOX_WRITE_FILE_NOT_OPENED_ERROR;
        return retVal;
    }

    template <typename Derived>
    int writeTransposed(const Eigen::DenseBase<Derived> &audioData) {
        int retVal=NO_ERROR; // start assuming no error
        if (out) { // if the output file has been opened...
            if (out->signal.channels!=audioData.rows())
                retVal=SOX_WRITE_OUT_CHANNEL_MISMATCH;
            else {
                int ch=out->signal.channels;
                int len=audioData.cols();
                int total=ch*len;
                if (outputBuffer.size()<total)
                    outputBuffer.resize(total);
                for (int i=0; i<audioData.rows(); i++) // stride the interleaved outputBuffer with each channel
                    for (int j=0; j<len; j++)
                        outputBuffer[j*ch+i]=(sox_sample_t)((double)audioData(i,j)/outputMaxVal*(double)numeric_limits<sox_sample_t>::max());
                size_t writeCount=sox_write(out, &outputBuffer[0], total);
                retVal=writeCount;
            }
        } else
            retVal=SOX_WRITE_FILE_NOT_OPENED_ERROR;
        return retVal;
    }

    int closeRead(void);

    int closeWrite(void);

    void setMaxVal(double newMax) {
        maxVal=newMax;
    }

    double getMaxVal(void) {
        return maxVal;
    }

    double getFSIn(void) {
        if (in)
            return in->signal.rate;
        return 0.;
    }

    double getFSOut(void) {
        if (out)
            return out->signal.rate;
        return 0.;
    }

    int getChCntIn(void) {
        if (in)
            return in->signal.channels;
        return SOX_READ_FILE_NOT_OPENED_ERROR;
    }

    int getChCntOut(void) {
        if (out)
            return out->signal.channels;
        return SOX_WRITE_FILE_NOT_OPENED_ERROR;
    }

    vector<string> availableFormats(void);

    void printFormats();

#ifdef HAVE_EMSCRIPTEN

  FP_TYPE_ getSample(unsigned int r, unsigned int c);

  unsigned int getRows();

  unsigned int getCols();

  int readJS(unsigned int count=0);

private:
  Eigen::Matrix<FP_TYPE_, Eigen::Dynamic, Eigen::Dynamic> audio; 
#endif // HAVE_EMSCRIPTEN
};
#endif // SOX_H_