FileWvIn.cpp

Go to the documentation of this file.

/***************************************************/
/***************************************************/

#include "../include/FileWvIn.h"
#include <cmath>
#include <iostream>
using namespace std;

FileWvIn::FileWvIn (unsigned long chunkThreshold, unsigned long chunkSize):
finished_ (true),
interpolate_ (false),
time_ (0.0),
chunkThreshold_ (chunkThreshold),
chunkSize_ (chunkSize)
{
}

FileWvIn::FileWvIn (std::string fileName, bool raw, bool doNormalize,
                    unsigned long chunkThreshold, unsigned long chunkSize):
finished_ (true),
interpolate_ (false),
time_ (0.0),
chunkThreshold_ (chunkThreshold),
chunkSize_ (chunkSize)
{
        openFile (fileName, raw, doNormalize);
        _loop = false;
file_loop = false;
        _gain = 1.0;
}

FileWvIn::~FileWvIn ()
{
        this->closeFile ();
}

void
FileWvIn::closeFile (void)
{
        if (file_.isOpen ())
                file_.close ();
        finished_ = true;
}

void
FileWvIn::openFile (std::string fileName, bool raw, bool doNormalize)
{
        // Call close() in case another file is already open.
        this->closeFile ();

        // Attempt to open the file ... an error might be thrown here.
        file_.open (fileName, raw);

        // Determine whether chunking or not.
        if (true)               // always
                //( file_.fileSize() > chunkThreshold_ ) 
        {
                chunking_ = true;
                chunkPointer_ = 0;
                data_.resize (chunkSize_, file_.channels ());
                data1.resize (chunkSize_, file_.channels ());
                data2.resize (chunkSize_, file_.channels ());
                if (doNormalize)
                        normalizing_ = true;
                else
                        normalizing_ = false;
        }
        else
        {
                chunking_ = false;
                data_.resize ((size_t) file_.fileSize (), file_.channels ());
        }

        // Load all or part of the data.
        file_.read (data_, 0, doNormalize);

        // Resize our lastOutputs container.
        lastOutputs_.resize (1, file_.channels ());

        // Set default rate based on file sampling rate.
        this->setRate (data_.dataRate () / Stk::sampleRate ());

        if (doNormalize & !chunking_)
                this->normalize ();

        this->reset ();
}

void
FileWvIn::reset (void)
{
        QMutexLocker locker (&mutex);
//      time_ = (StkFloat) 0.0;
        for (unsigned int i = 0; i < lastOutputs_.size (); i++)
                lastOutputs_[i] = 0.0;
        finished_ = false;
        ptr = 0;                // cc
        file_.read (data1, chunkPointer_, normalizing_);
        file_.read (data2, chunkPointer_, normalizing_);
        data1old = false;
        data2old = true;        // to trigger next read
//      cout << "init loaded data1" << endl;
}

void
FileWvIn::normalize (void)
{
        this->normalize (1.0);
}

// Normalize all channels equally by the greatest magnitude in all of the data.
void
FileWvIn::normalize (StkFloat peak)
{
        // When chunking, the "normalization" scaling is performed by FileRead.
        if (chunking_)
                return;

        size_t i;
        StkFloat max = 0.0;

        for (i = 0; i < data_.size (); i++)
        {
                if (fabs (data_[i]) > max)
                        max = (StkFloat) fabs ((double) data_[i]);
        }

        if (max > 0.0)
        {
                max = 1.0 / max;
                max *= peak;
                for (i = 0; i < data_.size (); i++)
                        data_[i] *= max;
        }
}

void
FileWvIn::setRate (StkFloat rate)
{
        rate_ = rate;

        // If negative rate and at beginning of sound, move pointer to end
        // of sound.
        if ((rate_ < 0) && (time_ == 0.0))
                time_ = file_.fileSize () - 1.0;

        if (fmod (rate_, 1.0) != 0.0)
                interpolate_ = true;
        else
                interpolate_ = false;
}

void
FileWvIn::addTime (StkFloat time)
{
        // Add an absolute time in samples 
        time_ += time;

        if (time_ < 0.0)
                time_ = 0.0;
        if (time_ > file_.fileSize () - 1.0)
        {
                time_ = file_.fileSize () - 1.0;
                for (unsigned int i = 0; i < lastOutputs_.size (); i++)
                        lastOutputs_[i] = 0.0;
                finished_ = true;
        }
}

StkFloat
FileWvIn::lastOut (void) 
{
        if (finished_)
                return 0.0;
        return WvIn::lastOut ();
}

void
FileWvIn::loadFrames (void)
{
        QMutexLocker locker (&mutex);
        if (finished_)
                return;
        if (chunkPointer_ > (file_.fileSize ()-1))
                if (file_loop)  
                {
                        chunkPointer_ = 0;
                        //cout << "repeat" << endl;
                }
                        else 
                        {
                                finished_ = true;
               cout << "finish" << endl;
                        }
        if (ptr < chunkSize_)
        {
                if (data2old)
                {
                        file_.read (data2, chunkPointer_, normalizing_);
                        data2old = false;
                        chunkPointer_ += chunkSize_;
//               cout << "loaded data2" << endl;
                }
        }
        else
        {
                if (data1old)
                {
                        file_.read (data1, chunkPointer_, normalizing_);
                        data1old = false;
                        chunkPointer_ += chunkSize_;
//               cout << "loaded data1" << endl;
                }
        }
}

void
FileWvIn::computeFrame (void)
{
        QMutexLocker locker (&mutex);
        if (finished_)
                return;


//cout << ptr << endl;  
        if (ptr < chunkSize_)
        {
                if ((ptr == 0) && (data1old == true))
                        cout << "behind  1" << endl;
                for (unsigned int i = 0; i < lastOutputs_.size (); i++)
                        lastOutputs_[i] = data1 ((size_t) (double) ptr, i);
                data1old = true;
        }
        else
        {
                if ((ptr == chunkSize_) && (data2old == true))
                        cout << "behind  2" << endl;
                for (unsigned int i = 0; i < lastOutputs_.size (); i++)
                        lastOutputs_[i] =
                                data2 ((size_t) (double) (ptr - chunkSize_),
                                       i);
                data2old = true;
        }
        ptr++;
        int mod = 2 * chunkSize_;
        ptr = ptr % mod;
                for (unsigned int i = 0; i < lastOutputs_.size (); i++)
                        lastOutputs_[i] *= _gain;
/*      
 double tmp1 = sin(6.28*0.001*(double)time_);
                for (unsigned int i = 0; i < lastOutputs_.size (); i++)
                        lastOutputs_[i] =
                                tmp1;
        */
        }

extern int set_fifo_priority (bool half);

void
FileWvIn::run ()
/* start thread */
{
        _loop = true;

        set_fifo_priority (true);
        while (_loop)
        {
                loadFrames ();
                msleep (10);
        }
}

void
FileWvIn::go ()
/* cause run loop to start */
{
  //cout << "Starting loop" << endl;
        start ();
}

void
FileWvIn::stop ()
/* cause run loop to finish */
{
        _loop = false;
}

void
FileWvIn::join ()
/* wait for thread to exit */
{
        wait ();
}

---