CS 312 - Week 8.1 Class
CS 312 Audio Programming Winter 2020

cd $HOME312/cs312/hw81/hw811_qtwavio
mkdir build-debug

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>

QT_BEGIN_NAMESPACE
namespace Ui
{
class MainWindow;
}
QT_END_NAMESPACE

class MainWindow : public QMainWindow
{
    Q_OBJECT

  public:
    MainWindow( QWidget* parent = nullptr );
    ~MainWindow();

  private slots:
    void on_pushButton_Play_clicked();

    void on_actionOpen_triggered();

    void on_actionSave_As_triggered();

  private:
    Ui::MainWindow* ui;

    void doMessageBox( const QString& qs );
};
#endif // MAINWINDOW_H

#include "mainwindow.h"
#include "ui_mainwindow.h"

#include <QFileDialog>
#include <QMessageBox>

MainWindow::MainWindow( QWidget* parent )
    : QMainWindow( parent ), ui( new Ui::MainWindow )
{
    ui->setupUi( this );
}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::on_actionOpen_triggered()
{
    /*
       * Call QFileDialog::getOpenFileName
       * Set qCurrentOpenFileName
       * Set label_filename to the name of the file opened
       */

    QString qs = "See \nhttps://doc.qt.io/qt-5/qfiledialog.html#getOpenFileName  \
                          \n\n Then continue to follow steps class web page.";
    doMessageBox( qs );
}

void MainWindow::on_actionSave_As_triggered()
{
    /*
   * Call QFileDialog::getSaveFileName
   * Copy writeWav() from hw811
   * Set qCurrentSaveAsFileName
   */

    QString qs = "See \nhttps://doc.qt.io/qt-5/qfiledialog.html#getSaveFileName  \
            \n\n Then continue to follow steps on class web page.";
    doMessageBox( qs );
}

void MainWindow::on_pushButton_Play_clicked()
{
    doMessageBox( "See \nhttps://doc.qt.io/qt-5/audiooverview.html" );
}

void MainWindow::doMessageBox( const QString& qs )
{
    // copied directly from the Help page for MessageBox
    QMessageBox msgBox;
    msgBox.setText( qs );
    msgBox.exec();
}

#ifndef WAVIO_H
#define WAVIO_H

#ifndef SNDFILE_HH
#include "sndfile.hh"
#endif

#include <string>
#include <vector>

#include <QMessageBox>
#include <QString>

typedef double MY_TYPE;
#define FORMAT RTAUDIO_FLOAT64

std::vector<double> vsamps;

extern void doMessageBox( const QString& qs );
extern std::vector<MY_TYPE> readWav( std::string fname );
extern void writeWav( std::string fname, const std::vector<MY_TYPE>& vin );

#endif // WAVIO_H

#ifndef WAVIO_H
#include "wavio.h"
#endif

std::vector<double> vsamps;

void doMessageBox( const QString& qs )
{
    QMessageBox msgBox;
    msgBox.setText( qs );
    msgBox.exec();
}

std::vector<MY_TYPE> readWav( std::string path )
{
    // Create SndfileHandle class variable named infile initialized with the parameter path

    // get the number of samples in the file and create a vector of that size
    std::vector<double> v( /*number of samples in the file*/ );

    // read samples into v and report the number read in nRead
    // a valid read would report frames == nRead
    sf_count_t nRead = infile.read( &v[ 0 ], infile.frames() );

    // Display the results in the Application Output panel
    // finish each fo the following lines with the appropriate SndfileHandle
    //  function to display that particular information

    // qDebug() << path.c_str();
    // qDebug() << "frames " << ;
    // qDebug() << "format " << ;
    // qDebug() << "channels " << ;
    // qDebug() << "samplerate " << );
    // qDebug() << "nRead " << ;

    return v;
}

void writeWav( std::string fname, const std::vector<MY_TYPE>& v )
{
    doMessageBox( "You need to implement writeWav(...) in wavio.cpp" );

    // from libsndfile example sndfile.hh
    /*
      These are the parameters you'll need for creating a SndfileHandle
      use the constructor shown in the web page notes parameters follow
        path = fname
        mode = SFM_WRITE
        format = SF_FORMAT_WAV | SF_FORMAT_DOUBLE
        channels = 1
        samplerate = 44100

      declare and initialize variable: nWritten
      create the SndfileHandle outfile = SndfileHandle( fname, mode, format, channels, samplerate );
      declare and initialize variable: sz is equal to size of vsamps vector set in readSF()
      call nWritten = outfile.write( &vsamps[ 0 ], sz );
    */
}

/* A pointer to a SF_INFO structure is passed to sf_open () and filled in.
   On write, the SF_INFO structure is filled in by the user and passed into sf_open ().
*/

struct SF_INFO
{
  sf_count_t	frames ;		/* Used to be called samples.  Changed to avoid confusion. */
  int			samplerate ;
  int			channels ;
  int			format ;
  int			sections ;
  int			seekable ;
} ;

typedef	struct SF_INFO SF_INFO ;

class SndfileHandle
{ private :
    struct SNDFILE_ref
    { SNDFILE_ref (void) ;
      ~SNDFILE_ref (void) ;

      SNDFILE *sf ;
      SF_INFO sfinfo ;
      int ref ;
    } ;

    SNDFILE_ref *p ;

  public :

sf_count_t  frames (void) const   { return p ? p->sfinfo.frames : 0 ; }
int     format (void) const   { return p ? p->sfinfo.format : 0 ; }
int     channels (void) const { return p ? p->sfinfo.channels : 0 ; }
int     samplerate (void) const { return p ? p->sfinfo.samplerate : 0 ; }

int format (void)
// is the same as
int format()

return (a > b)  ? true : false;
// means
if (a > b)
    return true;
else
    return false;

SndfileHandle (std::string const & path, int mode = SFM_WRITE) ;

// generate some data:
QVector<double> x(101), y(101); // initialize with entries 0..100
for (int i=0; i<101; ++i)
{
  x[i] = i/50.0 - 1; // x goes from -1 to 1
  y[i] = x[i]*x[i]; // let's plot a quadratic function
}
// create graph and assign data to it:
customPlot->addGraph();
customPlot->graph(0)->setData(x, y);
// give the axes some labels:
customPlot->xAxis->setLabel("x");
customPlot->yAxis->setLabel("y");
// set axes ranges, so we see all data:
customPlot->xAxis->setRange(-1, 1);
customPlot->yAxis->setRange(0, 1);
customPlot->replot();

void MainWindow::plot()
{
    // generate some data:
    QVector<double> x( 101 ), y( 101 ); // initialize with entries 0..100
    for ( int i = 0; i < 101; ++i )
    {
        x[ i ] = i / 50.0 - 1;    // x goes from -1 to 1
        y[ i ] = x[ i ] * x[ i ]; // let's plot a quadratic function
    }
    // create graph and assign data to it:
    ui->customPlot->addGraph();
    ui->customPlot->graph( 0 )->setData( x, y );
    // give the axes some labels:
    ui->customPlot->xAxis->setLabel( "x" );
    ui->customPlot->yAxis->setLabel( "y" );
    // set axes ranges, so we see all data:
    ui->customPlot->xAxis->setRange( -1, 1 );
    ui->customPlot->yAxis->setRange( 0, 1 );
    ui->customPlot->replot();
}

 // generate some data:

 /* JE
 size_t sz = vsamps.size();
 QVector<MY_TYPE> x(sz); // the n sample indices on the x axis = vsamps.size()
 QVector<MY_TYPE> y(sz); // the n sample values on the y axis for each vsamp[n]

The for loop for the x and y axes needs to be revised.

 for ( int i = 0; n < sz; ++i )
 {
  // fill the qx[i] QVector with sample indices
  // fill the qy[i] QVector with sample values
 }
 */

 // create graph and assign data to it:
 customPlot->addGraph();
 customPlot->graph(0)->setData(x, y);


 /* JE
 // give the axes some labels:
 //  customPlot->xAxis->setLabel("x");
 // customPlot->yAxis->setLabel("y");
 */

 /* JE
 // set axes ranges, so we see all data
// set axes ranges, so we see all data:
    ui->customPlot->xAxis->setRange( -1, 1 );
    ui->customPlot->yAxis->setRange( 0, 1 );

 These two lines need to be adjusted based on how much of the waveform is being plotted.
 When a file is first opened the x axis ranges from 0 to sz-1 \\
 and the y axis ranges from -1 t0 +1.

 After that use the on_horizontalScrollBar_zoom_valueChanged( int value ) function change the xAxis range
 */

customPlot->replot();

void MainWindow::on_horizontalScrollBar_zoom_valueChanged( int value )
{
  // scaling based on vsamps.size() and value parameter
  ui->customPlot->xAxis->setRange( 0, /*scaling*/ );
  ui->customPlot->replot();
}