• Main Page
  • Namespaces
  • Classes
  • Files
  • File List
  • File Members

src/audio/src/OALFramework/CWaves.cpp

Go to the documentation of this file.
00001 /*
00002  * Copyright (c) 2006, Creative Labs Inc.
00003  * All rights reserved.
00004  * 
00005  * Redistribution and use in source and binary forms, with or without modification, are permitted provided
00006  * that the following conditions are met:
00007  * 
00008  *     * Redistributions of source code must retain the above copyright notice, this list of conditions and
00009  *           the following disclaimer.
00010  *     * Redistributions in binary form must reproduce the above copyright notice, this list of conditions
00011  *           and the following disclaimer in the documentation and/or other materials provided with the distribution.
00012  *     * Neither the name of Creative Labs Inc. nor the names of its contributors may be used to endorse or
00013  *           promote products derived from this software without specific prior written permission.
00014  * 
00015  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
00016  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
00017  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
00018  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
00019  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
00020  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
00021  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
00022  * POSSIBILITY OF SUCH DAMAGE.
00023  */
00024 
00025 #include "../h/OpenAL.h"
00026 /*#include "CWaves.h"
00027 #include <ks.h>
00028 #include <ksmedia.h>*/
00029 
00030 #pragma pack(push, 4)
00031 
00032 typedef struct
00033 {
00034         char                    szRIFF[4];
00035         unsigned long   ulRIFFSize;
00036         char                    szWAVE[4];
00037 } WAVEFILEHEADER;
00038 
00039 typedef struct
00040 {
00041         char                    szChunkName[4];
00042         unsigned long   ulChunkSize;
00043 } RIFFCHUNK;
00044 
00045 typedef struct
00046 {
00047         unsigned short  usFormatTag;
00048         unsigned short  usChannels;
00049         unsigned long   ulSamplesPerSec;
00050         unsigned long   ulAvgBytesPerSec;
00051         unsigned short  usBlockAlign;
00052         unsigned short  usBitsPerSample;
00053         unsigned short  usSize;
00054         unsigned short  usReserved;
00055         unsigned long   ulChannelMask;
00056     GUID            guidSubFormat;
00057 } WAVEFMT;
00058 
00059 #pragma pack(pop)
00060 
00062 // Construction/Destruction
00064 
00065 CWaves::CWaves(int numIDs)
00066 {
00067         m_WaveIDs = new LPWAVEFILEINFO[m_numWaveIDs = numIDs];
00068         memset(m_WaveIDs, 0, sizeof(LPWAVEFILEINFO)*numIDs);
00069 }
00070 
00071 CWaves::~CWaves()
00072 {
00073         long lLoop;
00074 
00075         if(m_WaveIDs)
00076         {
00077                 for (lLoop = 0; lLoop < m_numWaveIDs; lLoop++)
00078                 {
00079                         if (m_WaveIDs[lLoop])
00080                         {
00081                                 if (m_WaveIDs[lLoop]->pData)
00082                                         delete m_WaveIDs[lLoop]->pData;
00083 
00084                                 if (m_WaveIDs[lLoop]->pFile)
00085                                         fclose(m_WaveIDs[lLoop]->pFile);
00086 
00087                                 delete m_WaveIDs[lLoop];
00088                                 m_WaveIDs[lLoop] = 0;
00089                         }
00090                 }
00091                 delete [] m_WaveIDs;
00092                 m_WaveIDs = 0;
00093         }
00094 }
00095 
00096 
00097 WAVERESULT CWaves::LoadWaveFile(const rchar *szFilename, WAVEID *pWaveID)
00098 {
00099         WAVERESULT wr = WR_OUTOFMEMORY;
00100         LPWAVEFILEINFO pWaveInfo;
00101 
00102         pWaveInfo = new WAVEFILEINFO;
00103         if (pWaveInfo)
00104         {
00105                 if (SUCCEEDED(wr = ParseFile(szFilename, pWaveInfo)))
00106                 {
00107                         // Allocate memory for sample data
00108                         pWaveInfo->pData = new char[pWaveInfo->ulDataSize];
00109                         if (pWaveInfo->pData)
00110                         {
00111                                 // Seek to start of audio data
00112                                 fseek(pWaveInfo->pFile, pWaveInfo->ulDataOffset, SEEK_SET);
00113 
00114                                 // Read Sample Data
00115                                 if (fread(pWaveInfo->pData, 1, pWaveInfo->ulDataSize, pWaveInfo->pFile) == pWaveInfo->ulDataSize)
00116                                 {
00117                                         long lLoop = 0;
00118                                         for (lLoop = 0; lLoop < MAX_NUM_WAVEID; lLoop++)
00119                                         {
00120                                                 if (!m_WaveIDs[lLoop])
00121                                                 {
00122                                                         m_WaveIDs[lLoop] = pWaveInfo;
00123                                                         *pWaveID = lLoop;
00124                                                         wr = WR_OK;
00125                                                         break;
00126                                                 }
00127                                         }
00128 
00129                                         if (lLoop == MAX_NUM_WAVEID)
00130                                         {
00131                                                 delete pWaveInfo->pData;
00132                                                 wr = WR_OUTOFMEMORY;
00133                                         }
00134                                 }
00135                                 else
00136                                 {
00137                                         delete pWaveInfo->pData;
00138                                         wr = WR_BADWAVEFILE;
00139                                 }
00140                         }
00141                         else
00142                         {
00143                                 wr = WR_OUTOFMEMORY;
00144                         }
00145 
00146                         fclose(pWaveInfo->pFile);
00147                         pWaveInfo->pFile = 0;
00148                 }
00149 
00150                 if (wr != WR_OK)
00151                         delete pWaveInfo;
00152         }
00153 
00154         return wr;
00155 }
00156 
00157 
00158 WAVERESULT CWaves::OpenWaveFile(const rchar *szFilename, WAVEID *pWaveID)
00159 {
00160         WAVERESULT wr = WR_OUTOFMEMORY;
00161         LPWAVEFILEINFO pWaveInfo;
00162 
00163         pWaveInfo = new WAVEFILEINFO;
00164         if (pWaveInfo)
00165         {
00166                 if (SUCCEEDED(wr = ParseFile(szFilename, pWaveInfo)))
00167                 {
00168                         long lLoop = 0;
00169                         for (lLoop = 0; lLoop < MAX_NUM_WAVEID; lLoop++)
00170                         {
00171                                 if (!m_WaveIDs[lLoop])
00172                                 {
00173                                         m_WaveIDs[lLoop] = pWaveInfo;
00174                                         *pWaveID = lLoop;
00175                                         wr = WR_OK;
00176                                         break;
00177                                 }
00178                         }
00179 
00180                         if (lLoop == MAX_NUM_WAVEID)
00181                                 wr = WR_OUTOFMEMORY;
00182                 }
00183 
00184                 if (wr != WR_OK)
00185                         delete pWaveInfo;
00186         }
00187 
00188         return wr;
00189 }
00190 
00191 WAVERESULT CWaves::ReadWaveData(WAVEID WaveID, void *pData, unsigned long ulDataSize, unsigned long *pulBytesWritten)
00192 {
00193         LPWAVEFILEINFO pWaveInfo;
00194         WAVERESULT wr = WR_BADWAVEFILE;
00195 
00196         if (!pData || !pulBytesWritten || ulDataSize == 0)
00197                 return WR_INVALIDPARAM;
00198 
00199         if (IsWaveID(WaveID))
00200         {
00201                 pWaveInfo = m_WaveIDs[WaveID];
00202                 if (pWaveInfo->pFile)
00203                 {
00204                         unsigned long ulOffset = ftell(pWaveInfo->pFile);
00205 
00206                         if ((ulOffset - pWaveInfo->ulDataOffset + ulDataSize) > pWaveInfo->ulDataSize)
00207                                 ulDataSize = pWaveInfo->ulDataSize - (ulOffset - pWaveInfo->ulDataOffset);
00208 
00209                         *pulBytesWritten = (unsigned long)fread(pData, 1, ulDataSize, pWaveInfo->pFile);
00210 
00211                         wr = WR_OK;
00212                 }
00213         }
00214         else
00215         {
00216                 wr = WR_INVALIDWAVEID;
00217         }
00218 
00219         return wr;
00220 }
00221 
00222 WAVERESULT CWaves::SetWaveDataOffset(WAVEID WaveID, unsigned long ulOffset)
00223 {
00224         LPWAVEFILEINFO pWaveInfo;
00225         WAVERESULT wr = WR_INVALIDPARAM;
00226 
00227         if (IsWaveID(WaveID))
00228         {
00229                 pWaveInfo = m_WaveIDs[WaveID];
00230                 if (pWaveInfo->pFile)
00231                 {
00232                         // Seek into audio data
00233                         fseek(pWaveInfo->pFile, pWaveInfo->ulDataOffset + ulOffset, SEEK_SET);
00234                         wr = WR_OK;
00235                 }
00236         }
00237         else
00238         {
00239                 wr = WR_INVALIDWAVEID;
00240         }
00241 
00242         return wr;
00243 }
00244 
00245 WAVERESULT CWaves::GetWaveDataOffset(WAVEID WaveID, unsigned long *pulOffset)
00246 {
00247         LPWAVEFILEINFO pWaveInfo;
00248         WAVERESULT wr = WR_INVALIDPARAM;
00249 
00250         if (IsWaveID(WaveID))
00251         {
00252                 pWaveInfo = m_WaveIDs[WaveID];
00253                 if ((pWaveInfo->pFile) && (pulOffset))
00254                 {
00255                         // Get current position
00256                         *pulOffset = ftell(pWaveInfo->pFile);
00257                         *pulOffset -= pWaveInfo->ulDataOffset;
00258                         wr = WR_OK;
00259                 }
00260         }
00261         else
00262         {
00263                 wr = WR_INVALIDWAVEID;
00264         }
00265 
00266         return wr;
00267 }
00268 
00269 WAVERESULT CWaves::ParseFile(const rchar *szFilename, LPWAVEFILEINFO pWaveInfo)
00270 {
00271         WAVEFILEHEADER  waveFileHeader;
00272         RIFFCHUNK               riffChunk;
00273         WAVEFMT                 waveFmt;
00274         WAVERESULT              wr = WR_BADWAVEFILE;
00275 
00276         if (!szFilename || !pWaveInfo)
00277                 return WR_INVALIDPARAM;
00278 
00279         memset(pWaveInfo, 0, sizeof(WAVEFILEINFO));
00280 
00281         // Open the wave file for reading
00282         if (FOPEN(&pWaveInfo->pFile, szFilename, _T("rb")))
00283         {
00284                 // Read Wave file header
00285                 fread(&waveFileHeader, 1, sizeof(WAVEFILEHEADER), pWaveInfo->pFile);
00286                 if (!_strnicmp(waveFileHeader.szRIFF, "RIFF", 4) && !_strnicmp(waveFileHeader.szWAVE, "WAVE", 4))
00287                 {
00288                         while (fread(&riffChunk, 1, sizeof(RIFFCHUNK), pWaveInfo->pFile) == sizeof(RIFFCHUNK))
00289                         {
00290                                 if (!_strnicmp(riffChunk.szChunkName, "fmt ", 4))
00291                                 {
00292                                         if (riffChunk.ulChunkSize <= sizeof(WAVEFMT))
00293                                         {
00294                                                 fread(&waveFmt, 1, riffChunk.ulChunkSize, pWaveInfo->pFile);
00295                                         
00296                                                 // Determine if this is a WAVEFORMATEX or WAVEFORMATEXTENSIBLE wave file
00297                                                 if (waveFmt.usFormatTag == WAVE_FORMAT_PCM)
00298                                                 {
00299                                                         pWaveInfo->wfType = WF_EX;
00300                                                         memcpy(&pWaveInfo->wfEXT.Format, &waveFmt, sizeof(PCMWAVEFORMAT));
00301                                                 }
00302                                                 else if (waveFmt.usFormatTag == WAVE_FORMAT_EXTENSIBLE)
00303                                                 {
00304                                                         pWaveInfo->wfType = WF_EXT;
00305                                                         memcpy(&pWaveInfo->wfEXT, &waveFmt, sizeof(WAVEFORMATEXTENSIBLE));
00306                                                 }
00307                                         }
00308                                         else
00309                                         {
00310                                                 fseek(pWaveInfo->pFile, riffChunk.ulChunkSize, SEEK_CUR);
00311                                         }
00312                                 }
00313                                 else if (!_strnicmp(riffChunk.szChunkName, "data", 4))
00314                                 {
00315                                         pWaveInfo->ulDataSize = riffChunk.ulChunkSize;
00316                                         pWaveInfo->ulDataOffset = ftell(pWaveInfo->pFile);
00317                                         fseek(pWaveInfo->pFile, riffChunk.ulChunkSize, SEEK_CUR);
00318                                 }
00319                                 else
00320                                 {
00321                                         fseek(pWaveInfo->pFile, riffChunk.ulChunkSize, SEEK_CUR);
00322                                 }
00323 
00324                                 // Ensure that we are correctly aligned for next chunk
00325                                 if (riffChunk.ulChunkSize & 1)
00326                                         fseek(pWaveInfo->pFile, 1, SEEK_CUR);
00327                         }
00328 
00329                         if (pWaveInfo->ulDataSize && pWaveInfo->ulDataOffset && ((pWaveInfo->wfType == WF_EX) || (pWaveInfo->wfType == WF_EXT)))
00330                                 wr = WR_OK;
00331                         else
00332                                 fclose(pWaveInfo->pFile);
00333                 }
00334         }
00335         else
00336         {
00337                 wr = WR_INVALIDFILENAME;
00338         }
00339 
00340         return wr;
00341 }
00342 
00343 
00344 WAVERESULT CWaves::DeleteWaveFile(WAVEID WaveID)
00345 {
00346         WAVERESULT wr = WR_OK;
00347 
00348         if (IsWaveID(WaveID))
00349         {
00350                 if (m_WaveIDs[WaveID]->pData)
00351                         delete m_WaveIDs[WaveID]->pData;
00352 
00353                 if (m_WaveIDs[WaveID]->pFile)
00354                         fclose(m_WaveIDs[WaveID]->pFile);
00355 
00356                 delete m_WaveIDs[WaveID];
00357                 m_WaveIDs[WaveID] = 0;
00358         }
00359         else
00360         {
00361                 wr = WR_INVALIDWAVEID;
00362         }
00363 
00364         return wr;
00365 }
00366 
00367 
00368 WAVERESULT CWaves::GetWaveType(WAVEID WaveID, WAVEFILETYPE *wfType)
00369 {
00370         if (!IsWaveID(WaveID))
00371                 return WR_INVALIDWAVEID;
00372 
00373         if (!wfType)
00374                 return WR_INVALIDPARAM;
00375 
00376         *wfType = m_WaveIDs[WaveID]->wfType;
00377 
00378         return WR_OK;
00379 }
00380 
00381 
00382 WAVERESULT CWaves::GetWaveFormatExHeader(WAVEID WaveID, WAVEFORMATEX *wfex)
00383 {
00384         if (!IsWaveID(WaveID))
00385                 return WR_INVALIDWAVEID;
00386 
00387         if (!wfex)
00388                 return WR_INVALIDPARAM;
00389 
00390         memcpy(wfex, &(m_WaveIDs[WaveID]->wfEXT.Format), sizeof(WAVEFORMATEX));
00391 
00392         return WR_OK;
00393 }
00394 
00395 
00396 WAVERESULT CWaves::GetWaveFormatExtensibleHeader(WAVEID WaveID, WAVEFORMATEXTENSIBLE *wfext)
00397 {
00398         if (!IsWaveID(WaveID))
00399                 return WR_INVALIDWAVEID;
00400 
00401         if (m_WaveIDs[WaveID]->wfType != WF_EXT)
00402                 return WR_NOTWAVEFORMATEXTENSIBLEFORMAT;
00403 
00404         if (!wfext)
00405                 return WR_INVALIDPARAM;
00406 
00407         memcpy(wfext, &(m_WaveIDs[WaveID]->wfEXT), sizeof(WAVEFORMATEXTENSIBLE));
00408 
00409         return WR_OK;
00410 }
00411 
00412 WAVERESULT CWaves::GetWaveData(WAVEID WaveID, void **lplpAudioData)
00413 {
00414         if (!IsWaveID(WaveID))
00415                 return WR_INVALIDWAVEID;
00416 
00417         if (!lplpAudioData)
00418                 return WR_INVALIDPARAM;
00419 
00420         *lplpAudioData = m_WaveIDs[WaveID]->pData;
00421 
00422         return WR_OK;
00423 }
00424 
00425 WAVERESULT CWaves::GetWaveSize(WAVEID WaveID, unsigned long *size)
00426 {
00427         if (!IsWaveID(WaveID))
00428                 return WR_INVALIDWAVEID;
00429 
00430         if (!size)
00431                 return WR_INVALIDPARAM;
00432 
00433         *size = m_WaveIDs[WaveID]->ulDataSize;
00434 
00435         return WR_OK;
00436 }
00437 
00438 
00439 WAVERESULT CWaves::GetWaveFrequency(WAVEID WaveID, unsigned long *pulFrequency)
00440 {
00441         WAVERESULT wr = WR_OK;
00442 
00443         if (IsWaveID(WaveID))
00444         {
00445                 if (pulFrequency)
00446                         *pulFrequency = m_WaveIDs[WaveID]->wfEXT.Format.nSamplesPerSec;
00447                 else
00448                         wr = WR_INVALIDPARAM;
00449         }
00450         else
00451         {
00452                 wr = WR_INVALIDWAVEID;
00453         }
00454 
00455         return wr;
00456 }
00457 
00458 
00459 WAVERESULT CWaves::GetWaveALBufferFormat(WAVEID WaveID, PFNALGETENUMVALUE pfnGetEnumValue, unsigned long *pulFormat)
00460 {
00461         WAVERESULT wr = WR_OK;
00462 
00463         if (IsWaveID(WaveID))
00464         {
00465                 if (pfnGetEnumValue && pulFormat)
00466                 {
00467                         *pulFormat = 0;
00468 
00469                         if (m_WaveIDs[WaveID]->wfType == WF_EX)
00470                         {
00471                                 if (m_WaveIDs[WaveID]->wfEXT.Format.nChannels == 1)
00472                                         *pulFormat = m_WaveIDs[WaveID]->wfEXT.Format.wBitsPerSample == 16 ? pfnGetEnumValue("AL_FORMAT_MONO16") : pfnGetEnumValue("AL_FORMAT_MONO8");
00473                                 else if (m_WaveIDs[WaveID]->wfEXT.Format.nChannels == 2)
00474                                         *pulFormat = m_WaveIDs[WaveID]->wfEXT.Format.wBitsPerSample == 16 ? pfnGetEnumValue("AL_FORMAT_STEREO16") : pfnGetEnumValue("AL_FORMAT_STEREO8");
00475                                 else if ((m_WaveIDs[WaveID]->wfEXT.Format.nChannels == 4) && (m_WaveIDs[WaveID]->wfEXT.Format.wBitsPerSample == 16))
00476                                         *pulFormat = pfnGetEnumValue("AL_FORMAT_QUAD16");
00477                         }
00478                         else if (m_WaveIDs[WaveID]->wfType == WF_EXT)
00479                         {
00480                                 if ((m_WaveIDs[WaveID]->wfEXT.Format.nChannels == 1) && (m_WaveIDs[WaveID]->wfEXT.dwChannelMask == SPEAKER_FRONT_CENTER))
00481                                         *pulFormat = m_WaveIDs[WaveID]->wfEXT.Format.wBitsPerSample == 16 ? pfnGetEnumValue("AL_FORMAT_MONO16") : pfnGetEnumValue("AL_FORMAT_MONO8");
00482                                 else if ((m_WaveIDs[WaveID]->wfEXT.Format.nChannels == 2) && (m_WaveIDs[WaveID]->wfEXT.dwChannelMask == (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT)))
00483                                         *pulFormat = m_WaveIDs[WaveID]->wfEXT.Format.wBitsPerSample == 16 ? pfnGetEnumValue("AL_FORMAT_STEREO16") : pfnGetEnumValue("AL_FORMAT_STEREO8");
00484                                 else if ((m_WaveIDs[WaveID]->wfEXT.Format.nChannels == 2) && (m_WaveIDs[WaveID]->wfEXT.Format.wBitsPerSample == 16) && (m_WaveIDs[WaveID]->wfEXT.dwChannelMask == (SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT)))
00485                                         *pulFormat =  pfnGetEnumValue("AL_FORMAT_REAR16");
00486                                 else if ((m_WaveIDs[WaveID]->wfEXT.Format.nChannels == 4) && (m_WaveIDs[WaveID]->wfEXT.Format.wBitsPerSample == 16) && (m_WaveIDs[WaveID]->wfEXT.dwChannelMask == (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT)))
00487                                         *pulFormat = pfnGetEnumValue("AL_FORMAT_QUAD16");
00488                                 else if ((m_WaveIDs[WaveID]->wfEXT.Format.nChannels == 6) && (m_WaveIDs[WaveID]->wfEXT.Format.wBitsPerSample == 16) && (m_WaveIDs[WaveID]->wfEXT.dwChannelMask == (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT)))
00489                                         *pulFormat = pfnGetEnumValue("AL_FORMAT_51CHN16");
00490                                 else if ((m_WaveIDs[WaveID]->wfEXT.Format.nChannels == 7) && (m_WaveIDs[WaveID]->wfEXT.Format.wBitsPerSample == 16) && (m_WaveIDs[WaveID]->wfEXT.dwChannelMask == (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT|SPEAKER_BACK_CENTER)))
00491                                         *pulFormat = pfnGetEnumValue("AL_FORMAT_61CHN16");
00492                                 else if ((m_WaveIDs[WaveID]->wfEXT.Format.nChannels == 8) && (m_WaveIDs[WaveID]->wfEXT.Format.wBitsPerSample == 16) && (m_WaveIDs[WaveID]->wfEXT.dwChannelMask == (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT|SPEAKER_SIDE_LEFT|SPEAKER_SIDE_RIGHT)))
00493                                         *pulFormat = pfnGetEnumValue("AL_FORMAT_71CHN16");
00494                         }
00495 
00496                         if (*pulFormat == 0)
00497                                 wr = WR_INVALIDWAVEFILETYPE;
00498                 }
00499                 else
00500                 {
00501                         wr = WR_INVALIDPARAM;
00502                 }
00503         }
00504         else
00505         {
00506                 wr = WR_INVALIDWAVEID;
00507         }
00508 
00509         return wr;
00510 }
00511 
00512 
00513 bool CWaves::IsWaveID(WAVEID WaveID)
00514 {
00515         bool bReturn = false;
00516 
00517         if ((WaveID >= 0) && (WaveID < MAX_NUM_WAVEID))
00518         {
00519                 if (m_WaveIDs[WaveID])
00520                         bReturn = true;
00521         }
00522 
00523         return bReturn;
00524 }
00525 
00526 
00527 char *CWaves::GetErrorString(WAVERESULT wr, char *szErrorString, unsigned long nSizeOfErrorString)
00528 {       
00529         switch (wr)
00530         {
00531                 case WR_OK:
00532                         strncpy(szErrorString, "Success\n", nSizeOfErrorString-1);
00533                         break;
00534 
00535                 case WR_INVALIDFILENAME:
00536                         strncpy(szErrorString, "Invalid file name or file does not exist\n", nSizeOfErrorString-1);
00537                         break;
00538 
00539                 case WR_BADWAVEFILE:
00540                         strncpy(szErrorString, "Invalid Wave file\n", nSizeOfErrorString-1);
00541                         break;
00542 
00543                 case WR_INVALIDPARAM:
00544                         strncpy(szErrorString, "Invalid parameter passed to function\n", nSizeOfErrorString-1);
00545                         break;
00546 
00547                 case WR_FILEERROR:
00548                         strncpy(szErrorString, "File I/O error\n", nSizeOfErrorString-1);
00549                         break;
00550 
00551                 case WR_INVALIDWAVEID:
00552                         strncpy(szErrorString, "Invalid WAVEID\n", nSizeOfErrorString-1);
00553                         break;
00554 
00555                 case WR_NOTSUPPORTEDYET:
00556                         strncpy(szErrorString, "Function not supported yet\n", nSizeOfErrorString-1);
00557                         break;
00558 
00559                 case WR_WAVEMUSTBEMONO:
00560                         strncpy(szErrorString, "Input wave files must be mono\n", nSizeOfErrorString-1);
00561                         break;
00562 
00563                 case WR_WAVEMUSTBEWAVEFORMATPCM:
00564                         strncpy(szErrorString, "Input wave files must be in Wave Format PCM\n", nSizeOfErrorString-1);
00565                         break;
00566                 
00567                 case WR_WAVESMUSTHAVESAMEBITRESOLUTION:
00568                         strncpy(szErrorString, "Input wave files must have the same Bit Resolution\n", nSizeOfErrorString-1);
00569                         break;
00570 
00571                 case WR_WAVESMUSTHAVESAMEFREQUENCY:
00572                         strncpy(szErrorString, "Input wave files must have the same Frequency\n", nSizeOfErrorString-1);
00573                         break;
00574 
00575                 case WR_WAVESMUSTHAVESAMEBITRATE:
00576                         strncpy(szErrorString, "Input wave files must have the same Bit Rate\n", nSizeOfErrorString-1);
00577                         break;
00578 
00579                 case WR_WAVESMUSTHAVESAMEBLOCKALIGNMENT:
00580                         strncpy(szErrorString, "Input wave files must have the same Block Alignment\n", nSizeOfErrorString-1);
00581                         break;
00582 
00583                 case WR_OFFSETOUTOFDATARANGE:
00584                         strncpy(szErrorString, "Wave files Offset is not within audio data\n", nSizeOfErrorString-1);
00585                         break;
00586 
00587                 case WR_INVALIDSPEAKERPOS:
00588                         strncpy(szErrorString, "Invalid Speaker Destinations\n", nSizeOfErrorString-1);
00589                         break;
00590 
00591                 case WR_OUTOFMEMORY:
00592                         strncpy(szErrorString, "Out of memory\n", nSizeOfErrorString-1);
00593                         break;
00594 
00595                 case WR_INVALIDWAVEFILETYPE:
00596                         strncpy(szErrorString, "Invalid Wave File Type\n", nSizeOfErrorString-1);
00597                         break;
00598 
00599                 case WR_NOTWAVEFORMATEXTENSIBLEFORMAT:
00600                         strncpy(szErrorString, "Wave file is not in WAVEFORMATEXTENSIBLE format\n", nSizeOfErrorString-1);
00601                         break;
00602 
00603                 default:
00604                         strncpy(szErrorString, "Undefined error\n", nSizeOfErrorString-1);
00605         }
00606         szErrorString[nSizeOfErrorString-1] = '\0';
00607         return szErrorString;
00608 }

Generated on Fri Jun 18 2010 17:48:39 for Cannonball by  doxygen 1.7.0