From 0ea5fc66924303d1bf73ba283a383e2aadee02f2 Mon Sep 17 00:00:00 2001 From: neodarz Date: Sat, 11 Aug 2018 20:21:34 +0200 Subject: Initial commit --- docs/doxygen/nel/a03346.html | 1594 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1594 insertions(+) create mode 100644 docs/doxygen/nel/a03346.html (limited to 'docs/doxygen/nel/a03346.html') diff --git a/docs/doxygen/nel/a03346.html b/docs/doxygen/nel/a03346.html new file mode 100644 index 00000000..60d92c73 --- /dev/null +++ b/docs/doxygen/nel/a03346.html @@ -0,0 +1,1594 @@ + + +NeL: NLSOUND::CSampleBank class Reference + + + +
+Main Page | Namespace List | Class Hierarchy | Alphabetical List | Data Structures | File List | Namespace Members | Data Fields | Globals | Related Pages | Search for 
+

NLSOUND::CSampleBank Class Reference

#include <sample_bank.h> +

+

Inheritance diagram for NLSOUND::CSampleBank: +

+ +NLSOUND::CAudioMixerUser::IMixerUpdate +NLMISC::CDbgRefCount< IMixerUpdate > + +

Detailed Description

+A set of samples.
Author:
Peter Hanappe

+Nevrax France

+
Date:
2001
+ +

+ +

+Definition at line 67 of file sample_bank.h. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions

uint countSamples ()
 Return the number of samples in this bank.

 CSampleBank (const std::string &name, ISoundDriver *sd)
 Constructor.

const NLMISC::TStringId getName () const
 Return the name (must be unique).

IBuffer * getSample (const NLMISC::TStringId &name)
 Return a samples corresponding to a name.

uint getSize ()
 Return the size of this bank in bytes.

bool isLoaded ()
 Returns true if the samples in this bank have been loaded.

void load (bool async)
bool unload ()
virtual ~CSampleBank ()
 Destructor.


Static Public Member Functions

CSampleBank * findSampleBank (const NLMISC::TStringId &filename)
 Return an existing bank for the given file name, NULL if no bank for this file.

IBuffer * get (const NLMISC::TStringId &name)
 Return the name corresponding to a name. The sample is searched.

void getLoadedSampleBankInfo (std::vector< std::pair< std::string, uint > > &result)
 Fill a vector with current loaded sample banks.

uint getTotalByteSize ()
 Return the total loaded samples size.

void init (NLGEORGES::UFormElm *mixerConfig)
void releaseAll ()
 Delete all the loaded banks.

void reload (bool async)
 Reload all the sample bank.


Private Types

typedef std::hash_map< NLMISC::TStringId,
+ CSampleBank * > 		TSampleBankContainer
typedef std::hash_map< NLMISC::TStringId,
+ std::vector< TFilteredBank > > 		TVirtualBankCont
 List of virtual sample bank.


Private Member Functions

void onUpdate ()
 The update method. Used when waiting for async sample loading.


Private Attributes

uint _ByteSize
bool _Loaded
bool _LoadingDone
std::list< std::pair< IBuffer *,
+ NLMISC::TStringId > > 		_LoadList
 List of sample that need to be loaded asynchronously.

NLMISC::TStringId _Name
TSampleTable _Samples
ISoundDriver * _SoundDriver
bool _SplitLoadDone
 Flag for splitted load.


Static Private Attributes

TSampleBankContainer _Banks
uint _LoadedSize = 0
TVirtualBankCont _VirtualBanks
+

Member Typedef Documentation

+

+ + + + +
+ + +
typedef std::hash_map<NLMISC::TStringId, CSampleBank*> NLSOUND::CSampleBank::TSampleBankContainer [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 140 of file sample_bank.h.

+

+ + + + +
+ + +
typedef std::hash_map<NLMISC::TStringId, std::vector<TFilteredBank> > NLSOUND::CSampleBank::TVirtualBankCont [private] +
+
+ + + + + +
+   + + +

+List of virtual sample bank. +

+ +

+Definition at line 177 of file sample_bank.h.

+

Constructor & Destructor Documentation

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
NLSOUND::CSampleBank::CSampleBank ( const std::string &  name,
ISoundDriver *  sd
) 
+
+ + + + + +
+   + + +

+Constructor. +

+ +

+Definition at line 180 of file sample_bank.cpp. +

+Referenced by init(). +

+

00181 : _SoundDriver(sd), _Name(CStringMapper::map(name)), _Loaded(false), _LoadingDone(true), _ByteSize(0)
+00182 {
+00183 //      _Name = CFile::getFilenameWithoutExtension(_Path);
+00184         _Banks.insert(make_pair(_Name, this));
+00185 }
+
+

+ + + + +
+ + + + + + + + + +
NLSOUND::CSampleBank::~CSampleBank (   )  [virtual]
+
+ + + + + +
+   + + +

+Destructor. +

+ +

+Definition at line 190 of file sample_bank.cpp. +

+References _LoadingDone, _Samples, NLMISC::nlSleep(), and unload(). +

+

00191 {
+00192         CAudioMixerUser::instance()->unregisterUpdate(this);
+00193         while (!_LoadingDone)
+00194         {
+00195                 // need to wait for loading end.
+00196                 nlSleep(100);
+00197         }
+00198 
+00199         if (_Loaded)
+00200                 unload();
+00201 
+00202         // remove the bank from the list of known banks
+00203         TSampleBankContainer::iterator iter(_Banks.begin()), end(_Banks.end());
+00204 
+00205         for (; iter != end; ++iter)
+00206         {
+00207                 if (iter->second == this)
+00208                 {
+00209                         _Banks.erase(iter);
+00210                         break;
+00211                 }
+00212         }
+00213 
+00214 
+00215         // delete all the samples.
+00216         while (!_Samples.empty())
+00217         {
+00218                 delete _Samples.begin()->second;
+00219                 _Samples.erase(_Samples.begin());
+00220         }
+00221 
+00222         _Samples.clear();
+00223 }
+
+

Member Function Documentation

+

+ + + + +
+ + + + + + + + + +
uint NLSOUND::CSampleBank::countSamples (   ) 
+
+ + + + + +
+   + + +

+Return the number of samples in this bank. +

+ +

+Definition at line 587 of file sample_bank.cpp. +

+References _Samples, and uint. +

+Referenced by NLSOUND::CAudioMixerUser::loadSampleBank(). +

+

00588 {
+00589         return _Samples.size();
+00590 }
+
+

+ + + + +
+ + + + + + + + + + +
CSampleBank * NLSOUND::CSampleBank::findSampleBank ( const NLMISC::TStringId &  filename  )  [static]
+
+ + + + + +
+   + + +

+Return an existing bank for the given file name, NULL if no bank for this file. +

+ +

+Definition at line 115 of file sample_bank.cpp. +

+Referenced by load(). +

+

00116 {
+00117         TSampleBankContainer::iterator  it(_Banks.find(filename));
+00118 
+00119         if (it != _Banks.end())
+00120                 return it->second;
+00121 
+00122         return NULL;
+00123 }
+
+

+ + + + +
+ + + + + + + + + + +
IBuffer * NLSOUND::CSampleBank::get ( const NLMISC::TStringId &  name  )  [static]
+
+ + + + + +
+   + + +

+Return the name corresponding to a name. The sample is searched. +

+ +

+Definition at line 127 of file sample_bank.cpp. +

+References buffer. +

+

00128 {
+00129         IBuffer* buffer;
+00130         TSampleBankContainer::iterator iter;
+00131 
+00132         for (iter = _Banks.begin(); iter != _Banks.end(); ++iter)
+00133         {
+00134                 buffer = iter->second->getSample(name);
+00135                 if (buffer != 0)
+00136                 {
+00137                         return buffer;
+00138                 }
+00139         }
+00140         
+00141         //nlwarning ("Try to get an unknown sample '%s'", name);
+00142         return 0;
+00143 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLSOUND::CSampleBank::getLoadedSampleBankInfo ( std::vector< std::pair< std::string, uint > > &  result  )  [static]
+
+ + + + + +
+   + + +

+Fill a vector with current loaded sample banks. +

+ +

+Definition at line 157 of file sample_bank.cpp. +

+References NLMISC::CStringMapper::unmap(). +

+

00158 {
+00159         result.clear();
+00160 
+00161         TSampleBankContainer::iterator first(_Banks.begin()), last(_Banks.end());
+00162         for (; first != last; ++first)
+00163         {
+00164                 std::pair<std::string, uint> p;
+00165                 if (first->second->isLoaded())
+00166                 {
+00167                         p.first = NLMISC::CStringMapper::unmap(first->first);
+00168                         p.second = first->second->getSize();
+00169                         result.push_back(p);
+00170                 }
+00171         }
+00172 }
+
+

+ + + + +
+ + + + + + + + + + +
const NLMISC::TStringId NLSOUND::CSampleBank::getName ( void   )  const [inline]
+
+ + + + + +
+   + + +

+Return the name (must be unique). +

+ +

+Definition at line 129 of file sample_bank.h. +

+

00129 { return _Name; }
+
+

+ + + + +
+ + + + + + + + + + +
IBuffer * NLSOUND::CSampleBank::getSample ( const NLMISC::TStringId &  name  ) 
+
+ + + + + +
+   + + +

+Return a samples corresponding to a name. +

+ +

+Definition at line 555 of file sample_bank.cpp. +

+References _Samples. +

+

00556 {
+00557         {
+00558 /*              // dump the sample list.
+00559                 TSampleTable::iterator it (_Samples.begin()), last(_Samples.end());
+00560                 std::string s;
+00561 
+00562 //              while (first != last)
+00563                 for (it = _Samples.begin(); it != _Samples.end(); ++it)
+00564                 {
+00565                         s += std::string(" [")+it->first+"] ";
+00566                         //first++;
+00567                 }
+00568 
+00569                 nldebug("getSample(%s) : sample list = [%s]", name, s.c_str());
+00570 */
+00571         }
+00572 
+00573         // Find sound
+00574         TSampleTable::iterator iter = _Samples.find(name);
+00575         if ( iter == _Samples.end() )
+00576         {
+00577                 return 0;
+00578         }
+00579         else
+00580         {
+00581                 return (*iter).second;
+00582         }
+00583 }
+
+

+ + + + +
+ + + + + + + + + +
uint NLSOUND::CSampleBank::getSize (   ) 
+
+ + + + + +
+   + + +

+Return the size of this bank in bytes. +

+ +

+Definition at line 594 of file sample_bank.cpp. +

+References _Samples, size, and uint. +

+

00595 {
+00596         uint size = 0;
+00597 
+00598         TSampleTable::const_iterator iter;
+00599         for (iter = _Samples.begin(); iter != _Samples.end(); iter++)
+00600         {
+00601                 size += (*iter).second->getSize();
+00602         }
+00603 
+00604         return size;
+00605 }
+
+

+ + + + +
+ + + + + + + + + +
uint NLSOUND::CSampleBank::getTotalByteSize (   )  [inline, static]
+
+ + + + + +
+   + + +

+Return the total loaded samples size. +

+ +

+Definition at line 86 of file sample_bank.h. +

+References _LoadedSize, and uint. +

+

00086 {       return _LoadedSize; };
+
+

+ + + + +
+ + + + + + + + + + +
void NLSOUND::CSampleBank::init ( NLGEORGES::UFormElm *  mixerConfig  )  [static]
+
+ + + + + +
+   + + +

+Initialise the sample bank with the mixer config file. +

+Definition at line 55 of file sample_bank.cpp. +

+References _VirtualBanks, NLSOUND::CSampleBank::TFilteredBank::BankName, CSampleBank(), NLSOUND::CSampleBank::TFilteredBank::Filter, NLGEORGES::UFormElm::getArrayNode(), NLGEORGES::UFormElm::getArraySize(), NLGEORGES::UFormElm::getNodeByName(), NLGEORGES::UFormElm::getValueByName(), size, and uint. +

+

00056 {
+00057         NL_ALLOC_CONTEXT(NLSOUND_CSampleBank);
+00058         if (mixerConfig == 0)
+00059                 return;
+00060 
+00061         NLGEORGES::UFormElm     *virtualBanks;
+00062         mixerConfig->getNodeByName(&virtualBanks, ".VirtualBanks");
+00063         if (virtualBanks == 0)
+00064                 return;
+00065 
+00066         uint size;
+00067         virtualBanks->getArraySize(size);
+00068 
+00069         for (uint i=0; i<size; ++i)
+00070         {
+00071                 NLGEORGES::UFormElm     *virtualBank;
+00072                 virtualBanks->getArrayNode(&virtualBank, i);
+00073 
+00074                 if (virtualBank != 0)
+00075                 {
+00076                         std::vector<TFilteredBank> vfb;
+00077                         std::string virtualName;
+00078                         virtualBank->getValueByName(virtualName, ".VirtualName");
+00079                         NLGEORGES::UFormElm     *realBanks;
+00080                         virtualBank->getNodeByName(&realBanks, ".FilteredBank");
+00081                         if (realBanks != 0)
+00082                         {
+00083                                 uint size2;
+00084                                 realBanks->getArraySize(size2);
+00085 
+00086                                 for (uint j=0; j<size2; ++j)
+00087                                 {
+00088                                         TFilteredBank fb;
+00089                                         std::string     bankName;
+00090                                         NLGEORGES::UFormElm     *realBank;
+00091                                         realBank->getArrayNode(&realBank, j);
+00092 
+00093                                         realBank->getValueByName(bankName, ".SampleBank");
+00094                                         fb.BankName = CStringMapper::map(bankName);
+00095                                         realBank->getValueByName(fb.Filter, ".Filter");
+00096 
+00097                                         vfb.push_back(fb);
+00098                                 }
+00099                         }
+00100 
+00101                         if (!vfb.empty())
+00102                         {
+00103                                 _VirtualBanks.insert(std::make_pair(NLMISC::CStringMapper::map(virtualName), vfb));
+00104                                 // create the sample bank
+00105                                 new CSampleBank(virtualName, NULL);
+00106                         }
+00107                 }
+00108         }
+00109 }
+
+

+ + + + +
+ + + + + + + + + +
bool NLSOUND::CSampleBank::isLoaded (   ) 
+
+ + + + + +
+   + + +

+Returns true if the samples in this bank have been loaded. +

+ +

+Definition at line 548 of file sample_bank.cpp. +

+

00549 {
+00550         return _Loaded;
+00551 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLSOUND::CSampleBank::load ( bool  async  ) 
+
+ + + + + +
+   + + +

+Load all the samples.

+Can throw EPathNotFound or ESoundFileNotFound (check Exception)

Parameters:
+ + +
async If true, the samples are loaded in background.
+
+ +

+Definition at line 228 of file sample_bank.cpp. +

+References _ByteSize, _LoadedSize, _LoadingDone, _Samples, _VirtualBanks, NLSOUND::ISoundDriver::createBuffer(), data, findSampleBank(), NLSOUND::CAudioMixerUser::TSampleBankHeader::Freq, NLSOUND::CAudioMixerUser::getBackgroundFlags(), NLSOUND::CAudioMixerUser::getPackedSheetUpdate(), NLMISC::CIFile::getPos(), NLSOUND::IBuffer::getSize(), NLSOUND::Mono16, NLSOUND::Mono16ADPCM, NLSOUND::CAudioMixerUser::TSampleBankHeader::Name, nlassert, nlinfo, nlwarning, NLSOUND::CAudioMixerUser::TSampleBankHeader::OffsetAdpcm, NLSOUND::CAudioMixerUser::TSampleBankHeader::OffsetMono16, NLSOUND::IBuffer::presetName(), NLSOUND::ISoundDriver::readRawBuffer(), NLMISC::CIFile::seek(), NLMISC::IStream::serial(), NLMISC::CIFile::serialBuffer(), sint32, NLSOUND::CAudioMixerUser::TSampleBankHeader::SizeAdpcm, NLSOUND::CAudioMixerUser::TSampleBankHeader::SizeMono16, uint, and uint8. +

+Referenced by NLSOUND::CAudioMixerUser::loadSampleBank(). +

+

00229 {
+00230         // TODO : add async loading support !
+00231 
+00232         TVirtualBankCont::iterator it(_VirtualBanks.find(_Name));
+00233         if (it != _VirtualBanks.end())
+00234         {
+00235                 // this is a virtual sample bank !
+00236                 nlinfo("Loading virtual sample bank %s", CStringMapper::unmap(_Name).c_str());
+00237 
+00238                 CAudioMixerUser *mixer = CAudioMixerUser::instance();
+00239                 const CAudioMixerUser::TBackgroundFlags &flags = mixer->getBackgroundFlags();
+00240 
+00241                 for (uint i=0; i<it->second.size(); ++i)
+00242                 {
+00243                         if (flags.Flags[it->second[i].Filter])
+00244                         {
+00245                                 CSampleBank *bank = findSampleBank(it->second[i].BankName);
+00246                                 if (bank)
+00247                                         bank->load(async);
+00248                         }
+00249                 }
+00250         }
+00251 
+00252         nlinfo("Loading sample bank %s %", CStringMapper::unmap(_Name).c_str(), async?"":"Asynchronously");
+00253 
+00254         vector<string> filenames;
+00255 //      vector<string>::iterator iter;
+00256 
+00257         if (_Loaded)
+00258         {
+00259                 nlwarning("Trying to load an already loaded bank : %s", CStringMapper::unmap(_Name).c_str ());
+00260                 return;
+00261         }
+00262 
+00263 
+00264         // Load the sample bank from the builded sample_bank file.
+00265         string bankName(CStringMapper::unmap(_Name)+".sample_bank");
+00266         string filename = CPath::lookup(bankName);
+00267         if (filename.empty())
+00268         {
+00269                 nlwarning("Trying to load an unknown sample bank [%s]", bankName.c_str());
+00270                 return;
+00271         }
+00272 
+00273         try
+00274         {
+00275 
+00276                 CIFile  sampleBank(filename);
+00277 
+00278                 CAudioMixerUser::TSampleBankHeader sbh;
+00279                 sampleBank.serial(sbh);
+00280                 _LoadingDone = false;
+00281 
+00282                 sint32 seekStart = sampleBank.getPos();
+00283 
+00284 
+00285                 uint8   *data = 0;
+00286                 uint    i;
+00287                 for (i=0; i<sbh.Name.size(); ++i)
+00288                 {
+00289                         IBuffer *ibuffer = _SoundDriver->createBuffer();
+00290                         nlassert(ibuffer);
+00291 
+00292                         TStringId       nameId = CStringMapper::map(CFile::getFilenameWithoutExtension(sbh.Name[i]));
+00293                         ibuffer->presetName(nameId);
+00294                         
+00295         /*              {
+00296                                 sint16 *data16 = new sint16[sbh.NbSample[i]];
+00297                                 IBuffer::TADPCMState    state;
+00298                                 state.PreviousSample = 0;
+00299                                 state.StepIndex = 0;
+00300                                 uint count =0;
+00301                                 for (count=0; count+1024<sbh.NbSample[i]; count+=1024)
+00302                                 {
+00303                                         IBuffer::decodeADPCM(data+count/2, data16+count, 1024, state);
+00304                                 }
+00305                                 IBuffer::decodeADPCM(data+count/2, data16+count, sbh.NbSample[i]-count, state);
+00306 
+00307                                 state.PreviousSample = 0;
+00308                                 state.StepIndex = 0;
+00309                                 sint16  *data16_2 = new sint16[sbh.NbSample[i]];
+00310                                 IBuffer::decodeADPCM(data, data16_2, sbh.NbSample[i], state);
+00311 
+00312                                 for (uint j=0; j<sbh.NbSample[i]; ++j)
+00313                                 {
+00314                                         if (data16[j] != data16_2[j])
+00315                                         {
+00316                                                 nlwarning("Sample differ at %u", j);
+00317                                         }
+00318                                 }
+00319 
+00320                                 _SoundDriver->readRawBuffer(ibuffer, sbh.Name[i], (uint8*)data16, sbh.NbSample[i]*2, Mono16, sbh.Freq[i]);
+00321                                 delete [] data16;
+00322                                 delete [] data16_2;
+00323                         }
+00324         */
+00325 
+00326                         if (CAudioMixerUser::instance()->useAPDCM())
+00327                         {
+00328                                 data = (uint8*) realloc(data, sbh.SizeAdpcm[i]);
+00329                                 sampleBank.seek(seekStart + sbh.OffsetAdpcm[i], CIFile::begin);
+00330                                 sampleBank.serialBuffer(data, sbh.SizeAdpcm[i]);
+00331                                 _SoundDriver->readRawBuffer(ibuffer, sbh.Name[i], data, sbh.SizeAdpcm[i], Mono16ADPCM, sbh.Freq[i]);
+00332                         }
+00333                         else
+00334                         {
+00335                                 data = (uint8*) realloc(data, sbh.SizeMono16[i]);
+00336                                 sampleBank.seek(seekStart + sbh.OffsetMono16[i], CIFile::begin);
+00337                                 sampleBank.serialBuffer(data, sbh.SizeMono16[i]);
+00338                                 _SoundDriver->readRawBuffer(ibuffer, sbh.Name[i], data, sbh.SizeMono16[i], Mono16, sbh.Freq[i]);
+00339                         }
+00340                         
+00341                         _ByteSize += ibuffer->getSize();
+00342 
+00343                         _Samples[nameId] = ibuffer;
+00344 
+00345                         // Warn the sound bank that the sample are available.
+00346                         CSoundBank::instance()->bufferLoaded(nameId, ibuffer);
+00347                 }
+00348                 free(data);
+00349 
+00350                 _LoadedSize += _ByteSize;
+00351         }
+00352         catch(Exception &e)
+00353         {
+00354                 // loading failed !
+00355                 nlwarning("Exception %s during loading of sample bank %s", e.what(), filename.c_str());
+00356                 CAudioMixerUser *mixer = CAudioMixerUser::instance();
+00357 
+00358                 if (mixer->getPackedSheetUpdate())
+00359                 {
+00360                         nlinfo("Deleting offending sound bank, you need to restart to recreate it!");
+00361                         CFile::deleteFile(filename);
+00362                 }
+00363         }
+00364 
+00365         _Loaded = true;
+00366         _LoadingDone = true;
+00367 
+00368 
+00369 
+00371 /*
+00372 
+00373         std::string list = CPath::lookup(CStringMapper::unmap(_Name)+CAudioMixerUser::SampleBankListExt, false);
+00374         if (list.empty())
+00375         {
+00376                 nlwarning("File %s not found to load sample bank %s", (CStringMapper::unmap(_Name)+CAudioMixerUser::SampleBankListExt).c_str(), CStringMapper::unmap(_Name).c_str());
+00377                 return;
+00378         }
+00379 
+00380 
+00381         NLMISC::CIFile sampleBankList(list);
+00382         sampleBankList.serialCont(filenames);
+00383 
+00384         for (iter = filenames.begin(); iter != filenames.end(); iter++)
+00385         {
+00386                 IBuffer* ibuffer = NULL;
+00387                 try
+00388                 {
+00389                         ibuffer = _SoundDriver->createBuffer();
+00390                         nlassert(ibuffer);
+00391 
+00392 //                      std::string sampleName(CFile::getFilenameWithoutExtension(*iter));
+00393                         NLMISC::TStringId sampleName(CStringMapper::map(CFile::getFilenameWithoutExtension(*iter)));
+00394 
+00395                         if (async)
+00396                         {
+00397                                 ibuffer->presetName(sampleName);
+00398                                 nldebug("Preloading sample [%s]", CStringMapper::unmap(sampleName).c_str());
+00399                         }
+00400                         else
+00401                         {
+00402                                 std::string fullName = NLMISC::CPath::lookup(*iter, false);
+00403                                 if (!fullName.empty())
+00404                                 {
+00405                                         NLMISC::CIFile  ifile(fullName);
+00406                                         uint size = ifile.getFileSize();
+00407                                         uint8 *buffer = new uint8[ifile.getFileSize()];
+00408                                         ifile.serialBuffer(buffer, size);
+00409 
+00410                                         _SoundDriver->readWavBuffer(ibuffer, fullName, buffer, size);
+00411                                         _ByteSize += ibuffer->getSize();
+00412 
+00413                                         delete [] buffer;
+00414                                 }
+00415                         }
+00416                         _Samples[sampleName] = ibuffer ;
+00417 
+00418                         // Warn the sound bank that the sample are available.
+00419                         CSoundBank::instance()->bufferLoaded(sampleName, ibuffer);
+00420                 }
+00421                 catch (ESoundDriver &e)
+00422                 {
+00423                         if (ibuffer != NULL) {
+00424                                 delete ibuffer;
+00425                                 ibuffer = NULL;
+00426                         }
+00427                         nlwarning("Problem with file '%s': %s", (*iter).c_str(), e.what());
+00428                 }
+00429         }
+00430 
+00431         _Loaded = true;
+00432 
+00433         if (!async)
+00434         {
+00435                 _LoadingDone = true;
+00436                 // compute the sample bank size.
+00437                 _LoadedSize += _ByteSize;
+00438         }
+00439         else
+00440         {
+00441                 // fill the loading list.
+00442                 TSampleTable::iterator first(_Samples.begin()), last(_Samples.end());
+00443                 for (; first != last; ++first)
+00444                 {
+00445                         _LoadList.push_back(make_pair(first->second, first->first));
+00446                 }
+00447                 _SplitLoadDone = false;
+00448                 // send the first files
+00449                 for (uint i=0; i<ASYNC_LOADING_SPLIT && !_LoadList.empty(); ++i)
+00450                 {
+00451                         CAsyncFileManagerSound::getInstance().loadWavFile(_LoadList.front().first, CStringMapper::unmap(_LoadList.front().second)+".wav");
+00452                         _LoadList.pop_front();
+00453                 }
+00454                 // add a end loading event...
+00455                 CAsyncFileManagerSound::getInstance().signal(&_SplitLoadDone);
+00456                 // and register for update on the mixer
+00457                 CAudioMixerUser::instance()->registerUpdate(this);
+00458         }
+00459         */
+00460 }
+
+

+ + + + +
+ + + + + + + + + +
void NLSOUND::CSampleBank::onUpdate (   )  [private, virtual]
+
+ + + + + +
+   + + +

+The update method. Used when waiting for async sample loading. +

+ +

+Implements NLSOUND::CAudioMixerUser::IMixerUpdate. +

+Definition at line 462 of file sample_bank.cpp. +

+References _ByteSize, _LoadedSize, _LoadingDone, _LoadList, _Samples, _SplitLoadDone, NLSOUND::ASYNC_LOADING_SPLIT, nldebug, nlinfo, and uint. +

+

00463 {
+00464         if (_SplitLoadDone)
+00465         {
+00466                 nldebug("Some samples have been loaded");
+00467                 if (_LoadList.empty())
+00468                 {
+00469                         // all the samples are loaded, we can compute the bank size.
+00470                         TSampleTable::iterator  first(_Samples.begin()), last(_Samples.end());
+00471                         for (; first != last; ++first)
+00472                         {
+00473                                 _ByteSize += first->second->getSize();
+00474                         }
+00475                 
+00476                         _LoadedSize += _ByteSize;
+00477 
+00478                         // stop the update.
+00479                         CAudioMixerUser::instance()->unregisterUpdate(this);
+00480                         _LoadingDone = true;
+00481 
+00482                         // Force an update in the background manager (can restar stoped sound).
+00483                         CAudioMixerUser::instance()->getBackgroundSoundManager()->updateBackgroundStatus();
+00484 
+00485                         nlinfo("Sample bank %s loaded.", CStringMapper::unmap(_Name).c_str());
+00486                 }
+00487                 else
+00488                 {
+00489                         _SplitLoadDone = false;
+00490                         for (uint i=0; i<ASYNC_LOADING_SPLIT && !_LoadList.empty(); ++i)
+00491                         {
+00492                                 CAsyncFileManagerSound::getInstance().loadWavFile(_LoadList.front().first, CStringMapper::unmap(_LoadList.front().second)+".wav");
+00493                                 _LoadList.pop_front();
+00494                         }
+00495                         // add a end loading event...
+00496                         CAsyncFileManagerSound::getInstance().signal(&_SplitLoadDone);
+00497                 }
+00498         }
+00499 }
+
+

+ + + + +
+ + + + + + + + + +
void NLSOUND::CSampleBank::releaseAll (   )  [static]
+
+ + + + + +
+   + + +

+Delete all the loaded banks. +

+ +

+Definition at line 607 of file sample_bank.cpp. +

+References nldebug. +

+

00608 {
+00609         nldebug( "SampleBanks: Releasing..." );
+00610 
+00611         while (!_Banks.empty())
+00612         {
+00613                 delete _Banks.begin()->second;
+00614         }
+00615         nldebug( "SampleBanks: Released" );
+00616 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLSOUND::CSampleBank::reload ( bool  async  )  [static]
+
+ + + + + +
+   + + +

+Reload all the sample bank. +

+ +

+Definition at line 145 of file sample_bank.cpp. +

+

00146 {
+00147         TSampleBankContainer::iterator first(_Banks.begin()), last(_Banks.end());
+00148 
+00149         for (; first != last; ++first)
+00150         {
+00151                 first->second->unload();
+00152                 first->second->load(async);
+00153         }
+00154 }
+
+

+ + + + +
+ + + + + + + + + +
bool NLSOUND::CSampleBank::unload (   ) 
+
+ + + + + +
+   + + +

+Unload all the samples in this bank. Return false is unload can't be done (if an async loading is not terminated. +

+Definition at line 503 of file sample_bank.cpp. +

+References _ByteSize, _LoadedSize, _LoadingDone, _Samples, buffer, nlinfo, and nlwarning. +

+Referenced by NLSOUND::CAudioMixerUser::unloadSampleBank(), and ~CSampleBank(). +

+

00504 {
+00505         vector<IBuffer*> vec;
+00506         TSampleTable::iterator it;
+00507 
+00508         if (!_Loaded)
+00509         {
+00510                 nlwarning("Trying to unload an already unloaded bank : %s", CStringMapper::unmap(_Name).c_str ());
+00511                 return  true;
+00512         }
+00513 
+00514         // need to wait end of load ?
+00515         if (!_LoadingDone)
+00516                 return false;
+00517 
+00518         nlinfo("Unloading sample bank %s", CStringMapper::unmap(_Name).c_str());
+00519 
+00520         for (it = _Samples.begin(); it != _Samples.end(); ++it)
+00521         {
+00522                 IBuffer *buffer = it->second;
+00523                 if (buffer)
+00524                 {
+00525                         const NLMISC::TStringId & bufferName = buffer->getName();
+00526 
+00527                         // Warn the mixer to stop any track playing this buffer.
+00528                         CAudioMixerUser::instance()->bufferUnloaded(buffer);
+00529                         // Warn the sound banks abount this buffer.
+00530                         CSoundBank::instance()->bufferUnloaded(bufferName);
+00531 
+00532                         // delete
+00533                         it->second = NULL;
+00534                         delete buffer;
+00535                 }
+00536         }
+00537 
+00538         _Loaded = false;
+00539 
+00540         _LoadedSize -= _ByteSize;
+00541         _ByteSize = 0;
+00542 
+00543         return true;
+00544 }
+
+

Field Documentation

+

+ + + + +
+ + +
CSampleBank::TSampleBankContainer NLSOUND::CSampleBank::_Banks [static, private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 47 of file sample_bank.cpp.

+

+ + + + +
+ + +
uint NLSOUND::CSampleBank::_ByteSize [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 162 of file sample_bank.h. +

+Referenced by load(), onUpdate(), and unload().

+

+ + + + +
+ + +
bool NLSOUND::CSampleBank::_Loaded [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 158 of file sample_bank.h.

+

+ + + + +
+ + +
uint NLSOUND::CSampleBank::_LoadedSize = 0 [static, private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 48 of file sample_bank.cpp. +

+Referenced by getTotalByteSize(), load(), onUpdate(), and unload().

+

+ + + + +
+ + +
bool NLSOUND::CSampleBank::_LoadingDone [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 160 of file sample_bank.h. +

+Referenced by load(), onUpdate(), unload(), and ~CSampleBank().

+

+ + + + +
+ + +
std::list<std::pair<IBuffer *, NLMISC::TStringId> > NLSOUND::CSampleBank::_LoadList [private] +
+
+ + + + + +
+   + + +

+List of sample that need to be loaded asynchronously. +

+ +

+Definition at line 168 of file sample_bank.h. +

+Referenced by onUpdate().

+

+ + + + +
+ + +
NLMISC::TStringId NLSOUND::CSampleBank::_Name [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 155 of file sample_bank.h.

+

+ + + + +
+ + +
TSampleTable NLSOUND::CSampleBank::_Samples [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 151 of file sample_bank.h. +

+Referenced by countSamples(), getSample(), getSize(), load(), onUpdate(), unload(), and ~CSampleBank().

+

+ + + + +
+ + +
ISoundDriver* NLSOUND::CSampleBank::_SoundDriver [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 148 of file sample_bank.h.

+

+ + + + +
+ + +
bool NLSOUND::CSampleBank::_SplitLoadDone [private] +
+
+ + + + + +
+   + + +

+Flag for splitted load. +

+ +

+Definition at line 165 of file sample_bank.h. +

+Referenced by onUpdate().

+

+ + + + +
+ + +
CSampleBank::TVirtualBankCont NLSOUND::CSampleBank::_VirtualBanks [static, private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 50 of file sample_bank.cpp. +

+Referenced by init(), and load().

+

The documentation for this class was generated from the following files: +
Generated on Tue Mar 16 14:39:54 2004 for NeL by + +doxygen +1.3.6
+ + -- cgit v1.2.1