livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add Firestorm tagging to previous commit

Ansariel 2015-06-17 10:20:47 +02:00
parent c12f153b68
commit 6dd2070446
5 changed files with 221 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
indra/llaudio/llaudioengine.cpp
View File

@ -72,8 +72,10 @@ LLStreamingAudioInterface* LLAudioEngine::getStreamingAudioImpl()
void LLAudioEngine::setStreamingAudioImpl(LLStreamingAudioInterface *impl)
{
// <FS> FMOD fixes
if (mStreamingAudioImpl)
delete mStreamingAudioImpl;
// </FS>
mStreamingAudioImpl = impl;
}
@ -136,9 +138,11 @@ bool LLAudioEngine::init(const S32 num_channels, void* userdata)
void LLAudioEngine::shutdown()
{
// <FS> FMOD fixes
// Clean up streaming audio
delete mStreamingAudioImpl;
mStreamingAudioImpl = NULL;
// </FS>
// Clean up decode manager
delete gAudioDecodeMgrp;

101
indra/llaudio/llaudioengine_fmodex.cpp
View File

@ -180,6 +180,12 @@ bool LLAudioEngine_FMODEX::init(const S32 num_channels, void* userdata)
if(mEnableProfiler)
{
fmod_flags |= FMOD_INIT_ENABLE_PROFILE;
// <FS> FMOD fixes
//mSystem->createChannelGroup("None", &mChannelGroups[AUDIO_TYPE_NONE]);
//mSystem->createChannelGroup("SFX", &mChannelGroups[AUDIO_TYPE_SFX]);
//mSystem->createChannelGroup("UI", &mChannelGroups[AUDIO_TYPE_UI]);
//mSystem->createChannelGroup("Ambient", &mChannelGroups[AUDIO_TYPE_AMBIENT]);
// </FS>
}
#if LL_LINUX
@ -190,7 +196,10 @@ bool LLAudioEngine_FMODEX::init(const S32 num_channels, void* userdata)
if (NULL == getenv("LL_BAD_FMOD_PULSEAUDIO")) /*Flawfinder: ignore*/
{
LL_DEBUGS("AppInit") << "Trying PulseAudio audio output..." << LL_ENDL;
// <FS> FMOD fixes
//if(mSystem->setOutput(FMOD_OUTPUTTYPE_PULSEAUDIO) == FMOD_OK &&
if((result = mSystem->setOutput(FMOD_OUTPUTTYPE_PULSEAUDIO)) == FMOD_OK &&
// </FS>
(result = mSystem->init(num_channels + 2, fmod_flags, 0)) == FMOD_OK)
{
LL_DEBUGS("AppInit") << "PulseAudio output initialized OKAY" << LL_ENDL;
@ -211,7 +220,10 @@ bool LLAudioEngine_FMODEX::init(const S32 num_channels, void* userdata)
if (NULL == getenv("LL_BAD_FMOD_ALSA")) /*Flawfinder: ignore*/
{
LL_DEBUGS("AppInit") << "Trying ALSA audio output..." << LL_ENDL;
// <FS> FMOD fixes
//if(mSystem->setOutput(FMOD_OUTPUTTYPE_ALSA) == FMOD_OK &&
if((result = mSystem->setOutput(FMOD_OUTPUTTYPE_ALSA)) == FMOD_OK &&
// </FS>
(result = mSystem->init(num_channels + 2, fmod_flags, 0)) == FMOD_OK)
{
LL_DEBUGS("AppInit") << "ALSA audio output initialized OKAY" << LL_ENDL;
@ -232,7 +244,10 @@ bool LLAudioEngine_FMODEX::init(const S32 num_channels, void* userdata)
if (NULL == getenv("LL_BAD_FMOD_OSS")) /*Flawfinder: ignore*/
{
LL_DEBUGS("AppInit") << "Trying OSS audio output..." << LL_ENDL;
// <FS> FMOD fixes
//if(mSystem->setOutput(FMOD_OUTPUTTYPE_OSS) == FMOD_OK &&
if((result = mSystem->setOutput(FMOD_OUTPUTTYPE_OSS)) == FMOD_OK &&
// </FS>
(result = mSystem->init(num_channels + 2, fmod_flags, 0)) == FMOD_OK)
{
LL_DEBUGS("AppInit") << "OSS audio output initialized OKAY" << LL_ENDL;
@ -257,22 +272,27 @@ bool LLAudioEngine_FMODEX::init(const S32 num_channels, void* userdata)
// We're interested in logging which output method we
// ended up with, for QA purposes.
FMOD_OUTPUTTYPE output_type;
// <FS> FMOD fixes
//mSystem->getOutput(&output_type);
if(!Check_FMOD_Error(mSystem->getOutput(&output_type), "FMOD::System::getOutput"))
{
switch (output_type)
{
case FMOD_OUTPUTTYPE_NOSOUND:
LL_INFOS("AppInit") << "Audio output: NoSound" << LL_ENDL; break;
case FMOD_OUTPUTTYPE_PULSEAUDIO:
LL_INFOS("AppInit") << "Audio output: PulseAudio" << LL_ENDL; break;
case FMOD_OUTPUTTYPE_ALSA:
LL_INFOS("AppInit") << "Audio output: ALSA" << LL_ENDL; break;
case FMOD_OUTPUTTYPE_OSS:
LL_INFOS("AppInit") << "Audio output: OSS" << LL_ENDL; break;
default:
LL_INFOS("AppInit") << "Audio output: Unknown!" << LL_ENDL; break;
};
// </FS>
switch (output_type)
{
case FMOD_OUTPUTTYPE_NOSOUND:
LL_INFOS("AppInit") << "Audio output: NoSound" << LL_ENDL; break;
case FMOD_OUTPUTTYPE_PULSEAUDIO:
LL_INFOS("AppInit") << "Audio output: PulseAudio" << LL_ENDL; break;
case FMOD_OUTPUTTYPE_ALSA:
LL_INFOS("AppInit") << "Audio output: ALSA" << LL_ENDL; break;
case FMOD_OUTPUTTYPE_OSS:
LL_INFOS("AppInit") << "Audio output: OSS" << LL_ENDL; break;
default:
LL_INFOS("AppInit") << "Audio output: Unknown!" << LL_ENDL; break;
};
// <FS> FMOD fixes
}
// </FS>
#else // LL_LINUX
// initialize the FMOD engine
@ -294,6 +314,7 @@ bool LLAudioEngine_FMODEX::init(const S32 num_channels, void* userdata)
return false;
#endif
// <FS> FMOD fixes
if (mEnableProfiler)
{
Check_FMOD_Error(mSystem->createChannelGroup("None", &mChannelGroups[AUDIO_TYPE_NONE]), "FMOD::System::createChannelGroup");
@ -301,6 +322,7 @@ bool LLAudioEngine_FMODEX::init(const S32 num_channels, void* userdata)
Check_FMOD_Error(mSystem->createChannelGroup("UI", &mChannelGroups[AUDIO_TYPE_UI]), "FMOD::System::createChannelGroup");
Check_FMOD_Error(mSystem->createChannelGroup("Ambient", &mChannelGroups[AUDIO_TYPE_AMBIENT]), "FMOD::System::createChannelGroup");
}
// </FS>
// set up our favourite FMOD-native streaming audio implementation if none has already been added
if (!getStreamingAudioImpl()) // no existing implementation added
@ -364,16 +386,22 @@ void LLAudioEngine_FMODEX::allocateListener(void)
void LLAudioEngine_FMODEX::shutdown()
{
// <FS> FMOD fixes
//stopInternetStream();
LL_INFOS() << "About to LLAudioEngine::shutdown()" << LL_ENDL;
LLAudioEngine::shutdown();
LL_INFOS() << "LLAudioEngine_FMODEX::shutdown() closing FMOD Ex" << LL_ENDL;
if ( mSystem ) // speculative fix for MAINT-2657
{
// <FS> FMOD fixes
//mSystem->close();
//mSystem->release();
Check_FMOD_Error(mSystem->close(), "FMOD::System::close");
// <FS:Ansariel> Additional debug message; viewer might hang somewhere in here
LL_INFOS() << "LLAudioEngine_FMODEX::shutdown() FMOD Ex system closed. Now releasing..." << LL_ENDL;
Check_FMOD_Error(mSystem->release(), "FMOD::System::release");
// </FS>
}
LL_INFOS() << "LLAudioEngine_FMODEX::shutdown() done closing FMOD Ex" << LL_ENDL;
@ -429,8 +457,12 @@ void LLAudioEngine_FMODEX::cleanupWind()
{
if (mWindDSP)
{
// <FS> FMOD fixes
//mWindDSP->remove();
//mWindDSP->release();
Check_FMOD_Error(mWindDSP->remove(), "FMOD::DSP::remove");
Check_FMOD_Error(mWindDSP->release(), "FMOD::DSP::release");
// </FS>
mWindDSP = NULL;
}
@ -482,8 +514,11 @@ void LLAudioEngine_FMODEX::setInternalGain(F32 gain)
gain = llclamp( gain, 0.0f, 1.0f );
FMOD::ChannelGroup *master_group;
// <FS> FMOD fixes
//mSystem->getMasterChannelGroup(&master_group);
if(Check_FMOD_Error(mSystem->getMasterChannelGroup(&master_group), "FMOD::System::getMasterChannelGroup"))
return;
// </FS>
master_group->setVolume(gain);
LLStreamingAudioInterface *saimpl = getStreamingAudioImpl();
@ -611,7 +646,10 @@ void LLAudioChannelFMODEX::updateLoop()
// yield false negatives.
//
U32 cur_pos;
// <FS> FMOD fixes
//mChannelp->getPosition(&cur_pos,FMOD_TIMEUNIT_PCMBYTES);
Check_FMOD_Error(mChannelp->getPosition(&cur_pos,FMOD_TIMEUNIT_PCMBYTES),"FMOD::Channel::getPosition");
// </FS>
if (cur_pos < (U32)mLastSamplePos)
{
@ -645,12 +683,18 @@ void LLAudioChannelFMODEX::play()
return;
}
// <FS> FMOD fixes
//Check_FMOD_Error(mChannelp->setPaused(false), "FMOD::Channel::pause");
Check_FMOD_Error(mChannelp->setPaused(false), "FMOD::Channel::setPaused");
// </FS>
getSource()->setPlayedOnce(true);
if(LLAudioEngine_FMODEX::mChannelGroups[getSource()->getType()])
// <FS> FMOD fixes
//mChannelp->setChannelGroup(LLAudioEngine_FMODEX::mChannelGroups[getSource()->getType()]);
Check_FMOD_Error(mChannelp->setChannelGroup(LLAudioEngine_FMODEX::mChannelGroups[getSource()->getType()]),"FMOD::Channel::setChannelGroup");
// </FS>
}
@ -685,8 +729,12 @@ bool LLAudioChannelFMODEX::isPlaying()
}
bool paused, playing;
// <FS> FMOD fixes
//mChannelp->getPaused(&paused);
//mChannelp->isPlaying(&playing);
Check_FMOD_Error(mChannelp->getPaused(&paused),"FMOD::Channel::getPaused");
Check_FMOD_Error(mChannelp->isPlaying(&playing),"FMOD::Channel::isPlaying");
// </FS>
return !paused && playing;
}
@ -705,7 +753,10 @@ LLAudioBufferFMODEX::~LLAudioBufferFMODEX()
{
if(mSoundp)
{
// <FS> FMOD fixes
//mSoundp->release();
Check_FMOD_Error(mSoundp->release(),"FMOD::Sound::Release");
// </FS>
mSoundp = NULL;
}
}
@ -721,7 +772,10 @@ bool LLAudioBufferFMODEX::loadWAV(const std::string& filename)
return false;
}
// <FS> FMOD fixes
//if (!LLAPRFile::isExist(filename, NULL, LL_APR_RPB))
if (!gDirUtilp->fileExists(filename))
// </FS>
{
// File not found, abort.
return false;
@ -730,7 +784,10 @@ bool LLAudioBufferFMODEX::loadWAV(const std::string& filename)
if (mSoundp)
{
// If there's already something loaded in this buffer, clean it up.
// <FS> FMOD fixes
//mSoundp->release();
Check_FMOD_Error(mSoundp->release(),"FMOD::Sound::release");
// </FS>
mSoundp = NULL;
}
@ -773,7 +830,10 @@ U32 LLAudioBufferFMODEX::getLength()
}
U32 length;
// <FS> FMOD fixes
//mSoundp->getLength(&length, FMOD_TIMEUNIT_PCMBYTES);
Check_FMOD_Error(mSoundp->getLength(&length, FMOD_TIMEUNIT_PCMBYTES),"FMOD::Sound::getLength");
// </FS>
return length;
}
@ -781,7 +841,10 @@ U32 LLAudioBufferFMODEX::getLength()
void LLAudioChannelFMODEX::set3DMode(bool use3d)
{
FMOD_MODE current_mode;
// <FS> FMOD fixes
//if(mChannelp->getMode(&current_mode) != FMOD_OK)
if(Check_FMOD_Error(mChannelp->getMode(&current_mode),"FMOD::Channel::getMode"))
// </FS>
return;
FMOD_MODE new_mode = current_mode;
new_mode &= ~(use3d ? FMOD_2D : FMOD_3D);
@ -789,7 +852,10 @@ void LLAudioChannelFMODEX::set3DMode(bool use3d)
if(current_mode != new_mode)
{
// <FS> FMOD fixes
//mChannelp->setMode(new_mode);
Check_FMOD_Error(mChannelp->setMode(new_mode),"FMOD::Channel::setMode");
// </FS>
}
}
@ -808,9 +874,14 @@ FMOD_RESULT F_CALLBACK windCallback(FMOD_DSP_STATE *dsp_state, float *originalbu
FMOD::DSP *thisdsp = (FMOD::DSP *)dsp_state->instance;
thisdsp->getUserData((void **)&windgen);
// <FS> FMOD fixes
//S32 channels, configwidth, configheight;
//thisdsp->getInfo(0, 0, &channels, &configwidth, &configheight);
//
//windgen->windGenerate((LLAudioEngine_FMODEX::MIXBUFFERFORMAT *)newbuffer, length);
if (windgen)
windgen->windGenerate((LLAudioEngine_FMODEX::MIXBUFFERFORMAT *)newbuffer, length);
// </FS>
return FMOD_OK;
}

127
indra/llaudio/llstreamingaudio_fmodex.cpp
View File

@ -33,6 +33,7 @@
#include "llstreamingaudio_fmodex.h"
// <FS> FMOD fixes
inline bool Check_FMOD_Error(FMOD_RESULT result, const char *string)
{
if (result == FMOD_OK)
@ -40,6 +41,7 @@ inline bool Check_FMOD_Error(FMOD_RESULT result, const char *string)
LL_WARNS("AudioImpl") << string << " Error: " << FMOD_ErrorString(result) << LL_ENDL;
return true;
}
// </FS>
class LLAudioStreamManagerFMODEX
{
@ -51,7 +53,10 @@ public:
const std::string& getURL() { return mInternetStreamURL; }
// <FS> FMOD fixes
//FMOD_OPENSTATE getOpenState(unsigned int* percentbuffered=NULL, bool* starving=NULL, bool* diskbusy=NULL);
FMOD_RESULT getOpenState(FMOD_OPENSTATE& openstate, unsigned int* percentbuffered = NULL, bool* starving = NULL, bool* diskbusy = NULL);
// </FS>
protected:
FMOD::System* mSystem;
FMOD::Channel* mStreamChannel;
@ -72,19 +77,33 @@ LLStreamingAudio_FMODEX::LLStreamingAudio_FMODEX(FMOD::System *system) :
mFMODInternetStreamChannelp(NULL),
mGain(1.0f)
{
// <FS> FMOD fixes
FMOD_RESULT result;
// Number of milliseconds of audio to buffer for the audio card.
// Must be larger than the usual Second Life frame stutter time.
const U32 buffer_seconds = 10; //sec
const U32 estimated_bitrate = 128; //kbit/sec
// <FS> FMOD fixes
//mSystem->setStreamBufferSize(estimated_bitrate * buffer_seconds * 128/*bytes/kbit*/, FMOD_TIMEUNIT_RAWBYTES);
result = mSystem->setStreamBufferSize(estimated_bitrate * buffer_seconds * 128/*bytes/kbit*/, FMOD_TIMEUNIT_RAWBYTES);
Check_FMOD_Error(result, "FMOD::System::setStreamBufferSize");
// </FS>
// Here's where we set the size of the network buffer and some buffering
// parameters. In this case we want a network buffer of 16k, we want it
// to prebuffer 40% of that when we first connect, and we want it
// to rebuffer 80% of that whenever we encounter a buffer underrun.
// Leave the net buffer properties at the default.
//FSOUND_Stream_Net_SetBufferProperties(20000, 40, 80);
}
LLStreamingAudio_FMODEX::~LLStreamingAudio_FMODEX()
{
// <FS> FMOD fixes
//// nothing interesting/safe to do.
LL_INFOS() << "LLStreamingAudio_FMODEX::~LLStreamingAudio_FMODEX() destructing FMOD Ex Streaming" << LL_ENDL;
stop();
for (U32 i = 0; i < 100; ++i)
@ -94,6 +113,7 @@ LLStreamingAudio_FMODEX::~LLStreamingAudio_FMODEX()
ms_sleep(10);
}
LL_INFOS() << "LLStreamingAudio_FMODEX::~LLStreamingAudio_FMODEX() finished" << LL_ENDL;
// </FS>
}
void LLStreamingAudio_FMODEX::start(const std::string& url)
@ -109,6 +129,10 @@ void LLStreamingAudio_FMODEX::start(const std::string& url)
if (!url.empty())
{
// <FS> FMOD fixes
//LL_INFOS() << "Starting internet stream: " << url << LL_ENDL;
//mCurrentInternetStreamp = new LLAudioStreamManagerFMODEX(mSystem,url);
//mURL = url;
if(mDeadStreams.empty())
{
LL_INFOS() << "Starting internet stream: " << url << LL_ENDL;
@ -120,6 +144,7 @@ void LLStreamingAudio_FMODEX::start(const std::string& url)
LL_INFOS() << "Deferring stream load until buffer release: " << url << LL_ENDL;
mPendingURL = url;
}
// <FS>
}
else
{
@ -131,6 +156,23 @@ void LLStreamingAudio_FMODEX::start(const std::string& url)
void LLStreamingAudio_FMODEX::update()
{
// <FS> FMOD fixes
//// Kill dead internet streams, if possible
//std::list<LLAudioStreamManagerFMODEX *>::iterator iter;
//for (iter = mDeadStreams.begin(); iter != mDeadStreams.end();)
//{
// LLAudioStreamManagerFMODEX *streamp = *iter;
// if (streamp->stopStream())
// {
// LL_INFOS() << "Closed dead stream" << LL_ENDL;
// delete streamp;
// mDeadStreams.erase(iter++);
// }
// else
// {
// iter++;
// }
//}
if (!releaseDeadStreams())
{
llassert_always(mCurrentInternetStreamp == NULL);
@ -145,6 +187,7 @@ void LLStreamingAudio_FMODEX::update()
mURL = mPendingURL;
mPendingURL.clear();
}
// </FS>
// Don't do anything if there are no streams playing
if (!mCurrentInternetStreamp)
@ -155,6 +198,11 @@ void LLStreamingAudio_FMODEX::update()
unsigned int progress;
bool starving;
bool diskbusy;
// <FS> FMOD fixes
//FMOD_OPENSTATE open_state = mCurrentInternetStreamp->getOpenState(&progress, &starving, &diskbusy);
//if (open_state == FMOD_OPENSTATE_READY)
FMOD_OPENSTATE open_state;
FMOD_RESULT result = mCurrentInternetStreamp->getOpenState(open_state, &progress, &starving, &diskbusy);
@ -164,6 +212,7 @@ void LLStreamingAudio_FMODEX::update()
return;
}
else if (open_state == FMOD_OPENSTATE_READY)
// </FS>
{
// Stream is live
@ -173,9 +222,19 @@ void LLStreamingAudio_FMODEX::update()
{
// Reset volume to previously set volume
setGain(getGain());
// <FS> FMOD fixes
//mFMODInternetStreamChannelp->setPaused(false);
Check_FMOD_Error(mFMODInternetStreamChannelp->setPaused(false), "FMOD::Channel::setPaused");
// </FS>
}
}
// <FS> FMOD fixes
//else if(open_state == FMOD_OPENSTATE_ERROR)
//{
// stop();
// return;
//}
// </FS>
if(mFMODInternetStreamChannelp)
{
@ -288,17 +347,27 @@ void LLStreamingAudio_FMODEX::update()
if(starving)
{
bool paused = false;
// <FS> FMOD fixes
//mFMODInternetStreamChannelp->getPaused(&paused);
//if(!paused)
if (mFMODInternetStreamChannelp->getPaused(&paused) == FMOD_OK && !paused)
// </FS>
{
LL_INFOS() << "Stream starvation detected! Pausing stream until buffer nearly full." << LL_ENDL;
LL_INFOS() << " (diskbusy="<<diskbusy<<")" << LL_ENDL;
LL_INFOS() << " (progress="<<progress<<")" << LL_ENDL;
// <FS> FMOD fixes
//mFMODInternetStreamChannelp->setPaused(true);
Check_FMOD_Error(mFMODInternetStreamChannelp->setPaused(true), "FMOD::Channel::setPaused");
// </FS>
}
}
else if(progress > 80)
{
// <FS> FMOD fixes
//mFMODInternetStreamChannelp->setPaused(false);
Check_FMOD_Error(mFMODInternetStreamChannelp->setPaused(false), "FMOD::Channel::setPaused");
// </FS>
}
}
}
@ -306,12 +375,17 @@ void LLStreamingAudio_FMODEX::update()
void LLStreamingAudio_FMODEX::stop()
{
// <FS> FMOD fixes
mPendingURL.clear();
if (mFMODInternetStreamChannelp)
{
// <FS> FMOD fixes
//mFMODInternetStreamChannelp->setPaused(true);
//mFMODInternetStreamChannelp->setPriority(0);
Check_FMOD_Error(mFMODInternetStreamChannelp->setPaused(true), "FMOD::Channel::setPaused");
Check_FMOD_Error(mFMODInternetStreamChannelp->setPriority(0), "FMOD::Channel::setPriority");
// </FS>
mFMODInternetStreamChannelp = NULL;
}
@ -328,6 +402,7 @@ void LLStreamingAudio_FMODEX::stop()
mDeadStreams.push_back(mCurrentInternetStreamp);
}
mCurrentInternetStreamp = NULL;
//mURL.clear();
}
}
@ -360,7 +435,10 @@ int LLStreamingAudio_FMODEX::isPlaying()
{
return 1; // Active and playing
}
// <FS> FMOD fixes
//else if (!mURL.empty())
else if (!mURL.empty() || !mPendingURL.empty())
// </FS>
{
return 2; // "Paused"
}
@ -391,7 +469,10 @@ void LLStreamingAudio_FMODEX::setGain(F32 vol)
{
vol = llclamp(vol * vol, 0.f, 1.f); //should vol be squared here?
// <FS> FMOD fixes
//mFMODInternetStreamChannelp->setVolume(vol);
Check_FMOD_Error(mFMODInternetStreamChannelp->setVolume(vol), "FMOD::Channel::setVolume");
// </FS>
}
}
@ -444,8 +525,11 @@ LLAudioStreamManagerFMODEX::LLAudioStreamManagerFMODEX(FMOD::System *system, con
FMOD::Channel *LLAudioStreamManagerFMODEX::startStream()
{
// We need a live and opened stream before we try and play it.
// <FS> FMOD fixes
//if (!mInternetStream || getOpenState() != FMOD_OPENSTATE_READY)
FMOD_OPENSTATE open_state;
if (getOpenState(open_state) != FMOD_OK || open_state != FMOD_OPENSTATE_READY)
// </FS>
{
LL_WARNS() << "No internet stream to start playing!" << LL_ENDL;
return NULL;
@ -454,7 +538,10 @@ FMOD::Channel *LLAudioStreamManagerFMODEX::startStream()
if(mStreamChannel)
return mStreamChannel; //Already have a channel for this stream.
// <FS> FMOD fixes
//mSystem->playSound(FMOD_CHANNEL_FREE, mInternetStream, true, &mStreamChannel);
Check_FMOD_Error(mSystem->playSound(FMOD_CHANNEL_FREE, mInternetStream, true, &mStreamChannel), "FMOD::System::playSound");
// </FS>
return mStreamChannel;
}
@ -463,21 +550,31 @@ bool LLAudioStreamManagerFMODEX::stopStream()
if (mInternetStream)
{
bool close = true;
// <FS> FMOD fixes
//switch (getOpenState())
FMOD_OPENSTATE open_state;
if (getOpenState(open_state) == FMOD_OK)
{
switch (open_state)
{
case FMOD_OPENSTATE_CONNECTING:
close = false;
break;
default:
close = true;
}
// </FS>
{
case FMOD_OPENSTATE_CONNECTING:
close = false;
break;
default:
close = true;
}
// <FS> FMOD fixes
}
// </FS>
// <FS> FMOD fixes
//if (close)
//{
// mInternetStream->release();
if (close && mInternetStream->release() == FMOD_OK)
{
// </FS>
mStreamChannel = NULL;
mInternetStream = NULL;
return true;
@ -493,6 +590,13 @@ bool LLAudioStreamManagerFMODEX::stopStream()
}
}
// <FS> FMOD fixes
//FMOD_OPENSTATE LLAudioStreamManagerFMODEX::getOpenState(unsigned int* percentbuffered, bool* starving, bool* diskbusy)
//{
// FMOD_OPENSTATE state;
// mInternetStream->getOpenState(&state, percentbuffered, starving, diskbusy);
// return state;
//}
FMOD_RESULT LLAudioStreamManagerFMODEX::getOpenState(FMOD_OPENSTATE& state, unsigned int* percentbuffered, bool* starving, bool* diskbusy)
{
if (!mInternetStream)
@ -501,17 +605,25 @@ FMOD_RESULT LLAudioStreamManagerFMODEX::getOpenState(FMOD_OPENSTATE& state, unsi
Check_FMOD_Error(result, "FMOD::Sound::getOpenState");
return result;
}
// </FS>
void LLStreamingAudio_FMODEX::setBufferSizes(U32 streambuffertime, U32 decodebuffertime)
{
// <FS> FMOD fixes
//mSystem->setStreamBufferSize(streambuffertime/1000*128*128, FMOD_TIMEUNIT_RAWBYTES);
Check_FMOD_Error(mSystem->setStreamBufferSize(streambuffertime / 1000 * 128 * 128, FMOD_TIMEUNIT_RAWBYTES), "FMOD::System::setStreamBufferSize");
// </FS>
FMOD_ADVANCEDSETTINGS settings;
memset(&settings,0,sizeof(settings));
settings.cbsize=sizeof(settings);
settings.defaultDecodeBufferSize = decodebuffertime;//ms
// <FS> FMOD fixes
//mSystem->setAdvancedSettings(&settings);
Check_FMOD_Error(mSystem->setAdvancedSettings(&settings), "FMOD::System::setAdvancedSettings");
// </FS>
}
// <FS> FMOD fixes
bool LLStreamingAudio_FMODEX::releaseDeadStreams()
{
// Kill dead internet streams, if possible
@ -533,3 +645,4 @@ bool LLStreamingAudio_FMODEX::releaseDeadStreams()
return mDeadStreams.empty();
}
// </FS>

3
indra/llaudio/llstreamingaudio_fmodex.h
View File

@ -64,6 +64,7 @@ class LLStreamingAudio_FMODEX : public LLStreamingAudioInterface
// </FS:CR>
private:
// <FS> FMOD fixes
bool releaseDeadStreams();
FMOD::System *mSystem;
@ -73,7 +74,7 @@ private:
std::list<LLAudioStreamManagerFMODEX *> mDeadStreams;
std::string mURL;
std::string mPendingURL;
std::string mPendingURL; // <FS> FMOD fixes
F32 mGain;
// <FS:CR> Streamtitle display

10
indra/newview/llappviewer.cpp
View File

@ -2135,8 +2135,16 @@ bool LLAppViewer::cleanup()
if (gAudiop)
{
// shut down the streaming audio sub-subsystem first, in case it relies on not outliving the general audio subsystem.
// <FS> FMOD fixes
//LLStreamingAudioInterface *sai = gAudiop->getStreamingAudioImpl();
//delete sai;
//gAudiop->setStreamingAudioImpl(NULL);
// </FS>
// shut down the audio subsystem
gAudiop->shutdown();
gAudiop->shutdown();
delete gAudiop;
gAudiop = NULL;