#include <buffer_dsound.h>
Inheritance diagram for NLSOUND::CBufferDSound:
A buffer represents a sound file loaded in RAM.
Nevrax France
Definition at line 45 of file buffer_dsound.h.
Public Member Functions | |
| CBufferDSound () | |
| Constructor. | |
| virtual bool | fillBuffer (void *src, uint32 bufsize) |
| Set the buffer size and fill the buffer. Return true if ok. Call setFormat() first. | |
| virtual bool | fillMore (void *src, uint32 srcsize) |
| virtual uint32 | getBufferADPCMEncoded (std::vector< uint8 > &result) |
| virtual uint32 | getBufferMono16 (std::vector< sint16 > &result) |
| virtual uint8 * | getData () const |
| Return a pointer to the sample data. | |
| virtual float | getDuration () const |
| Return the duration (in ms) of the sample in the buffer. | |
| virtual void | getFormat (TSampleFormat &format, uint &freq) const |
| Return the format and frequency. | |
| virtual const NLMISC::TStringId & | getName () |
| Return the name of the buffer. | |
| virtual uint32 | getSize () const |
| Return the size of the buffer, in bytes. | |
| virtual bool | isBufferLoaded () |
| Return true if the buffer is loaded. Used for async load/unload. | |
| virtual bool | isFillMoreSupported () const |
| virtual bool | isStereo () const |
| Return true if the buffer is stereo, false if mono. | |
| virtual void | presetName (const NLMISC::TStringId &bufferName) |
| virtual bool | readRawBuffer (const std::string &name, uint8 *rawData, uint dataSize, TSampleFormat format, uint32 frequency) |
| virtual bool | readWavBuffer (const std::string &name, uint8 *wavData, uint dataSize) |
| Load a sound file in the buffer. Throws an exception is an error occurs. | |
| virtual void | setFormat (TSampleFormat format, uint freq) |
| Set the sample format. Example: freq=44100. | |
| virtual void | setSize (uint32 size) |
| Force the buffer size without filling data (if isFillMoreSupported() only). | |
| virtual | ~CBufferDSound () |
| Destructor. | |
Static Public Member Functions | |
Source properties | |
| void | decodeADPCM (uint8 *indata, sint16 *outdata, uint nbSample, TADPCMState &state) |
| void | encodeADPCM (sint16 *indata, uint8 *outdata, uint nbSample, TADPCMState &state) |
Source properties | |
| void | decodeADPCM (uint8 *indata, sint16 *outdata, uint nbSample, TADPCMState &state) |
| void | encodeADPCM (sint16 *indata, uint8 *outdata, uint nbSample, TADPCMState &state) |
Private Attributes | |
| uint8 * | _Data |
| TSampleFormat | _Format |
| uint | _Freq |
| NLMISC::TStringId | _Name |
| uint32 | _Size |
|
|
Constructor.
Definition at line 131 of file buffer_dsound.cpp. References _Format, _Freq, NLSOUND::EmptyString, and NLSOUND::Mono16.
|
|
|
Destructor.
Definition at line 140 of file buffer_dsound.cpp.
|
|
||||||||||||||||||||
|
Unoptimized utility function designed to build ADPCM encoded sample bank file. Return the number of sample in the buffer. Definition at line 164 of file buffer.cpp. References NLSOUND::IBuffer::_IndexTable, NLSOUND::IBuffer::_StepsizeTable, index, NLSOUND::IBuffer::TADPCMState::PreviousSample, sint16, NLSOUND::IBuffer::TADPCMState::StepIndex, uint, and uint8.
00165 {
00166 uint8 *inp; /* Input buffer pointer */
00167 sint16 *outp; /* output buffer pointer */
00168 int sign; /* Current adpcm sign bit */
00169 int delta; /* Current adpcm output value */
00170 int step; /* Stepsize */
00171 int valpred; /* Predicted value */
00172 int vpdiff; /* Current change to valpred */
00173 int index; /* Current step change index */
00174 int inputbuffer; /* place to keep next 4-bit value */
00175 int bufferstep; /* toggle between inputbuffer/input */
00176
00177 outp = outdata;
00178 inp = indata;
00179
00180 valpred = state.PreviousSample;
00181 index = state.StepIndex;
00182 step = _StepsizeTable[index];
00183
00184 bufferstep = 0;
00185
00186 for ( ; nbSample > 0 ; nbSample-- )
00187 {
00188
00189 /* Step 1 - get the delta value */
00190 if ( bufferstep )
00191 {
00192 delta = inputbuffer & 0xf;
00193 }
00194 else
00195 {
00196 inputbuffer = *inp++;
00197 delta = (inputbuffer >> 4) & 0xf;
00198 }
00199 bufferstep = !bufferstep;
00200
00201 /* Step 2 - Find new index value (for later) */
00202 index += _IndexTable[delta];
00203 if ( index < 0 )
00204 index = 0;
00205 if ( index > 88 )
00206 index = 88;
00207
00208 /* Step 3 - Separate sign and magnitude */
00209 sign = delta & 8;
00210 delta = delta & 7;
00211
00212 /* Step 4 - Compute difference and new predicted value */
00213 /*
00214 ** Computes 'vpdiff = (delta+0.5)*step/4', but see comment
00215 ** in adpcm_coder.
00216 */
00217 vpdiff = step >> 3;
00218 if ( delta & 4 )
00219 vpdiff += step;
00220 if ( delta & 2 )
00221 vpdiff += step>>1;
00222 if ( delta & 1 )
00223 vpdiff += step>>2;
00224
00225 if ( sign )
00226 valpred -= vpdiff;
00227 else
00228 valpred += vpdiff;
00229
00230 /* Step 5 - clamp output value */
00231 if ( valpred > 32767 )
00232 valpred = 32767;
00233 else if ( valpred < -32768 )
00234 valpred = -32768;
00235
00236 /* Step 6 - Update step value */
00237 step = _StepsizeTable[index];
00238
00239 /* Step 7 - Output value */
00240 *outp++ = valpred;
00241 }
00242
00243 state.PreviousSample = valpred;
00244 state.StepIndex = index;
00245 }
|
|
||||||||||||||||||||
|
Unoptimized utility function designed to build ADPCM encoded sample bank file. Return the number of sample in the buffer. Definition at line 51 of file buffer.cpp. References NLSOUND::IBuffer::_IndexTable, NLSOUND::IBuffer::_StepsizeTable, index, NLSOUND::IBuffer::TADPCMState::PreviousSample, sint16, NLSOUND::IBuffer::TADPCMState::StepIndex, uint, and uint8. Referenced by getBufferADPCMEncoded().
00052 {
00053 sint16 *inp; /* Input buffer pointer */
00054 uint8 *outp; /* output buffer pointer */
00055 int val; /* Current input sample value */
00056 int sign; /* Current adpcm sign bit */
00057 int delta; /* Current adpcm output value */
00058 int diff; /* Difference between val and valprev */
00059 int step; /* Stepsize */
00060 int valpred; /* Predicted output value */
00061 int vpdiff; /* Current change to valpred */
00062 int index; /* Current step change index */
00063 int outputbuffer; /* place to keep previous 4-bit value */
00064 int bufferstep; /* toggle between outputbuffer/output */
00065
00066 outp = outdata;
00067 inp = indata;
00068
00069 valpred = state.PreviousSample;
00070 index = state.StepIndex;
00071 step = _StepsizeTable[index];
00072
00073 bufferstep = 1;
00074
00075 for ( ; nbSample > 0 ; nbSample-- )
00076 {
00077 val = *inp++;
00078
00079 /* Step 1 - compute difference with previous value */
00080 diff = val - valpred;
00081 sign = (diff < 0) ? 8 : 0;
00082 if ( sign ) diff = (-diff);
00083
00084 /* Step 2 - Divide and clamp */
00085 /* Note:
00086 ** This code *approximately* computes:
00087 ** delta = diff*4/step;
00088 ** vpdiff = (delta+0.5)*step/4;
00089 ** but in shift step bits are dropped. The net result of this is
00090 ** that even if you have fast mul/div hardware you cannot put it to
00091 ** good use since the fixup would be too expensive.
00092 */
00093 delta = 0;
00094 vpdiff = (step >> 3);
00095
00096 if ( diff >= step )
00097 {
00098 delta = 4;
00099 diff -= step;
00100 vpdiff += step;
00101 }
00102 step >>= 1;
00103 if ( diff >= step )
00104 {
00105 delta |= 2;
00106 diff -= step;
00107 vpdiff += step;
00108 }
00109 step >>= 1;
00110 if ( diff >= step )
00111 {
00112 delta |= 1;
00113 vpdiff += step;
00114 }
00115
00116 /* Step 3 - Update previous value */
00117 if ( sign )
00118 valpred -= vpdiff;
00119 else
00120 valpred += vpdiff;
00121
00122 /* Step 4 - Clamp previous value to 16 bits */
00123 if ( valpred > 32767 )
00124 {
00125 printf("over+ %d\n",valpred);
00126 valpred = 32767;
00127 }
00128 else if ( valpred < -32768 )
00129 {
00130 printf("over- %d\n",valpred);
00131 valpred = -32768;
00132 }
00133
00134 /* Step 5 - Assemble value, update index and step values */
00135 delta |= sign;
00136
00137 index += _IndexTable[delta];
00138 if ( index < 0 )
00139 index = 0;
00140 if ( index > 88 )
00141 index = 88;
00142 step = _StepsizeTable[index];
00143
00144 /* Step 6 - Output value */
00145 if ( bufferstep )
00146 {
00147 outputbuffer = (delta << 4) & 0xf0;
00148 }
00149 else
00150 {
00151 *outp++ = (delta & 0x0f) | outputbuffer;
00152 }
00153 bufferstep = !bufferstep;
00154 }
00155
00156 /* Output last step, if needed */
00157 if ( !bufferstep )
00158 *outp++ = outputbuffer;
00159
00160 state.PreviousSample = valpred;
00161 state.StepIndex = index;
00162 }
|
|
||||||||||||
|
Set the buffer size and fill the buffer. Return true if ok. Call setFormat() first.
Implements NLSOUND::IBuffer. Definition at line 163 of file buffer_dsound.cpp.
00164 {
00165 return false;
00166 }
|
|
||||||||||||
|
Fill the buffer partially (if isFillMoreSupported() only), beginning at the pos changed by a previous call to fillMore(). If the pos+srcsize exceeds the buffer size, the exceeding data is put at the beginning of the buffer. srcsize must be smaller than the buffer size. Reimplemented in NLSOUND::CBufferAL. Definition at line 79 of file buffer.h. References uint32. Referenced by NLSOUND::ILoader::fillBufferPart().
00079 { throw ESoundDriverNotSupp(); }
|
|
|
Unoptimized utility function designed to build ADPCM encoded sample bank file. Return the number of sample in the buffer. Implements NLSOUND::IBuffer. Definition at line 451 of file buffer_dsound.cpp. References _Format, NLSOUND::IBuffer::encodeADPCM(), NLSOUND::Mono16, sint16, and uint32.
00452 {
00453 result.clear();
00454
00455 if (_Data == 0)
00456 return 0;
00457
00458 if (_Format != Mono16)
00459 return 0;
00460
00461 uint32 nbSample = _Size/2;
00462 nbSample &= 0xfffffffe;
00463
00464 result.resize(nbSample / 2);
00465
00466 TADPCMState state;
00467 state.PreviousSample = 0;
00468 state.StepIndex = 0;
00469 encodeADPCM((sint16*)_Data, &result[0], nbSample, state);
00470
00471 return nbSample;
00472 }
|
|
|
Unoptimized utility function designed to build Mono 16 bits encoded sample bank file. Return the number of sample in the buffer. Implements NLSOUND::IBuffer. Definition at line 474 of file buffer_dsound.cpp. References _Format, NLSOUND::Mono16, sint16, NLSOUND::Stereo16, uint, and uint32.
00475 {
00476 result.clear();
00477
00478 if (_Data == 0)
00479 return 0;
00480
00481 if (_Format == Mono16)
00482 {
00483 uint nbSample = _Size/2;
00484 nbSample &= 0xfffffffe;
00485
00486 result.reserve(nbSample);
00487 result.insert(result.begin(), (sint16*)_Data, ((sint16*)_Data)+nbSample);
00488
00489 return nbSample;
00490 }
00491 else if (_Format == Stereo16)
00492 {
00493 uint nbSample = _Size/4;
00494 nbSample &= 0xfffffffe;
00495
00496 struct TFrame
00497 {
00498 sint16 Channel1;
00499 sint16 Channel2;
00500 };
00501 result.reserve(nbSample);
00502 TFrame *frame = (TFrame *)_Data;
00503 for (uint i=0; i<nbSample; ++i)
00504 {
00505 result[i] = (frame->Channel1>>1) +(frame->Channel2>>1);
00506 }
00507
00508 return nbSample;
00509 }
00510 else
00511 return 0;
00512 }
|
|
|
Return a pointer to the sample data.
Definition at line 103 of file buffer_dsound.h. References uint8.
00103 { return _Data; }
|
|
|
Return the duration (in ms) of the sample in the buffer.
Implements NLSOUND::IBuffer. Definition at line 169 of file buffer_dsound.cpp. References _Format, _Freq, NLSOUND::Mono16, NLSOUND::Mono16ADPCM, NLSOUND::Mono8, NLSOUND::Stereo16, and NLSOUND::Stereo8.
00170 {
00171 float frames = (float) _Size;
00172
00173 switch (_Format)
00174 {
00175 case Mono8:
00176 break;
00177 case Mono16ADPCM:
00178 frames *= 2.0f;
00179 break;
00180 case Mono16:
00181 frames /= 2.0f;
00182 break;
00183 case Stereo8:
00184 frames /= 2.0f;
00185 break;
00186 case Stereo16:
00187 frames /= 4.0f;
00188 break;
00189 }
00190
00191 return 1000.0f * frames / (float) _Freq;
00192 }
|
|
||||||||||||
|
Return the format and frequency.
Implements NLSOUND::IBuffer. Definition at line 72 of file buffer_dsound.h. References _Format, _Freq, format, and uint.
|
|
|
Return the name of the buffer.
Implements NLSOUND::IBuffer. Definition at line 106 of file buffer_dsound.h.
00106 { return _Name; }
|
|
|
Return the size of the buffer, in bytes.
Implements NLSOUND::IBuffer. Definition at line 63 of file buffer_dsound.h. References uint32.
00063 { return _Size; }
|
|
|
Return true if the buffer is loaded. Used for async load/unload.
Implements NLSOUND::IBuffer. Definition at line 108 of file buffer_dsound.h.
00108 { return _Data != 0; }
|
|
|
Return true if the buffer is able to be fill part by part, false if it must be filled in one call (OpenAL 1.0 -> false) Implements NLSOUND::IBuffer. Definition at line 78 of file buffer_dsound.h.
00078 { return false; }
|
|
|
Return true if the buffer is stereo, false if mono.
Implements NLSOUND::IBuffer. Definition at line 69 of file buffer_dsound.h. References _Format, NLSOUND::Stereo16, and NLSOUND::Stereo8.
|
|
|
Preset the name of the buffer. Used for async loading to give a name before the buffer is effectivly loaded. If the name after loading of the buffer doesn't match the preset name, the load will assert. Implements NLSOUND::IBuffer. Definition at line 150 of file buffer_dsound.cpp.
00151 {
00152 _Name = bufferName;
00153 }
|
|
||||||||||||||||||||||||
|
Definition at line 416 of file buffer_dsound.cpp. References _Format, _Freq, format, nlassertex, uint, uint32, and uint8.
00417 {
00418 NL_ALLOC_CONTEXT(NLSOUND_CBufferDSound);
00419 // free any existing data
00420 if (_Data != NULL)
00421 {
00422 free(_Data);
00423 _Data = NULL;
00424 }
00425
00426 _Format = format;
00427 _Size = dataSize;
00428 // Allocate the sample buffer
00429 _Data = new uint8 [_Size];
00430
00431 // read in the format data
00432 memcpy(_Data, rawData, dataSize);
00433
00434 _Freq = frequency;
00435
00436
00437 // Allocate the sample buffer
00438
00439 static NLMISC::TStringId empty(CSoundDriverDSound::instance()->getStringMapper()->map(""));
00440 NLMISC::TStringId nameId = CSoundDriverDSound::instance()->getStringMapper()->map(CFile::getFilenameWithoutExtension(name));
00441 // if name is preseted, the name must match.
00442 if (_Name != empty)
00443 {
00444 nlassertex(nameId == _Name, ("The preseted name and buffer name doen't match !"));
00445 }
00446 _Name = nameId;
00447
00448 return true;
00449 }
|
|
||||||||||||||||
|
Load a sound file in the buffer. Throws an exception is an error occurs. Fill the buffer partially (if isFillMoreSupported() only), beginning at the pos changed by a previous call to fillMore(). If the pos+srcsize exceeds the buffer size, the exceeding data is put at the beginning of the buffer. srcsize must be smaller than the buffer size. Definition at line 196 of file buffer_dsound.cpp. References _Format, _Freq, buffer, format, NLSOUND::Mono16, NLSOUND::Mono8, nlassertex, num, sint, sint32, size, NLSOUND::Stereo16, NLSOUND::Stereo8, uint, uint32, and uint8.
00197 {
00198 NL_ALLOC_CONTEXT(NLSOUND_CBufferDSound);
00199 sint error;
00200 sint32 num;
00201 HMMIO hmmio;
00202 WAVEFORMATEX format;
00203 MMCKINFO riff_chunk;
00204 MMCKINFO data_chunk;
00205 MMCKINFO chunk;
00206
00207
00208 if (_Data != NULL)
00209 {
00210 delete [] _Data;
00211 _Data = NULL;
00212 }
00213
00214 /* NLMISC::CIFile ifile(file);
00215 uint size = ifile.getFileSize();
00216 uint8 *buffer = new uint8[ifile.getFileSize()];
00217 ifile.serialBuffer(buffer, size);
00218 */
00219 uint size = dataSize;
00220 uint8 *buffer = wavData;
00221
00222 MMIOINFO mmioInfo;
00223 memset(&mmioInfo, 0, sizeof(mmioInfo));
00224 mmioInfo.pchBuffer = (char*)buffer;
00225 mmioInfo.fccIOProc = FOURCC_MEM;
00226 mmioInfo.cchBuffer = size;
00227
00228
00229 hmmio = mmioOpen(NULL, &mmioInfo, MMIO_READ | MMIO_DENYWRITE);
00230
00231 if (hmmio == NULL)
00232 {
00233 delete [] buffer;
00234 throw ESoundDriver("Failed to open the file");
00235 }
00236
00237
00238 // Check it's a WAVE file
00239 riff_chunk.ckid = FOURCC_RIFF;
00240
00241 error = (sint) mmioDescend(hmmio, &riff_chunk, NULL, 0);
00242
00243 if ((error != 0) || (riff_chunk.ckid != FOURCC_RIFF) || (riff_chunk.fccType != mmioFOURCC('W', 'A', 'V', 'E')))
00244 {
00245 mmioClose(hmmio, 0);
00246 delete buffer;
00247 throw ESoundDriver("Not a WAVE file");
00248 }
00249
00250
00251 // Search the format chunk
00252 chunk.ckid = mmioFOURCC('f', 'm', 't', ' ');
00253
00254 error = (sint) mmioDescend(hmmio, &chunk, &riff_chunk, MMIO_FINDCHUNK);
00255
00256 if (error != 0)
00257 {
00258 mmioClose(hmmio, 0);
00259
00260 delete [] buffer;
00261 throw ESoundDriver("Couldn't find the format chunk");
00262 }
00263
00264 if (chunk.cksize < (long) sizeof(PCMWAVEFORMAT))
00265 {
00266 mmioClose(hmmio, 0);
00267 delete [] buffer;
00268 throw ESoundDriver("Invalid format chunk size");
00269 }
00270
00271
00272 // read in the format data
00273
00274 num = mmioRead(hmmio, (HPSTR) &format, (long) sizeof(format));
00275 if (num != (long) sizeof(format))
00276 {
00277 mmioClose(hmmio, 0);
00278 delete [] buffer;
00279 throw ESoundDriver("Read failed");
00280 }
00281
00282 format.cbSize = 0;
00283
00284 // Get out of the format chunk
00285
00286 if (mmioAscend(hmmio, &chunk, 0) != 0)
00287 {
00288 mmioClose(hmmio, 0);
00289 delete [] buffer;
00290 throw ESoundDriver("Read failed");
00291 }
00292
00293
00294 // copy the format data
00295
00296 if (format.wFormatTag != WAVE_FORMAT_PCM)
00297 {
00298 mmioClose(hmmio, 0);
00299 delete [] buffer;
00300 throw ESoundDriver("Unsupported sample format");
00301 }
00302
00303 _Freq = format.nSamplesPerSec;
00304
00305 if (format.nChannels == 1)
00306 {
00307 if (format.wBitsPerSample == 8)
00308 {
00309 _Format = Mono8;
00310 }
00311 else if (format.wBitsPerSample == 16)
00312 {
00313 _Format = Mono16;
00314 }
00315 else
00316 {
00317 mmioClose(hmmio, 0);
00318 delete [] buffer;
00319 throw ESoundDriver("Unsupported sample size");
00320 }
00321 }
00322 else if (format.nChannels == 2)
00323 {
00324 if (format.wBitsPerSample == 8)
00325 {
00326 _Format = Stereo8;
00327 }
00328 else if (format.wBitsPerSample == 16)
00329 {
00330 _Format = Stereo16;
00331 }
00332 else
00333 {
00334 mmioClose(hmmio, 0);
00335 delete [] buffer;
00336 throw ESoundDriver("Unsupported sample size");
00337 }
00338 }
00339 else // Shouldn't normally happen
00340 {
00341 mmioClose(hmmio, 0);
00342 delete [] buffer;
00343 throw ESoundDriver("Unsupported number of channels");
00344 }
00345
00346
00347 // Set the file position to the beginning of the data chunk */
00348
00349 sint32 pos = mmioSeek(hmmio, riff_chunk.dwDataOffset + sizeof(FOURCC), SEEK_SET);
00350
00351 if (pos < 0)
00352 {
00353 mmioClose(hmmio, 0);
00354 delete [] buffer;
00355 throw ESoundDriver("Read to set the read position");
00356 }
00357
00358 data_chunk.ckid = mmioFOURCC('d', 'a', 't', 'a');
00359
00360 if (mmioDescend(hmmio, &data_chunk, &riff_chunk, MMIO_FINDCHUNK) != 0)
00361 {
00362 mmioClose(hmmio, 0);
00363 delete [] buffer;
00364 throw ESoundDriver("Read to set the read position");
00365 }
00366
00367
00368 // Allocate the sample buffer
00369 _Size = data_chunk.cksize;
00370
00371 _Data = new uint8[_Size];
00372
00373 if (_Data == NULL)
00374 {
00375 mmioClose(hmmio, 0);
00376 delete [] buffer;
00377 throw ESoundDriver("Out of memory");
00378 }
00379
00380
00381 // Read the sample data
00382
00383 num = mmioRead(hmmio, (HPSTR) _Data, _Size);
00384
00385 if (num < 0)
00386 {
00387 delete [] buffer;
00388 throw ESoundDriver("Failed to read the samples");
00389 }
00390 else if ((uint32) num < _Size)
00391 {
00392 // FIXME: print warning or throw exception ???
00393 char* p = (char*) _Data;
00394 ZeroMemory(p + num, _Size - num);
00395 }
00396
00397
00398 mmioClose(hmmio, 0);
00399
00400 // delete [] buffer;
00401
00402 static NLMISC::TStringId empty(CSoundDriverDSound::instance()->getStringMapper()->map(""));
00403 // NLMISC::TStringId name = CSoundDriverDSound::instance()->getStringMapper()->map(CFile::getFilenameWithoutExtension(file));
00404 NLMISC::TStringId nameId = CSoundDriverDSound::instance()->getStringMapper()->map(CFile::getFilenameWithoutExtension(name));
00405 // if name is preseted, the name must match.
00406 if (_Name != empty)
00407 {
00408 nlassertex(nameId == _Name, ("The preseted name and buffer name doen't match !"));
00409 }
00410 _Name = nameId;
00411
00412 return true;
00413 }
|
|
||||||||||||
|
Set the sample format. Example: freq=44100.
Implements NLSOUND::IBuffer. Definition at line 156 of file buffer_dsound.cpp. References _Format, _Freq, format, and uint.
|
|
|
Force the buffer size without filling data (if isFillMoreSupported() only).
Reimplemented in NLSOUND::CBufferAL. Definition at line 73 of file buffer.h.
00073 { throw ESoundDriverNotSupp(); }
|
|
|
Definition at line 114 of file buffer_dsound.h. |
|
|
Definition at line 118 of file buffer_dsound.h. Referenced by CBufferDSound(), getBufferADPCMEncoded(), getBufferMono16(), getDuration(), getFormat(), isStereo(), readRawBuffer(), readWavBuffer(), and setFormat(). |
|
|
Definition at line 120 of file buffer_dsound.h. Referenced by CBufferDSound(), getDuration(), getFormat(), readRawBuffer(), readWavBuffer(), and setFormat(). |
|
|
Definition at line 112 of file buffer_dsound.h. |
|
|
Definition at line 116 of file buffer_dsound.h. |
1.3.6