---

/root/src/subsynth/syn/Stream/OpenALAudioOStream.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: OpenALAudioOStream.cpp,v $
 * Date modified: $Date: 2002/04/05 16:28:28 $
 * Version:       $Revision: 1.9 $
 * -----------------------------------------------------------------
 *
 ****************** <SYN heading END do not edit this line> ******************/

#ifdef _WIN32
   #include <windows.h>
#endif

#include <iostream>
#include <vector>
#include <string>

#include <AL/al.h>
#include <AL/alc.h>
#include <AL/alut.h>

//#include <vpr/Thread/Thread.h> // for yield 

#include "syn/Util/AudioFormat.h"
#include "syn/Stream/AudioContext.h"
#include "syn/Stream/AudioOStream.h"
#include "syn/Stream/OpenALAudioOStream.h" // my header goes last...

namespace syn
{
   OpenALAudioOStream::OpenALAudioOStream() : 
      mFormat( AL_FORMAT_STEREO16 ),
      mIsOpen( false ), 
      mBufferHackSwitch( 0 ),
      mPcount( 0 )
   {
      // hard coded to a double buffered source.
      mBuffers.resize( 2 ); // double buffered
      mSources.resize( 1 ); // one source
   }

   bool OpenALAudioOStream::isPlaying() const
   {
      
      if (alIsSource(mSources[0]) == AL_FALSE) 
      {
         return AL_FALSE;
      }

      ALint source_state = AL_INITIAL;
#     ifdef WIN32
      alGetSourcei( mSources[0], AL_SOURCE_STATE, &source_state );
#     else
      alGetSourceiv( mSources[0], AL_SOURCE_STATE, &source_state );
#     endif
      
      switch (source_state) 
      {
         case AL_PLAYING:
         case AL_PAUSED:
            return true;
         default:
            break;
      }

      return false;
   }

   /* blocking call, waits until stream is done writing */
   void OpenALAudioOStream::flush()
   {
      // wait for the stream to finish playing...
      while (this->isPlaying())
      {
         //vpr::Thread::yield();
      }
   }

   // open the stream
   // specify the format of your data you'll be passing to write()
   bool OpenALAudioOStream::open( const syn::AudioFormat& fmt )
   {
      if (mIsOpen == true)
      {
         this->close();
      }
      
      ALint error;

      // convert the AudioFormat params to OpenAL tags...
      // this block is an ugly beast...
      mSampRate = fmt.samplingRateHz;
      switch (fmt.datatype)
      {
      case syn::AudioFormat::UNSIGNED8:
         std::cout << "[syn] WARNING: UNSIGNED8 unsupported."
                   << "Could not not open stream\n" << std::flush; 
         return false;
      case syn::AudioFormat::SIGNED8:
         if (fmt.channels == 1) 
            mFormat = AL_FORMAT_MONO8;
         else if (fmt.channels == 2)
            mFormat = AL_FORMAT_STEREO8;
         else 
         {
            std::cout << "[syn] WARNING: Only 1 or 2 channels unsupported. "
                      << "Could not not open stream\n" << std::flush; 
            return false;
         }
         break;
      case syn::AudioFormat::UNSIGNED16:
         std::cout << "[syn] WARNING: UNSIGNED16 unsupported. "
                   << "Could not not open stream\n" << std::flush; 
         return false;
      case syn::AudioFormat::SIGNED16:
         if (fmt.channels == 1) 
            mFormat = AL_FORMAT_MONO16;
         else if (fmt.channels == 2) 
            mFormat = AL_FORMAT_STEREO16;
         else 
         {
            std::cout << "[syn] WARNING: Only 1 or 2 channels unsupported. "
                      << "Could not not open stream\n" << std::flush; 
            return false;
         }
         break;
      case syn::AudioFormat::FLOAT32:  
         std::cout << "[syn] WARNING: FLOAT32 unsupported."
                   << "Could not not open stream\n" << std::flush; 
         return false;
      }
      
      // We are going to be queuing x buffers on our source 
      // (multi buffered sound)
      alGenBuffers( mBuffers.size(), &mBuffers.front() );
      if ((error = alGetError()) != AL_NO_ERROR)
      {
         std::cout << "alGenBuffers : " << error << "\n" << std::flush;
         return false;
      }

      // init the buffers the stream reads from
      std::vector<char> junk;
      junk.resize( 1024 );
      for (unsigned int x = 0; x < mBuffers.size(); x++)
      {
         alBufferData( mBuffers[x], mFormat, &junk[0], 
                        junk.size(), mSampRate);
         if ((error = alGetError()) != AL_NO_ERROR)
            std::cout  <<  "[syn] ERROR: alBufferData : "  <<  error << "\n"  <<  std::flush;
      }
   
      // create the stream:

      // create one sound source
      alGenSources( 1, &mSources[0] );
      if ((error = alGetError()) != AL_NO_ERROR)
      {
         std::cout  <<  "[syn] ERROR: alGenSources 1 : "  <<  error  <<  "\n"  <<  std::flush;
         alDeleteBuffers( mBuffers.size(), &mBuffers[0] );
         return false;
      }

      // Queue the multiple buffers on the source
      alSourceQueueBuffers( mSources[0], mBuffers.size(), &mBuffers[0] );
      if ((error = alGetError()) != AL_NO_ERROR)
         std::cout << "[syn] ERROR: alSourceQueueBuffers : " << error << "\n" << std::flush;
      mBufferHackSwitch = mBuffers[0];
      
      // don't loop.
      alSourcei( mSources[0], AL_LOOPING, AL_FALSE );

      // Start playing source
      alSourcePlay( mSources[0] );
      if ((error = alGetError()) != AL_NO_ERROR)
         std::cout << "[syn] ERROR: alSourcePlay source 0 : " << error << "\n" << std::flush;

      mFmt = fmt;
      mIsOpen = true;
      return true;
   }

   // SOURCE_RELATIVE



   // poll this function to know when to give more data to update
   bool OpenALAudioOStream::canAcceptMoreData() const 
   {
      if (mIsOpen == false)
         return false;

      if (alIsSource( mSources[0] ) == AL_FALSE)
         return false;
      
      if (this->isPlaying() == false)
      {
         // Starved Stream (bad):
         // OpenAL played through all queued buffers without another 
         // being queued in time, so the source went into a "stopped" 
         // state. We definately can accept more data in this starved 
         // state, so return true...
         //alSourcePlay( mSources[0] );
         return true;
      }

      ALuint buffers_processed;
#     ifdef WIN32
      alGetSourcei( mSources[0], AL_BUFFERS_PROCESSED, 
                    (int*)&buffers_processed );
#     else
      alGetSourceiv( mSources[0], AL_BUFFERS_PROCESSED, 
                    (int*)&buffers_processed );
#     endif

      // if there is at least one buffer finished playing, 
      // we can requeue a new one with the given data
      // NOTE: we can always count on at least 2 buffers queued
      //       because that is always how we leave the source in 
      //       init() and in write()
      if (buffers_processed >= 1)
         return true;
      else
         return false;
   }

   // write data to the sound hardware. 
   // make sure it is still in the format you opened the steam in...
   bool OpenALAudioOStream::write( const void* const data, int samples )
   {
      int numBytes = samples * mFmt.sampsize();
      mPcount = samples;
      
      if (mIsOpen == false)
         return false;

      //ALuint count = 0;
      //ALuint buffersreturned = 0;
      //ALboolean bFinishedPlaying = AL_FALSE;
      //ALuint buffersinqueue = mBuffers.size();
      ALint error;

      // if there is at least one buffer finished playing, 
      // we can requeue a new one with the given data
      if (this->canAcceptMoreData() == true)
      {
         // If some buffers have been played, 
         // unqueue them and load new audio into them, 
         // then add them to the queue

         // Pseudo code for Streaming with Open AL
         // while (buffers_processed >= 1)
         //    Unqueue a buffer "buf"
         //    write audio data into "buf"
         //    re-Queue "buf"

         
         // unqueue a finished buffer (takes first available in 
         // order of appearance)

         ALuint buffer_id = 0;
         
#ifdef UNIX_STREAMING_BUG 
         // loki function semantics... (old openal unix tree only)
         // NOTE: this should work under both the new and the old ways,
         //       but will be limited to 2 buffers...
         buffer_id = mBufferHackSwitch;
         alSourceUnqueueBuffers( mSources[0], 1, &buffer_id );
         if ((error = alGetError()) != AL_NO_ERROR)
         {
            std::cout << "[syn] ERROR: alSourceUnqueueBuffers: "
                      << error << " " << alGetString( error ) 
                      << "\n" << std::flush;

            return false;
         }

         // unqueued successfully, swap, so we unqueue the other next time.
         if (mBufferHackSwitch == mBuffers[0])
            mBufferHackSwitch = mBuffers[1];
         else
            mBufferHackSwitch = mBuffers[0];
#else // ifndef UNIX_STREAMING_BUG

         // openal spec function semantics (win32, and new unix tree)
         alSourceUnqueueBuffers( mSources[0], 1, &buffer_id );
         if ((error = alGetError()) != AL_NO_ERROR)
         {
            std::cout << "[syn] ERROR: alSourceUnqueueBuffers 1 : "
                      << error << " " << alGetString( error ) << "\n" 
                      << std::flush;
            return false;
         }
#endif // UNIX_STREAMING_BUG
         
         //std::cout<<"unqueued: "<<buffer_id<<" buf:("<<mBuffers[0]<<" "<<mBuffers[1]<<")\n"<<std::flush;
         
         // write the new data into the recently unqueued buffer.
         alBufferData( buffer_id, mFormat, const_cast<void*>( data ), numBytes, mSampRate );
         if ((error = alGetError()) != AL_NO_ERROR)
         {
            std::cout << "[syn] ERROR: alBufferData [id:"<<buffer_id<<" sz:"<<numBytes<<"] : "
                      <<  error << " " << alGetString( error ) << "\n" << std::flush;
            return false;
         }

         // re-Queue the buffer
         alSourceQueueBuffers( mSources[0], 1, &buffer_id );
         if ((error = alGetError()) != AL_NO_ERROR)
         {
            if (error == AL_INVALID_VALUE)
               std::cout << "[syn] ERROR: alSourceQueueBuffers 1 : "
                      << "AL_INVALID_VALUE\n"  << std::flush;
            else
               std::cout << "[syn] ERROR: alSourceQueueBuffers 1 : "
                      <<  error << " " << alGetString( error ) << "\n" << std::flush;
            return false;
         }
      
         // if our stream stopped (dropout), then restart it
         // now that we have something queued to play.
         if (this->isPlaying() == false)
         {
            std::cout << "[syn] WARNING: stream was stopped, "
                      << "restarting\n" << std::flush;
            alSourcePlay( mSources[0] );
         }

         // queued data successfully (done with it.)
         return true;
      }
      else
      {
         return false;
      }
   }

   bool OpenALAudioOStream::close()
   {
      if (mIsOpen == false)
         return false;

      ALuint error;
      alSourceStopv(1, &mSources[0]);
      if ((error = alGetError()) != AL_NO_ERROR)
         std::cout << "[syn] ERROR: alSourceStopv 1 : " 
               << error << "\n" << std::flush;

      alDeleteSources(1, &mSources[0]);
      if ((error = alGetError()) != AL_NO_ERROR)
         std::cout << "[syn] ERROR: alDeleteSources 1 : " 
               << error << "\n" << std::flush;

      alDeleteBuffers(mBuffers.size(), &mBuffers[0]);
      if ((error = alGetError()) != AL_NO_ERROR)
         std::cout << "[syn] ERROR: alDeleteBuffers : " 
               << error << "\n" << std::flush;

      mIsOpen = false;
      return true;
   }

   // set the number of audio buffers to queue...
   void OpenALAudioOStream::resizeBuffers( int numBuffers )
   {
      if (mIsOpen == true)
      {
         this->close();
         mBuffers.resize( numBuffers );
         this->open( mFmt );
      }
      else
      {
         mBuffers.resize( numBuffers );
      }
   }
   
} // namespace

---