Ticket #1223: patch12.diff

build/premake/premake4.lua

@@ -519 +519 @@
         "ps/Network",
         "ps/GameSetup",
         "ps/XML",
-        "sound",
+        "soundmanager",
+        "soundmanager/data",
+        "soundmanager/items",
+        "soundmanager/js",
         "scripting",
         "maths",
         "maths/scripting",
@@ -533 +536 @@
         "boost",
         "enet",
         "libcurl",
+        "vorbis",
+        "openal"
     }
     setup_static_lib_project("engine", source_dirs, extern_libs, {})
 
@@ -553 +558 @@
     end
     setup_static_lib_project("graphics", source_dirs, extern_libs, {})
 
-
     source_dirs = {
         "tools/atlas/GameInterface",
         "tools/atlas/GameInterface/Handlers"

source/ps/GameSetup/Config.cpp

@@ -23 +23 @@
 #include "lib/timer.h"
 #include "lib/res/sound/snd_mgr.h"
 #include "Config.h"
+#include "soundmanager/CSoundManager.h"
 
-
 // (these variables are documented in the header.)
 
 CStrW g_CursorName = L"test";
@@ -81 +81 @@
     CFG_GET_USER_VAL("particles", Bool, g_Particles);
 
     float gain = -1.0f;
+    float musicGain = -1.0f;
+    float ambientGain = -1.0f;
+    float actionGain = -1.0f;
+    int bufferCount = 50;
+    unsigned long   bufferSize = 65536;
+    
     CFG_GET_USER_VAL("sound.mastergain", Float, gain);
-    if(gain >= 0.0f)
-        WARN_IF_ERR(snd_set_master_gain(gain));
+    CFG_GET_USER_VAL("sound.musicgain", Float, musicGain);
+    CFG_GET_USER_VAL("sound.ambientgain", Float, ambientGain);
+    CFG_GET_USER_VAL("sound.actiongain", Float, actionGain);
+
+    CFG_GET_USER_VAL("sound.bufferCount", Int, bufferCount);
+    CFG_GET_USER_VAL("sound.bufferSize", UnsignedLong, bufferSize);
+
+    g_SoundManager->setMasterGain( gain );
+    g_SoundManager->setMusicGain( musicGain );
+    g_SoundManager->setAmbientGain( ambientGain );
+    g_SoundManager->setActionGain( actionGain );
+
+    g_SoundManager->setMemoryUsage( bufferSize, bufferCount);
 }
 
 

source/ps/GameSetup/GameSetup.cpp

@@ -102 +102 @@
 #include "tools/atlas/GameInterface/GameLoop.h"
 #include "tools/atlas/GameInterface/View.h"
 
+#include "soundmanager/CSoundManager.h"
 
 #if !(OS_WIN || OS_MACOSX || OS_ANDROID) // assume all other platforms use X11 for wxWidgets
 #define MUST_INIT_X11 1
@@ -203 +204 @@
 {
     PROFILE3("render");
 
+    g_SoundManager->idleTask();
+
     ogl_WarnIfError();
 
     g_Profiler2.RecordGPUFrameStart();
@@ -330 +333 @@
 {
     // maths
     JSI_Vector3D::init();
-
+    
+    CSoundManager::ScriptingInit();
     // graphics
     CGameView::ScriptingInit();
 
@@ -338 +342 @@
     CRenderer::ScriptingInit();
 
     // sound
-    JSI_Sound::ScriptingInit();
+//  JSI_Sound::ScriptingInit();
 
     // ps
     JSI_Console::init();
@@ -476 +480 @@
         g_VFS->Mount(L"", modLoosePath / modName/"", flags, priority);
         g_VFS->Mount(L"", modArchivePath / modName/"", flags, priority);
     }
+    
+    g_SoundManager = new CSoundManager();
 
     // note: don't bother with g_VFS->TextRepresentation - directories
     // haven't yet been populated and are empty.
@@ -691 +697 @@
     // resource
     // first shut down all resource owners, and then the handle manager.
     TIMER_BEGIN(L"resource modules");
-        snd_shutdown();
+        delete g_SoundManager;
 
         g_VFS.reset();
 
@@ -930 +936 @@
         // speed up startup by disabling all sound
         // (OpenAL init will be skipped).
         // must be called before first snd_open.
-        snd_disable(true);
+        g_SoundManager->setEnabled( false );
     }
 
     g_GUI = new CGUIManager(g_ScriptingHost.GetScriptInterface());

source/ps/Game.cpp

@@ -45 +45 @@
 #include "simulation2/components/ICmpPlayerManager.h"
 
 #include "gui/GUIManager.h"
+#include "soundmanager/CSoundManager.h"
 
 extern bool g_GameRestarted;
 
@@ -299 +300 @@
     if (doInterpolate)
     {
         m_TurnManager->Interpolate(deltaTime);
+        g_SoundManager->idleTask();
     }
     
     // TODO: maybe we should add a CCmpParticleInterface that passes the interpolation commands

source/soundmanager/items/CSoundItem.h

@@ +1 @@
+/* Copyright (C) 2012 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. 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.
+ *
+ * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef SoundTester_CSoundItem_h
+#define SoundTester_CSoundItem_h
+
+#include "CSoundBase.h"
+#include "soundmanager/data/CSoundData.h"
+
+
+class CSoundItem :public CSoundBase
+{
+protected:
+    
+public:
+    CSoundItem      ();
+    CSoundItem      (CSoundData* sndData);
+    
+    virtual ~CSoundItem     ();
+    void    attach          ( CSoundData* itemData );
+    bool    idleTask        ();
+
+protected:
+
+    
+};
+
+
+
+
+
+
+#endif

source/soundmanager/items/CBufferItem.h

@@ +1 @@
+/* Copyright (C) 2012 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. 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.
+ *
+ * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef SoundTester_CBufferItem_h
+#define SoundTester_CBufferItem_h
+
+#include "CSoundBase.h"
+
+class CBufferItem : public CSoundBase
+{
+public:
+    CBufferItem             (CSoundData* sndData);
+    virtual ~CBufferItem    ();
+    
+    virtual void    setLooping   ( bool loops );
+    virtual bool    idleTask     ();
+    
+protected:    
+    virtual void    attach       ( CSoundData* itemData );
+
+    
+};
+
+
+#endif

source/soundmanager/items/CStreamItem.h

@@ +1 @@
+/* Copyright (C) 2012 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. 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.
+ *
+ * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SoundTester_CStreamItem_h
+#define SoundTester_CStreamItem_h
+
+#include "soundmanager/data/CSoundData.h"
+#include "CSoundBase.h"
+
+class CStreamItem : public CSoundBase
+{
+public:
+    CStreamItem                 (CSoundData* sndData);
+    virtual ~CStreamItem        ();
+    
+    virtual void    setLooping  ( bool loops );
+    virtual bool    idleTask    ();
+    
+protected:    
+    virtual void    attach      ( CSoundData* itemData );
+
+};
+
+#endif

source/soundmanager/items/ISoundItem.h

@@ +1 @@
+/* Copyright (C) 2012 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. 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.
+ *
+ * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SoundTester_ISoundItem_h
+#define SoundTester_ISoundItem_h
+
+#include <string>
+#include "lib/external_libraries/openal.h"
+#include "maths/Vector3D.h"
+
+
+class ISoundItem
+{
+    
+public:
+    virtual ~ISoundItem(){};
+    virtual bool getLooping     () = 0;
+    virtual void    setLooping       (bool loop) = 0;
+    virtual bool    isPlaying        () = 0;
+    
+    
+    virtual std::string    getName         () = 0;
+    virtual bool    idleTask         () = 0;
+    
+    virtual void    play             () = 0;
+    virtual void    stop             () = 0;
+
+    virtual void    ensurePlay       () = 0;
+    virtual void    playAsMusic      () = 0;
+    virtual void    playAsAmbient    () = 0;
+
+    virtual void    playAndDelete    () = 0;
+    virtual void    stopAndDelete    () = 0;
+    virtual void    fadeToIn        ( ALfloat newVolume, double fadeDuration) = 0;
+    virtual void    fadeAndDelete    ( double fadeTime ) = 0;
+    virtual void    playLoop         () = 0;
+
+    virtual void    setCone     (ALfloat innerCone, ALfloat outerCone, ALfloat coneGain) = 0;
+    virtual void    setPitch    (ALfloat pitch) = 0;
+    virtual void    setGain     (ALfloat gain) = 0;
+    virtual void    setLocation (const CVector3D& position) = 0;
+    virtual void    setRollOff     (ALfloat gain) = 0;
+};
+
+
+#endif //SoundTester_ISoundItem_h
+ No newline at end of file

source/soundmanager/items/CSoundBase.cpp

@@ +1 @@
+/* Copyright (C) 2012 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. 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.
+ *
+ * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "precompiled.h"
+
+#include "CSoundBase.h"
+#include "soundmanager/CSoundManager.h"
+#include "soundmanager/data/CSoundData.h"
+
+#include <iostream>
+
+#include "lib/timer.h"
+
+
+CSoundBase::CSoundBase()
+{
+    resetVars();
+}
+
+CSoundBase::~CSoundBase()
+{
+    stop();
+    if ( mALSource != 0 ) {
+        alDeleteSources( 1, &mALSource);
+        mALSource = 0;
+    }
+    if ( mSoundData != 0 ) {
+        CSoundData::releaseSoundData( mSoundData );
+        mSoundData = 0;
+    }
+    if ( mName )
+        delete mName;
+}
+
+void CSoundBase::resetVars()
+{
+    mALSource = 0;
+    mSoundData = 0;
+    mLastPlay = false;
+    mLooping = false;
+    mStartFadeTime = 0;
+    mEndFadeTime = 0;
+    mStartVolume = 0;
+    mEndVolume = 0;
+
+    resetFade();
+    mName = new std::string( "sound name" );
+}
+
+void CSoundBase::resetFade()
+{
+    mStartFadeTime = 0;
+    mEndFadeTime = 0;
+    mStartVolume = 0;
+    mEndVolume = 0;
+    mShouldBePlaying = false;
+}
+
+void CSoundBase::setGain(ALfloat gain)
+{
+    alSourcef(mALSource, AL_GAIN, gain);
+}
+void CSoundBase::setRollOff(ALfloat rolls)
+{
+   alSourcef(mALSource, AL_ROLLOFF_FACTOR, rolls);
+}
+void CSoundBase::ensurePlay()
+{
+    if ( mShouldBePlaying && !isPlaying() )
+        play();
+}
+
+void CSoundBase::setCone(ALfloat innerCone, ALfloat outerCone, ALfloat coneGain)
+{
+    alSourcef( mALSource, innerCone, AL_CONE_INNER_ANGLE);
+    alSourcef( mALSource, outerCone, AL_CONE_OUTER_ANGLE);
+    alSourcef( mALSource, coneGain, AL_CONE_OUTER_GAIN);
+}
+
+void CSoundBase::setPitch(ALfloat pitch)
+{
+    alSourcef( mALSource, AL_PITCH, pitch);
+}
+
+void CSoundBase::setDirection(const CVector3D& direction)
+{
+    alSourcefv( mALSource, AL_DIRECTION, direction.GetFloatArray() );
+}
+
+bool CSoundBase::initOpenAL()
+{
+    alGetError(); /* clear error */
+    alGenSources( 1, &mALSource);
+    long anErr = alGetError();
+    if( anErr != AL_NO_ERROR) 
+    {
+        printf("- Error creating sources %ld !!\n", anErr );
+    }
+    else
+    {
+        ALfloat source0Pos[]={ -2.0, 0.0, 0.0};
+        ALfloat source0Vel[]={ 0.0, 0.0, 0.0};
+        
+        alSourcef( mALSource,AL_PITCH,1.0f);
+        alSourcef( mALSource,AL_GAIN,1.0f);
+        alSourcefv( mALSource,AL_POSITION,source0Pos);
+        alSourcefv( mALSource,AL_VELOCITY,source0Vel);
+        alSourcei( mALSource,AL_LOOPING,AL_FALSE);
+        return true;
+    }
+    return false;
+}
+
+bool CSoundBase::isPlaying()
+{
+    int proc_state;
+    alGetSourceiv( mALSource, AL_SOURCE_STATE, &proc_state);
+
+    return ( proc_state == AL_PLAYING );
+}
+
+void CSoundBase::setLastPlay( bool last )
+{
+    mLastPlay = last;
+}
+
+bool CSoundBase::idleTask()
+{
+    return true;
+}
+
+void CSoundBase::setLocation (const CVector3D& position)
+{
+    alSourcefv( mALSource,AL_POSITION, position.GetFloatArray() );
+}
+
+bool CSoundBase::handleFade()
+{
+    if ( mStartFadeTime != 0 ) {
+        double currTime = timer_Time();
+        double pctDone = std::min( 1.0, (currTime - mStartFadeTime) / (mEndFadeTime - mStartFadeTime) );
+        pctDone = std::max( 0.0, pctDone );
+        ALfloat curGain = ((mEndVolume - mStartVolume ) * pctDone) + mStartVolume;
+
+        if  (curGain == 0 )
+            stop();
+        else if ( curGain == mEndVolume ) {
+            alSourcef( mALSource, AL_GAIN, curGain);     
+            resetFade();
+        }
+        else
+            alSourcef( mALSource, AL_GAIN, curGain);     
+    }
+    return true;
+}
+
+bool CSoundBase::getLooping()
+{
+    return mLooping;
+}
+void CSoundBase::setLooping( bool loops )
+{
+    mLooping = loops;
+    alSourcei( mALSource, AL_LOOPING, loops ? AL_TRUE : AL_FALSE );
+}
+
+void CSoundBase::play()
+{
+    mShouldBePlaying = true;
+    if ( mALSource != 0 )
+        alSourcePlay( mALSource );
+}
+void CSoundBase::playAndDelete()
+{
+    setLastPlay( true );
+    play();
+}
+
+void CSoundBase::fadeAndDelete( double fadeTime )
+{
+    setLastPlay( true );
+    fadeToIn( 0, fadeTime );
+}
+
+void    CSoundBase::stopAndDelete()
+{
+    setLastPlay( true );
+    stop();
+}
+
+void CSoundBase::playLoop()
+{
+    if ( mALSource != 0 ) {
+        setLooping( true );
+        play();
+    }
+}
+
+void CSoundBase::fadeToIn( ALfloat newVolume, double fadeDuration)
+{
+    int proc_state;
+    alGetSourceiv( mALSource, AL_SOURCE_STATE, &proc_state);
+    if ( proc_state == AL_PLAYING ) {
+        mStartFadeTime = timer_Time();
+        mEndFadeTime = mStartFadeTime + fadeDuration;
+        alGetSourcef( mALSource, AL_GAIN, &mStartVolume);
+        mEndVolume = newVolume;
+    }
+
+}
+
+void CSoundBase::playAsMusic()
+{
+    g_SoundManager->setMusicItem( this );
+}
+
+void CSoundBase::playAsAmbient()
+{
+    g_SoundManager->setAmbientItem( this );
+}
+
+void CSoundBase::stop()
+{
+    mShouldBePlaying = false;
+    if ( mALSource != 0 ) {
+        int proc_state;
+        alSourcei( mALSource, AL_LOOPING, AL_FALSE );
+        alGetSourceiv( mALSource, AL_SOURCE_STATE, &proc_state);
+        if ( proc_state == AL_PLAYING )
+            alSourceStop( mALSource );
+    }
+}
+
+const char* CSoundBase::Name()
+{
+    return mName->c_str();
+}
+
+std::string CSoundBase::getName()
+{
+    return std::string( mName->c_str() );
+}
+
+void CSoundBase::setNameFromPath(  char* fileLoc )
+{
+    std::string anst( fileLoc );
+    size_t pos = anst.find_last_of("/");
+    if(pos != std::wstring::npos)
+        mName->assign(anst.begin() + pos + 1, anst.end());
+    else
+        mName->assign(anst.begin(), anst.end());
+}
+

source/soundmanager/items/CSoundItem.cpp

@@ +1 @@
+/* Copyright (C) 2012 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. 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.
+ *
+ * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "precompiled.h"
+
+#include "CSoundItem.h"
+#include "soundmanager/data/CSoundData.h"
+
+#include <iostream>
+
+
+CSoundItem::CSoundItem()
+{
+    resetVars();
+}
+
+CSoundItem::CSoundItem(CSoundData* sndData)
+{
+    resetVars();
+    if ( initOpenAL() )
+        attach( sndData );
+}
+
+CSoundItem::~CSoundItem()
+{
+    ALuint al_buf;
+    
+    stop();
+    alSourceUnqueueBuffers(mALSource, 1, &al_buf);
+}
+
+bool CSoundItem::idleTask()
+{
+    handleFade();
+
+    if ( mLastPlay )
+    {
+        int proc_state;
+        alGetSourceiv( mALSource, AL_SOURCE_STATE, &proc_state);
+        return ( proc_state != AL_STOPPED );
+    }
+    return true;
+}
+
+void CSoundItem::attach( CSoundData* itemData )
+{
+    if ( itemData != NULL ) {
+        mSoundData = itemData->incrementCount();
+        alSourcei( mALSource, AL_BUFFER, mSoundData->getBuffer() );
+    }
+}

source/soundmanager/items/CBufferItem.cpp

@@ +1 @@
+/* Copyright (C) 2012 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. 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.
+ *
+ * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "precompiled.h"
+#include "CBufferItem.h"
+#include "soundmanager/data/CSoundData.h"
+
+#include <iostream>
+
+CBufferItem::CBufferItem(CSoundData* sndData)
+{
+    resetVars();
+    if ( initOpenAL() )
+        attach( sndData );
+}
+
+
+CBufferItem::~CBufferItem()
+{
+    stop();
+    int num_processed;
+    alGetSourcei( mALSource, AL_BUFFERS_PROCESSED, &num_processed);
+    
+    if (num_processed > 0)
+    {
+        ALuint* al_buf = new ALuint[num_processed];
+        alSourceUnqueueBuffers(mALSource, num_processed, al_buf);
+
+        delete[] al_buf;
+    }
+}
+
+
+bool CBufferItem::idleTask()
+{
+    handleFade();
+    
+    if ( mLastPlay )
+    {
+        int proc_state;
+        alGetSourceiv( mALSource, AL_SOURCE_STATE, &proc_state);
+        return ( proc_state != AL_STOPPED );
+    }
+    
+    if ( getLooping() ) {
+        int num_processed;
+        alGetSourcei( mALSource, AL_BUFFERS_PROCESSED, &num_processed);
+        
+        for ( int i = 0; i < num_processed; i++ )
+        {
+            ALuint al_buf;
+            alSourceUnqueueBuffers(mALSource, 1, &al_buf);
+            alSourceQueueBuffers(mALSource, 1, &al_buf);
+        }
+    }
+
+    return true;
+}
+
+void CBufferItem::attach( CSoundData* itemData )
+{
+    if ( itemData != NULL ) {
+        mSoundData = itemData->incrementCount();
+        alSourceQueueBuffers(mALSource, mSoundData->getBufferCount(),(const ALuint *) mSoundData->getBufferPtr());
+    }
+}
+
+void CBufferItem::setLooping( bool loops )
+{
+    mLooping = loops;
+}
+

source/soundmanager/items/CSoundBase.h

@@ +1 @@
+/* Copyright (C) 2012 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. 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.
+ *
+ * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef SoundTester_CSoundBase_h
+#define SoundTester_CSoundBase_h
+
+#include <string>
+#include "lib/external_libraries/openal.h"
+#include "soundmanager/items/ISoundItem.h"
+#include "soundmanager/data/CSoundData.h"
+
+
+class CSoundBase :public ISoundItem
+{
+protected:
+    
+    ALuint              mALSource;
+    CSoundData*         mSoundData;
+
+    std::string*        mName;
+    bool                mLastPlay;
+    bool                mLooping;
+    bool                mShouldBePlaying;
+    
+    double          mStartFadeTime;
+    double          mEndFadeTime;
+    ALfloat         mStartVolume;
+    ALfloat         mEndVolume;
+
+public:
+    CSoundBase      ();
+    
+    virtual ~CSoundBase      ();
+    
+    virtual bool    initOpenAL();
+    virtual void    resetVars();
+    virtual void    ensurePlay();
+
+    virtual void setGain     (ALfloat gain);
+    virtual void setRollOff     (ALfloat gain);
+    virtual void setPitch(ALfloat pitch);
+    virtual void setDirection(const CVector3D& direction);
+    virtual void setCone(ALfloat innerCone, ALfloat outerCone, ALfloat coneGain);
+    virtual void setLastPlay( bool last );
+
+    void    play            ();
+    void    playAndDelete   ();
+    bool    idleTask        ();
+    void    playLoop        ();
+    void    stop            ();
+    void    stopAndDelete    ();
+    void    fadeToIn        ( ALfloat newVolume, double fadeDuration);
+
+    void    playAsMusic      ();
+    void    playAsAmbient    ();
+
+    const char*   Name();
+    std::string getName();
+
+    virtual bool getLooping     ();
+    virtual void setLooping     ( bool loops );
+    virtual bool isPlaying();
+    virtual void setLocation (const CVector3D& position);
+    virtual void    fadeAndDelete    ( double fadeTime );
+
+protected:
+
+    void setNameFromPath(  char* fileLoc );
+    void resetFade();
+    bool handleFade();
+
+    
+};
+
+
+
+
+
+
+#endif

source/soundmanager/items/CStreamItem.cpp

@@ +1 @@
+/* Copyright (C) 2012 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. 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.
+ *
+ * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "precompiled.h"
+
+#include "CStreamItem.h"
+#include "soundmanager/data/COggData.h"
+
+#include <iostream>
+
+CStreamItem::CStreamItem(CSoundData* sndData)
+{
+    resetVars();
+    if ( initOpenAL() )
+        attach( sndData );
+}
+
+CStreamItem::~CStreamItem()
+{
+    stop();
+
+    int num_processed;
+    alGetSourcei( mALSource, AL_BUFFERS_PROCESSED, &num_processed);
+    
+    if (num_processed > 0)
+    {
+        ALuint* al_buf = new ALuint[num_processed];
+        alSourceUnqueueBuffers(mALSource, num_processed, al_buf);
+        delete[] al_buf;
+    }
+}
+
+bool CStreamItem::idleTask()
+{
+    handleFade();
+
+    int proc_state;
+    alGetSourceiv( mALSource, AL_SOURCE_STATE, &proc_state);
+    
+    if ( proc_state == AL_STOPPED ) {
+        if ( mLastPlay )
+            return ( proc_state != AL_STOPPED );
+    }
+    else {
+        COggData* tmp = (COggData*)mSoundData;
+        
+        if ( ! tmp->isFileFinished() ) {
+            int num_processed;
+            alGetSourcei( mALSource, AL_BUFFERS_PROCESSED, &num_processed);
+            
+            if (num_processed > 0)
+            {
+                ALuint* al_buf = new ALuint[num_processed];
+                alSourceUnqueueBuffers(mALSource, num_processed, al_buf);
+                int didWrite = tmp->fetchDataIntoBuffer( num_processed, al_buf);
+                alSourceQueueBuffers( mALSource, didWrite, al_buf);
+                delete[] al_buf;
+            }
+        }
+        else if ( getLooping() )
+        {
+            tmp->resetFile();
+        }
+    }
+    return true;
+}
+
+void CStreamItem::attach( CSoundData* itemData )
+{
+    if ( itemData != NULL ) {
+        mSoundData = itemData->incrementCount();
+        alSourceQueueBuffers(mALSource, mSoundData->getBufferCount(), (const ALuint *)mSoundData->getBufferPtr());
+    }
+}
+
+void CStreamItem::setLooping( bool loops )
+{
+    mLooping = loops;
+}
+

source/soundmanager/CSoundManager.cpp

@@ +1 @@
+/* Copyright (C) 2012 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. 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.
+ *
+ * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "precompiled.h"
+
+#include "CSoundManager.h"
+#include "soundmanager/items/CSoundItem.h"
+#include "soundmanager/items/CBufferItem.h"
+#include "soundmanager/items/CStreamItem.h"
+#include "soundmanager/js/JAmbientSound.h"
+#include "soundmanager/js/JMusicSound.h"
+#include "soundmanager/js/JSound.h"
+#include "soundmanager/data/CSoundData.h"
+
+
+CSoundManager*  g_SoundManager;
+
+void CSoundManager::ScriptingInit()
+{
+    JAmbientSound::ScriptingInit();
+    JMusicSound::ScriptingInit();
+    JSound::ScriptingInit();
+}
+
+CSoundManager::CSoundManager()
+{    
+    mItems = new ItemsList;
+    mCurrentEnvirons    = 0;
+    mCurrentTune        = 0;
+    mGain               = 1;
+    mMusicGain          = 1;
+    mAmbientGain        = 1;
+    mActionGain         = 1;
+    mEnabled            = true;
+    mBufferCount        = 50;
+    mBufferSize         = 65536;
+    
+    alc_init();
+}
+
+CSoundManager::~CSoundManager()
+{    
+    ItemsList::iterator lstr = mItems->begin();
+    while ( lstr != mItems->end() ) {
+        (*lstr)->stop();
+        delete *lstr;
+        lstr++;
+    }
+
+    alcDestroyContext( mContext );
+    alcCloseDevice( mDevice );
+
+    delete mItems;
+    mItems = 0L;
+    mCurrentEnvirons    = 0;
+    mCurrentTune        = 0;
+}
+
+
+Status CSoundManager::alc_init()
+{   
+    Status ret = INFO::OK;
+
+    mDevice = alcOpenDevice(NULL);
+    if(mDevice)
+    {
+        mContext = alcCreateContext(mDevice, 0);    // no attrlist needed
+        if(mContext)
+            alcMakeContextCurrent(mContext);
+    }
+
+    // check if init succeeded.
+    // some OpenAL implementations don't indicate failure here correctly;
+    // we need to check if the device and context pointers are actually valid.
+    ALCenum err = alcGetError(mDevice);
+    if(err != ALC_NO_ERROR || !mDevice || !mContext)
+    {
+#if OS_UNIX
+        ret = INFO::OK;
+#else
+        ret = ERR::FAIL;
+#endif
+    }
+
+    const char* dev_name = (const char*)alcGetString(mDevice, ALC_DEVICE_SPECIFIER);
+    wchar_t buf[200];
+    swprintf(buf, ARRAY_SIZE(buf), L"SND| alc_init: success, using %hs\n", dev_name);
+
+    return ret;
+}
+void CSoundManager::setMemoryUsage( long bufferSize, int bufferCount )
+{
+    mBufferCount = bufferCount;
+    mBufferSize = bufferSize;
+}
+long CSoundManager::getBufferCount()
+{
+    return mBufferCount;
+}
+long CSoundManager::getBufferSize()
+{
+    return mBufferSize;
+}
+
+
+void CSoundManager::setMasterGain( float gain)
+{
+    mGain = gain;
+}
+void CSoundManager::setMusicGain( float gain)
+{
+    mMusicGain = gain;
+}
+void CSoundManager::setAmbientGain( float gain)
+{
+    mAmbientGain = gain;
+}
+void CSoundManager::setActionGain( float gain)
+{
+    mActionGain = gain;
+}
+
+
+ISoundItem* CSoundManager::loadItem( const VfsPath* itemPath )
+{    
+    CSoundData*   itemData = CSoundData::soundDataFromFile( itemPath );
+    ISoundItem*   answer  = NULL;
+    
+    if ( itemData != NULL ) {
+        if ( itemData->isOneShot() ) {
+            if ( itemData->getBufferCount() == 1 )
+                answer = new CSoundItem( itemData );
+            else
+                answer = new CBufferItem( itemData );
+        }
+        else {
+            answer = new CStreamItem( itemData );
+        }
+
+        if ( answer != NULL )
+            mItems->push_back( answer );
+    }
+
+    
+    return answer;
+}
+
+unsigned long CSoundManager::count()
+{
+    return mItems->size();
+}
+
+void CSoundManager::idleTask()
+{
+    if ( mItems )
+    {
+        ItemsList::iterator lstr = mItems->begin();
+        ItemsList  deadItemList;
+        ItemsList* nextItemList = new ItemsList;
+
+
+        while ( lstr != mItems->end() ) {
+            if ( (*lstr)->idleTask() )
+                nextItemList->push_back( *lstr );
+            else
+                deadItemList.push_back( *lstr );
+            lstr++;
+        }
+        delete mItems;
+        mItems = nextItemList;
+
+        ItemsList::iterator deadItems = deadItemList.begin();
+        while ( deadItems != deadItemList.end() )
+        {   
+            delete *deadItems;
+            deadItems++;
+        }
+    }
+    if ( mCurrentTune )
+        mCurrentTune->ensurePlay();
+    if ( mCurrentEnvirons )
+        mCurrentEnvirons->ensurePlay();
+}
+
+void CSoundManager::deleteItem( long itemNum )
+{
+    ItemsList::iterator lstr = mItems->begin();
+    lstr += itemNum;
+    
+    delete *lstr;
+    
+    mItems->erase( lstr );
+}
+
+ISoundItem* CSoundManager::getSoundItem( unsigned long itemRow )
+{
+   return (*mItems)[itemRow];
+}
+
+void CSoundManager::InitListener()
+{
+    ALfloat listenerPos[]={0.0,0.0,0.0};
+    ALfloat listenerVel[]={0.0,0.0,0.0};
+    ALfloat listenerOri[]={0.0,0.0,-1.0, 0.0,1.0,0.0};
+
+    alListenerfv(AL_POSITION,listenerPos);
+    alListenerfv(AL_VELOCITY,listenerVel);
+    alListenerfv(AL_ORIENTATION,listenerOri);
+
+    alDistanceModel(AL_EXPONENT_DISTANCE);
+}
+
+void CSoundManager::setEnabled( bool doEnable )
+{
+    mEnabled = doEnable;
+}
+
+void CSoundManager::playActionItem( ISoundItem* anItem )
+{
+    if ( anItem )
+    {
+        if ( mEnabled && ( mActionGain > 0 ) ) {
+            anItem->setGain( mGain * mActionGain );
+            anItem->play();
+        }
+    }
+}
+void CSoundManager::playGroupItem( ISoundItem* anItem, ALfloat groupGain)
+{
+    if ( anItem )
+    {
+        if ( mEnabled && ( mActionGain > 0 ) ) {
+            anItem->setGain( mGain * groupGain );
+            anItem->play();
+        }
+    }
+}
+void CSoundManager::setMusicItem( ISoundItem* anItem )
+{
+    if ( mCurrentTune ) {
+        mCurrentTune->fadeAndDelete(3.00);
+        mCurrentTune = 0L;
+    }
+    idleTask();
+    if ( anItem )
+    {
+        if ( mEnabled && ( mMusicGain > 0 ) ) {
+            mCurrentTune = anItem;
+            mCurrentTune->setGain( 0 );
+            mCurrentTune->playLoop();
+            mCurrentTune->fadeToIn( mGain * mMusicGain, 3.00 );
+        }
+    }
+}
+
+void CSoundManager::setAmbientItem( ISoundItem* anItem )
+{
+    if ( mCurrentEnvirons ) {
+        mCurrentEnvirons->fadeAndDelete(3.00);
+        mCurrentEnvirons = 0L;
+    }
+    idleTask();
+    
+    if ( anItem )
+    {
+        if ( mEnabled && ( mAmbientGain > 0 ) ) {
+            mCurrentEnvirons = anItem;
+            mCurrentEnvirons->setGain( 0 );
+            mCurrentEnvirons->playLoop();
+            mCurrentEnvirons->fadeToIn( mGain * mAmbientGain, 3.00 );
+        }
+    }
+}
+

source/soundmanager/data/COggData.h

@@ +1 @@
+/* Copyright (C) 2012 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. 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.
+ *
+ * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef SoundTester_COggData_h
+#define SoundTester_COggData_h
+
+#include "CSoundData.h"
+#include "vorbis/vorbisfile.h"
+#include "lib/external_libraries/openal.h"
+
+class COggData : public CSoundData
+{
+    ALuint mFormat;
+    long mFrequency;
+
+public:
+    COggData      ();
+    virtual ~COggData      ();                                     
+                                     
+    virtual bool InitOggFile( const wchar_t* fileLoc );
+    virtual bool isFileFinished();
+    virtual bool isOneShot();
+
+    virtual int fetchDataIntoBuffer( int count, ALuint* buffers);
+    virtual void resetFile();
+
+protected:
+    OggVorbis_File  m_vf;
+    int            m_current_section;
+    bool           mFileFinished;
+    bool           mOneShot;
+    ALuint         mBuffer[100];
+    int            mBuffersUsed;
+
+    bool addDataBuffer( char* data, long length);
+    void setFormatAndFreq( int form, ALsizei freq);
+    ALsizei  getBufferCount();
+    ALuint getBuffer();
+    ALuint* getBufferPtr();  
+};
+
+
+
+#endif

source/soundmanager/data/CSoundData.cpp

@@ +1 @@
+/* Copyright (C) 2012 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. 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.
+ *
+ * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "precompiled.h"
+#include "CSoundData.h"
+
+
+#include <iostream>
+#include "COggData.h"
+#include "ps/Filesystem.h"
+#include "lib/file/vfs/vfs_util.h"
+
+DataMap* CSoundData::sSoundData = NULL;
+
+CSoundData::CSoundData()
+{
+    initProperties();
+}
+
+CSoundData::~CSoundData()
+{
+    if ( mALBuffer != 0 )
+        alDeleteBuffers( 1, &mALBuffer );
+}
+
+void CSoundData::initProperties()
+{
+    mALBuffer = 0;
+    mRetentionCount = 0;
+}
+
+void CSoundData::releaseSoundData( CSoundData* theData )
+{
+    DataMap::iterator   itemFind;
+
+    if ( theData->decrementCount() ) {
+        if ( ( itemFind = CSoundData::sSoundData->find( theData->getFileName() ) ) != sSoundData->end() )
+        {
+            CSoundData* dier = itemFind->second;
+            CSoundData::sSoundData->erase( itemFind );
+            delete dier;
+        }
+    }
+}
+
+CSoundData* CSoundData::soundDataFromFile( const VfsPath* itemPath )
+{
+    if ( CSoundData::sSoundData == NULL )
+        CSoundData::sSoundData = new DataMap;
+    
+    Path                fExt = itemPath->Extension();
+    DataMap::iterator   itemFind;
+    CSoundData*          answer = NULL;
+
+
+    if ( ( itemFind = CSoundData::sSoundData->find( itemPath->string() ) ) != sSoundData->end() )
+    {
+//        debug_printf(L"data found in cache at: %ls\n\n", itemPath.string().c_str());
+        answer = itemFind->second;
+    }
+    else
+    {
+        if ( fExt == ".ogg" )
+            answer = soundDataFromOgg( itemPath );
+    
+        if ( answer && answer->isOneShot() )
+            (*CSoundData::sSoundData)[itemPath->string()] = answer;
+    
+    }
+    return answer;
+}
+
+bool CSoundData::isOneShot()
+{
+    return true;
+}
+
+
+CSoundData* CSoundData::soundDataFromOgg( const VfsPath* itemPath )
+{
+    CSoundData* answer = NULL;
+    COggData*   oggAnswer = new COggData();
+
+    OsPath realPath;
+    Status ret = g_VFS->GetRealPath( *itemPath, realPath);
+    if ( ret == INFO::OK ) {
+        if ( oggAnswer->InitOggFile( realPath.string().c_str() ) ) {
+            answer = oggAnswer;
+        }
+    }    
+    return answer;
+}
+
+
+ALsizei CSoundData::getBufferCount()
+{
+    return 1;
+}
+
+std::wstring     CSoundData::getFileName()
+{
+    return mFileName;
+}
+
+
+
+
+
+
+
+
+
+CSoundData* CSoundData::incrementCount()
+{
+    mRetentionCount++;
+    return this;
+}
+
+bool CSoundData::decrementCount()
+{
+    mRetentionCount--;
+    
+    return ( mRetentionCount <= 0 );
+}
+
+ALuint CSoundData::getBuffer()
+{
+    return mALBuffer;
+}
+ALuint* CSoundData::getBufferPtr()
+{
+    return &mALBuffer;
+}
+

source/soundmanager/data/COggData.cpp

@@ +1 @@
+/* Copyright (C) 2012 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. 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.
+ *
+ * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "precompiled.h"
+
+
+#include "COggData.h"
+
+
+#include <wchar.h>
+#include <iostream>
+#include "soundmanager/CSoundManager.h"
+#include "lib/external_libraries/openal.h"
+
+COggData::COggData()
+{
+    mOneShot = false;
+}
+
+COggData::~COggData()
+{
+    alDeleteBuffers( mBuffersUsed, mBuffer );
+    ov_clear(&m_vf);
+}
+
+void COggData::setFormatAndFreq( int form, ALsizei freq)
+{
+    mFormat = form;
+    mFrequency = freq;
+}
+
+bool COggData::InitOggFile( const wchar_t* fileLoc )
+{
+    int buffersToStart = g_SoundManager->getBufferCount();
+    
+//    fprintf(stderr, "ready to open ogg file at:%ls \r\r", fileLoc); 
+
+    char nameH[300];
+    sprintf( nameH, "%ls", fileLoc );
+    
+    FILE* f = fopen( nameH, "rb");
+    m_current_section = 0;
+    int err = ov_open_callbacks(f, &m_vf, NULL, 0, OV_CALLBACKS_DEFAULT);
+    if ( err < 0) {
+        fprintf(stderr,"Input does not appear to be an Ogg bitstream :%d :%d.\n", err, ferror(f) );
+        return false;
+    }
+
+    mFileName       = std::wstring(fileLoc);
+
+    mFileFinished = false;
+    setFormatAndFreq( (m_vf.vi->channels == 1)? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16 , (ALsizei)m_vf.vi->rate );
+
+    alGetError(); /* clear error */
+    alGenBuffers( buffersToStart, mBuffer);
+    
+    if(alGetError() != AL_NO_ERROR) 
+    {
+        printf("- Error creating initial buffer !!\n");
+        return false;
+    }
+    else
+    {
+        mBuffersUsed = fetchDataIntoBuffer( buffersToStart, mBuffer);
+        if ( mFileFinished ) {
+            mOneShot = true;
+            if ( mBuffersUsed < buffersToStart ) {
+                alDeleteBuffers( buffersToStart - mBuffersUsed, &mBuffer[mBuffersUsed] );
+            }
+        }
+    }
+    return true;
+}
+
+ALsizei COggData::getBufferCount()
+{
+    return mBuffersUsed;
+}
+
+bool COggData::isFileFinished()
+{
+    return mFileFinished;
+}
+
+void COggData::resetFile()
+{
+    ov_time_seek( &m_vf, 0 );
+    m_current_section = 0;
+    mFileFinished = false;
+}
+
+bool COggData::isOneShot()
+{
+    return mOneShot;
+}
+
+int COggData::fetchDataIntoBuffer( int count, ALuint* buffers)
+{
+    long bufferSize = g_SoundManager->getBufferSize();
+    
+    char* pcmout = new char[bufferSize + 5000];
+    int buffersWritten = 0;
+    
+    for(int i = 0; ( i < count ) && !mFileFinished; i++) {
+        char*   readDest = pcmout;
+        long  totalRet = 0;
+        while (totalRet < bufferSize )
+        {
+            long ret=ov_read(&m_vf,readDest, 4096,0,2,1, &m_current_section);
+            if (ret == 0) {
+                mFileFinished=true;
+                break;
+            } else if (ret < 0) {
+                /* error in the stream.  Not a problem, just reporting it in
+                 case we (the app) cares.  In this case, we don't. */
+            } else {
+                totalRet += ret;
+                readDest += ret;
+            }
+        }
+        if ( totalRet > 0 )
+        {
+            buffersWritten++;
+            alBufferData( buffers[i], mFormat, pcmout, (ALsizei)totalRet, (int)mFrequency);
+        }
+    }
+    delete[] pcmout;
+    return buffersWritten;
+}
+
+
+ALuint COggData::getBuffer()
+{
+    return mBuffer[0];
+}
+ALuint* COggData::getBufferPtr()
+{
+    return mBuffer;
+}
+
+
+
+
+

source/soundmanager/data/CSoundData.h

@@ +1 @@
+/* Copyright (C) 2012 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. 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.
+ *
+ * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef SoundTester_CSoundData_h
+#define SoundTester_CSoundData_h
+#include "lib/os_path.h"
+
+#include "string"
+#include "map"
+#include "lib/external_libraries/openal.h"
+#include "lib/file/vfs/vfs_path.h"
+
+class CSoundData;
+typedef std::map<std::wstring, CSoundData*> DataMap;
+
+
+
+class CSoundData
+{
+public:
+    static CSoundData* soundDataFromFile( const VfsPath* itemPath );
+    static CSoundData* soundDataFromOgg( const VfsPath* itemPath );
+
+    static void releaseSoundData( CSoundData* theData );
+
+    CSoundData      ();
+    CSoundData      (ALuint dataSource);
+    virtual ~CSoundData     ();
+    
+    CSoundData*     incrementCount();
+    bool            decrementCount();
+    void            initProperties();
+    virtual bool isOneShot();
+
+    
+    virtual ALuint      getBuffer();
+    virtual ALsizei     getBufferCount();
+    std::wstring        getFileName();
+    virtual ALuint*     getBufferPtr();
+
+protected:
+    static     DataMap*  sSoundData;
+
+    ALuint          mALBuffer;
+    int             mRetentionCount;
+    std::wstring    mFileName;
+    
+    
+    
+};
+
+
+
+
+
+
+#endif

source/soundmanager/CSoundManager.h

@@ +1 @@
+/* Copyright (C) 2012 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. 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.
+ *
+ * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef SoundTester_CSoundManager_h
+#define SoundTester_CSoundManager_h
+
+#include "vector"
+#include "map"
+
+#include "soundmanager/items/ISoundItem.h"
+#include "lib/file/vfs/vfs_path.h"
+
+typedef std::vector<ISoundItem*> ItemsList;
+
+
+class CSoundManager
+{
+protected:
+
+    ALuint              mALEnvironment;
+    ALCcontext*         mContext;
+    ALCdevice*          mDevice;
+    ISoundItem*         mCurrentTune;
+    ISoundItem*         mCurrentEnvirons;
+    ItemsList*          mItems;
+    float               mGain;
+    float               mMusicGain;
+    float               mAmbientGain;
+    float               mActionGain;
+    bool                mEnabled;
+    long                mBufferSize;
+    int                 mBufferCount;
+    
+public:
+     CSoundManager      ();
+    virtual ~CSoundManager      ();
+
+    ISoundItem* loadItem( const VfsPath* itemPath );
+
+    static void ScriptingInit();
+
+    float radiansOffCenter( const CVector3D& position, bool& onScreen );
+
+    
+    ISoundItem*     itemFromWAV     ( VfsPath& fname);
+    ISoundItem*     itemFromOgg     ( VfsPath& fname);
+
+    ISoundItem*     getSoundItem    ( unsigned long itemRow );
+    unsigned long   count           ();
+    void            idleTask        ();
+    void            deleteItem      ( long itemNum );
+    
+    void    setMemoryUsage( long bufferSize, int bufferCount );
+    long    getBufferCount();
+    long    getBufferSize();
+
+    void        setMusicItem( ISoundItem* anItem );
+    void        setAmbientItem( ISoundItem* anItem );
+    void        playActionItem( ISoundItem* anItem );
+    void        playGroupItem( ISoundItem* anItem, ALfloat groupGain);
+
+    void        setMasterGain( float gain);
+    void        setMusicGain( float gain);
+    void        setAmbientGain( float gain);
+    void        setActionGain( float gain);
+    
+    void        setEnabled( bool doEnable );
+protected:
+    void    InitListener();
+    virtual Status alc_init();
+
+};
+
+
+
+extern CSoundManager*  g_SoundManager;
+
+
+
+
+
+
+
+#endif

source/soundmanager/js/JAmbientSound.cpp

@@ +1 @@
+/* Copyright (C) 2009 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. 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.
+ *
+ * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "precompiled.h"
+
+#include "JAmbientSound.h"
+#include "maths/Vector3D.h"
+
+#include "lib/utf8.h"
+#include "ps/Filesystem.h"
+
+#include "soundmanager/CSoundManager.h"
+
+JAmbientSound::JAmbientSound(const VfsPath& pathname)
+{
+    mFileName = new VfsPath( pathname.string().c_str() );
+}
+
+JAmbientSound::~JAmbientSound()
+{
+}
+
+
+// start playing the sound, all ambient sounds loop
+bool JAmbientSound::Play(JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv))
+{
+    ISoundItem* aSnd = g_SoundManager->loadItem( mFileName );
+
+    aSnd->playAsAmbient();
+
+    return true;
+}
+
+// start playing the sound, all ambient sounds loop
+bool JAmbientSound::Loop(JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv))
+{
+    ISoundItem* aSnd = g_SoundManager->loadItem( mFileName );
+
+    aSnd->playAsAmbient();
+    return true;
+}
+bool JAmbientSound::Free(JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv))
+{
+    g_SoundManager->setAmbientItem( 0L );
+
+    return true;
+}
+
+// Script-bound functions
+
+
+void JAmbientSound::ScriptingInit()
+{
+    AddMethod<CStr, &JAmbientSound::ToString>("toString", 0);
+    AddMethod<bool, &JAmbientSound::Play>("play", 0);
+    AddMethod<bool, &JAmbientSound::Loop>("loop", 0);
+    AddMethod<bool, &JAmbientSound::Free>("free", 0);
+    
+    CJSObject<JAmbientSound>::ScriptingInit("AmbientSound", &JAmbientSound::Construct, 1);
+}
+
+CStr JAmbientSound::ToString(JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv))
+{
+    std::ostringstream stringStream;
+    stringStream << "[object AmbientSound: ";
+    stringStream << mFileName->string().c_str();
+    
+    return stringStream.str();
+}
+
+JSBool JAmbientSound::Construct(JSContext* cx, uintN UNUSED(argc), jsval* vp)
+{
+//  JSU_REQUIRE_MIN_PARAMS(1);
+    
+    CStrW filename;
+    if (! ToPrimitive<CStrW>(cx, JS_ARGV(cx, vp)[0], filename))
+        return JS_FALSE;
+    
+    JAmbientSound* newObject = new JAmbientSound(filename);
+    newObject->m_EngineOwned = false;
+
+    JS_SET_RVAL(cx, vp, OBJECT_TO_JSVAL(newObject->GetScript()));
+    
+    return JS_TRUE;
+}

source/soundmanager/js/JSound.cpp

@@ +1 @@
+/* Copyright (C) 2009 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. 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.
+ *
+ * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "precompiled.h"
+#include "JSound.h"
+#include "maths/Vector3D.h"
+
+#include "lib/utf8.h"
+#include "ps/Filesystem.h"
+
+#include "soundmanager/CSoundManager.h"
+
+
+JSound::JSound(const VfsPath& pathname)
+{
+    mSndItem = g_SoundManager->loadItem( &pathname );
+}
+
+JSound::~JSound()
+{
+    if ( mSndItem ) {
+        mSndItem->fadeAndDelete(0.2);
+        mSndItem = 0;
+    }
+}
+
+bool JSound::clearSoundItem()
+{
+    mSndItem = 0L;
+    return true;
+}
+
+bool JSound::SetGain(JSContext* cx, uintN UNUSED(argc), jsval* argv)
+{
+    if (! mSndItem )
+        return false;
+
+    float gain;
+    if (! ToPrimitive<float>(cx, argv[0], gain))
+        return false;
+    
+    mSndItem->setGain( gain );  
+    return true;
+}
+
+bool JSound::SetPitch(JSContext* cx, uintN UNUSED(argc), jsval* argv)
+{
+    if (! mSndItem )
+        return false;
+
+    float pitch;
+    if (! ToPrimitive<float>(cx, argv[0], pitch))
+        return false;
+    
+    mSndItem->setPitch( pitch );
+    return true;
+}
+
+bool JSound::SetPosition(JSContext* cx, uintN argc, jsval* argv)
+{
+    if (! mSndItem )
+        return false;
+    
+    ENSURE(argc >= 1); // FIXME
+    
+    CVector3D pos;
+    // absolute world coords
+    if (!ToPrimitive<CVector3D>(cx, argv[0], pos))
+        return false;
+
+    mSndItem->setLocation( pos );
+    
+    return true;
+}
+
+
+bool JSound::Fade(JSContext* cx, uintN UNUSED(argc), jsval* argv)
+{
+    if (! mSndItem )
+        return false;
+    
+//  ENSURE(argc >= 3); // FIXME
+    float initial_gain, final_gain;
+    float length;
+    if (! (ToPrimitive<float>(cx, argv[0], initial_gain)
+           && ToPrimitive<float>(cx, argv[1], final_gain)
+           && ToPrimitive<float>(cx, argv[2], length)))
+        return false;
+    
+    mSndItem->setGain( initial_gain );
+    mSndItem->fadeToIn( final_gain, length );
+
+    return true;
+}
+
+bool JSound::Play(JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv))
+{
+    if (! mSndItem )
+        return false;
+
+    mSndItem->play();
+
+    return true;
+}
+
+bool JSound::Loop(JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv))
+{
+    if (! mSndItem )
+        return false;
+
+    mSndItem->playLoop();
+
+    return true;
+}
+
+bool JSound::Free(JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv))
+{
+    if ( mSndItem ) {
+        mSndItem->fadeAndDelete(0.2);
+        mSndItem = 0;
+    }
+
+    return true;
+}
+
+void JSound::ScriptingInit()
+{
+    AddMethod<CStr, &JSound::ToString>("toString", 0);
+    AddMethod<bool, &JSound::Play>("play", 0);
+    AddMethod<bool, &JSound::Loop>("loop", 0);
+    AddMethod<bool, &JSound::Free>("free", 0);
+    AddMethod<bool, &JSound::SetGain>("setGain", 0);
+    AddMethod<bool, &JSound::SetPitch>("setPitch", 0);
+    AddMethod<bool, &JSound::SetPosition>("setPosition", 0);
+    AddMethod<bool, &JSound::Fade>("fade", 0);
+    
+    CJSObject<JSound>::ScriptingInit("Sound", &JSound::Construct, 1);
+}
+
+CStr JSound::ToString(JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv))
+{
+    return "[object Sound: " + ( mSndItem ? mSndItem->getName() : "(null)" ) + "]";
+}
+
+JSBool JSound::Construct(JSContext* cx, uintN UNUSED(argc), jsval* vp)
+{
+//  JSU_REQUIRE_MIN_PARAMS(1);
+    
+    CStrW filename;
+    if (! ToPrimitive<CStrW>(cx, JS_ARGV(cx, vp)[0], filename))
+        return JS_FALSE;
+    
+    JSound* newObject = new JSound(filename);
+    newObject->m_EngineOwned = false;
+    JS_SET_RVAL(cx, vp, OBJECT_TO_JSVAL(newObject->GetScript()));
+    
+    return JS_TRUE;
+}

source/soundmanager/js/JMusicSound.cpp

@@ +1 @@
+/* Copyright (C) 2009 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. 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.
+ *
+ * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "precompiled.h"
+
+#include "JMusicSound.h"
+#include "maths/Vector3D.h"
+
+#include "lib/utf8.h"
+#include "ps/Filesystem.h"
+
+#include "soundmanager/CSoundManager.h"
+
+
+JMusicSound::JMusicSound(const VfsPath& pathname)
+{
+    mFileName = new VfsPath( pathname.string().c_str() );
+}
+
+JMusicSound::~JMusicSound()
+{
+    delete mFileName;
+}
+
+bool JMusicSound::Play(JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv))
+{
+    ISoundItem* aSnd = g_SoundManager->loadItem( mFileName );
+    aSnd->playAsMusic();
+
+    return true;
+}
+
+// request the sound be played until free() is called. returns immediately.
+bool JMusicSound::Loop(JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv))
+{
+    ISoundItem* aSnd = g_SoundManager->loadItem( mFileName );
+    aSnd->playAsMusic();
+
+    return true;
+}
+
+void JMusicSound::ScriptingInit()
+{
+    AddMethod<CStr, &JMusicSound::ToString>("toString", 0);
+    AddMethod<bool, &JMusicSound::Play>("play", 0);
+    AddMethod<bool, &JMusicSound::Loop>("loop", 0);
+    
+    CJSObject<JMusicSound>::ScriptingInit("MusicSound", &JMusicSound::Construct, 1);
+}
+
+CStr JMusicSound::ToString(JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv))
+{
+    std::ostringstream stringStream;
+    stringStream << "[object MusicSound: ";
+    stringStream << mFileName->string().c_str();
+    
+    return stringStream.str();
+}
+
+JSBool JMusicSound::Construct(JSContext* cx, uintN UNUSED(argc), jsval* vp)
+{
+//  JSU_REQUIRE_MIN_PARAMS(1);
+    
+    CStrW filename;
+    if (! ToPrimitive<CStrW>(cx, JS_ARGV(cx, vp)[0], filename))
+        return JS_FALSE;
+    
+    JMusicSound* newObject = new JMusicSound(filename);
+    newObject->m_EngineOwned = false;
+    JS_SET_RVAL(cx, vp, OBJECT_TO_JSVAL(newObject->GetScript()));
+    
+    return JS_TRUE;
+}

source/soundmanager/js/SMSoundGroup.cpp

@@ +1 @@
+/* Copyright (C) 2010 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. 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.
+ *
+ * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+* =========================================================================
+* File        : SoundGroup.cpp
+* Project     : 0 A.D.
+* Description : Loads up a group of sound files with shared properties, 
+*               and provides a simple interface for playing them.        
+* =========================================================================
+*/
+
+#include "precompiled.h"
+#include "soundmanager/CSoundManager.h"
+#include "SMSoundGroup.h"
+
+#include <algorithm>
+
+#include "lib/rand.h"
+
+#include "ps/XML/Xeromyces.h"
+#include "ps/CLogger.h"
+#include "ps/Filesystem.h"
+#include "ps/Util.h"
+#include "ps/Game.h"
+#include "ps/CLogger.h"
+#include "graphics/GameView.h"
+#include "graphics/Camera.h"
+#include "soundmanager/items/ISoundItem.h"
+
+extern CGame *g_Game;
+
+#define PI 3.14126f
+
+
+static const bool DISABLE_INTENSITY = true; // disable for now since it's broken
+
+void CSMSoundGroup::SetGain(float gain)
+{
+    gain = std::min(gain, 1.0f);
+    m_Gain = gain;
+}
+
+void CSMSoundGroup::SetDefaultValues()
+{
+    m_index = 0;
+    m_Flags = 0;
+    m_Intensity = 0;
+    m_CurTime = 0.0f;
+
+    // sane defaults; will probably be replaced by the values read during LoadSoundGroup.
+    SetGain(0.7f);
+    m_Pitch = 1.0f;
+    m_Priority = 60;
+    m_PitchUpper = 1.1f;
+    m_PitchLower = 0.9f;
+    m_GainUpper = 1.0f;
+    m_GainLower = 0.8f;
+    m_ConeOuterGain = 0.0f;
+    m_ConeInnerAngle = 360.0f;
+    m_ConeOuterAngle = 360.0f;
+    m_Decay = 3.0f;
+    m_IntensityThreshold = 3;
+    // WARNING: m_TimeWindow is currently unused and uninitialized
+}
+
+CSMSoundGroup::CSMSoundGroup()
+{
+    SetDefaultValues();
+}
+
+CSMSoundGroup::CSMSoundGroup(const VfsPath& pathnameXML)
+{
+    SetDefaultValues();
+    LoadSoundGroup(pathnameXML);
+}
+
+CSMSoundGroup::~CSMSoundGroup()
+{
+    // clean up all the handles from this group.
+    ReleaseGroup();
+}
+
+static float RandFloat(float min, float max)
+{
+    return float(rand(min*100.0f, max*100.0f) / 100.0f);
+}
+
+float CSMSoundGroup::radiansOffCenter( const CVector3D& position, bool& onScreen, float& itemRollOff )
+{
+    float x, y;
+    float answer = 0.0;
+    const size_t screenWidth = g_Game->GetView()->GetCamera()->GetViewPort().m_Width;
+    const size_t screenHeight = g_Game->GetView()->GetCamera()->GetViewPort().m_Height;
+    float bufferSize = screenWidth * 0.10;
+    const size_t audioWidth = screenWidth;
+    float radianCap = PI / 3;
+    
+    g_Game->GetView()->GetCamera()->GetScreenCoordinates(position, x, y);
+    
+    onScreen = true;
+
+    if ( x < -bufferSize ){
+        onScreen = false;
+        answer = -radianCap;
+    }
+    else if ( x > screenWidth + bufferSize ) {
+        onScreen = false;
+        answer = radianCap;
+    }
+    else {
+        if ( ( x < 0 ) || ( x > screenWidth ) ) {
+            itemRollOff = 0.5;
+        }
+        float pixPerRadian = audioWidth / ( radianCap * 2 );
+        answer = ( x - (screenWidth/2) ) / pixPerRadian;
+    }
+
+    if ( y < -bufferSize ){
+        onScreen = false;
+    }
+    else if ( y > screenHeight + bufferSize ) {
+        onScreen = false;
+    }
+    else {
+        if ( ( y < 0 ) || ( y > screenHeight ) ) {
+            itemRollOff = 0.5;
+        }
+    }
+
+        
+ //   debug_printf(L"do play at x portion:%f pts x:%f, y=%f at radians=%f\n\n", answer, x, y, answer );
+
+    return answer;
+}
+
+void CSMSoundGroup::UploadPropertiesAndPlay(int theIndex, const CVector3D& position)
+{
+    bool    isOnscreen;
+    ALfloat itemRollOff = 0.02f;
+
+    float   offSet = radiansOffCenter( position, isOnscreen, itemRollOff);
+
+    if ( isOnscreen || TestFlag(eDistanceless) || TestFlag(eOmnipresent) ) {
+        if ( snd_group.size() == 0 )
+            Reload();
+
+        ISoundItem* hSound = snd_group[theIndex];
+        CVector3D origin = g_Game->GetView()->GetCamera()->GetOrientation().GetTranslation();
+        float sndDist = origin.Y;
+
+        if(!TestFlag(eOmnipresent)) {
+            hSound->setLocation( CVector3D(  (sndDist * sin(offSet)), 0, sndDist * cos(offSet) ));
+            hSound->setRollOff( itemRollOff );
+        }
+
+        if( TestFlag(eRandPitch) )
+            hSound->setPitch( RandFloat( m_PitchLower, m_PitchUpper ) );
+        else
+            hSound->setPitch( m_Pitch );
+
+        ALfloat theGain = m_Gain;
+        if( TestFlag(eRandGain) )
+            theGain = RandFloat( m_GainLower, m_GainUpper);
+
+        hSound->setCone( m_ConeInnerAngle, m_ConeOuterAngle, m_ConeOuterGain);
+
+        g_SoundManager->playGroupItem( hSound, theGain );
+    }
+}
+
+
+static void HandleError(const std::wstring& message, const VfsPath& pathname, Status err)
+{
+    if(err == ERR::AGAIN)
+        return; // open failed because sound is disabled (don't log this)
+    LOGERROR(L"%ls: pathname=%ls, error=%ls", message.c_str(), pathname.string().c_str(), ErrorString(err));
+}
+
+void CSMSoundGroup::PlayNext(const CVector3D& position)
+{
+    // if no sounds, return
+    if (filenames.size() == 0)
+        return;
+    
+    m_index = (size_t)rand(0, (size_t)filenames.size());
+    UploadPropertiesAndPlay( m_index, position);
+}
+
+void CSMSoundGroup::Reload()
+{
+    m_index = 0; // reset our index
+
+    snd_group.clear();
+
+    for(size_t i = 0; i < filenames.size(); i++)
+    {
+        VfsPath  thePath =  m_filepath/filenames[i];
+        ISoundItem* temp = g_SoundManager->loadItem( &thePath );
+
+        if ( temp == NULL )
+            HandleError( L"error loading sound", thePath, NULL);
+        else
+            snd_group.push_back(temp);
+    }
+
+    if(TestFlag(eRandOrder))
+        random_shuffle(snd_group.begin(), snd_group.end());
+}
+
+void CSMSoundGroup::ReleaseGroup()
+{
+    for(size_t i = 0; i < snd_group.size(); i++)
+    {
+        snd_group[i]->fadeAndDelete(0.2);
+    }
+    snd_group.clear();
+}
+
+void CSMSoundGroup::Update(float UNUSED(TimeSinceLastFrame))
+{
+}
+
+bool CSMSoundGroup::LoadSoundGroup(const VfsPath& pathnameXML)
+{
+//    LOGERROR(L"loading new sound group '%ls'", pathnameXML.string().c_str());
+
+    CXeromyces XeroFile;
+    if (XeroFile.Load(g_VFS, pathnameXML) != PSRETURN_OK) {
+        HandleError( L"error loading file", pathnameXML, NULL);
+        return false;
+    }
+    // Define elements used in XML file
+    #define EL(x) int el_##x = XeroFile.GetElementID(#x)
+    #define AT(x) int at_##x = XeroFile.GetAttributeID(#x)
+    EL(soundgroup);
+    EL(gain);
+    EL(looping);
+    EL(omnipresent);
+    EL(pitch);
+    EL(priority);
+    EL(randorder);
+    EL(randgain);
+    EL(randpitch);
+    EL(conegain);
+    EL(coneinner);
+    EL(coneouter);
+    EL(sound);
+    EL(gainupper);
+    EL(gainlower);
+    EL(pitchupper);
+    EL(pitchlower);
+    EL(path);
+    EL(threshold);
+    EL(decay);
+    #undef AT
+    #undef EL
+
+    XMBElement root = XeroFile.GetRoot();
+
+    if (root.GetNodeName() != el_soundgroup)
+    {
+        LOGERROR(L"Invalid SoundGroup format (unrecognised root element '%hs')", XeroFile.GetElementString(root.GetNodeName()).c_str());
+        return false;
+    }
+    
+    XERO_ITER_EL(root, child)
+    {
+    
+        int child_name = child.GetNodeName();           
+        
+        if(child_name == el_gain)
+        {
+            SetGain(child.GetText().ToFloat());
+        }
+        else if(child_name == el_looping)
+        {
+            if(child.GetText().ToInt() == 1)
+                SetFlag(eLoop);
+        }
+        else if(child_name == el_omnipresent)
+        {
+            if(child.GetText().ToInt() == 1)
+                SetFlag(eOmnipresent);
+        }
+        else if(child_name == el_pitch)
+        {
+            this->m_Pitch = child.GetText().ToFloat();
+        }
+        else if(child_name == el_priority)
+        {
+            this->m_Priority = child.GetText().ToFloat();
+        }
+        else if(child_name == el_randorder)
+        {
+            if(child.GetText().ToInt() == 1)
+                SetFlag(eRandOrder);
+        }
+        else if(child_name == el_randgain)
+        {
+            if(child.GetText().ToInt() == 1)
+                SetFlag(eRandGain);
+        }
+        else if(child_name == el_gainupper)
+        {
+            this->m_GainUpper = child.GetText().ToFloat();
+        }
+        else if(child_name == el_gainlower)
+        {
+            this->m_GainLower = child.GetText().ToFloat();
+        }
+        else if(child_name == el_randpitch)
+        {
+            if(child.GetText().ToInt() == 1)
+                SetFlag(eRandPitch);
+        }
+        else if(child_name == el_pitchupper)
+        {
+            this->m_PitchUpper = child.GetText().ToFloat();
+        }
+        else if(child_name == el_pitchlower)
+        {
+            this->m_PitchLower = child.GetText().ToFloat();
+        }
+        else if(child_name == el_conegain)
+        {
+            this->m_ConeOuterGain = child.GetText().ToFloat();
+        }
+        else if(child_name == el_coneinner)
+        {
+            this->m_ConeInnerAngle = child.GetText().ToFloat();
+        }
+        else if(child_name == el_coneouter)
+        {
+            this->m_ConeOuterAngle = child.GetText().ToFloat();
+        }
+        else if(child_name == el_sound)
+        {
+            this->filenames.push_back(child.GetText().FromUTF8());
+        }
+        else if(child_name == el_path)
+        {
+            m_filepath = child.GetText().FromUTF8();
+        }
+        else if(child_name == el_threshold)
+        {
+            m_IntensityThreshold = child.GetText().ToFloat();
+        }
+        else if(child_name == el_decay)
+        {
+            m_Decay = child.GetText().ToFloat();
+        }
+    }
+
+    return true;
+}

source/soundmanager/js/JAmbientSound.h

@@ +1 @@
+/* Copyright (C) 2009 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. 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.
+ *
+ * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef INCLUDED_JAMBIENTSOUND
+#define INCLUDED_JAMBIENTSOUND
+
+#include "scripting/ScriptableObject.h"
+#include "soundmanager/items/ISoundItem.h"
+
+class JAmbientSound : public CJSObject<JAmbientSound>
+{
+public:    
+             JAmbientSound  (const VfsPath& pathname);
+    virtual ~JAmbientSound  ();
+
+    
+    CStr ToString(JSContext* cx, uintN argc, jsval* argv);
+    
+    bool Play(JSContext* cx, uintN argc, jsval* argv);
+    
+    bool Loop(JSContext* cx, uintN argc, jsval* argv);
+    bool Free(JSContext* cx, uintN argc, jsval* argv);
+  
+    bool SetGain(JSContext* cx, uintN argc, jsval* argv);
+    bool SetPitch(JSContext* cx, uintN argc, jsval* argv);    
+    bool Fade(JSContext* cx, uintN argc, jsval* argv);
+    
+    static JSBool Construct(JSContext* cx, uintN argc, jsval* vp);
+    void clearSoundItem();
+    static void ScriptingInit();
+protected:
+    
+    VfsPath*    mFileName;
+
+};
+
+#endif  // #ifndef INCLUDED_JAMBIENTSOUND

source/soundmanager/js/JSound.h

@@ +1 @@
+/* Copyright (C) 2009 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. 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.
+ *
+ * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// JS sound binding
+
+// interface rationale:
+// - can't just expose fire and forget playSound to script code:
+//   we sometimes need to loop until a certain condition is met
+//   (e.g. building is complete) => need means of access (Handle) to sound.
+//
+// - the current 64-bit Handle can't be stored as-is by JS code;
+//   we could make it 32 bit, but that limits its usefulness
+//   (barely enough tag bits).
+//
+// - instead, we provide a thin class wrapper (using scriptableobject.h)
+//   on top of the snd API that encapsulates the Handle.
+
+#ifndef INCLUDED_JSOUND
+#define INCLUDED_JSOUND
+
+#include "scripting/ScriptableObject.h"
+#include "soundmanager/items/ISoundItem.h"
+
+class JSound : public CJSObject<JSound>
+{
+public:
+        
+    // note: filename is stored by handle manager; no need to keep a copy here.
+    
+             JSound(const VfsPath& pathname);
+    virtual ~JSound();
+    
+    CStr ToString(JSContext* cx, uintN argc, jsval* argv);
+    
+    bool Play(JSContext* cx, uintN argc, jsval* argv);
+    bool Loop(JSContext* cx, uintN argc, jsval* argv);
+    
+    bool Free(JSContext* cx, uintN argc, jsval* argv);
+    bool SetGain(JSContext* cx, uintN argc, jsval* argv);
+    bool SetPitch(JSContext* cx, uintN argc, jsval* argv);
+    bool SetPosition(JSContext* cx, uintN argc, jsval* argv);
+    bool clearSoundItem();
+    
+    bool Fade(JSContext* cx, uintN argc, jsval* argv);
+    
+    static JSBool Construct(JSContext* cx, uintN argc, jsval* vp);
+    static void ScriptingInit();
+
+protected:
+    ISoundItem*     mSndItem;
+};
+
+#endif  // #ifndef INCLUDED_JSOUND

source/soundmanager/js/JMusicSound.h

@@ +1 @@
+/* Copyright (C) 2009 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. 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.
+ *
+ * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// JS sound binding
+
+// interface rationale:
+// - can't just expose fire and forget playSound to script code:
+//   we sometimes need to loop until a certain condition is met
+//   (e.g. building is complete) => need means of access (Handle) to sound.
+//
+// - the current 64-bit Handle can't be stored as-is by JS code;
+//   we could make it 32 bit, but that limits its usefulness
+//   (barely enough tag bits).
+//
+// - instead, we provide a thin class wrapper (using scriptableobject.h)
+//   on top of the snd API that encapsulates the Handle.
+
+#ifndef INCLUDED_JMUSICSOUND
+#define INCLUDED_JMUSICSOUND
+
+#include "scripting/ScriptableObject.h"
+#include "soundmanager/items/ISoundItem.h"
+
+class JMusicSound : public CJSObject<JMusicSound>
+{
+public:    
+             JMusicSound(const VfsPath& pathname);
+    virtual ~JMusicSound();
+    
+    // Script-bound functions
+    
+    CStr ToString(JSContext* cx, uintN argc, jsval* argv);
+    
+    bool Play(JSContext* cx, uintN argc, jsval* argv);
+    bool Loop(JSContext* cx, uintN argc, jsval* argv);
+    
+    static JSBool Construct(JSContext* cx, uintN argc, jsval* vp);
+    
+    static void ScriptingInit();
+    
+protected:
+    VfsPath*    mFileName;
+};
+
+#endif  // #ifndef INCLUDED_JMUSICSOUND

source/soundmanager/js/SMSoundGroup.h

@@ +1 @@
+/* Copyright (C) 2009 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. 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.
+ *
+ * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+* =========================================================================
+* File        : SoundGroup.h
+* Project     : 0 A.D.
+* Description : Loads up a group of sound files with shared properties, 
+*               and provides a simple interface for playing them.        
+* =========================================================================
+*/
+
+/*
+Example usage:
+
+
+Example SoundGroup.xml
+    <?xml version="1.0" encoding="utf-8"?>
+    <SoundGroup>
+        <Gain>1.0</Gain>
+        <Looping>0</Looping>
+        <Pitch>1.0</Pitch>
+        <Priority>100</Priority>
+        <RandOrder>0</RandOrder>
+        <RandGain>0</RandGain>
+        <RandPitch>0</RandPitch>
+        <ConeGain>1.0</ConeGain>
+        <ConeInner>360</ConeInner>
+        <ConeOuter>360</ConeOuter>
+        <Sound>audio/voice/hellenes/soldier/Attack_Attackx.ogg</Sound>
+        <Sound>audio/voice/hellenes/soldier/Attack_Chargex.ogg</Sound>
+        <Sound>audio/voice/hellenes/soldier/Attack_Engagex.ogg</Sound>
+        <Sound>audio/voice/hellenes/soldier/Attack_ForMyFamily.ogg</Sound>
+    </SoundGroup>
+
+*/
+
+#ifndef INCLUDED_SMSOUNDGROUP
+#define INCLUDED_SMSOUNDGROUP
+
+#include "lib/file/vfs/vfs_path.h"
+
+#include <vector>
+
+class ISoundItem;
+
+enum eSndGrpFlags
+{
+    eRandOrder     = 0x01,
+    eRandGain      = 0x02,
+    eRandPitch     = 0x04,
+    eLoop          = 0x08,
+    eOmnipresent   = 0x10,
+    eDistanceless  = 0x20
+};
+
+
+class CSMSoundGroup
+{
+    NONCOPYABLE(CSMSoundGroup);
+public:
+        CSMSoundGroup(const VfsPath& pathnameXML);
+    CSMSoundGroup(void);
+    ~CSMSoundGroup(void);
+
+    // Play next sound in group
+    // @param position world position of the entity generating the sound
+    // (ignored if the eOmnipresent flag is set)
+    void PlayNext(const CVector3D& position);
+
+    float radiansOffCenter( const CVector3D& position, bool& onScreen, float& itemRollOff  );
+
+    // Load a group
+    bool LoadSoundGroup(const VfsPath& pathnameXML);
+
+    void Reload();
+
+    // Release all remaining loaded handles
+    void ReleaseGroup();
+
+    // Update SoundGroup, remove dead sounds from intensity count
+    void Update(float TimeSinceLastFrame);
+
+    // Set a flag using a value from eSndGrpFlags
+    inline void SetFlag(int flag) { m_Flags = (unsigned char)(m_Flags | flag); }
+
+    // Test flag, returns true if flag is set.
+    inline bool TestFlag(int flag) { return (m_Flags & flag) != 0; }
+    
+private:
+    void SetGain(float gain);
+    void UploadPropertiesAndPlay(int theIndex, const CVector3D& position);
+    void SetDefaultValues();
+
+    size_t m_index;  // index of the next sound to play
+        
+    std::vector<ISoundItem*> snd_group;  // we store the handles so we can load now and play later
+    std::vector<std::wstring> filenames; // we need the filenames so we can reload when necessary.
+
+    VfsPath m_filepath; // the file path for the list of sound file resources
+
+    float m_CurTime; // Time elapsed since soundgroup was created
+    float m_TimeWindow; // The Intensity Threshold Window
+    size_t m_IntensityThreshold; // the allowable intensity before a sound switch   
+    size_t m_Intensity;  // our current intensity(number of sounds played since m_CurTime - m_TimeWindow) 
+    float m_Decay; // 
+    unsigned char m_Flags; // up to eight individual parameters, use with eSndGrpFlags.
+    
+    float m_Gain;  
+    float m_Pitch;
+    float m_Priority;
+    float m_ConeOuterGain; 
+    float m_PitchUpper;
+    float m_PitchLower;
+    float m_GainUpper;
+    float m_GainLower;
+    float m_ConeInnerAngle;
+    float m_ConeOuterAngle;
+};
+
+#endif //#ifndef INCLUDED_SOUNDGROUP

source/main.cpp

@@ -383 +383 @@
         // coincide in position and orientation.
         float down[3] = { -up[0], -up[1], -up[2] };
 
-        {
-            PROFILE3("sound update");
-            if (snd_update(pos, dir, down) < 0)
-                debug_printf(L"snd_update failed\n");
-        }
+//      {
+//          PROFILE3("sound update");
+//          if (snd_update(pos, dir, down) < 0)
+//              debug_printf(L"snd_update failed\n");
+//      }
     }
     else
     {
-        PROFILE3("sound update (0)");
-        if (snd_update(0, 0, 0) < 0)
-            debug_printf(L"snd_update (pos=0 version) failed\n");
+//      PROFILE3("sound update (0)");
+//      if (snd_update(0, 0, 0) < 0)
+//          debug_printf(L"snd_update (pos=0 version) failed\n");
     }
 
     // Immediately flush any messages produced by simulation code
@@ -477 +477 @@
     // run non-visual simulation replay if requested
     if (args.Has("replay"))
     {
-        snd_disable(true);
-
         Paths paths(args);
         g_VFS = CreateVfs(20 * MiB);
         g_VFS->Mount(L"cache/", paths.Cache(), VFS_MOUNT_ARCHIVABLE);

source/simulation2/components/CCmpSoundManager.cpp

@@ -24 +24 @@
 #include "simulation2/MessageTypes.h"
 #include "simulation2/components/ICmpPosition.h"
 #include "simulation2/components/ICmpRangeManager.h"
-#include "sound/SoundGroup.h"
+#include "soundmanager/js/SMSoundGroup.h"
 
 class CCmpSoundManager : public ICmpSoundManager
 {
@@ -36 +36 @@
 
     DEFAULT_COMPONENT_ALLOCATOR(SoundManager)
 
-    std::map<std::wstring, CSoundGroup*> m_SoundGroups;
+    std::map<std::wstring, CSMSoundGroup*> m_SoundGroups;
 
     static std::string GetSchema()
     {
@@ -49 +49 @@
 
     virtual void Deinit()
     {
-        for (std::map<std::wstring, CSoundGroup*>::iterator it = m_SoundGroups.begin(); it != m_SoundGroups.end(); ++it)
+        for (std::map<std::wstring, CSMSoundGroup*>::iterator it = m_SoundGroups.begin(); it != m_SoundGroups.end(); ++it)
             delete it->second;
         m_SoundGroups.clear();
     }
@@ -76 +76 @@
             // or on some other timer?
             const CMessageUpdate& msgData = static_cast<const CMessageUpdate&> (msg);
             float t = msgData.turnLength.ToFloat();
-            for (std::map<std::wstring, CSoundGroup*>::iterator it = m_SoundGroups.begin(); it != m_SoundGroups.end(); ++it)
+            for (std::map<std::wstring, CSMSoundGroup*>::iterator it = m_SoundGroups.begin(); it != m_SoundGroups.end(); ++it)
                 if (it->second)
                     it->second->Update(t);
             break;
@@ -87 +87 @@
     virtual void PlaySoundGroup(std::wstring name, entity_id_t source)
     {
         // Make sure the sound group is loaded
-        CSoundGroup* group;
+        CSMSoundGroup* group;
         if (m_SoundGroups.find(name) == m_SoundGroups.end())
         {
-            group = new CSoundGroup();
+            group = new CSMSoundGroup();
             if (!group->LoadSoundGroup(L"audio/" + name))
             {
                 LOGERROR(L"Failed to load sound group '%ls'", name.c_str());

binaries/data/mods/public/gui/session/session.js

@@ -408 +408 @@
 //          currentAmbient = newRandomSound("ambient", "temperate_", "dayscape");
 
             const AMBIENT = "audio/ambient/dayscape/day_temperate_gen_03.ogg";
-            currentAmbient = new Sound(AMBIENT);
+            currentAmbient = new AmbientSound(AMBIENT);
 
             if (currentAmbient)
             {
                 currentAmbient.loop();
-                currentAmbient.setGain(0.8);
             }
             break;
 
@@ -428 +427 @@
 {
     if (currentAmbient)
     {
-        currentAmbient.fade(-1, 0.0, 5.0);
+        currentAmbient.free();
         currentAmbient = null;
     }
 }

binaries/data/mods/public/gui/common/music.js

@@ -72 +72 @@
         switch (this.currentState)
         {
             case this.states.OFF:
-                    if (this.isPlaying())
-                {
-                    this.currentMusic.fade(-1, 0.0, 3.0);
-                    this.currentMusic = null;
-                }
                 break;
 
             case this.states.MENU:
@@ -146 +141 @@
 
 Music.prototype.switchMusic = function(track, fadeInPeriod, isLooping)
 {
-    if (this.currentMusic)
-    {
-        this.currentMusic.fade(-1, 0.0, 5.0);
-        this.currentMusic = null;
-    }
+    this.currentMusic = new MusicSound(this.RELATIVE_MUSIC_PATH + track);
 
-    this.currentMusic = new Sound(this.RELATIVE_MUSIC_PATH + track);
-
     if (this.currentMusic)
     {
         if (isLooping)
             this.currentMusic.loop();
         else
             this.currentMusic.play();
-
-        if (fadeInPeriod)
-            this.currentMusic.fade(0.0, this.musicGain, fadeInPeriod);
     }
 };
 

binaries/data/mods/public/gui/common/functions_utility_music.js

@@ -66 +66 @@
 
     //console.write("Playing " + randomSoundPath + " ...");
 
+    switch (soundType)
+    {
+        case "music":
+            return new MusicSound(randomSoundPath);
+        break;
+        case "ambient":
+            return new AmbientSound(randomSoundPath);
+        break;
+        case "effect":
+            console.write ("am loading effect '*"+randomSoundPath+"*'");
+        break;
+        default:
+        break;
+    }
     return new Sound(randomSoundPath);
 }
 

binaries/data/mods/public/hwdetect/hwdetect.js

@@ -213 +213 @@
     }
 
     // http://trac.wildfiregames.com/ticket/685
-    if (os_macosx)
-    {
-        warnings.push("Audio has been disabled, due to problems with OpenAL on OS X.");
-        disable_audio = true;
-    }
+//  if (os_macosx)
+//  {
+//      warnings.push("Audio has been disabled, due to problems with OpenAL on OS X.");
+//      disable_audio = true;
+//  }
 
     // http://trac.wildfiregames.com/ticket/684
     // https://bugs.freedesktop.org/show_bug.cgi?id=24047

binaries/data/config/default.cfg

@@ -73 +73 @@
 
 ; GENERAL PREFERENCES:
 
-sound.mastergain = 0.5
+sound.mastergain = 0.9
+sound.musicgain = 0.2
+sound.ambientgain = 0.6
+sound.actiongain = 0.7
+sound.bufferCount = 50
+sound.bufferSize = 65536
 
 ; Camera control settings
 view.scroll.speed = 120.0