---

/root/src/subsynth/syn/Stream/WavAudioIStream.cpp

Go to the documentation of this file.

/****************** <SYN heading BEGIN do not edit this line> *****************
 *
 * subsynth - modular audio synthesizer
 * subsynth is (C) Copyright 2001-2002 by Kevin Meinert
 *
 * Original Author: Kevin Meinert
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 * -----------------------------------------------------------------
 * File:          $RCSfile: WavAudioIStream.cpp,v $
 * Date modified: $Date: 2002/02/16 19:24:16 $
 * Version:       $Revision: 1.10 $
 * -----------------------------------------------------------------
 *
 ****************** <SYN heading END do not edit this line> ******************/

#include "syn/Stream/WavAudioIStream.h"

namespace syn
{
   
WavAudioIStream::WavAudioIStream() : mFilename( "filename_not_set.wav" ), mAmplitude( 1.0f ), mDcOffset( 0.0f )
{
}

void WavAudioIStream::setName( const std::string& filename )
{
   mFilename = filename;
}     

bool WavAudioIStream::open( const syn::AudioFormat& fmt, syn::AudioIStream::Operation op )
{
   syn::WavHeader wave;

   mFile.open( mFilename.c_str(), std::ios::in | std::ios::binary );

   if (mFile.bad())
   {
      std::cout<<"Failed to open "<<mFilename<<"\n"<<std::flush;
      mFile.close();
      return false;
   }

   mFile.read( (char*)&wave, sizeof(syn::WavHeader) );
   if (mFile.eof() == true || mFile.bad() == true)
   {
      std::cout<<"Invalid wave file\n"<<std::flush;
      mFile.close();
      return false;
   }

   // filter the data to the correct host byte ordering...
   //syn::byteReverse( syn::LITTLE, *((int*)wave.riff) );
   syn::byteReverse( syn::LITTLE, wave.riffSize );
   //syn::byteReverse( syn::LITTLE, *((int*)wave.wave) );
   //syn::byteReverse( syn::LITTLE, *((int*)wave.fmt) );
   syn::byteReverse( syn::LITTLE, wave.fmtSize );
   syn::byteReverse( syn::LITTLE, wave.Format );
   syn::byteReverse( syn::LITTLE, wave.Channels );
   syn::byteReverse( syn::LITTLE, wave.SamplesPerSec );
   syn::byteReverse( syn::LITTLE, wave.BytesPerSec );
   syn::byteReverse( syn::LITTLE, wave.BlockAlign );
   syn::byteReverse( syn::LITTLE, wave.BitsPerSample );
   //syn::byteReverse( syn::LITTLE, *((int*)wave.data) );
   syn::byteReverse( syn::LITTLE, wave.dataSize );

   // make sure the format is one that we can read...
   std::string r, w, f, d;
   r.assign( (char*)wave.riff, 4 );
   w.assign( (char*)wave.wave, 4 );
   f.assign( (char*)wave.fmt, 4 );
   d.assign( (char*)wave.data, 4 );

   if (std::string( "RIFF" ) != r || std::string( "WAVE" ) != w ||
       std::string( "fmt " ) != f || std::string( "data" ) != d )
   {
      std::cout<<"unsupported wave file format\n"<<std::flush;
      std::cout<<r<<" "<<w<<" "<<f<<" "<<d<<"\n"<<std::flush;
      mFile.close();
      return false;
   }

   // save the streampos at the beginning of the data...
   mDataPosition = mFile.tellp();

   // save the important data read from the header...
   mSourceFormat.channels = wave.Channels;
   mSourceFormat.samplingRateHz = wave.SamplesPerSec;
   int bytes_per_sample = wave.BitsPerSample / 8;
   //std::cout<<"bytes per sample: "<<bytes_per_sample<<"\n"<<std::flush;
   switch (bytes_per_sample)
   {
      case 1: mSourceFormat.datatype = syn::AudioFormat::SIGNED8; break;
      case 2: mSourceFormat.datatype = syn::AudioFormat::SIGNED16; break;
      default:
         std::cout<<"unsuported bit depth\n"<<std::flush;
         assert( false && "unsupported" );
         mFile.close();
         return false;
   }
   mDestFormat = fmt;
   mNumBytes = wave.dataSize;

   // make sure everything is sane, then return.
   assert( mFile.bad() == false ); // to record a loss of integrity of the stream buffer
   assert( mFile.fail() == false ); // to record a failure to extract a valid field from a stream 
   assert( mFile.eof() == false ); // to record end-of-file while extracting from a stream 
   assert( mFile.good() == true ); // no bits set
   assert( mFile.is_open() == true ); // we didn't accidentally close it.
   return true;
}

void WavAudioIStream::read( void* data, unsigned int samples )
{
   // handle the case where dest channels is different than src channels.
   // if we are converting to more channles, then we only need to read half as much
   // if we are converting to less channles, then we need to read twice as many samples...
   samples = (unsigned int)((float)samples * (float)mSourceFormat.channels / (float)mDestFormat.channels);

   actual_data.resize( samples * mSourceFormat.sampsize() );
   assert( actual_data.size() == samples * mSourceFormat.sampsize() && "couldn't resize" );

   mFile.read( (char*)&actual_data.front(), actual_data.size() );

   // get the actual number read...
   int actual_bytes_read = mFile.gcount();
   actual_samples_read = actual_bytes_read / mSourceFormat.sampsize();

   // convert the data to host byte order...
   if (mSourceFormat.sampsize() == 2 && syn::isBig() == true)
   {
      short* temp = (short*)&actual_data.front();
      for (int x = 0; x < actual_samples_read; ++x)
      {
         syn::byteReverse( temp[x] );
      }
   }

   if (mAmplitude != 1.0f || mDcOffset != 0.0f)
   {
      float_data.resize( actual_samples_read );

      // get the data in floats...
      AudioFormat fmt = mSourceFormat;
      fmt.datatype = AudioFormat::FLOAT32;
      syn::audio_convert( mSourceFormat, fmt,
                          (char*)&actual_data[0], actual_samples_read, (char*)&float_data[0], actual_samples_read );

      for (int x = 0; x < actual_samples_read; ++x)
      {
         float_data[x] = audio_clamp<float>( float_data[x] * mAmplitude + mDcOffset );
      }

      // get the data in the requested format
      syn::audio_convert( fmt, mDestFormat,
                          (char*)&float_data[0], actual_samples_read, data, actual_samples_read );
   }
   else
   {
      // get the data in the requested format
      syn::audio_convert( mSourceFormat, mDestFormat,
                          (char*)&actual_data[0], actual_samples_read, data, actual_samples_read );
   }
}




bool WavAudioIStream::close()
{
   mFile.close();
   return true;
}

int WavAudioIStream::numsamps()
{
   return mNumBytes / mSourceFormat.sampsize();
}


bool WavAudioIStream::good() const
{
   return mFile.good();
}

bool WavAudioIStream::bad() const
{
   return mFile.bad();
}

bool WavAudioIStream::eof() const
{
   return mFile.eof();
}

bool WavAudioIStream::isOpen() const
{
   return mFile.is_open();
}

int WavAudioIStream::gcount() const
{
   return actual_samples_read;
}

void WavAudioIStream::seek( int sampleNum )
{
   if (mFile.is_open())
   {
      mFile.clear();
      this->seek_data( sampleNum * mSourceFormat.sampsize() );
   }
}      

int WavAudioIStream::numbytes()
{
   return mNumBytes;
}  

void WavAudioIStream::seek_data( int numBytes )
{
   mFile.seekg( mDataPosition );
   mFile.seekg( numBytes, std::ios::cur );
}


};

---