---

o_sound.cpp

Go to the documentation of this file.

// OMICRON ENGINE HEADER FILE
//
// --------------------------------------------------------------------------
// Copyright (C) 2001-2002 by Bjoern Paetzel <kolrabi@gmx.de>
//
// This file is part of the Omicron Engine.
//
// The Omicron Engine is free software; you can redistribute it and/or modify
// it under the terms of the  GNU General Public License  as published by the
// Free Software Foundation;  either version  2  of the License,  or (at your
// option) any later version.
//
// The Omicron Engine  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 General Public License
// for more details.
//
// You should have  received a copy of the  GNU General Public License  along
// with The Omicron Engine;  if not,  write to the  Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
//
// --------------------------------------------------------------------------
// Last modified:       $Date: 2002/12/18 14:35:11 $
// By           :       $Author: kolrabi $
// $Id: o_sound.cpp,v 1.7 2002/12/18 14:35:11 kolrabi Exp $ 

/*

  $Log: o_sound.cpp,v $
  Revision 1.7  2002/12/18 14:35:11  kolrabi
  no message

  Revision 1.6  2002/12/14 20:02:33  kolrabi
  fixed some memory leaks

  Revision 1.5  2002/12/13 15:59:47  kolrabi
  several bug fixes

  Revision 1.4  2002/12/13 12:29:26  kolrabi
  fixed some bugs

  Revision 1.3  2002/12/13 10:20:16  kolrabi
  no message

  Revision 1.2  2002/12/12 13:13:39  kolrabi
  made the fullscreen work under X11

  Revision 1.1  2002/12/12 11:44:04  kolrabi
  *** empty log message ***



*/
 
#include "omicron/internal.h"
#include "omicron/array.h"
#include "omicron/sound.h"
#include "omicron/file.h"

sound_manager_c::sound_manager_c()
{
    sounds = NULL;
    sounddevice = NULL;
    soundcontext = NULL;

    if (gv.init.nosound)
        return;

    SafeDelete(gv.soundman);

    gv.soundman = this;

#if !defined(NOSOUND)
//  alutInit(&gv.init.argc, gv.init.argv);

    _log_printf(0, "initializing sound...");

    _log_printf(0, "opening device...");

    if (NULL == (sounddevice = alcOpenDevice(NULL)))
    {
        _log_printf(0, "could not open device: %s", 
                        sound_alerror(alGetError()));
        gv.init.nosound = true;
        return;
    }

    _log_printf(0, "creating context...");

    int attr[] = { ALC_REFRESH, 100, ALC_SYNC, 0 };

    if (NULL == (soundcontext = alcCreateContext(sounddevice, attr)))
    {
        _log_printf(0, "could not create context: %s", 
                        sound_alerror(alGetError()));

        gv.init.nosound = true;
        alcCloseDevice(sounddevice);
        return;
    }

    _log_printf(0, "making context current...");

    alcMakeContextCurrent(soundcontext);
    int err = alGetError();

    if (AL_NO_ERROR != err)
    {
        _log_printf(0, "could not make context current: %s", 
                        sound_alerror(err));

        gv.init.nosound = true;
        alcDestroyContext(soundcontext);
        alcCloseDevice(sounddevice);
        return;
    }

    ALfloat listenerOri[]={ /* at */ 0.0, 0.0, -1.0, /* up */ 0.0, 1.0, 0.0};

    alListener3f(AL_POSITION,       0, 0, 0);
    alListener3f(AL_VELOCITY,       0, 0, 0);
    alListenerfv(AL_ORIENTATION,    listenerOri);

    sounds = new array_c<sound_t>;

#endif
}

sound_manager_c::~sound_manager_c()
{
    AssertThis;
    if (gv.init.nosound)
        return;

#if !defined(NOSOUND)

    for (sshort i=0; i<sounds->get_count(); i++)
        unload(i);

    SafeDelete(sounds);

//    alDeleteSources(CHANNELCOUNT, schannels);

    alcMakeContextCurrent(NULL);
    alcDestroyContext(soundcontext);
    alcCloseDevice(sounddevice);
#endif
}

const char *
sound_manager_c::sound_alerror(
    ALenum  e                           
)
{
    switch(e)
    {
        case AL_NO_ERROR:
            return "No error occured.";
        case AL_INVALID_NAME:
            return "Invalid OpenAL name used.";
/*      case AL_INVALID_ENUM:
            return "Invalid OpenAL enumeration used.";*/
        case AL_INVALID_VALUE:
            return "Invalid value.";
/*      case AL_INVALID_OPERATION:
            return "Invalid operation requested.";*/
        case AL_OUT_OF_MEMORY:
            return "Out of memory.";
    }

    return "Unknown error.";
}

void
sound_manager_c::unload(
    sshort  num                         
)
{
    AssertThis;

    if (gv.init.nosound)
        return;

#if !defined(NOSOUND)

    sound_t *snd = sounds->get(num);

    if (snd)
    {
        alSourceStop(snd->source);
        alDeleteSources(1, &snd->source);

        if (!snd->iscopy)
            alDeleteBuffers(1, &snd->buffer);

        sounds->remove(num);
        SafeDelete(snd);
    }

#endif
}

sshort
sound_manager_c::load_wav(
    const char *fname                   
)
{
    if (gv.init.nosound)
        return 0;

    AssertThisValue(-1);

#if !defined(NOSOUND)

    _log_printf(MSG_DEBUG, "Loading wave...");
    file_t *f = gv.fileman->load(fname, false);

    if (!f)
        return 0;

    ALenum    format = AL_FORMAT_MONO8;
    char      *data  = NULL;
    ALuint    sndbuf = 0;
    ALuint    sndsrc = 0;

    char      chunkid[5] = "    ";
    ulong     chunksize = 0;

    _log_printf(MSG_DEBUG, "seeking fmt chunk...");
    gv.fileman->seek(f, 12, SEEK_SET);

    while(strcmp(chunkid, "fmt ") && !gv.fileman->eof(f))
    {
        gv.fileman->seek(f, chunksize, SEEK_CUR);
        gv.fileman->read(chunkid, 4, 1, f);
        gv.fileman->read(&chunksize, 4, 1, f);
    }

    if (gv.fileman->eof(f))
    {
        gv.fileman->close(f);
        return -1;
    }

    _log_printf(MSG_DEBUG, "found...");

    // wave format data
    sshort wv_formattag = 0;
    ushort wv_channels = 0;
    ulong  wv_avgsrate = 0;
    ulong  wv_avgbrate = 0;
    ushort wv_blockalign = 0;
    ushort wv_bits = 0;

    bool   invalidformat = false;

    gv.fileman->read(&wv_formattag, sizeof(sshort), 1, f);
    gv.fileman->read(&wv_channels, sizeof(ushort), 1, f);
    gv.fileman->read(&wv_avgsrate, sizeof(ulong), 1, f);
    gv.fileman->read(&wv_avgbrate, sizeof(ulong), 1, f);
    gv.fileman->read(&wv_blockalign, sizeof(ushort), 1, f);
    gv.fileman->read(&wv_bits, sizeof(ushort), 1, f);

    if (wv_channels == 1)
    {
        if (wv_bits == 8)
            format = AL_FORMAT_MONO8;
        else if (wv_bits == 16)
            format = AL_FORMAT_MONO16;
        else
            invalidformat = true;
    }
    else if (wv_channels == 2)
    {
        if (wv_bits == 8)
            format = AL_FORMAT_STEREO8;
        else if (wv_bits == 16)
            format = AL_FORMAT_STEREO16;
        else
            invalidformat = true;
    }

    _log_printf(MSG_DEBUG, "%u hz %u channels %u bits... format: %04x", wv_avgsrate, wv_channels, wv_bits, format);

    if (invalidformat)
    {
        gv.fileman->close(f);
        return -1;
    }

    _log_printf(MSG_DEBUG, "seeking data chunk...");
    gv.fileman->seek(f, 12, SEEK_SET);

    chunksize = 0;

    while(strcmp(chunkid, "data") && !gv.fileman->eof(f))
    {
        gv.fileman->seek(f, chunksize, SEEK_CUR);
        gv.fileman->read(chunkid, 4, 1, f);
        gv.fileman->read(&chunksize, 4, 1, f);
    }

    if (gv.fileman->eof(f))
    {
        gv.fileman->close(f);
        return -1;
    }

    _log_printf(MSG_DEBUG, "found... reading %u bytes of sound...", chunksize);
    data = new char[chunksize*2+1024];

    gv.fileman->read(data, 1, chunksize, f);

    _log_printf(MSG_DEBUG, "creating openal buffer...");
    alGenBuffers(1, &sndbuf);
    _log_printf(MSG_DEBUG2, "%s", sound_alerror(alGetError()));
    _log_printf(MSG_DEBUG, "filling buffer...");
    alBufferData(sndbuf, format, data, chunksize, wv_avgsrate);
    _log_printf(MSG_DEBUG3, "%s", sound_alerror(alGetError()));

    SafeArrayDelete(data);

    gv.fileman->close(f);

    _log_printf(MSG_DEBUG, "creating openal source...");
    alGenSources(1, &sndsrc);
    _log_printf(MSG_DEBUG3, "%s", sound_alerror(alGetError()));

    _log_printf(MSG_DEBUG, "attaching buffer to source...");
    alSourcei(sndsrc, AL_BUFFER, sndbuf);
    _log_printf(MSG_DEBUG3, "%s", sound_alerror(alGetError()));

    _log_printf(MSG_DEBUG, "setting source parameters...");
    alSource3f(sndsrc, AL_POSITION, 0,0,0);
    alSource3f(sndsrc, AL_VELOCITY, 0,0,0);
    alSource3f(sndsrc, AL_DIRECTION, 0,0,1);

    _log_printf(MSG_DEBUG2, "new sound_t");
    sound_t *snd = new sound_t;

    snd->buffer = sndbuf;
    snd->source = sndsrc;

    _log_printf(MSG_DEBUG2, "adding sound_t to list");
    return sounds->add(snd);
#endif

    return INVALID_INDEX;
}

sshort
sound_manager_c::duplicate(
    sshort  num                         
)
{
    if (gv.init.nosound)
        return INVALID_INDEX;

    AssertThisValue(INVALID_INDEX);

    sound_t *snd, *snd2;
    
    snd = sounds->get(num);
    if (snd)
    {
        snd2 = new sound_t;
        snd2->buffer = snd->buffer;
        alGenSources(1, &snd2->source);

        alSourcei(snd2->source, AL_BUFFER, snd2->buffer);
        alSource3f(snd2->source, AL_POSITION, 0,0,0);
        alSource3f(snd2->source, AL_VELOCITY, 0,0,0);
        alSource3f(snd2->source, AL_DIRECTION, 0,0,1);

        snd2->iscopy = true;

        return sounds->add(snd2);
    }
    return INVALID_INDEX;
}

void
sound_manager_c::play(
    sshort  num                         
)
{
    if (gv.init.nosound)
        return;

    AssertThis;

#if !defined(NOSOUND)
    sound_t *snd = sounds->get(num);

    if (snd)
    {
        ALint state;

        alGetSourcei(snd->source, AL_SOURCE_STATE, &state);

        if (state != AL_PLAYING)
            alSourcePlay(snd->source);
    }
#endif
}

void
sound_manager_c::play_copy(
    sshort  num                         
)
{
    if (gv.init.nosound)
        return;

    AssertThis;

    sshort  num2 = duplicate(num);
    sound_t *snd = sounds->get(num2);

    if (snd)
    {
        snd->temporary = true;
        play(num2);
    }
}

void
sound_manager_c::stop(
    sshort  num                         
)
{
    if (gv.init.nosound)
        return;

    AssertThis;

#if !defined(NOSOUND)
    sound_t *snd = sounds->get(num);

    if (snd)
        alSourceStop(snd->source);
#endif
}

void
sound_manager_c::update()
{
    if (gv.init.nosound)
        return;

    AssertThis;

    for (sshort i=0; i<sounds->get_count(); i++)
    {
        sound_t *snd = sounds->get(i);

        if (snd)
        {
            if (snd->iscopy && snd->temporary)
            {
                ALint state;

                alGetSourcei(snd->source, AL_SOURCE_STATE, &state);

                if (state != AL_PLAYING)
                {
                    unload(i);
                    // alSourcePlay(snd->source);
                }
            }
        }
    }
}

---