root/trunk/orca/gl/audio.c

//============================================================================
//
// ORCA OpenAL Module
// Copyright (C) 2005-2006  Karl Robillard
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Lesser General Public
//  License as published by the Free Software Foundation; either
//  version 2.1 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
//  Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser 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
//
//============================================================================


#include <stdio.h>
#include <stdlib.h>
#ifdef __APPLE__
#include <OpenAL/al.h>
#include <OpenAL/alc.h>
#include <OpenAL/alut.h>
#elif defined(_WIN32)
#include <al.h>
#include <alc.h>
#include <alut.h>
#else
#include <AL/al.h>
#include <AL/alc.h>
#include <AL/alut.h>
#include <AL/alext.h>
#endif
#include "os.h"
#include "ovalue.h"
#include "audio.h"


void audioStopMusic();


#define SAMPLE_ID(sd)   (sd->index)

// Counts must be a power of 2.
#define FX_COUNT        8
#define AMBIENT_COUNT   2

#define SOURCE_COUNT    FX_COUNT + AMBIENT_COUNT


static int _audioUp = 0;
static ALCdevice*  _adevice  = 0;
static ALCcontext* _acontext = 0;
static ALuint _asource[ SOURCE_COUNT ];


#define MUSIC_BUFFERS       1
static int     _hasVorbis = 0;
static ALuint  _musicSource = 0;
static ALfloat _musicGain = 1.0f;
static ALuint  _musicBuffers[ MUSIC_BUFFERS ];


/**
  Called once at program startup.
  Returns 0 on a fatal error.
*/
int audioStartup()
{
#if 1
    _adevice = alcOpenDevice( 0 );
    if( ! _adevice )
        return 0;
    _acontext = alcCreateContext( _adevice, 0 );
    alcMakeContextCurrent( _acontext );
#else
    alutInit( 0, 0 );
#endif

    alGenSources( SOURCE_COUNT, _asource );
    alGenBuffers( MUSIC_BUFFERS, _musicBuffers );

    _audioUp = 1;

    if( alIsExtensionPresent( (ALubyte*) "AL_EXT_vorbis" ) )
        _hasVorbis = 1;
    else
        dprint( "OpenAL AL_EXT_vorbis not present - music disabled\n" );

    return 1;
}


/**
  Called once when program exits.
  It is safe to call this even if audioStartup() was not called.
*/
void audioShutdown()
{
    if( _audioUp )
    {
        audioStopMusic();

        alDeleteSources( SOURCE_COUNT, _asource );
        alDeleteBuffers( MUSIC_BUFFERS, _musicBuffers );

#if 1
        // Cannot use alutExit() on my box (FC3/Shuttle XPC) since
        // alcMakeContextCurrent(0) -> _alLockMixerPause() will hangup.
        alcDestroyContext( _acontext );
        alcCloseDevice( _adevice );
#else
        alutExit();
#endif
    }
}


#if 0
/**
  Called periodically (once per frame) to drive sound engine.
*/
void audioUpdate()
{
}
#endif


static int wav_sig( uint8_t* sig, int sigLen )
{
    if( sigLen < 4 )
        return 0;
    return( sig[0]=='R' && sig[1]=='I' && sig[2]=='F' && sig[3]=='F');
}


int wav_loader( char* filename, uint8_t* sig, int sigLen )
{
    if( wav_sig( sig, sigLen ) )
    {
        ALenum format;
        ALsizei size;
        ALvoid* data;
        ALsizei freq;
        ALboolean loop;

        alutLoadWAVFile( (ALbyte*) filename, &format,&data,&size,&freq,&loop );

        if( data )
        {
            ALuint buffer;
            alGenBuffers( 1, &buffer );
            alBufferData( buffer, format, data, size, freq );
            {
            OValue* a1 = orTOS;
            orResult( OT_SOUND, buffer );
            }
        }
        else
        {
            orError( "alutLoadWAVFile() failed" );
        }

        alutUnloadWAV( format, data, size, freq );

        return 1;
    }
    return 0;
}


#if 0
bool osLoadSample( OS_SAMPLE* sp, BSample* bs )
{
    if( _audioUp )
    {
        ALenum format;

        switch( bs->format )
        {
            case BSAMPLE_MONO8:    format = AL_FORMAT_MONO8;    break;
            case BSAMPLE_MONO16:   format = AL_FORMAT_MONO16;   break;
            case BSAMPLE_STEREO8:  format = AL_FORMAT_STEREO8;  break;
            case BSAMPLE_STEREO16: format = AL_FORMAT_STEREO16; break;
        }

        alGenBuffers( 1, &sp->uh );
        alBufferData( sp->uh, format, bs->pcm(), bs->size, bs->freq );
    }
    else
    {
        sp->uh = 0;
    }

    return 1;
}


void osInitSample( OS_SAMPLE* sp )
{
    sp->uh = 0;
}


void osFreeSample( OS_SAMPLE* sp )
{
    if( sp->uh )
    {
        alDeleteBuffers( 1, &sp->uh );
        sp->uh = 0;
    }
}
#endif


int audioPlaySound( OValue* sound )
{
    static int n = 0;
    if( sound && _audioUp )
    {
        ALuint src = _asource[ n ];

        alSourcei( src, AL_BUFFER, SAMPLE_ID( sound ) );
        alSourcePlay( src );

        ++n;
        n &= FX_COUNT - 1;          // Requires FX_COUNT to be a power of 2.
        return src;
    }
    return 0;
}


#if 0
int osPlayAmbientLoop( SoundData* sd )
{
    static int n = 0;
    if( sd && _audioUp )
    {
        ALuint src = _asource[ n + FX_COUNT ];

        alSourcei( src, AL_BUFFER, SAMPLE_ID( sd ) );
        alSourcei( src, AL_LOOPING, AL_TRUE );
        alSourcePlay( src );

        ++n;
        n &= AMBIENT_COUNT - 1;     // Requires count to be a power of 2.
        return src;
    }
    return 0;
}


void osStopSound( int id )
{
    if( _audioUp )
        alSourceStop( id );
}
#endif


void audioPlayMusic( const char* file )
{
#ifdef AL_FORMAT_VORBIS_EXT
    if( _audioUp && _hasVorbis )
    {
        int   size;
        void* fileBuf = 0;
        int   ok = 0;

        //dprint( "osPlayMusic( %s )", file );

        audioStopMusic();

        size = orFileSize( file );
        if( size > 0 )
        {
            fileBuf = memAlloc( size );
            if( fileBuf )
            {
                FileHandle fp = fileOpen( file, FILE_READ_BINARY );
                if( fp )
                {
                    if( fileRead( fp, fileBuf, size ) == (size_t) size )
                        ok = 1;
                    fileClose( fp );
                }
            }
        }

        if( ok )
        {
            alGenSources( 1, &_musicSource );

            alSourcei ( _musicSource, AL_LOOPING, AL_FALSE );
            alSourcei ( _musicSource, AL_SOURCE_RELATIVE, AL_TRUE );
            alSource3f( _musicSource, AL_POSITION,  0.0f, 0.0f, 0.0f );
            alSource3f( _musicSource, AL_VELOCITY,  0.0f, 0.0f, 0.0f );
            alSource3f( _musicSource, AL_DIRECTION, 0.0f, 0.0f, 0.0f );
            alSourcef ( _musicSource, AL_ROLLOFF_FACTOR, 0.0f );
            alSourcef ( _musicSource, AL_GAIN, _musicGain );

            alBufferData( _musicBuffers[0], AL_FORMAT_VORBIS_EXT, fileBuf,
                          size, 44100 );
            alSourcei( _musicSource, AL_BUFFER, _musicBuffers[0] );

            alSourcePlay( _musicSource );
        }
        else
        {
            dprint( "audioPlayMusic - could not open %s\n", file );
        }

        if( fileBuf )
            memFree( fileBuf );
    }
#endif
}


void audioStopMusic()
{
    if( _audioUp )
    {
        if( _musicSource )
        {
            alSourceStop( _musicSource );
            alDeleteSources( 1, &_musicSource );
            _musicSource = 0;
        }
    }
}


void audioSetSoundVolume( int v )
{
    alListenerf( AL_GAIN, ((ALfloat) v) / 256.0f );
}


void audioSetMusicVolume( int v )
{
    //ALfloat gain;
    //alGetListenerfv( AL_GAIN, &gain );
    _musicGain = ((ALfloat) v) / 256.0f;
    if( _musicSource )
        alSourcef( _musicSource, AL_GAIN, _musicGain );
}


//EOF