---

/root/src/subsynth/syn/Stream/OpenALSound.h

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: OpenALSound.h,v $
 * Date modified: $Date: 2002/02/16 19:24:16 $
 * Version:       $Revision: 1.10 $
 * -----------------------------------------------------------------
 *
 ****************** <SYN heading END do not edit this line> ******************/
#ifndef OAL_SOUND
#define OAL_SOUND

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

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

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

#include "syn/Stream/WavImporter.h"

namespace syn
{
   class OpenALSound
   {
   public:
      OpenALSound() : mSource( 0 )
      {
         position[0] = 0; position[1] = 0; position[2] = 0;
      }
   
      bool load( const syn::AudioFormat& fmt, char* fname )
      {
         std::vector<unsigned char> data;

         
         ALfloat zeroes[] = { 0.0f, 0.0f,  0.0f };
         alListenerfv( AL_POSITION, zeroes );
         /* alListenerfv(AL_VELOCITY, zeroes ); */
         
         ALfloat front[]  = { 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f };
         alListenerfv( AL_ORIENTATION, front );

         alGenBuffers( 1, &mBuffer );

         // read the data from the file.
         WavImporter i;
         int channels, samp_rate, format;
         if (false == i.import( fmt, fname, data ))
         {
            return false;
         }

         // convert the AudioFormat params to OpenAL tags...
         // this block is an ugly beast...
         samp_rate = fmt.samplingRateHz;
         channels = fmt.channels;
         switch (fmt.datatype)
         {
         case syn::AudioFormat::UNSIGNED8:
            std::cout << "WARNING: UNSIGNED8 unsupported."
                      << "Could not not open stream\n" << std::flush; 
            return false;
         case syn::AudioFormat::SIGNED8:
            if (fmt.channels == 1) 
               format = AL_FORMAT_MONO8;
            else if (fmt.channels == 2)
               format = AL_FORMAT_STEREO8;
            else 
            {
               std::cout << "WARNING: Only 1 or 2 channels unsupported. "
                         << "Could not not open stream\n" << std::flush; 
               return false;
            }
            break;
         case syn::AudioFormat::UNSIGNED16:
            std::cout << "WARNING: UNSIGNED16 unsupported. "
                      << "Could not not open stream\n" << std::flush; 
            return false;
         case syn::AudioFormat::SIGNED16:
            if (fmt.channels == 1) 
               format = AL_FORMAT_MONO16;
            else if (fmt.channels == 2) 
               format = AL_FORMAT_STEREO16;
            else 
            {
               std::cout << "WARNING: Only 1 or 2 channels unsupported. "
                         << "Could not not open stream\n" << std::flush; 
               return false;
            }
            break;
         case syn::AudioFormat::FLOAT32:  
            std::cout << "WARNING: FLOAT32 unsupported."
                      << "Could not not open stream\n" << std::flush; 
            return false;
         }

         alGetError();

         // save the .wav file data under "mBuffer" identifier
         alBufferData( mBuffer, format, &data[0], data.size(), samp_rate );
         if (alGetError() != AL_NO_ERROR)
         {
            std::cerr<<"Could not BufferData\n"<<std::flush;
            exit( 1 );
         }

         alGenSources( 1, &mSource );

         alSourcei( mSource, AL_BUFFER, mBuffer );
         alSourcei( mSource, AL_LOOPING, AL_TRUE );

         return true;
      }

      void play()
      {
         alSourcePlay( mSource );
      }
   
      void setPos( float x, float y, float z )
      {
         #define ALMAXDISTANCE 60.0f
         clamp( x, -ALMAXDISTANCE, ALMAXDISTANCE );
         clamp( y, -ALMAXDISTANCE, ALMAXDISTANCE );
         clamp( z, -ALMAXDISTANCE, ALMAXDISTANCE );
      
         ALfloat lispos[] = { x, y, z };
         alListenerfv( AL_POSITION, lispos );
      }   
   
      void stop()
      {
         alSourceStop(mSource);
      }   
   
      void step()
      {
         static ALfloat position[] = { 10.0, 0.0, 4.0 };
//       static ALfloat movefactor = 4.5;
//       static time_t then = 0;
         //time_t now;

         /*now = time( NULL );

         // Switch between left and right stereo sample every two seconds.
         if( now - then > 2 ) {
            then = now;

            movefactor *= -1.0;
         }

         position[0] += movefactor;
         */
         
         alSourcefv( mSource, AL_POSITION, position );

//         micro_sleep( 500000 );

   //    ALint byteloki;
   //    alGetSourceiv( mSource, AL_BYTE_LOKI, &byteloki );
   //    alGetBufferi( mBuffer,     AL_SIZE,      &size );

         //fprintf(stderr, "byteloki = %d size = %d\n", byteloki, size);

         return;
      }
   
      bool isPlaying()
      {
         ALuint sid = mSource;
         ALint state;

         if(alIsSource(sid) == AL_FALSE) 
         {
            return false;
         }

         state = AL_INITIAL;

#   ifdef WIN32
         alGetSourcei( sid, AL_SOURCE_STATE, &state );
#   else
         alGetSourceiv( sid, AL_SOURCE_STATE, &state );
#   endif 

         switch(state) 
         {
            case AL_PLAYING:
            case AL_PAUSED:
              return true;
            default:
              break;
         }

         return false;
      }
   private:
   
   
/*
      #ifdef _WIN32
      void micro_sleep(unsigned int n) 
      {
         Sleep( n / 1000 );
         return;
      }

      #else

      void micro_sleep(unsigned int n) 
      {
         struct timeval tv = { 0, 0 };
              tv.tv_usec = n;
         select( 0, NULL, NULL, NULL, &tv );
         return;
      }


      #endif // _WIN32
*/   
      void clamp( float& val, float low, float high ) const
      {
         if (val < low)
         {
            val = low;
         }
         else if (val > high)
         {
            val = high;
         }         
      }   
   
      float position[3];
      ALuint mSource;
      ALuint mBuffer;
   };

}

#endif

---