Home

nevrax.com

Nevrax.org News Mailing-list Documentation CVS Bugs License

Documentation                       Search   audio_mixer_user.cpp Go to the documentation of this file. /* Copyright, 2001 Nevrax Ltd. * * This file is part of NEVRAX NEL. * NEVRAX NEL 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, or (at your option) * any later version. * NEVRAX NEL 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 NEVRAX NEL; see the file COPYING. If not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, * MA 02111-1307, USA. */ #include "stdsound.h" //#include "env_sound_user.h" //#include "env_effect.h" #include "simple_sound.h" #include "complex_sound.h" //#include "ambiant_source.h" //#include "bounding_sphere.h" //#include "bounding_box.h" #include "driver/buffer.h" #include "sample_bank.h" #include "sound_bank.h" #include "background_sound_manager.h" #include "simple_source.h" #include "complex_source.h" #include "background_source.h" #include "nel/misc/file.h" #include "nel/misc/path.h" #include "nel/misc/time_nl.h" #include "nel/misc/command.h" #include "context_sound.h" #include <iomanip.h> //#include <crtdbg.h> using namespace NLMISC; using namespace std; namespace NLSOUND { #ifdef _DEBUG CAudioMixerUser::IMixerEvent *CurrentEvent = 0; #endif #define NL_TRACE_MIXER 0 #if NL_TRACE_MIXER #define _profile(_a) nldebug ## _a #else #define _profile(_a) #endif // The audio mixer singleton instance CAudioMixerUser *CAudioMixerUser::_Instance = NULL; // Return the priority cstring (debug info) const char *PriToCStr [NbSoundPriorities] = { "XH", "HI", "MD", "LO" }; // ****************************************************************** const char *getPriorityStr( TSoundPriority p ) { nlassert( ((uint)p) < NbSoundPriorities ); return PriToCStr[p]; } // ****************************************************************** UAudioMixer *UAudioMixer::createAudioMixer() { return new CAudioMixerUser(); } // ****************************************************************** CAudioMixerUser::CAudioMixerUser() : _SoundDriver(NULL), _ListenPosition(CVector::Null), // _EnvSounds(NULL), // _BalancePeriod(0), _CurEnvEffect(NULL), _NbTracks(0), _MaxNbTracks(0), _Leaving(false), _BackgroundSoundManager(0), _PlayingSources(0) { if ( _Instance == NULL ) { _Instance = this; #if NL_PROFILE_MIXER _UpdateTime = 0.0; _CreateTime = 0.0; _UpdateCount = 0; _CreateCount = 0; #endif } else { nlerror( "Audio mixer singleton instanciated twice" ); } } // ****************************************************************** CAudioMixerUser::~CAudioMixerUser() { nldebug( "AM: Releasing..." ); if (_BackgroundSoundManager != 0) delete _BackgroundSoundManager; // CBackgroundSoundManager::release(); reset(); _Leaving = true; // Release the sound bank CSoundBank::release(); // Release all the SampleBanks CSampleBank::releaseAll(); // Tracks uint i; for ( i=0; i!=_NbTracks; i++ ) { if ( _Tracks[i] ) delete _Tracks[i]; } // Sound driver if ( _SoundDriver != NULL ) delete _SoundDriver; _Instance = NULL; nldebug( "AM: Released" ); } void CAudioMixerUser::setPriorityReserve(TSoundPriority priorityChannel, uint reserve) { _PriorityReserve[priorityChannel] = min(_NbTracks, reserve); } void CAudioMixerUser::setLowWaterMark(uint value) { _LowWaterMark = min(_NbTracks, value); } // ****************************************************************** void CAudioMixerUser::writeProfile(std::ostream& out) { // compute number of muted source uint nb = 0; /* TSourceContainer::iterator first(_Sources.begin()), last(_Sources.end()); for (; first != last; ++first) { CSimpleSource *psu = *first; if (psu->getTrack() == NULL) { ++nb; } } */ /* hash_set<CSimpleSource*>::const_iterator ips; for ( ips=_Sources.begin(); ips!=_Sources.end(); ++ips ) { CSimpleSource *psu = *ips; if (psu->getTrack() == NULL) { ++nb; } } */ out << "Mixer: \n"; out << "Playing sources: " << getPlayingSourcesNumber() << " \n"; out << "Available tracks: " << getNumberAvailableTracks() << " \n"; // out << "Muted sources: " << nb << " \n"; // out << "Muted sources: " << max(0, sint(_PlayingSources.size())-sint(_NbTracks)) << " \n"; out << "Muted sources: " << max(0, sint(_PlayingSources)-sint(_NbTracks)) << " \n"; out << "Sources waiting for play: " << _SourceWaitingForPlay.size() << " \n"; out << "HighestPri: " << _ReserveUsage[HighestPri] << " \n"; out << "HighPri: " << _ReserveUsage[HighPri] << " \n"; out << "MidPri: " << _ReserveUsage[MidPri] << " \n"; out << "LowPri: " << _ReserveUsage[LowPri] << " \n"; out << "Average update time: " << std::setw(10) << (1000.0 * _UpdateTime / _UpdateCount) << " msec\n"; out << "Average create time: " << std::setw(10) <<(1000.0 * _CreateTime / _CreateCount) << " msec\n"; out << "Estimated CPU: " << std::setiosflags(ios::right) << std::setprecision(6) << std::setw(10) << (100.0 * 1000.0 * (_UpdateTime + _CreateTime) / curTime()) << "%\n"; if (_SoundDriver) { out << "\n"; out << "Driver: \n"; _SoundDriver->writeProfile(out); } } // ****************************************************************** void CAudioMixerUser::addSourceWaitingForPlay(CSimpleSource *source) { _SourceWaitingForPlay.push_back(source); } // ****************************************************************** void CAudioMixerUser::reset() { _Leaving = true; _SourceWaitingForPlay.clear(); // Stop tracks uint i; for ( i=0; i!=_NbTracks; i++ ) { if ( _Tracks[i] ) { CSimpleSource* src = _Tracks[i]->getSource(); if (src && src->isPlaying()) { src->stop(); } } } // Sources while (!_Sources.empty()) { //removeSource( _Sources.begin(), true ); // 3D sources, the envsounds were removed above CSourceCommon *source = *(_Sources.begin()); if (source->isPlaying()) source->stop(); else delete source; } _Leaving = false; } // ****************************************************************** void CAudioMixerUser::init( /*uint32 balance_period */) { nldebug( "AM: Init..." ); _profile(( "AM: ---------------------------------------------------------------" )); _profile(( "AM: DRIVER: %s", NLSOUND_DLL_NAME )); // Init sound driver try { _SoundDriver = ISoundDriver::createDriver(); } catch(...) { delete this; _Instance = NULL; throw; } uint i; // Init registrable classes static bool initialized = false; if (!initialized) { // CSimpleSource::init(); initialized = true; } // Init listener _Listener.init( _SoundDriver ); // Init tracks (physical sources) _NbTracks = MAX_TRACKS; // could be chosen by the user, or according to the capabilities of the sound card for ( i=0; i<MAX_TRACKS; i++ ) { _Tracks[i] = NULL; } try { for ( i=0; i!=_NbTracks; i++ ) { _Tracks[i] = new CTrack(); _Tracks[i]->init( _SoundDriver ); _FreeTracks.push_back(_Tracks[i]); } } catch ( ESoundDriver & ) { // If the source generation failed, keep only the generated number of sources _NbTracks = i; //delete _Tracks[i]; // Bug: the desctructor would not work because the source's name is invalid } _MaxNbTracks = _NbTracks; // Init the reserve stuff. _LowWaterMark = 0; for (i=0; i<NbSoundPriorities; ++i) { _PriorityReserve[i] = _NbTracks; _ReserveUsage[i] = 0; } _StartTime = CTime::getLocalTime(); // Create the background sound manager. _BackgroundSoundManager = new CBackgroundSoundManager(); // Load the sound bank singleton CSoundBank::instance()->load(); nlinfo( "Initialized audio mixer with %u voices", _NbTracks ); } // ****************************************************************** void CAudioMixerUser::bufferUnloaded(IBuffer *buffer) { // check all track to find a track playing this buffer. uint i; for ( i=0; i!=_NbTracks; ++i ) { CTrack *track = _Tracks[i]; if ( track && track->getSource()) { if (track->getSource()->getBuffer() == buffer) { track->getSource()->stop(); } } } } // ****************************************************************** void CAudioMixerUser::enable( bool b ) { // TODO : rewrite this method nlassert(false); /* if ( b ) { // Reenable _NbTracks = _MaxNbTracks; } else { // Disable uint i; for ( i=0; i!=_NbTracks; i++ ) { if ( _Tracks[i] && ! _Tracks[i]->isAvailable() ) { _Tracks[i]->getSource()->leaveTrack(); // nlassert(_PlayingSources.find(_Tracks[i]->getSource()) != _PlayingSources.end()); // _PlayingSources.erase(_Tracks[i]->getSource()); } } _NbTracks = 0; } */ } // ****************************************************************** ISoundDriver* CAudioMixerUser::getSoundDriver() { return _SoundDriver; } // ****************************************************************** /*void CAudioMixerUser::computeEnvEffect( const CVector& listenerpos, bool force ) { // Find the first matching, linear search vector<CEnvEffect*>::iterator ipe; for ( ipe=_EnvEffects.begin(); ipe!=_EnvEffects.end(); ++ipe ) { if ( (*ipe)->include( listenerpos ) ) { // Set the effect only if it has changed if ( (_CurEnvEffect != *ipe) || force ) { _CurEnvEffect = *ipe; _Listener.getListener()->setEnvironment( _CurEnvEffect->getEnvNum(), _CurEnvEffect->getEnvSize() ); nldebug( "AM: Listener environmental effect changed to %u", _CurEnvEffect->getEnvNum() ); } return; } } // If not found, set the default (only if it wasn't the default before) if ( _CurEnvEffect != NULL ) { _Listener.getListener()->setEnvironment( ENVFX_DEFAULT_NUM ); _CurEnvEffect = NULL; nldebug( "AM: Listener environmental effect reset" ); } } */ // ****************************************************************** void CAudioMixerUser::getFreeTracks( uint nb, CTrack **tracks ) { std::vector<CTrack*>::iterator first(_FreeTracks.begin()), last(_FreeTracks.end()); for (nb =0; first != last; ++first, ++nb) { tracks[nb] = *first; } } // ****************************************************************** void CAudioMixerUser::applyListenerMove( const NLMISC::CVector& listenerpos ) { // Store position _ListenPosition = listenerpos; // Environmental effect // computeEnvEffect( listenerpos ); /* // Environment sounds if ( _EnvSounds != NULL ) { _EnvSounds->recompute(); } */ } // ****************************************************************** void CAudioMixerUser::reloadSampleBanks(bool async) { CSampleBank::reload(async); } // ****************************************************************** CTrack *CAudioMixerUser::getFreeTrack(CSimpleSource *source) { // at least some track free ? if (!_FreeTracks.empty()) { // under the low water mark or under the reserve if (_FreeTracks.size() > _LowWaterMark || _ReserveUsage[source->getPriority()] < _PriorityReserve[source->getPriority()] ) { // non discardable track or not too many waiting source if (source->getPriority() == HighestPri || _FreeTracks.size() > _SourceWaitingForPlay.size()) { CTrack *ret = _FreeTracks.back(); _FreeTracks.pop_back(); ret->setSource(source); _ReserveUsage[source->getPriority()]++; // nldebug("Track %p assign to source %p", ret, ret->getSource()); return ret; } } } // try to find a track with a source cuttable { float d1, d2, t1, t2; d1 = (source->getPos() - _ListenPosition).norm(); t1 = max(0.0f, 1-((d1-source->getSimpleSound()->getMinDistance()) / (source->getSimpleSound()->getMaxDistance() - source->getSimpleSound()->getMinDistance()))); for (uint i=0; i<_NbTracks; ++i) { CSimpleSource *src2 = _Tracks[i]->getSource(); if (src2 != 0) { d2 = (src2->getPos() - _ListenPosition).norm(); t2 = max(0.0f, 1-((d2-src2->getSimpleSound()->getMinDistance()) / (src2->getSimpleSound()->getMaxDistance() - src2->getSimpleSound()->getMinDistance()))); const float tfactor = 1.3f; if (t1 > t2 * tfactor) // if (d1 < d2) { nldebug("Cutting source %p with source %p (%f > %f*%f)", src2, source, t1, tfactor, t2); // on peut cuter cette voie ! src2->stop(); if (_FreeTracks.empty()) { nlwarning("No free track after cutting a playing sound source !"); } else { CTrack *ret = _FreeTracks.back(); _FreeTracks.pop_back(); ret->setSource(source); nldebug("Track %p assign to source %p", ret, ret->getSource()); return ret; } } } } } return 0; } void CAudioMixerUser::freeTrack(CTrack *track) { nlassert(track != 0); nlassert(track->getSource() != 0); // nldebug("Track %p free by source %p", track, track->getSource()); _ReserveUsage[track->getSource()->getPriority()]--; track->setSource(0); _FreeTracks.push_back(track); } void CAudioMixerUser::getPlayingSoundsPos(std::vector<std::pair<bool, NLMISC::CVector> > &pos) { int nbplay = 0; int nbmute = 0; int nbsrc = 0; TSourceContainer::iterator first(_Sources.begin()), last(_Sources.end()); for (; first != last; ++first) { CSourceCommon *ps = *first; if (ps->getType() == CSourceCommon::SOURCE_SIMPLE) { CSimpleSource *source = static_cast<CSimpleSource*>(*first); nbsrc++; if (source->isPlaying()) { pos.push_back(make_pair(source->getTrack() == 0, source->getPos())); if (source->getTrack() == 0) nbmute++; else { // nldebug ("Source %p playing on track %p", source, source->getTrack()); nbplay ++; } } } } // nldebug("Total source : %d, playing : %d, muted : %d", nbsrc, nbplay, nbmute); } void CAudioMixerUser::update() { #if NL_PROFILE_MIXER TTicks start = CTime::getPerformanceTime(); #endif // update the object. { // 1st, update the event list { std::vector<std::pair<IMixerUpdate*, bool> >::iterator first(_UpdateEventList.begin()), last(_UpdateEventList.end()); for (; first != last; ++first) { if (first->second) _UpdateList.insert(first->first); else _UpdateList.erase(first->first); } _UpdateEventList.clear(); } // 2nd, do the update { TMixerUpdateContainer::iterator first(_UpdateList.begin()), last(_UpdateList.end()); for (; first != last; ++first) { // call the update method. const_cast<IMixerUpdate*>(*first)->onUpdate(); } } } // send the event. { // 1st, update the event list { std::vector<std::pair<NLMISC::TTime, IMixerEvent*> >::iterator first(_EventListUpdate.begin()), last(_EventListUpdate.end()); for (; first != last; ++first) { if (first->first != 0) { // add an event // nldebug ("Add event %p", first->second); TTimedEventContainer::iterator it(_EventList.insert(*first)); _Events.insert(make_pair(first->second, it)); } else { // remove the events pair<TEventContainer::iterator, TEventContainer::iterator> range = _Events.equal_range(first->second); TEventContainer::iterator first2(range.first), last2(range.second); for (; first2 != last2; ++first2) { // remove the event nldebug("Remove event %p", first2->second->second); _EventList.erase(first2->second); } _Events.erase(range.first, range.second); } } _EventListUpdate.clear(); } // 2nd, call the events TTime now = NLMISC::CTime::getLocalTime(); while (!_EventList.empty() && _EventList.begin()->first <= now) { #ifdef _DEBUG CurrentEvent = _EventList.begin()->second; #endif // nldebug("Sending Event %p", _EventList.begin()->second); _EventList.begin()->second->onEvent(); TEventContainer::iterator it(_Events.lower_bound(_EventList.begin()->second)); while (it->first == _EventList.begin()->second) { if (it->second == _EventList.begin()) { _Events.erase(it); break; } it++; } _EventList.erase(_EventList.begin()); #ifdef _DEBUG CurrentEvent = 0; #endif } } // update the background sound // _BackgroundSoundManager->update(); // Check all playing track and stop any terminated buffer. for (uint i=0; i<_NbTracks; ++i) { if (!_Tracks[i]->isPlaying()) { if (_Tracks[i]->getSource() != 0) { CSimpleSource *source = _Tracks[i]->getSource(); source->stop(); } // try to play any waiting source. if (!_SourceWaitingForPlay.empty()) { // check if the source still exist before trying to play it if (_Sources.find(_SourceWaitingForPlay.front()) != _Sources.end()) _SourceWaitingForPlay.front()->play(); nldebug("Before POP Sources waiting : %u", _SourceWaitingForPlay.size()); _SourceWaitingForPlay.pop_front(); nldebug("After POP Sources waiting : %u", _SourceWaitingForPlay.size()); } } } // Debug info /*uint32 i; nldebug( "List of the %u tracks", _NbTracks ); for ( i=0; i!=_NbTracks; i++ ) { CSimpleSource *su; if ( su = _Tracks[i]->getSource() ) { nldebug( "%u: %p %s %s %s %s, vol %u", i, &_Tracks[i]->DrvSource, _Tracks[i]->isAvailable()?"FREE":"USED", _Tracks[i]->isAvailable()?"":(su->isPlaying()?"PLAYING":"STOPPED"), _Tracks[i]->isAvailable()?"":PriToCStr[su->getPriority()], _Tracks[i]->isAvailable()?"":(su->getSound()?su->getSound()->getFilename().c_str():""), (uint)(su->getGain()*100.0f) ); } }*/ _SoundDriver->commit3DChanges(); #if NL_PROFILE_MIXER _UpdateTime = CTime::ticksToSecond(CTime::getPerformanceTime() - start); _UpdateCount++; #endif /* // display the track using... { char tmp[2048] = ""; string str; for (uint i=0; i<_NbTracks/2; ++i) { sprintf(tmp, "[%2u]%8p ", i, _Tracks[i]->getSource()); str += tmp; } nldebug((string("Status1: ")+str).c_str()); str = ""; for (i=_NbTracks/2; i<_NbTracks; ++i) { sprintf(tmp, "[%2u]%8p ", i, _Tracks[i]->getSource()); str += tmp; } // nldebug((string("Status2: ")+str).c_str()); } */ } // ****************************************************************** TSoundId CAudioMixerUser::getSoundId( const std::string &name ) { return CSoundBank::instance()->getSound(name); } // ****************************************************************** void CAudioMixerUser::addSource( CSourceCommon *source ) { nlassert(_Sources.find(source) == _Sources.end()); _Sources.insert( source ); // _profile(( "AM: ADDSOURCE, SOUND: %d, TRACK: %p, NAME=%s", source->getSound(), source->getTrack(), // source->getSound() && (source->getSound()->getName()!="") ? source->getSound()->getName().c_str() : "" )); } // ****************************************************************** USource *CAudioMixerUser::createSource( TSoundId id, bool spawn, TSpawnEndCallback cb, void *userParam, CSoundContext *context ) { #if NL_PROFILE_MIXER TTicks start = CTime::getPerformanceTime(); #endif _profile(( "AM: [%u]---------------------------------------------------------------", curTime() )); _profile(( "AM: CREATESOURCE: SOUND=%p, NAME=%s, TIME=%d", id, id->getName().c_str(), curTime() )); _profile(( "AM: SOURCES: %d, PLAYING: %d, TRACKS: %d", getSourcesNumber(), getPlayingSourcesNumber(), getNumberAvailableTracks() )); if ( id == NULL ) { _profile(("AM: FAILED CREATESOURCE")); nldebug( "AM: Sound not created: invalid sound id" ); return NULL; } USource *ret = NULL; if (id->getSoundType() == CSound::SOUND_SIMPLE) { CSimpleSound *simpleSound = static_cast<CSimpleSound *>(id); // This is a simple sound if (simpleSound->getBuffer() == NULL) { nlwarning ("Can't create the sound '%s'", simpleSound->getBuffername().c_str()); return NULL; } // Create source CSimpleSource *source = new CSimpleSource( simpleSound, spawn, cb, userParam); // nldebug("Mixer : source %p created", source); if (source->getBuffer() != 0) { // Link the position to the listener position if it'a stereo source if ( source->getBuffer()->isStereo() ) { source->set3DPositionVector( &_ListenPosition ); } } else { nlassert(false); // FIXME } ret = source; } else if (id->getSoundType() == CSound::SOUND_COMPLEX) { CComplexSound *complexSound = static_cast<CComplexSound*>(id); // This is a pattern sound. ret = new CComplexSource(complexSound, spawn, cb, userParam); } else if (id->getSoundType() == CSound::SOUND_BACKGROUND) { // This is a background sound. CBackgroundSound *bgSound = static_cast<CBackgroundSound *>(id); ret = new CBackgroundSource(bgSound, spawn, cb, userParam); } else if (id->getSoundType() == CSound::SOUND_CONTEXT) { // This is a context sound. if (context != 0) { CContextSound *ctxSound = static_cast<CContextSound *>(id); // nlassert(context != 0); CSound *sound = ctxSound->getContextSound(*context); if (sound != 0) { ret = createSource(sound, spawn, cb, userParam); // Set the volume of the source according to the context volume if (ret != 0) ret->setGain(ret->getGain() * ctxSound->getGain()); } else ret = 0; } else ret = 0; } else { // nlassertex(false, ("Unknown sound class !")); nlwarning("Unknow sound class : %u", id->getSoundType()); } #if NL_PROFILE_MIXER _CreateTime = CTime::ticksToSecond(CTime::getPerformanceTime() - start); _CreateCount++; #endif //nldebug( "AM: Source created" ); return ret; } // ****************************************************************** USource *CAudioMixerUser::createSource( const std::string &name, bool spawn, TSpawnEndCallback cb, void *userParam, CSoundContext *context) { return createSource( getSoundId( name ), spawn, cb, userParam, context ); } // ****************************************************************** void CAudioMixerUser::removeSource( CSourceCommon *source ) { nlassert( source != NULL ); size_t n = _Sources.erase(source); nlassert(n == 1); } // ****************************************************************** void CAudioMixerUser::selectEnvEffects( const std::string &tag ) { nlassertex(false, ("Not implemented yet")); /* // Select Env vector<CEnvEffect*>::iterator ipe; for ( ipe=_EnvEffects.begin(); ipe!=_EnvEffects.end(); ++ipe ) { (*ipe)->selectEnv( tag ); } // Compute CVector pos; _Listener.getPos( pos ); computeEnvEffect( pos, true ); */ } // ****************************************************************** /* void CAudioMixerUser::loadEnvEffects( const char *filename ) { nlassert( filename != NULL ); nlinfo( "Loading environmental effects from %s...", filename ); // Unload previous env effects vector<CEnvEffect*>::iterator ipe; for ( ipe=_EnvEffects.begin(); ipe!=_EnvEffects.end(); ++ipe ) { delete (*ipe); } _EnvEffects.clear(); string str = CPath::lookup( filename, false ); // Load env effects CIFile file; if ( !str.empty() && file.open(str) ) { uint32 n = CEnvEffect::load( _EnvEffects, file ); nldebug( "AM: Loaded %u environmental effects", n ); } else { nlwarning( "AM: Environmental effects file not found" ); } } */ // ****************************************************************** uint32 CAudioMixerUser::loadSampleBank(bool async, const std::string &filename, std::vector<std::string> *notfoundfiles ) { // nlassert( filename != NULL ); string path = _SamplePath; path.append("/").append(filename); nldebug( "Loading samples from %s...", path.c_str() ); CSampleBank* bank = CSampleBank::findSampleBank(path); if (bank == NULL) { // create a new sample bank //_CrtCheckMemory(); bank = new CSampleBank(path, _SoundDriver); //_CrtCheckMemory(); } try { bank->load(async); } catch (Exception& e) { if (notfoundfiles) { notfoundfiles->push_back(path); } string reason = e.what(); nlwarning( "AM: Failed to load the samples: %s", reason.c_str() ); } return bank->countSamples(); } bool CAudioMixerUser::unloadSampleBank( const std::string &filename) { string path = _SamplePath; path.append("/").append(filename); nldebug( "Unloading samples from %s...", path.c_str() ); CSampleBank *pbank = CSampleBank::findSampleBank(path); if (pbank != NULL) { // ok, the bank exist. return pbank->unload(); } else return false; } // ****************************************************************** void CAudioMixerUser::getSoundNames( std::vector<std::string>& names ) const { CSoundBank::instance()->getNames(names); } // ****************************************************************** uint CAudioMixerUser::getPlayingSourcesNumber() const { return _PlayingSources; } // ****************************************************************** uint CAudioMixerUser::getNumberAvailableTracks() const { return _FreeTracks.size(); } // ****************************************************************** string CAudioMixerUser::getSourcesStats() const { // TODO : rewrite log output string s; TSourceContainer::iterator ips; for ( ips=_Sources.begin(); ips!=_Sources.end(); ++ips ) { if ( (*ips)->isPlaying() ) { // char line [80]; /* nlassert( (*ips)->getSound() && (*ips)->getSimpleSound()->getBuffer() ); smprintf( line, 80, "%s: %u%% %s %s", (*ips)->getSound()->getName().c_str(), (uint32)((*ips)->getGain()*100.0f), (*ips)->getBuffer()->isStereo()?"ST":"MO", PriToCStr[(*ips)->getPriority()] ); s += string(line) + "\n"; */ } } return s; } // ****************************************************************** /* void CAudioMixerUser::loadEnvSounds( const char *filename, UEnvSound **treeRoot ) { nlassert( filename != NULL ); nlinfo( "Loading environment sounds from %s...", filename ); string str = CPath::lookup( filename, false ); CIFile file; if ( !str.empty() && file.open( str ) ) { uint32 n = 0; //CEnvSoundUser::load( _EnvSounds, file ); nldebug( "AM: Loaded %u environment sounds", n ); } else { nlwarning( "AM: Environment sounds file not found: %s", filename ); } if ( treeRoot != NULL ) { *treeRoot = _EnvSounds; } } */ // ****************************************************************** struct CompareSources : public binary_function<const CSimpleSource*, const CSimpleSource*, bool> { // Constructor CompareSources( const CVector &pos ) : _Pos(pos) {} // Operator() bool operator()( const CSimpleSource *s1, const CSimpleSource *s2 ) { if (s1->getPriority() < s2->getPriority()) { return true; } else if (s1->getPriority() == s2->getPriority()) { // Equal priority, test distances to the listener const CVector &src1pos = s1->getPos(); const CVector &src2pos = s2->getPos();; return ( (src1pos-_Pos).sqrnorm() < (src2pos-_Pos).sqrnorm() ); } else { return false; } } // Listener pos const CVector &_Pos; }; // ****************************************************************** uint32 CAudioMixerUser::getLoadedSampleSize() { return CSampleBank::getTotalByteSize(); } // ****************************************************************** /* void CAudioMixerUser::redispatchSourcesToTrack() { */ // TODO : rewrite ? /* if ( _NbTracks == 0 ) { return; } _profile(( "AM: [%u]---------------------------------------------------------------", curTime() )); _profile(( "AM: Redispatching sources" )); const CVector &listenerpos = _Listener.getPos(); // Get a copy of the sources set (we will modify it) static TSourceContainer sources_copy; sources_copy = _PlayingSources; // FIXME: SWAPTEST //nlassert( sources_copy.size() >= _NbTracks ); // Select the nbtracks "smallest" sources (the ones that have the higher priorities) TSourceContainer::iterator ips; static TSourceContainer selected_sources; uint32 i; selected_sources.clear(); // Select the sources // Select the nbtracks "smallest" sources (the ones that have the higher priorities) // FIXME: SWAPTEST //for ( i=0; i!=_NbTracks; i++ ) // TODO : optimize : this is a very BAD PERFORMANCE code while (!sources_copy.empty() && (selected_sources.size() < _NbTracks)) { ips = min_element( sources_copy.begin(), sources_copy.end(), CompareSources( listenerpos ) ); if ((*ips)->isPlaying()) { selected_sources.insert( *ips ); } sources_copy.erase( ips ); } // Clear the current tracks where the sources are not selected anymore _profile(( "AM: Total sources: %u", _PlayingSources.size() )); _profile(( "AM: Selected sources: %u", selected_sources.size() )); for ( i=0; i!=_NbTracks; i++ ) { // FIXME: SWAPTEST if ( _Tracks[i] && ! _Tracks[i]->isAvailable() ) { // Optimization note: instead of searching the source in selected_sources, we could have // set a boolean in the source object and tested it. if ( (ips = selected_sources.find( _Tracks[i]->getSource() )) == selected_sources.end() ) { // There will be a new source in this track _profile(( "AM: TRACK: %p: REPLACED, SOURCE: %p", _Tracks[i], _Tracks[i]->getSource() )); if (_Tracks[i]->getSource() != 0) { _Tracks[i]->getSource()->leaveTrack(); // nlassert(_PlayingSources.find(_Tracks[i]->getSource()) != _PlayingSources.end()); _PlayingSources.erase(_Tracks[i]->getSource()); } } else { // The track will remain unchanged selected_sources.erase( ips ); _profile(( "AM: TRACK: %p: UNCHANGED, SOURCE: %p", _Tracks[i], _Tracks[i]->getSource() )); } } else { _profile(( "AM: TRACK: %p: FREE", _Tracks[i] )); } } if (!selected_sources.empty()) { // Now, only the sources to add into the tracks remain in selected_sources CTrack *track [MAX_TRACKS]; // a little bit more than needed (avoiding a "new") getFreeTracks( selected_sources.size(), track ); _profile(( "AM: Remaining sources: %u", selected_sources.size() )); for (i=0, ips=selected_sources.begin(); ips!=selected_sources.end(); ++ips ) { // FIXME: SWAPTEST (*ips)->enterTrack( track[i] ); // nlassert(_PlayingSources.find(*ips) == _PlayingSources.end()); // _PlayingSources.insert(*ips); // _profile(( "AM: TRACK: %p: ASSIGNED, SOURCE: %p", track[i], track[i]->getSource() )); _profile(( "AM: TRACK: %p: ASSIGNED, SOURCE: %p", track[i], *ips )); i++; } } */ //} void CAudioMixerUser::setListenerPos (const NLMISC::CVector &pos) { _Listener.setPos(pos); _BackgroundSoundManager->setListenerPosition(pos); } NLMISC_COMMAND (displaySoundInfo, "Display information about the audio mixer", "") { if(args.size() != 0) return false; if (CAudioMixerUser::instance() == NULL) { log.displayNL ("No audio mixer available"); return true; } log.displayNL ("%d tracks, MAX_TRACKS = %d, contains:", CAudioMixerUser::instance()->_NbTracks, MAX_TRACKS); for (uint i = 0; i < CAudioMixerUser::instance()->_NbTracks; i++) { if (CAudioMixerUser::instance()->_Tracks[i] == NULL) { log.displayNL ("Track %d is NULL", i); } else { log.displayNL ("Track %d %s available and %s playing.", i, (CAudioMixerUser::instance()->_Tracks[i]->isAvailable()?"is":"is not"), (CAudioMixerUser::instance()->_Tracks[i]->isPlaying()?"is":"is not")); if (CAudioMixerUser::instance()->_Tracks[i]->getSource() == NULL) { log.displayNL (" CUserSource is NULL"); } else { const CVector &pos = CAudioMixerUser::instance()->_Tracks[i]->getSource()->getPos(); string bufname; if (CAudioMixerUser::instance()->_Tracks[i]->getSource()->getBuffer()) bufname = CAudioMixerUser::instance()->_Tracks[i]->getSource()->getBuffer()->getName(); log.displayNL (" CUserSource is id %d buffer name '%s' pos %f %f %f", CAudioMixerUser::instance()->_Tracks[i]->getSource()->getSound(), bufname.c_str(), pos.x, pos.y, pos.z); } } } return true; } void CAudioMixerUser::registerBufferAssoc(CSound *sound, IBuffer *buffer) { _BufferToSources[buffer].push_back(sound); } void CAudioMixerUser::unregisterBufferAssoc(CSound *sound, IBuffer *buffer) { TBufferToSourceContainer::iterator it(_BufferToSources.find(buffer)); if (it != _BufferToSources.end()) { std::vector<CSound*>::iterator first(it->second.begin()), last(it->second.end()); for (; first != last; ++first) { if (*first == sound) { it->second.erase(first); break; } } } } void CAudioMixerUser::registerUpdate(CAudioMixerUser::IMixerUpdate *pmixerUpdate) { _UpdateEventList.push_back(make_pair(pmixerUpdate, true)); } void CAudioMixerUser::unregisterUpdate(CAudioMixerUser::IMixerUpdate *pmixerUpdate) { _UpdateEventList.push_back(make_pair(pmixerUpdate, false)); } void CAudioMixerUser::addEvent( CAudioMixerUser::IMixerEvent *pmixerEvent, const NLMISC::TTime &date) { // nldebug("Adding event %p", pmixerEvent); _EventListUpdate.push_back(make_pair(date, pmixerEvent)); } void CAudioMixerUser::removeEvents( CAudioMixerUser::IMixerEvent *pmixerEvent) { // nldebug("Removing event %p", pmixerEvent); // store the pointer fot future removal. _EventListUpdate.push_back(make_pair(0, pmixerEvent)); } void CAudioMixerUser::setBackgroundFlags(const TBackgroundFlags &backgroundFlags) { _BackgroundSoundManager->setBackgroundFlags(backgroundFlags); } void CAudioMixerUser::loadBackgroundSoundFromRegion (const NLLIGO::CPrimRegion &region) { _BackgroundSoundManager->loadSoundsFromRegion(region); } void CAudioMixerUser::loadBackgroundEffectsFromRegion (const NLLIGO::CPrimRegion &region) { _BackgroundSoundManager->loadEffecsFromRegion(region); } void CAudioMixerUser::loadBackgroundSamplesFromRegion (const NLLIGO::CPrimRegion &region) { _BackgroundSoundManager->loadSamplesFromRegion(region); } void CAudioMixerUser::playBackgroundSound () { _BackgroundSoundManager->play (); } void CAudioMixerUser::stopBackgroundSound () { _BackgroundSoundManager->stop (); } void CAudioMixerUser::loadBackgroundSound (const std::string &continent) { _BackgroundSoundManager->load (continent); } } // NLSOUND