/** * @file audioengine.cpp * @brief implementation of LLAudioEngine class abstracting the Open * AL audio support * * $LicenseInfo:firstyear=2000&license=viewerlgpl$ * Second Life Viewer Source Code * Copyright (C) 2010, Linden Research, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; * version 2.1 of the License only. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA * $/LicenseInfo$ */ #include "linden_common.h" #include "llaudioengine.h" #include "llstreamingaudio.h" #include "llerror.h" #include "llmath.h" #include "sound_ids.h" // temporary hack for min/max distances #include "llfilesystem.h" #include "lldir.h" #include "llaudiodecodemgr.h" #include "llassetstorage.h" // necessary for grabbing sounds from sim (implemented in viewer) extern void request_sound(const LLUUID &sound_guid); LLAudioEngine* gAudiop = NULL; // // LLAudioEngine implementation // LLAudioEngine::LLAudioEngine() { setDefaults(); } LLAudioEngine::~LLAudioEngine() { } LLStreamingAudioInterface* LLAudioEngine::getStreamingAudioImpl() { return mStreamingAudioImpl; } void LLAudioEngine::setStreamingAudioImpl(LLStreamingAudioInterface *impl) { mStreamingAudioImpl = impl; } void LLAudioEngine::setDefaults() { mMaxWindGain = 1.f; mListenerp = NULL; mMuted = false; mUserData = NULL; mLastStatus = 0; mEnableWind = false; mChannels.fill(nullptr); mBuffers.fill(nullptr); mMasterGain = 1.f; // Setting mInternalGain to an out of range value fixes the issue reported in STORM-830. // There is an edge case in setMasterGain during startup which prevents setInternalGain from // being called if the master volume setting and mInternalGain both equal 0, so using -1 forces // the if statement in setMasterGain to execute when the viewer starts up. mInternalGain = -1.f; mNextWindUpdate = 0.f; mStreamingAudioImpl = NULL; for (U32 i = 0; i < LLAudioEngine::AUDIO_TYPE_COUNT; i++) mSecondaryGain[i] = 1.0f; } bool LLAudioEngine::init(void* userdata, const std::string &app_title) { setDefaults(); mUserData = userdata; allocateListener(); LL_INFOS("AudioEngine") << "LLAudioEngine::init() AudioEngine successfully initialized" << LL_ENDL; return true; } void LLAudioEngine::shutdown() { // Clean up wind source cleanupWind(); // Clean up audio sources for (source_map::value_type& src_pair : mAllSources) { delete src_pair.second; } // Clean up audio data for (data_map::value_type& data_pair : mAllData) { delete data_pair.second; } // Clean up channels S32 i; for (i = 0; i < LL_MAX_AUDIO_CHANNELS; i++) { delete mChannels[i]; mChannels[i] = NULL; } // Clean up buffers for (i = 0; i < LL_MAX_AUDIO_BUFFERS; i++) { delete mBuffers[i]; mBuffers[i] = NULL; } } // virtual void LLAudioEngine::startInternetStream(const std::string& url) { if (mStreamingAudioImpl) mStreamingAudioImpl->start(url); } // virtual void LLAudioEngine::stopInternetStream() { if (mStreamingAudioImpl) mStreamingAudioImpl->stop(); } // virtual void LLAudioEngine::pauseInternetStream(S32 pause) { if (mStreamingAudioImpl) mStreamingAudioImpl->pause(pause); } // virtual void LLAudioEngine::updateInternetStream() { if (mStreamingAudioImpl) mStreamingAudioImpl->update(); } // virtual LLAudioEngine::LLAudioPlayState LLAudioEngine::isInternetStreamPlaying() { if (mStreamingAudioImpl) return (LLAudioEngine::LLAudioPlayState) mStreamingAudioImpl->isPlaying(); return LLAudioEngine::AUDIO_STOPPED; // Stopped } // virtual void LLAudioEngine::setInternetStreamGain(F32 vol) { if (mStreamingAudioImpl) mStreamingAudioImpl->setGain(vol); } // virtual std::string LLAudioEngine::getInternetStreamURL() { if (mStreamingAudioImpl) return mStreamingAudioImpl->getURL(); return std::string(); } void LLAudioEngine::updateChannels() { S32 i; for (i = 0; i < LL_MAX_AUDIO_CHANNELS; i++) { if (mChannels[i]) { mChannels[i]->updateBuffer(); mChannels[i]->update3DPosition(); mChannels[i]->updateLoop(); } } } void LLAudioEngine::idle() { // "Update" all of our audio sources, clean up dead ones. // Primarily does position updating, cleanup of unused audio sources. // Also does regeneration of the current priority of each audio source. S32 i; for (i = 0; i < LL_MAX_AUDIO_BUFFERS; i++) { if (mBuffers[i]) { mBuffers[i]->mInUse = false; } } F32 max_priority = -1.f; LLAudioSource *max_sourcep = NULL; // Maximum priority source without a channel source_map::iterator iter; for (iter = mAllSources.begin(); iter != mAllSources.end();) { LLAudioSource *sourcep = iter->second; // Update this source sourcep->update(); sourcep->updatePriority(); if (sourcep->isDone()) { // The source is done playing, clean it up. delete sourcep; iter = mAllSources.erase(iter); continue; } if (sourcep->isMuted()) { ++iter; continue; } if (!sourcep->getChannel() && sourcep->getCurrentBuffer()) { // We could potentially play this sound if its priority is high enough. if (sourcep->getPriority() > max_priority) { max_priority = sourcep->getPriority(); max_sourcep = sourcep; } } // Move on to the next source iter++; } // Now, do priority-based organization of audio sources. // All channels used, check priorities. // Find channel with lowest priority if (max_sourcep) { LLAudioChannel *channelp = getFreeChannel(max_priority); if (channelp) { //LL_INFOS() << "Replacing source in channel due to priority!" << LL_ENDL; max_sourcep->setChannel(channelp); channelp->setSource(max_sourcep); if (max_sourcep->isSyncSlave()) { // A sync slave, it doesn't start playing until it's synced up with the master. // Flag this channel as waiting for sync, and return true. channelp->setWaiting(true); } else { channelp->setWaiting(false); channelp->play(); } } } // Do this BEFORE we update the channels // Update the channels to sync up with any changes that the source made, // such as changing what sound was playing. updateChannels(); // Update queued sounds (switch to next queued data if the current has finished playing) for (source_map::value_type& src_pair : mAllSources) { // This is lame, instead of this I could actually iterate through all the sources // attached to each channel, since only those with active channels // can have anything interesting happen with their queue? (Maybe not true) LLAudioSource *sourcep = src_pair.second; if (!sourcep->mQueuedDatap || sourcep->isMuted()) { // Muted, or nothing queued, so we don't care. continue; } LLAudioChannel *channelp = sourcep->getChannel(); if (!channelp) { // This sound isn't playing, so we just process move the queue sourcep->mCurrentDatap = sourcep->mQueuedDatap; sourcep->mQueuedDatap = NULL; // Reset the timer so the source doesn't die. sourcep->mAgeTimer.reset(); // Make sure we have the buffer set up if we just decoded the data if (sourcep->mCurrentDatap) { updateBufferForData(sourcep->mCurrentDatap); } // Actually play the associated data. sourcep->setupChannel(); channelp = sourcep->getChannel(); if (channelp) { channelp->updateBuffer(); sourcep->getChannel()->play(); } continue; } // Check to see if the current sound is done playing. if (!channelp->isPlaying()) { sourcep->mCurrentDatap = sourcep->mQueuedDatap; sourcep->mQueuedDatap = NULL; // Reset the timer so the source doesn't die. sourcep->mAgeTimer.reset(); // Make sure we have the buffer set up if we just decoded the data if (sourcep->mCurrentDatap) { updateBufferForData(sourcep->mCurrentDatap); } // Actually play the associated data. sourcep->setupChannel(); channelp->updateBuffer(); sourcep->getChannel()->play(); continue; } // Check to see if the current sound is looped. if (sourcep->isLoop()) { // It's a loop, we need to check and see if we're done with it. if (channelp->mLoopedThisFrame) { sourcep->mCurrentDatap = sourcep->mQueuedDatap; sourcep->mQueuedDatap = NULL; // Actually, should do a time sync so if we're a loop master/slave // we don't drift away. sourcep->setupChannel(); sourcep->getChannel()->play(); } } } // Lame, update the channels AGAIN. // Update the channels to sync up with any changes that the source made, // such as changing what sound was playing. updateChannels(); // Hack! For now, just use a global sync master; LLAudioSource *sync_masterp = NULL; LLAudioChannel *master_channelp = NULL; F32 max_sm_priority = -1.f; for (source_map::value_type& src_pair : mAllSources) { LLAudioSource *sourcep = src_pair.second; if (!sourcep->isMuted() && sourcep->isSyncMaster() && sourcep->getPriority() > max_sm_priority) { sync_masterp = sourcep; master_channelp = sync_masterp->getChannel(); max_sm_priority = sourcep->getPriority(); } } if (master_channelp && master_channelp->mLoopedThisFrame) { // Synchronize loop slaves with their masters // Update queued sounds (switch to next queued data if the current has finished playing) for (source_map::value_type& src_pair : mAllSources) { LLAudioSource *sourcep = src_pair.second; if (!sourcep->isSyncSlave()) { // Not a loop slave, we don't need to do anything continue; } LLAudioChannel *channelp = sourcep->getChannel(); if (!channelp) { // Not playing, don't need to bother. continue; } if (!channelp->isPlaying()) { // Now we need to check if our loop master has just looped, and // start playback if that's the case. if (sync_masterp->getChannel()) { channelp->playSynced(master_channelp); channelp->setWaiting(false); } } } } // Sync up everything that the audio engine needs done. commitDeferredChanges(); // Flush unused buffers that are stale enough for (i = 0; i < LL_MAX_AUDIO_BUFFERS; i++) { if (mBuffers[i]) { if (!mBuffers[i]->mInUse && mBuffers[i]->mLastUseTimer.getElapsedTimeF32() > 30.f) { //LL_INFOS() << "Flushing unused buffer!" << LL_ENDL; mBuffers[i]->mAudioDatap->mBufferp = NULL; delete mBuffers[i]; mBuffers[i] = NULL; } } } // Clear all of the looped flags for the channels for (i = 0; i < LL_MAX_AUDIO_CHANNELS; i++) { if (mChannels[i]) { mChannels[i]->mLoopedThisFrame = false; } } // Decode audio files LLAudioDecodeMgr::getInstance()->processQueue(); // Call this every frame, just in case we somehow // missed picking it up in all the places that can add // or request new data. startNextTransfer(); updateInternetStream(); } bool LLAudioEngine::updateBufferForData(LLAudioData *adp, const LLUUID &audio_uuid) { if (!adp) { return false; } // Update the audio buffer first - load a sound if we have it. // Note that this could potentially cause us to waste time updating buffers // for sounds that actually aren't playing, although this should be mitigated // by the fact that we limit the number of buffers, and we flush buffers based // on priority. if (!adp->getBuffer()) { if (adp->hasDecodedData()) { adp->load(); } else if (adp->hasLocalData()) { if (audio_uuid.notNull()) { LLAudioDecodeMgr::getInstance()->addDecodeRequest(audio_uuid); } } else { return false; } } return true; } void LLAudioEngine::enableWind(bool enable) { if (enable && (!mEnableWind)) { mEnableWind = initWind(); } else if (mEnableWind && (!enable)) { mEnableWind = false; cleanupWind(); } } LLAudioBuffer * LLAudioEngine::getFreeBuffer() { S32 i; for (i = 0; i < LL_MAX_AUDIO_BUFFERS; i++) { if (!mBuffers[i]) { mBuffers[i] = createBuffer(); return mBuffers[i]; } } // Grab the oldest unused buffer F32 max_age = -1.f; S32 buffer_id = -1; for (i = 0; i < LL_MAX_AUDIO_BUFFERS; i++) { if (mBuffers[i]) { if (!mBuffers[i]->mInUse) { if (mBuffers[i]->mLastUseTimer.getElapsedTimeF32() > max_age) { max_age = mBuffers[i]->mLastUseTimer.getElapsedTimeF32(); buffer_id = i; } } } } if (buffer_id >= 0) { LL_DEBUGS() << "Taking over unused buffer " << buffer_id << LL_ENDL; //LL_INFOS() << "Flushing unused buffer!" << LL_ENDL; mBuffers[buffer_id]->mAudioDatap->mBufferp = NULL; delete mBuffers[buffer_id]; mBuffers[buffer_id] = createBuffer(); return mBuffers[buffer_id]; } return NULL; } LLAudioChannel * LLAudioEngine::getFreeChannel(const F32 priority) { S32 i; for (i = 0; i < LL_MAX_AUDIO_CHANNELS; i++) { if (!mChannels[i]) { // No channel allocated here, use it. mChannels[i] = createChannel(); return mChannels[i]; } else { // Channel is allocated but not playing right now, use it. if (!mChannels[i]->isPlaying() && !mChannels[i]->isWaiting()) { mChannels[i]->cleanup(); if (mChannels[i]->getSource()) { mChannels[i]->getSource()->setChannel(NULL); } return mChannels[i]; } } } // All channels used, check priorities. // Find channel with lowest priority and see if we want to replace it. F32 min_priority = 10000.f; LLAudioChannel *min_channelp = NULL; for (i = 0; i < LL_MAX_AUDIO_CHANNELS; i++) { LLAudioChannel *channelp = mChannels[i]; LLAudioSource *sourcep = channelp->getSource(); if (sourcep->getPriority() < min_priority) { min_channelp = channelp; min_priority = sourcep->getPriority(); } } if (min_priority > priority || !min_channelp) { // All playing channels have higher priority, return. return NULL; } // Flush the minimum priority channel, and return it. min_channelp->cleanup(); min_channelp->getSource()->setChannel(NULL); return min_channelp; } void LLAudioEngine::cleanupBuffer(LLAudioBuffer *bufferp) { S32 i; for (i = 0; i < LL_MAX_AUDIO_BUFFERS; i++) { if (mBuffers[i] == bufferp) { delete mBuffers[i]; mBuffers[i] = NULL; } } } bool LLAudioEngine::preloadSound(const LLUUID &uuid) { LL_DEBUGS("AudioEngine")<<"( "<addDecodeRequest(uuid)) { // This means that we do have a local copy, and we're working on decoding it. return true; } return false; } bool LLAudioEngine::isWindEnabled() { return mEnableWind; } void LLAudioEngine::setMuted(bool muted) { if (muted != mMuted) { mMuted = muted; setMasterGain(mMasterGain); } enableWind(!mMuted); } void LLAudioEngine::setMasterGain(const F32 gain) { mMasterGain = gain; F32 internal_gain = getMuted() ? 0.f : gain; if (internal_gain != mInternalGain) { mInternalGain = internal_gain; setInternalGain(mInternalGain); } } F32 LLAudioEngine::getMasterGain() { return mMasterGain; } void LLAudioEngine::setSecondaryGain(S32 type, F32 gain) { llassert(type < LLAudioEngine::AUDIO_TYPE_COUNT); mSecondaryGain[type] = gain; } F32 LLAudioEngine::getSecondaryGain(S32 type) { return mSecondaryGain[type]; } F32 LLAudioEngine::getInternetStreamGain() { if (mStreamingAudioImpl) return mStreamingAudioImpl->getGain(); else return 1.0f; } void LLAudioEngine::setMaxWindGain(F32 gain) { mMaxWindGain = gain; } F64 LLAudioEngine::mapWindVecToGain(LLVector3 wind_vec) { F64 gain = 0.0; gain = wind_vec.magVec(); if (gain) { if (gain > 20) { gain = 20; } gain = gain/20.0; } return (gain); } F64 LLAudioEngine::mapWindVecToPitch(LLVector3 wind_vec) { LLVector3 listen_right; F64 theta; // Wind frame is in listener-relative coordinates LLVector3 norm_wind = wind_vec; norm_wind.normVec(); listen_right.setVec(1.0,0.0,0.0); // measure angle between wind vec and listener right axis (on 0,PI) theta = acos(norm_wind * listen_right); // put it on 0, 1 theta /= F_PI; // put it on [0, 0.5, 0] if (theta > 0.5) theta = 1.0-theta; if (theta < 0) theta = 0; return (theta); } F64 LLAudioEngine::mapWindVecToPan(LLVector3 wind_vec) { LLVector3 listen_right; F64 theta; // Wind frame is in listener-relative coordinates listen_right.setVec(1.0,0.0,0.0); LLVector3 norm_wind = wind_vec; norm_wind.normVec(); // measure angle between wind vec and listener right axis (on 0,PI) theta = acos(norm_wind * listen_right); // put it on 0, 1 theta /= F_PI; return (theta); } void LLAudioEngine::triggerSound(const LLUUID &audio_uuid, const LLUUID& owner_id, const F32 gain, const S32 type, const LLVector3d &pos_global) { // Create a new source (since this can't be associated with an existing source. //LL_INFOS() << "Localized: " << audio_uuid << LL_ENDL; if (mMuted) { return; } LLUUID source_id; source_id.generate(); LLAudioSource *asp = new LLAudioSource(source_id, owner_id, gain, type); addAudioSource(asp); if (pos_global.isExactlyZero()) { // For sound preview and UI asp->setForcedPriority(true); } else { asp->setPositionGlobal(pos_global); } asp->updatePriority(); asp->play(audio_uuid); } void LLAudioEngine::triggerSound(SoundData& soundData) { triggerSound(soundData.audio_uuid, soundData.owner_id, soundData.gain, soundData.type, soundData.pos_global); } void LLAudioEngine::setListenerPos(LLVector3 aVec) { mListenerp->setPosition(aVec); } LLVector3 LLAudioEngine::getListenerPos() { if (mListenerp) { return(mListenerp->getPosition()); } else { return(LLVector3::zero); } } void LLAudioEngine::setListenerVelocity(LLVector3 aVec) { mListenerp->setVelocity(aVec); } void LLAudioEngine::translateListener(LLVector3 aVec) { mListenerp->translate(aVec); } void LLAudioEngine::orientListener(LLVector3 up, LLVector3 at) { mListenerp->orient(up, at); } void LLAudioEngine::setListener(LLVector3 pos, LLVector3 vel, LLVector3 up, LLVector3 at) { mListenerp->set(pos,vel,up,at); } void LLAudioEngine::setDopplerFactor(F32 factor) { if (mListenerp) { mListenerp->setDopplerFactor(factor); } } F32 LLAudioEngine::getDopplerFactor() { if (mListenerp) { return mListenerp->getDopplerFactor(); } else { return 0.f; } } void LLAudioEngine::setRolloffFactor(F32 factor) { if (mListenerp) { mListenerp->setRolloffFactor(factor); } } F32 LLAudioEngine::getRolloffFactor() { if (mListenerp) { return mListenerp->getRolloffFactor(); } else { return 0.f; } } void LLAudioEngine::commitDeferredChanges() { mListenerp->commitDeferredChanges(); } LLAudioSource * LLAudioEngine::findAudioSource(const LLUUID &source_id) { source_map::iterator iter; iter = mAllSources.find(source_id); if (iter == mAllSources.end()) { return NULL; } else { return iter->second; } } LLAudioData * LLAudioEngine::getAudioData(const LLUUID &audio_uuid) { LL_PROFILE_ZONE_SCOPED_CATEGORY_MEDIA; data_map::iterator iter; iter = mAllData.find(audio_uuid); if (iter == mAllData.end()) { // Create the new audio data LLAudioData *adp = new LLAudioData(audio_uuid); mAllData[audio_uuid] = adp; return adp; } else { return iter->second; } } void LLAudioEngine::addAudioSource(LLAudioSource *asp) { mAllSources[asp->getID()] = asp; } void LLAudioEngine::cleanupAudioSource(LLAudioSource *asp) { source_map::iterator iter; iter = mAllSources.find(asp->getID()); if (iter == mAllSources.end()) { LL_WARNS() << "Cleaning up unknown audio source!" << LL_ENDL; return; } else { LL_DEBUGS("AudioEngine") << "Cleaning up audio sources for "<< asp->getID() <getExpandedFilename(LL_PATH_CACHE,uuid_str); wav_path += ".dsf"; if (gDirUtilp->fileExists(wav_path)) { return true; } else { return false; } } bool LLAudioEngine::hasLocalFile(const LLUUID &uuid) { // See if it's in the cache. bool have_local = LLFileSystem::getExists(uuid, LLAssetType::AT_SOUND); LL_DEBUGS("AudioEngine") << "sound uuid " << uuid << " exists in cache" << LL_ENDL; return have_local; } void LLAudioEngine::startNextTransfer() { //LL_INFOS() << "LLAudioEngine::startNextTransfer()" << LL_ENDL; if (mCurrentTransfer.notNull() || getMuted()) { //LL_INFOS() << "Transfer in progress, aborting" << LL_ENDL; return; } // Get the ID for the next asset that we want to transfer. // Pick one in the following order: LLUUID asset_id; S32 i; LLAudioSource *asp = NULL; LLAudioData *adp = NULL; data_map::iterator data_iter; // Check all channels for currently playing sounds. F32 max_pri = -1.f; for (i = 0; i < LL_MAX_AUDIO_CHANNELS; i++) { if (!mChannels[i]) { continue; } asp = mChannels[i]->getSource(); if (!asp) { continue; } if (asp->getPriority() <= max_pri) { continue; } if (asp->getPriority() <= max_pri) { continue; } adp = asp->getCurrentData(); if (!adp) { continue; } if (!adp->hasLocalData() && !adp->hasDecodeFailed()) { asset_id = adp->getID(); max_pri = asp->getPriority(); } } // Check all channels for currently queued sounds. if (asset_id.isNull()) { max_pri = -1.f; for (i = 0; i < LL_MAX_AUDIO_CHANNELS; i++) { if (!mChannels[i]) { continue; } LLAudioSource *asp; asp = mChannels[i]->getSource(); if (!asp) { continue; } if (asp->getPriority() <= max_pri) { continue; } adp = asp->getQueuedData(); if (!adp) { continue; } if (!adp->hasLocalData() && !adp->hasDecodeFailed()) { asset_id = adp->getID(); max_pri = asp->getPriority(); } } } // Check all live channels for other sounds (preloads). if (asset_id.isNull()) { max_pri = -1.f; for (i = 0; i < LL_MAX_AUDIO_CHANNELS; i++) { if (!mChannels[i]) { continue; } LLAudioSource *asp; asp = mChannels[i]->getSource(); if (!asp) { continue; } if (asp->getPriority() <= max_pri) { continue; } for (data_map::value_type& preload_pair : asp->mPreloadMap) { LLAudioData *adp = preload_pair.second; if (!adp) { continue; } if (!adp->hasLocalData() && !adp->hasDecodeFailed()) { asset_id = adp->getID(); max_pri = asp->getPriority(); } } } } // Check all sources if (asset_id.isNull()) { max_pri = -1.f; source_map::iterator source_iter; for (source_map::value_type& source_pair : mAllSources) { asp = source_pair.second; if (!asp) { continue; } if (asp->getPriority() <= max_pri) { continue; } adp = asp->getCurrentData(); if (adp && !adp->hasLocalData() && !adp->hasDecodeFailed()) { asset_id = adp->getID(); max_pri = asp->getPriority(); continue; } adp = asp->getQueuedData(); if (adp && !adp->hasLocalData() && !adp->hasDecodeFailed()) { asset_id = adp->getID(); max_pri = asp->getPriority(); continue; } for (data_map::value_type& preload_pair : asp->mPreloadMap) { LLAudioData *adp = preload_pair.second; if (!adp) { continue; } if (!adp->hasLocalData() && !adp->hasDecodeFailed()) { asset_id = adp->getID(); max_pri = asp->getPriority(); break; } } } } if (asset_id.notNull()) { LL_INFOS() << "Getting asset data for: " << asset_id << LL_ENDL; mCurrentTransfer = asset_id; mCurrentTransferTimer.reset(); gAssetStorage->getAssetData(asset_id, LLAssetType::AT_SOUND, assetCallback, NULL); } else { //LL_INFOS() << "No pending transfers?" << LL_ENDL; } } // static void LLAudioEngine::assetCallback(const LLUUID &uuid, LLAssetType::EType type, void *user_data, S32 result_code, LLExtStat ext_status) { if (!gAudiop) { LL_WARNS("AudioEngine") << "LLAudioEngine instance doesn't exist!" << LL_ENDL; return; } if (result_code) { LL_INFOS() << "Boom, error in audio file transfer: " << LLAssetStorage::getErrorString( result_code ) << " (" << result_code << ")" << LL_ENDL; // Need to mark data as bad to avoid constant rerequests. LLAudioData *adp = gAudiop->getAudioData(uuid); if (adp) { // Make sure everything is cleared adp->setHasDecodeFailed(true); adp->setHasLocalData(false); adp->setHasDecodedData(false); adp->setHasCompletedDecode(true); } } else { LLAudioData *adp = gAudiop->getAudioData(uuid); if (!adp) { // Should never happen LL_WARNS() << "Got asset callback without audio data for " << uuid << LL_ENDL; } else { // LL_INFOS() << "Got asset callback with good audio data for " << uuid << ", making decode request" << LL_ENDL; adp->setHasDecodeFailed(false); adp->setHasLocalData(true); LLAudioDecodeMgr::getInstance()->addDecodeRequest(uuid); } } gAudiop->mCurrentTransfer = LLUUID::null; gAudiop->startNextTransfer(); } // // LLAudioSource implementation // LLAudioSource::LLAudioSource(const LLUUID& id, const LLUUID& owner_id, const F32 gain, const S32 type) : mID(id), mOwnerID(owner_id), mPriority(0.f), mGain(gain), mSourceMuted(false), mForcedPriority(false), mLoop(false), mSyncMaster(false), mSyncSlave(false), mQueueSounds(false), mPlayedOnce(false), mCorrupted(false), mType(type), mChannelp(NULL), mCurrentDatap(NULL), mQueuedDatap(NULL) { } LLAudioSource::~LLAudioSource() { if (mChannelp) { // Stop playback of this sound mChannelp->setSource(NULL); mChannelp = NULL; } } void LLAudioSource::setChannel(LLAudioChannel *channelp) { if (channelp == mChannelp) { return; } mChannelp = channelp; } void LLAudioSource::update() { if(mCorrupted) { return ; //no need to update } if (!getCurrentBuffer()) { LLAudioData *adp = getCurrentData(); if (adp) { // Hack - try and load the sound. Will do this as a callback // on decode later. if (adp->getBuffer()) { play(adp->getID()); } else if (adp->hasDecodedData() && !adp->hasWAVLoadFailed()) { adp->load(); } else if (adp->hasCompletedDecode() && adp->hasDecodeFailed()) // Only mark corrupted after decode is done { LL_WARNS() << "Marking LLAudioSource corrupted for " << adp->getID() << LL_ENDL; mCorrupted = true ; } } } } void LLAudioSource::updatePriority() { if (isForcedPriority()) { mPriority = 1.f; } else if (isMuted()) { mPriority = 0.f; } else { // Priority is based on distance LLVector3 dist_vec; dist_vec.setVec(getPositionGlobal()); if (gAudiop) { dist_vec -= gAudiop->getListenerPos(); } F32 dist_squared = llmax(1.f, dist_vec.magVecSquared()); mPriority = mGain / dist_squared; } } bool LLAudioSource::setupChannel() { LLAudioData *adp = getCurrentData(); if (!adp->getBuffer()) { // We're not ready to play back the sound yet, so don't try and allocate a channel for it. //LL_WARNS() << "Aborting, no buffer" << LL_ENDL; return false; } if (!gAudiop) { LL_WARNS("AudioEngine") << "LLAudioEngine instance doesn't exist!" << LL_ENDL; return false; } if (!mChannelp) { // Update the priority, in case we need to push out another channel. updatePriority(); setChannel(gAudiop->getFreeChannel(getPriority())); } if (!mChannelp) { // Ugh, we don't have any free channels. // Now we have to reprioritize. // For now, just don't play the sound. //LL_WARNS() << "Aborting, no free channels" << LL_ENDL; return false; } mChannelp->setSource(this); return true; } void LLAudioSource::stop() { play(LLUUID::null); if (mCurrentDatap) { // always reset data if something wants us to stop mCurrentDatap = nullptr; } } bool LLAudioSource::play(const LLUUID &audio_uuid) { // Special abuse of play(); don't play a sound, but kill it. if (audio_uuid.isNull()) { if (getChannel()) { getChannel()->setSource(NULL); setChannel(NULL); if (!isMuted()) { mCurrentDatap = NULL; } } return false; } // Reset our age timeout if someone attempts to play the source. mAgeTimer.reset(); if (!gAudiop) { LL_WARNS("AudioEngine") << "LLAudioEngine instance doesn't exist!" << LL_ENDL; return false; } LLAudioData *adp = gAudiop->getAudioData(audio_uuid); addAudioData(adp); if (isMuted()) { return false; } bool has_buffer = gAudiop->updateBufferForData(adp, audio_uuid); if (!has_buffer) { // Don't bother trying to set up a channel or anything, we don't have an audio buffer. return false; } if (!setupChannel()) { return false; } if (isSyncSlave()) { // A sync slave, it doesn't start playing until it's synced up with the master. // Flag this channel as waiting for sync, and return true. getChannel()->setWaiting(true); return true; } getChannel()->play(); return true; } bool LLAudioSource::isDone() const { if(mCorrupted) { return true ; } const F32 MAX_AGE = 60.f; const F32 MAX_UNPLAYED_AGE = 15.f; const F32 MAX_MUTED_AGE = 11.f; if (isLoop()) { // Looped sources never die on their own. return false; } if (hasPendingPreloads()) { return false; } if (mQueuedDatap) { // Don't kill this sound if we've got something queued up to play. return false; } F32 elapsed = mAgeTimer.getElapsedTimeF32(); // This is a single-play source if (!mChannelp) { if ((elapsed > (mSourceMuted ? MAX_MUTED_AGE : MAX_UNPLAYED_AGE)) || mPlayedOnce) { // We don't have a channel assigned, and it's been // over 15 seconds since we tried to play it. Don't bother. //LL_INFOS() << "No channel assigned, source is done" << LL_ENDL; return true; } else { return false; } } if (mChannelp->isPlaying()) { if (elapsed > MAX_AGE) { // Arbitarily cut off non-looped sounds when they're old. return true; } else { // Sound is still playing and we haven't timed out, don't kill it. return false; } } if ((elapsed > MAX_UNPLAYED_AGE) || mPlayedOnce) { // The sound isn't playing back after 15 seconds or we're already done playing it, kill it. return true; } return false; } void LLAudioSource::addAudioData(LLAudioData *adp, const bool set_current) { // Only handle a single piece of audio data associated with a source right now, // until I implement prefetch. if (!gAudiop) { LL_WARNS("AudioEngine") << "LLAudioEngine instance doesn't exist!" << LL_ENDL; return; } if (set_current) { if (!mCurrentDatap) { mCurrentDatap = adp; if (mChannelp) { mChannelp->updateBuffer(); mChannelp->play(); } // Make sure the audio engine knows that we want to request this sound. gAudiop->startNextTransfer(); return; } else if (mQueueSounds) { // If we have current data, and we're queuing, put // the object onto the queue. if (mQueuedDatap) { // We only queue one sound at a time, and it's a FIFO. // Don't put it onto the queue. return; } if (adp == mCurrentDatap && isLoop()) { // No point in queueing the same sound if // we're looping. return; } mQueuedDatap = adp; // Make sure the audio engine knows that we want to request this sound. gAudiop->startNextTransfer(); } else { if (mCurrentDatap != adp) { // Right now, if we're currently playing this sound in a channel, we // update the buffer that the channel's associated with // and play it. This may not be the correct behavior. mCurrentDatap = adp; if (mChannelp) { mChannelp->updateBuffer(); mChannelp->play(); } // Make sure the audio engine knows that we want to request this sound. gAudiop->startNextTransfer(); } } } else { // Add it to the preload list. mPreloadMap[adp->getID()] = adp; gAudiop->startNextTransfer(); } } bool LLAudioSource::hasPendingPreloads() const { // Check to see if we've got any preloads on deck for this source for (const data_map::value_type& preload_pair : mPreloadMap) { LLAudioData *adp = preload_pair.second; // note: a bad UUID will forever be !hasDecodedData() // but also hasDecodeFailed(), hence the check for hasDecodeFailed() if (!adp) { continue; } if (!adp->hasDecodedData() && !adp->hasDecodeFailed()) { // This source is still waiting for a preload return true; } } return false; } LLAudioData * LLAudioSource::getCurrentData() { return mCurrentDatap; } LLAudioData * LLAudioSource::getQueuedData() { return mQueuedDatap; } LLAudioBuffer * LLAudioSource::getCurrentBuffer() { if (!mCurrentDatap) { return NULL; } return mCurrentDatap->getBuffer(); } // // LLAudioChannel implementation // LLAudioChannel::LLAudioChannel() : mCurrentSourcep(NULL), mCurrentBufferp(NULL), mLoopedThisFrame(false), mWaiting(false), mSecondaryGain(1.0f) { } LLAudioChannel::~LLAudioChannel() { // Need to disconnect any sources which are using this channel. //LL_INFOS() << "Cleaning up audio channel" << LL_ENDL; if (mCurrentSourcep) { mCurrentSourcep->setChannel(NULL); } mCurrentBufferp = NULL; } void LLAudioChannel::setSource(LLAudioSource *sourcep) { //LL_INFOS() << this << ": setSource(" << sourcep << ")" << LL_ENDL; if (!sourcep) { // Clearing the source for this channel, don't need to do anything. //LL_INFOS() << "Clearing source for channel" << LL_ENDL; cleanup(); mCurrentSourcep = NULL; mWaiting = false; } else { LL_DEBUGS("AudioEngine") << "( id: " << sourcep->getID() << ")" << LL_ENDL; if (sourcep == mCurrentSourcep) { // Don't reallocate the channel, this will make FMOD goofy. //LL_INFOS() << "Calling setSource with same source!" << LL_ENDL; } mCurrentSourcep = sourcep; updateBuffer(); update3DPosition(); } } bool LLAudioChannel::updateBuffer() { if (!gAudiop) { LL_WARNS("AudioEngine") << "LLAudioEngine instance doesn't exist!" << LL_ENDL; return false; } if (!mCurrentSourcep) { // This channel isn't associated with any source, nothing // to be updated return false; } // Initialize the channel's gain setting for this sound. setSecondaryGain(gAudiop->getSecondaryGain(mCurrentSourcep->getType())); LLAudioBuffer *bufferp = mCurrentSourcep->getCurrentBuffer(); if (bufferp == mCurrentBufferp) { if (bufferp) { // The source hasn't changed what buffer it's playing bufferp->mLastUseTimer.reset(); bufferp->mInUse = true; } return false; } // // The source changed what buffer it's playing. We need to clean up // the existing channel // cleanup(); mCurrentBufferp = bufferp; if (bufferp) { bufferp->mLastUseTimer.reset(); bufferp->mInUse = true; } if (!mCurrentBufferp) { // There's no new buffer to be played, so we just abort. return false; } return true; } // // LLAudioData implementation // LLAudioData::LLAudioData(const LLUUID &uuid) : mID(uuid), mBufferp(NULL), mHasLocalData(false), mHasDecodedData(false), mHasCompletedDecode(false), mHasDecodeFailed(false), mHasWAVLoadFailed(false) { if (uuid.isNull()) { // This is a null sound. return; } if (!gAudiop) { LL_WARNS("AudioEngine") << "LLAudioEngine instance doesn't exist!" << LL_ENDL; return; } if (gAudiop->hasDecodedFile(uuid)) { // Already have a decoded version, don't need to decode it. setHasLocalData(true); setHasDecodedData(true); setHasCompletedDecode(true); } else if (gAssetStorage && gAssetStorage->hasLocalAsset(uuid, LLAssetType::AT_SOUND)) { setHasLocalData(true); } } //return false when the audio file is corrupted. bool LLAudioData::load() { // For now, just assume we're going to use one buffer per audiodata. if (mBufferp) { // We already have this sound in a buffer, don't do anything. LL_INFOS() << "Already have a buffer for this sound, don't bother loading!" << LL_ENDL; mHasWAVLoadFailed = false; return true; } if (!gAudiop) { LL_WARNS("AudioEngine") << "LLAudioEngine instance doesn't exist!" << LL_ENDL; mHasWAVLoadFailed = true; return false; } mBufferp = gAudiop->getFreeBuffer(); if (!mBufferp) { // No free buffers, abort. LL_INFOS() << "Not able to allocate a new audio buffer, aborting." << LL_ENDL; // *TODO: Mark this failure differently so the audio engine could retry loading this buffer in the future mHasWAVLoadFailed = true; return true; } std::string uuid_str; std::string wav_path; mID.toString(uuid_str); wav_path= gDirUtilp->getExpandedFilename(LL_PATH_CACHE,uuid_str) + ".dsf"; mHasWAVLoadFailed = !mBufferp->loadWAV(wav_path); if (mHasWAVLoadFailed) { // Hrm. Right now, let's unset the buffer, since it's empty. gAudiop->cleanupBuffer(mBufferp); mBufferp = nullptr; if (!gDirUtilp->fileExists(wav_path)) { mHasLocalData = false; mHasDecodedData = false; mHasCompletedDecode = false; mHasDecodeFailed = false; mHasWAVLoadFailed = false; gAudiop->preloadSound(mID); } return false; } mBufferp->mAudioDatap = this; return true; }