00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #include "../h/OpenAL.h"
00026
00027
00028
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
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
00108 pWaveInfo->pData = new char[pWaveInfo->ulDataSize];
00109 if (pWaveInfo->pData)
00110 {
00111
00112 fseek(pWaveInfo->pFile, pWaveInfo->ulDataOffset, SEEK_SET);
00113
00114
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
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
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
00282 if (FOPEN(&pWaveInfo->pFile, szFilename, _T("rb")))
00283 {
00284
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
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
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 }