nevrax.org : docs

00001 
+00007 /* Copyright, 2001 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 
+00026 
+00027 #include "stddsound.h"
+00028 #include "buffer_dsound.h"
+00029 #include "nel/misc/path.h"
+00030 
+00031 
+00032 #include <windows.h>
+00033 #include <mmsystem.h>
+00034 
+00035 using namespace NLMISC;
+00036 using namespace std;
+00037 
+00038 namespace NLSOUND {
+00039 
+00040 
+00041 CBufferDSound::CBufferDSound()
+00042 {
+00043     _Data = NULL;
+00044     _Size = 0; 
+00045     _Format = Mono16;
+00046     _Freq = 0;
+00047 }
+00048 
+00049 CBufferDSound::~CBufferDSound()
+00050 {
+00051         nldebug("Destroying DirectSound buffer %s (%p)", _Name.c_str(), this);
+00052 
+00053     if (_Data != NULL)
+00054     {
+00055         delete[] _Data;
+00056     }
+00057 }
+00058 
+00059 void CBufferDSound::presetName(const std::string &bufferName)
+00060 {
+00061         _Name = bufferName;
+00062 }
+00063 
+00064 
+00065 void CBufferDSound::setFormat( TSampleFormat format, uint freq )
+00066 {
+00067     _Format = format;
+00068     _Freq = freq;
+00069 }
+00070 
+00071 
+00072 bool CBufferDSound::fillBuffer( void *src, uint32 bufsize )
+00073 {
+00074     return false;
+00075 }
+00076 
+00077 
+00078 float CBufferDSound::getDuration() const
+00079 {
+00080     float frames = (float) _Size;
+00081 
+00082     switch (_Format) {
+00083     case Mono8:
+00084         break;
+00085     case Mono16:
+00086         frames /= 2.0f;
+00087         break;
+00088     case Stereo8:
+00089         frames /= 2.0f;
+00090         break;
+00091     case Stereo16:
+00092         frames /= 4.0f;
+00093         break;
+00094     }
+00095 
+00096     return 1000.0f * frames / (float) _Freq;
+00097 }
+00098 
+00099 
+00100 bool CBufferDSound::loadWavFile(const char* file) 
+00101 {
+00102     sint error; 
+00103     sint32 num;
+00104     HMMIO hmmio;
+00105     WAVEFORMATEX format;
+00106     MMCKINFO riff_chunk;
+00107     MMCKINFO data_chunk;
+00108     MMCKINFO chunk;
+00109 
+00110   
+00111     if (_Data != NULL)
+00112     {
+00113         free(_Data);
+00114         _Data = NULL;
+00115     }
+00116 
+00117 
+00118     // Open the file 
+00119     hmmio = mmioOpen((char*) file, NULL, MMIO_READ | MMIO_DENYWRITE);
+00120 
+00121     if (hmmio == NULL) 
+00122     {
+00123         throw ESoundDriver("Failed to open the file");
+00124     }
+00125 
+00126 
+00127     // Check it's a WAVE file 
+00128     riff_chunk.ckid = FOURCC_RIFF;
+00129 
+00130     error = (sint) mmioDescend(hmmio, &riff_chunk, NULL, 0);
+00131 
+00132     if ((error != 0) || (riff_chunk.ckid != FOURCC_RIFF) || (riff_chunk.fccType != mmioFOURCC('W', 'A', 'V', 'E'))) 
+00133     {
+00134         mmioClose(hmmio, 0);
+00135         throw ESoundDriver("Not a WAVE file");
+00136     }
+00137 
+00138 
+00139     // Search the format chunk 
+00140     chunk.ckid = mmioFOURCC('f', 'm', 't', ' ');
+00141 
+00142     error = (sint) mmioDescend(hmmio, &chunk, &riff_chunk, MMIO_FINDCHUNK);
+00143 
+00144     if (error != 0) 
+00145     {
+00146         mmioClose(hmmio, 0);
+00147         throw ESoundDriver("Couldn't find the format chunk");
+00148     }
+00149 
+00150     if (chunk.cksize < (long) sizeof(PCMWAVEFORMAT)) 
+00151     {
+00152         mmioClose(hmmio, 0);
+00153         throw ESoundDriver("Invalid format chunk size");
+00154     }
+00155 
+00156 
+00157     // read in the format data
+00158 
+00159     num = mmioRead(hmmio, (HPSTR) &format, (long) sizeof(format));
+00160     if (num != (long) sizeof(format)) 
+00161     {
+00162         mmioClose(hmmio, 0);
+00163         throw ESoundDriver("Read failed");
+00164     }
+00165 
+00166     format.cbSize = 0;
+00167 
+00168     // Get out of the format chunk
+00169 
+00170     if (mmioAscend(hmmio, &chunk, 0) != 0) 
+00171     {
+00172         mmioClose(hmmio, 0);
+00173         throw ESoundDriver("Read failed");
+00174     }
+00175 
+00176 
+00177     // copy the format data 
+00178 
+00179     if (format.wFormatTag != WAVE_FORMAT_PCM) 
+00180     {
+00181         mmioClose(hmmio, 0);
+00182         throw ESoundDriver("Unsupported sample format");
+00183     }
+00184 
+00185     _Freq = format.nSamplesPerSec;
+00186 
+00187     if (format.nChannels == 1) 
+00188     {
+00189         if (format.wBitsPerSample == 8)
+00190         {
+00191             _Format = Mono8;
+00192         } 
+00193         else if (format.wBitsPerSample == 16)
+00194         {
+00195             _Format = Mono16;
+00196         }
+00197         else
+00198         {
+00199             mmioClose(hmmio, 0);
+00200             throw ESoundDriver("Unsupported sample size");
+00201         }
+00202     }
+00203     else if (format.nChannels == 2)
+00204     {
+00205         if (format.wBitsPerSample == 8)
+00206         {
+00207             _Format = Stereo8;
+00208         } 
+00209         else if (format.wBitsPerSample == 16)
+00210         {
+00211             _Format = Stereo16;
+00212         }
+00213         else
+00214         {
+00215             mmioClose(hmmio, 0);
+00216             throw ESoundDriver("Unsupported sample size");
+00217         }
+00218     }
+00219     else // Shouldn't normally happen
+00220     {
+00221         mmioClose(hmmio, 0);
+00222         throw ESoundDriver("Unsupported number of channels");
+00223     }
+00224 
+00225     
+00226     // Set the file position to the beginning of the data chunk */
+00227  
+00228     sint32 pos = mmioSeek(hmmio, riff_chunk.dwDataOffset + sizeof(FOURCC), SEEK_SET);
+00229 
+00230     if (pos < 0) 
+00231     {
+00232         mmioClose(hmmio, 0);
+00233         throw ESoundDriver("Read to set the read position");
+00234     }
+00235 
+00236     data_chunk.ckid = mmioFOURCC('d', 'a', 't', 'a');
+00237 
+00238     if (mmioDescend(hmmio, &data_chunk, &riff_chunk, MMIO_FINDCHUNK) != 0) 
+00239     {
+00240         mmioClose(hmmio, 0);
+00241         throw ESoundDriver("Read to set the read position");
+00242     }
+00243 
+00244 
+00245     // Allocate the sample buffer
+00246     _Size = data_chunk.cksize;
+00247 
+00248     _Data = new uint8[_Size];
+00249 
+00250     if (_Data == NULL)
+00251     {
+00252         mmioClose(hmmio, 0);
+00253         throw ESoundDriver("Out of memory");
+00254     }
+00255 
+00256 
+00257     // Read the sample data
+00258 
+00259     num = mmioRead(hmmio, (HPSTR) _Data, _Size);
+00260 
+00261     if (num < 0) 
+00262     {
+00263         throw ESoundDriver("Failed to read the samples");
+00264     }
+00265     else if ((uint32) num < _Size)
+00266     {
+00267         // FIXME: print warning or throw exception ???
+00268         char* p = (char*) _Data;
+00269         ZeroMemory(p + num, _Size - num);
+00270     }
+00271 
+00272 
+00273     mmioClose(hmmio, 0);
+00274 
+00275 
+00276         std::string name = CFile::getFilenameWithoutExtension(file);
+00277         // if name is preseted, the name must match.
+00278         if (!_Name.empty())
+00279         {
+00280                 nlassertex(_Name == name, ("The preseted name and buffer name doen't match !"));
+00281         }
+00282         _Name = name;
+00283 
+00284         return true;
+00285 
+00286 }
+00287 
+00288 
+00289 } // NLSOUND
+00290 
+00291 
+00292 
+
buffer_dsound.cpp
