void Sounds::Load(string name, string filename)
{
DataFile file(filename);
void *data = malloc(file.getSize());
file.read(data, file.getSize());
sounds[name] = alutCreateBufferFromFileImage(data, file.getSize());
free(data);
};
Buffer* LoadWAV(const char* name, const void* data, size_t size)
{
Buffer* b = new Buffer(name);
b->bufferId[0] = alutCreateBufferFromFileImage(data,size);
ALenum error = alutGetError();
if (error != ALUT_ERROR_NO_ERROR)
{
freeslw::ErrorPrintf(alutGetErrorString(error));
delete b; return 0;
}
if (b->bufferId[0] == NO_BUFFER)
{
freeslw::ErrorPrintf("Failed to create buffer for \"%s\"",name);
delete b; return 0;
}
ALint format;
ALint isize;
ALint freq;
ALint bits;
ALint channels;
ALint d = 1;
alGetBufferi(b->bufferId[0],AL_CHANNELS,&format);
alGetBufferi(b->bufferId[0],AL_SIZE,&isize);
alGetBufferi(b->bufferId[0],AL_FREQUENCY,&freq);
if (format == AL_FORMAT_MONO8) b->format = freeslw::TA_MONO8;
else if (format == AL_FORMAT_MONO16) b->format = freeslw::TA_MONO16;
else if (format == AL_FORMAT_STEREO8) b->format = freeslw::TA_STEREO8;
else if (format == AL_FORMAT_STEREO16) b->format = freeslw::TA_STEREO16;
else freeslw::ErrorPrintf("Failed to retrieve a valid sound format (format = %d)",format);
alGetBufferi(b->bufferId[0],AL_BITS,&bits);
alGetBufferi(b->bufferId[0],AL_CHANNELS,&channels);
if (bits == 16 && channels == 1) d = 2;
else if (bits == 8 && channels == 2) d = 2;
else if (bits == 16 && channels == 2) d = 4;
if (freq == 0)
{
freeslw::ErrorPrintf("\"%s\": Frequency = 0",name);
freq = 1;
}
b->frequency = (int)freq;
b->length = (isize * 1000) / (freq * d);
b->activeBuffer = 0;
b->numBuffers = 1;
return b;
}
StaticSoundSample::StaticSoundSample(const ResourceWrapper& resource, bool playsLocal, float volume)
: mBuffer(0), mResource(resource)
{
mType = SoundGeneral::SAMPLE_WAV;
mBuffer = alutCreateBufferFromFileImage(mResource.getDataPtr(), mResource.getSize());
if (!SoundGeneral::checkAlError("Generated buffer for static sample.")) {
alDeleteBuffers(1, &mBuffer);
}
}
//----------------------------------------------------------------------------//
WavBuffer::WavBuffer(const Ogre::String &name)
{
mName = name;
mBuffers = new ALuint[1];
Ogre::DataStreamPtr dstream = Ogre::ResourceGroupManager::getSingleton().openResource(name);
Ogre::MemoryDataStream stream(dstream);
mBuffers[0] = alutCreateBufferFromFileImage((ALbyte *)stream.getPtr(), static_cast<ALsizei>(stream.size()));
SoundSystem::checkError(__FUNCTION__);
updateInfo();
}
Handle<Value> ALUTCreateBufferFromFileImageCallback(const Arguments& args) {
//if less that nbr of formal parameters then do nothing
if (args.Length() < 2)
return v8::Undefined();
//get arguments
String::Utf8Value value0(args[0]);
char* key0 = *value0;
void* arg0 = font_[key0];
//make call
alutCreateBufferFromFileImage((const ALvoid*)arg0, (ALsizei)arg1);
return v8::Undefined();
}
SoundBufferRes(const char *filename, bool &ok)
:_buffer(0){
assert(filename);
ok = false;
CPVRTResourceFile resFile(filename);
if (!resFile.IsOpen()) {
lwerror("sound file is not exist: %s", filename);
return;
}
_buffer = alutCreateBufferFromFileImage(resFile.DataPtr(), resFile.Size());
if (_buffer == AL_NONE) {
lwerror("sound buffer create failed: %s", filename);
return;
}
ok = true;
_filename = filename;
_soundBufferResMgr.add(filename, this);
};
////////////////////////////////////////////////////////////////////////////////
/// \fn AudioBuffer::AudioBuffer(const ALubyte* data, size_t size)
///
/// \brief Constructor.
///
/// \author Josh Douglas
/// \date 2013-08-22
///
/// \param data The data.
/// \param size The size.
Buffer::Buffer(const ALubyte* data, size_t size)
{
buffer_id_ = alutCreateBufferFromFileImage(data, size);
}
DWORD COpenALSoundUtility::OnAddSound(DWORD size, void *params)
{
VERIFY_MESSAGE_SIZE(sizeof(ADDSOUNDOBJECTPARAMS), size);
ADDSOUNDOBJECTPARAMS *asparams = (ADDSOUNDOBJECTPARAMS *) params;
IHashString *fileName = asparams->FileName;
IHashString *ext = asparams->fileType;
IEEStream *fileStream = asparams->fileStream;
static CHashString hsWav(_T("wav"));
static CHashString hsOgg(_T("ogg"));
if ((fileName) && (ext) && (fileStream))
{
if (ext->GetUniqueID() == hsWav.GetUniqueID())
{
// can't stream wav files with alut function, so we have to load the whole thing
// and add to buffer list
AUDIOBUFFERMAPBYFILE::iterator iter = m_AudioBufferMap.find(fileName->GetUniqueID());
if ( iter == m_AudioBufferMap.end() )
{
ALenum err;
// now we have to load this raw buffer into OpenAL
ALuint soundBuffer;
void *data;
UINT buffSize;
data = GetStreamData(fileStream, &buffSize);
if (data == NULL)
{
m_ToolBox->Log(LOGWARNING, _T("Sound manager: could not buffer data from stream for file %s\n"),
fileName->GetString());
return MSG_NOT_HANDLED;
}
soundBuffer = alutCreateBufferFromFileImage(data, buffSize);
free(data);
err = alutGetError();
if (err != ALUT_ERROR_NO_ERROR)
{
m_ToolBox->SetErrorValue(ERR_NULL_POINTER);
m_ToolBox->Log( LOGWARNING, _T("Sound manager: alut couldn't buffer the data for file %s: %s\n"), fileName->GetString(), alutGetErrorString(err));
return MSG_ERROR;
}
int size = 0;
if (GetALBufferI(soundBuffer, AL_SIZE, &size, __FILE__, __LINE__))
{
AddALMemUsageBytes((UINT)size);
}
m_AudioBufferMap[fileName->GetUniqueID()] = soundBuffer;
}
}
else if (ext->GetUniqueID() == hsOgg.GetUniqueID())
{
// ogg files sorta have to be streamed, not really, but it'll probably help,
// so we have to copy the file data and make buffers at play time
AUDIOBUFFERMAPBYFILE::iterator bufferIter = m_AudioBufferMap.find(fileName->GetUniqueID());
BUFFERSTREAMDATABYFILE::iterator streamIter = m_BufferStreamMap.find(fileName->GetUniqueID());
if ((streamIter == m_BufferStreamMap.end()) && (bufferIter == m_AudioBufferMap.end()))
{
// at some point, we may need to stream from disk, but for now, go ahead and load everything into
// a mem stream -- the beauty of this system is that the IEEStream can be a file stream or a mem
// stream and the buffers will still function
void *data;
UINT buffSize;
data = GetStreamData(fileStream, &buffSize);
// NOTE: do not free this data here; it will be freed in the mem stream when it deinits
CREATESTREAM cs;
cs.mode = STREAM_MODE_READ;
cs.streamData = data;
cs.streamSize = buffSize;
static DWORD msgHash_CreateStream_Memory = CHashString(_T("CreateStream_Memory")).GetUniqueID();
DWORD retval = m_ToolBox->SendMessage(msgHash_CreateStream_Memory, sizeof(CREATESTREAM), &cs);
if ((retval != MSG_HANDLED) || (cs.openStream == NULL))
{
m_ToolBox->Log(LOGWARNING, _T("Sound manager: could not create mem stream to store file data!\n"));
free(data);
return MSG_NOT_HANDLED;
}
else
{
// now check to see if this file is in the map, and if so, if we're caching buffers
bool bKeepMemStream = true;
FILETOKEYMAP::iterator fileMapIter = m_FileToKeyMap.find(fileName->GetUniqueID());
if (fileMapIter != m_FileToKeyMap.end())
{
SOUNDKEYMAP::iterator mapIter = m_SoundMap.find(fileMapIter->second);
if (mapIter != m_SoundMap.end())
{
if (mapIter->second.bCachedUncompressed)
{
bKeepMemStream = false;
COGGSoundBufferStream tempBufferStream(fileName, cs.openStream);
ALuint tempBuffer;
tempBuffer = tempBufferStream.BufferFullSound();
m_AudioBufferMap[fileName->GetUniqueID()] = tempBuffer;
}
}
}
if (bKeepMemStream)
{
m_BufferStreamMap[fileName->GetUniqueID()].pStream = cs.openStream;
m_BufferStreamMap[fileName->GetUniqueID()].pData = data;
}
else
{
cs.openStream->Close();
free(data);
}
}
}
}
// close and delete stream
fileStream->Close();
delete fileStream;
}
return MSG_HANDLED_STOP;
}
