wyAudioPlayer::~wyAudioPlayer() {
    // ensure audio is stopped
    stop();
    
    // free temp buffer
	if(m_tempBuffer) {
		wyFree(m_tempBuffer);
		m_tempBuffer = NULL;
	}
    
	// free source
	if(m_stream->isSingleBuffer() && m_source != 0) {
		wyOpenAL::freeSource(m_source);
	}
    
	// free buffer
	alDeleteBuffers(m_stream->isSingleBuffer() ? 1 : MAX_BUFFER, m_buffers);
	wyFree(m_buffers);
    
    // release stream
    wyObjectRelease(m_stream);
}
Exemple #2
0
void KLAL_RebuildBuffer(KLAL* p)
{	
	if( !p )
		p = &klal;
	
	p->current = 0;//(p->current+1)%KLAL_AL_RINGNUM;
	
	if(p->bufid)
	{
		alSourcei( p->src, AL_BUFFER, 0 );
#if KLAL_ERRCHECK
		ALenum aen = alGetError();
		if( aen!=AL_NO_ERROR )
		{
			KLLog("[ KLAL ] %s %u\n", __func__, aen);
		}
#endif
		alDeleteBuffers( 1, &p->bufid );
#if KLAL_ERRCHECK
		aen = alGetError();
		if( aen!=AL_NO_ERROR )
		{
			KLLog("[ KLAL ] %s %u\n", __func__, aen);
		}
#endif
		p->bufid=0;
	}
	
	alGenBuffers(1, &p->bufid);

#if KLAL_ERRCHECK
	ALenum aen = alGetError();
	if( aen!=AL_NO_ERROR )
	{
		KLLog("[ KLAL ] %s %u\n", __func__, aen);
	}
#endif
	
}
Exemple #3
0
void Audio::playAudioBuffer(ALuint alSource, const int16_t *data, int samples, unsigned channels, int sampleRate)
{
    assert(channels == 1 || channels == 2);
    QMutexLocker locker(&audioLock);

    if (!(alOutDev && outputInitialized))
        return;

    ALuint bufid;
    ALint processed = 0, queued = 16;
    alGetSourcei(alSource, AL_BUFFERS_PROCESSED, &processed);
    alGetSourcei(alSource, AL_BUFFERS_QUEUED, &queued);
    alSourcei(alSource, AL_LOOPING, AL_FALSE);

    if (processed)
    {
        ALuint bufids[processed];
        alSourceUnqueueBuffers(alSource, processed, bufids);
        alDeleteBuffers(processed - 1, bufids + 1);
        bufid = bufids[0];
    }
    else if (queued < 16)
    {
        alGenBuffers(1, &bufid);
    }
    else
    {
        return;
    }

    alBufferData(bufid, (channels == 1) ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16, data,
                    samples * 2 * channels, sampleRate);
    alSourceQueueBuffers(alSource, 1, &bufid);

    ALint state;
    alGetSourcei(alSource, AL_SOURCE_STATE, &state);
    if (state != AL_PLAYING)
        alSourcePlay(alSource);
}
Exemple #4
0
	SoundEffect::~SoundEffect()
	{
		for (size_t i = 0; i < m_children.size(); i++)
		{
			m_children[i]->Stop();

			if (m_children[i]->m_isFireAndForget)
			{
				// return the instance to the queue
				m_instancePool.push_back(m_children[i]);
			}
			else
			{
				// unlink (we don't own the pointer, so it's someone else's job to delete the instance)
				m_children[i]->m_parent = nullptr;
			}
		}

#if defined NXNA_AUDIOENGINE_OPENAL
		alDeleteBuffers(1, (ALuint*)&m_buffer);
#endif
	}
Exemple #5
0
/**
 * @brief Close active audio output device
 */
void OpenAL2::cleanupOutput()
{
    OpenAL::cleanupOutput();

    if (echoCancelSupported) {
        alcMakeContextCurrent(alOutContext);
        alSourceStop(alProxySource);
        ALint processed = 0;
        ALuint bufids[PROXY_BUFFER_COUNT];
        alGetSourcei(alProxySource, AL_BUFFERS_PROCESSED, &processed);
        alSourceUnqueueBuffers(alProxySource, processed, bufids);
        alDeleteBuffers(processed, bufids);
        alcMakeContextCurrent(nullptr);
        alcDestroyContext(alOutContext);
        alOutContext = nullptr;
        alcCloseDevice(alOutDev);
        alOutDev = nullptr;
    } else {
        alOutContext = nullptr;
        alOutDev = nullptr;
    }
}
SoundManager::~SoundManager() {

	// Clear all the sources.
	for (int sourceIndex = 0; sourceIndex < SOUNDMANAGER_MAX_NBR_OF_SOURCES;
			sourceIndex++) {
		ALuint source = mSourceIds[sourceIndex];
		alDeleteSources(1, &source);

		ALenum error = alGetError();
		if (error != AL_NO_ERROR) {
			reportOpenALError(error);
		}
	}

	// Clear the buffers by iterating through the hash table keys
	QHashIterator<ALuint, ALuint> iterator(mAttachedSourceIds);

	while (iterator.hasNext()) {
		iterator.next();

		// Get the buffer id and delete it.
		ALuint bufferId = iterator.key();
		alDeleteBuffers(1, &bufferId);

		ALenum error = alGetError();
		if (error != AL_NO_ERROR) {
			reportOpenALError(error);
		}
	}

	// Clear the QHash for buffer IDs.
	mAttachedSourceIds.clear();

	// Exit the ALUT.
	if (alutExit() == false) {
		reportALUTError(alutGetError());
	}
}
Exemple #7
0
void KLAL_Unload(KLAL* p)
{	
	if( !p )
		p = &klal;
	
	if(p->isLoaded)
	{
		KLAL_Stop(p);
		alSourcei( p->src, AL_BUFFER, 0 );
#if KLAL_ERRCHECK
		ALenum aen = alGetError();
		if( aen!=AL_NO_ERROR )
		{
			KLLog("[ KLAL ] \n\tFile:%s\n\tLine:%u\n\tErr:%x\n", __FUNCTION__, __LINE__, aen);
		}
#endif
		alDeleteBuffers( 1, &p->bufid );
#if KLAL_ERRCHECK
		aen = alGetError();
		if( aen!=AL_NO_ERROR )
		{
			KLLog("[ KLAL ] \n\tFile:%s\n\tLine:%u\n\tErr:%x\n", __FUNCTION__, __LINE__, aen);
		}
#endif
		p->bufid = 0;
		alDeleteSources( 1, &p->src );
#if KLAL_ERRCHECK
		aen = alGetError();
		if( aen!=AL_NO_ERROR )
		{
			KLLog("[ KLAL ] \n\tFile:%s\n\tLine:%u\n\tErr:%x\n", __FUNCTION__, __LINE__, aen);
		}
#endif
		p->src = 0;
		sfree( p->pData );
		p->isLoaded = 0;
	}
}
    static void stopBackground(bool bReleaseData)
    {
		alSourceStop(s_backgroundSource);

		if (bReleaseData)
		{
			for (BackgroundMusicsMap::iterator it = s_backgroundMusics.begin(); it != s_backgroundMusics.end(); ++it)
			{
				if (it->second->source == s_backgroundSource)
				{
					alDeleteBuffers(1, &it->second->buffer);
					checkALError("stopBackground");
					alDeleteSources(1, &it->second->source);
					checkALError("stopBackground");
					delete it->second;
					s_backgroundMusics.erase(it);
					break;
				}
			}
		}

		s_backgroundSource = AL_NONE;
    }
Exemple #9
0
int play_sound_internal(Notification what, bool loop)
{
    uint32_t source;
    uint32_t buffer;

    m_open_device();

    alGenSources(1, &source);
    alGenBuffers(1, &buffer);
    buffer = alutCreateBufferFromFile(Control.sounds[what]);
    alSourcei(source, AL_BUFFER, buffer);
    alSourcei(source, AL_LOOPING, loop);

    int rc = play_source(source, buffer, loop);
    if (rc < 0) {
        alSourceStop(source);
        alDeleteSources(1, &source);
        alDeleteBuffers(1,&buffer);
        return -1;
    }

    return rc;
}
Exemple #10
0
void MALContext::deleteBuffer(unsigned int * bufferId)
{
    M_PROFILE_SCOPE(MALContext::deleteBuffer);
	if(*bufferId > 0)
	{
		// unlink sources
		map<unsigned int, unsigned int>::iterator
		mit (m_sources.begin()),
		mend(m_sources.end());

		for(;mit!=mend;++mit)
		{
		  if(mit->second == (*bufferId))
		  {
			  stopSource(mit->first);
			  setSourceBufferId(mit->first, 0);
		  }
		}	

		// delete buffer
		alDeleteBuffers(1, bufferId);
	}
}
Exemple #11
0
void EdenSoundUnload(EdenSound_t **sound_p)
{
    if (!sound_p) return;
    if (!(*sound_p)) return;
    
#ifdef EDEN_HAVE_OPENAL
    alSourceStop((*sound_p)->uiSource);
    alDeleteSources(1, &(*sound_p)->uiSource);
    alDeleteBuffers(1, &(*sound_p)->uiBuffer);
#endif // EDEN_HAVE_OPENAL
    
    free(*sound_p);
    *sound_p = NULL;

    // One-time cleanup.
    refCount--;
    if (refCount == 0) {
#ifdef EDEN_HAVE_OPENAL
        ALFWShutdownOpenAL();
        ALFWShutdown();
#endif // EDEN_HAVE_OPENAL
    }
}
Exemple #12
0
static void al_free(void *data)
{
   al_t *al = (al_t*)data;

   if (!al)
      return;

   alSourceStop(al->source);
   alDeleteSources(1, &al->source);

   if (al->buffers)
      alDeleteBuffers(al->num_buffers, al->buffers);

   free(al->buffers);
   free(al->res_buf);
   alcMakeContextCurrent(NULL);

   if (al->ctx)
      alcDestroyContext(al->ctx);
   if (al->handle)
      alcCloseDevice(al->handle);
   free(al);
}
Exemple #13
0
void OpenAL_AudioInterface::update(float time_increase)
{
	int i,state,nProcessed;
	OpenAL_Buffer buff;

	// process played buffers

	alGetSourcei(mSource,AL_BUFFERS_PROCESSED,&nProcessed);
	for (i=0;i<nProcessed;i++)
	{
		buff=mBufferQueue.front();
		mBufferQueue.pop();
		mNumPlayedSamples+=buff.nSamples;
		alSourceUnqueueBuffers(mSource,1,&buff.id);
		alDeleteBuffers(1,&buff.id);
	}

	// control playback and return time position
	alGetSourcei(mSource,AL_SOURCE_STATE,&state);
	if (state == AL_PLAYING)
	{
		alGetSourcef(mSource,AL_SEC_OFFSET,&mTime);
		mTime+=(float) mNumPlayedSamples/mFreq;
		mTimeOffset=0;
	}
	else
	{
		mTime=(float) mNumProcessedSamples/mFreq+mTimeOffset;
		mTimeOffset+=time_increase;
	}

    //Deactivated output
	//if (mTimeOffset > 0) printf("%.2f\n",mTimeOffset);

	float duration=mClip->getDuration();
	if (mTime > duration) mTime=duration;
}
Exemple #14
0
/*!
	Destroyes the stream.
*/
	Stream::~Stream()
	{
		if( isPlaying() )
		{
			stopSound();
		}

		release();

		alDeleteBuffers( NUMBUFFERSOGG, _uiBuffers );

		if( _pDecodeBuffer )
		{
			free( _pDecodeBuffer );
			_pDecodeBuffer = NULL;
		}

		//fn_ov_clear(sOggVorbisFile);
		if( _sOggVorbisFile )
		{
			delete( _sOggVorbisFile );
		}

	}
void SimpleAudioEngine::unloadEffect(const char* pszFilePath)
{
    // Changing file path to full path
    std::string fullPath = FileUtils::getInstance()->fullPathForFilename(pszFilePath);

    EffectsMap::iterator iter = s_effects.find(fullPath);

    if (iter != s_effects.end())
    {
        checkALError("unloadEffect:init");

        alSourceStop(iter->second->source);
        checkALError("unloadEffect:alSourceStop");

        alDeleteSources(1, &iter->second->source);
        checkALError("unloadEffect:DeletSources");

        alDeleteBuffers(1, &iter->second->buffer);
        checkALError("unloadEffect:alDeleteBuffers");
        delete iter->second;

        s_effects.erase(iter);
    }
}
Exemple #16
0
osaOpenAL::~osaOpenAL()
{
    delete SoundSettings;
    SoundSettings = 0;
    delete CAIHeader;
    CAIHeader = 0;
    delete WAVHeader;
    WAVHeader = 0;

    if (SoundFile){
        fclose(SoundFile);
    }

    if (Data){
        alDeleteBuffers(1, SoundBuffer);
        alDeleteSources(1, SoundSource);
        delete[] Data;
    }

    if (!CloseOpenAL()) {
        CMN_LOG_CLASS_RUN_ERROR << "Failed to close OpenAL" << std::endl;
    }

}
Exemple #17
0
        SoundAL::~SoundAL()
        {
            if (sourceId)
            {
                alSourceStop(sourceId);
                alSourcei(sourceId, AL_BUFFER, 0);
                alDeleteSources(1, &sourceId);

                if (AudioAL::checkOpenALError())
                {
                    log("Failed to delete OpenAL source");
                }
            }

            if (outputBuffer)
            {
                alDeleteBuffers(1, &outputBuffer);

                if (AudioAL::checkOpenALError())
                {
                    log("Failed to delete OpenAL buffer");
                }
            }
        }
Exemple #18
0
DWORD WINAPI stream_run(void * data)
{
  SoundThread * me = (SoundThread *) data;
  while(me->running) {
    if(me->sound) {
      Sound * sound = me->sound;
      ALuint uiSource;
      ALint iState = AL_PLAYING;
      ALuint uiBuffers[1];

      alGenBuffers(1, uiBuffers);
      alGenSources(1, &uiSource);
      alBufferData(uiBuffers[0], sound->format, sound->data, sound->size, sound->freq);
      assert(AL_NO_ERROR == alGetError());
      alSourceQueueBuffers(uiSource, 1, &uiBuffers[0]);
      alSourcef(uiSource, AL_GAIN, sound->volume);
      alSourcePlay(uiSource);

      while(iState == AL_PLAYING) {
        Sleep(16);
        alGetSourcei(uiSource, AL_SOURCE_STATE, &iState);
      }

      alSourceStop(uiSource);
      alSourcei(uiSource, AL_BUFFER, 0);

      alDeleteSources(1, &uiSource);
      alDeleteBuffers(1, uiBuffers);

      me->occupied = false;
      me->sound = 0;
    }
    if(me->running) SuspendThread(me->handle);
  }
  return 0;
}
Exemple #19
0
/**
Play a 44100Hz mono 16bit PCM sound
*/
void Audio::playMono16Sound(const QByteArray& data)
{
    QMutexLocker lock(&audioOutLock);

    if (!alOutDev)
    {
        if (!openOutput(Settings::getInstance().getOutDev()))
            return;
    }

    ALuint buffer;
    alGenBuffers(1, &buffer);
    alBufferData(buffer, AL_FORMAT_MONO16, data.data(), data.size(), 44100);
    alSourcef(alMainSource, AL_GAIN, outputVolume);
    alSourcei(alMainSource, AL_BUFFER, buffer);
    alSourcePlay(alMainSource);

    ALint sizeInBytes;
    ALint channels;
    ALint bits;

    alGetBufferi(buffer, AL_SIZE, &sizeInBytes);
    alGetBufferi(buffer, AL_CHANNELS, &channels);
    alGetBufferi(buffer, AL_BITS, &bits);
    int lengthInSamples = sizeInBytes * 8 / (channels * bits);

    ALint frequency;
    alGetBufferi(buffer, AL_FREQUENCY, &frequency);
    qreal duration = (lengthInSamples / static_cast<qreal>(frequency)) * 1000;
    int remaining = timer->interval();

    if (duration > remaining)
        timer->start(duration);

    alDeleteBuffers(1, &buffer);
}
Exemple #20
0
void playSound() {
    char * sound [] = {"scale-a6.wav", "scale-c6.wav", "scale-c7.wav"
        , "scale-d6.wav", "scale-e6.wav", "scale-f6.wav",
        "scale-g6.wav", "scale-h6.wav"};
    int index = rand() % 8;
    ALuint buffer, source;
    ALuint state;

    // Initialize the environment
    alutInit(0, NULL);

    // Capture errors
    alGetError();

    // Load pcm data into buffer
    buffer = alutCreateBufferFromFile(sound[index]);

    // Create sound source (use buffer to fill source)
    alGenSources(1, &source);
    alSourcei(source, AL_BUFFER, buffer);

    // Play
    alSourcePlay(source);

    // Wait for the song to complete
    do {
        alGetSourcei(source, AL_SOURCE_STATE, &state);
    } while (state == AL_PLAYING);

    // Clean up sources and buffers
    alDeleteSources(1, &source);
    alDeleteBuffers(1, &buffer);

    // Exit everything
    alutExit();
}
void CsAudioManager::Cleanup()  {

	//for (int i = 0; i < mSourceList.size(); i++) {
	//	mSourceList[i]->UnloadSource();
	//}
	mSourceList.clear();
    alDeleteBuffers(NUM_SOUNDS, Buffer);
    ALCcontext* pCurContext;
    ALCdevice* pCurDevice;

    // Get the current context.
    pCurContext = alcGetCurrentContext();

    // Get the device used by that context.
    pCurDevice = alcGetContextsDevice(pCurContext);

    // Reset the current context to NULL.
    alcMakeContextCurrent(0);

    // Release the context and the device.
    alcDestroyContext(pCurContext);
    alcCloseDevice(pCurDevice);

}
Exemple #22
0
VoiceMessages::~VoiceMessages() {
	{
		QMutexLocker lock(&voicemsgsMutex);
		voicemsgs = 0;
	}

	for (int32 i = 0; i < AudioVoiceMsgSimultaneously; ++i) {
		alSourceStop(_data[i].source);
		if (alIsBuffer(_data[i].buffers[0])) {
			alDeleteBuffers(3, _data[i].buffers);
			for (int32 j = 0; j < 3; ++j) {
				_data[i].buffers[j] = _data[i].samplesCount[j] = 0;
			}
		}
		if (alIsSource(_data[i].source)) {
			alDeleteSources(1, &_data[i].source);
			_data[i].source = 0;
		}
	}
	_faderThread.quit();
	_loaderThread.quit();
	_faderThread.wait();
	_loaderThread.wait();
}
Exemple #23
0
void ttLibC_AlPlayer_close(ttLibC_AlPlayer **player) {
	ttLibC_AlPlayer_ *target = (ttLibC_AlPlayer_ *)*player;
	if(target == NULL) {
		return;
	}
	if(target->source != 0) {
		alDeleteSources(1, &target->source);
	}
	for(uint32_t i = 0;i < target->total_buffer_num;++ i) {
		if(target->buffers[i] != 0) {
			alDeleteBuffers(1, &target->buffers[i]);
			target->buffers[i] = 0;
		}
	}
	if(target->context != NULL) {
		alcMakeContextCurrent(NULL);
		alcDestroyContext(target->context);
	}
	if(target->device != NULL) {
		alcCloseDevice(target->device);
	}
	ttLibC_free(target);
	*player = NULL;
}
void x_async_snd_shutdown()
{
	
	if (!g_sound.g_audio_enable)
		return ;
	
	printf("async_snd_shutdown\n");

	if (!dev)
	{
		printf("err: openal device not initialized\n");
		return ;
	}
	alDeleteSources(1, &source);
	source = 0;
	alDeleteBuffers(AL_NUM_BUFFERS, buffers);

	alcMakeContextCurrent(NULL);
	alcDestroyContext(ctx);
	ctx=NULL;
	alcCloseDevice(dev);
	dev=NULL;

}
	//
	// background audio
	//
    void SimpleAudioEngine::preloadBackgroundMusic(const char* pszFilePath)
	{
		if (!s_isBackgroundInitialized || s_currentBackgroundStr != pszFilePath)
		{
			string path = pszFilePath;

			if (isOGGFile(path.data()))
			{
				s_backgroundBuffer = createBufferFromOGG(path.data());
			}
			else
			{
				s_backgroundBuffer = alutCreateBufferFromFile(path.data());
			}

			checkALError("preloadBackgroundMusic");

			if (s_backgroundBuffer == AL_NONE)
			{
				fprintf(stderr, "Error loading file: '%s'\n", path.data());
				alDeleteBuffers(1, &s_backgroundBuffer);
				return;
			}

			alGenSources(1, &s_backgroundSource);
			checkALError("preloadBackgroundMusic");

			alSourcei(s_backgroundSource, AL_BUFFER, s_backgroundBuffer);
			checkALError("preloadBackgroundMusic");

			s_currentBackgroundStr = pszFilePath;
		}

		s_currentBackgroundStr 	  = pszFilePath;
		s_isBackgroundInitialized = true;
	}
Exemple #26
0
////////////////////////////////////////////////////////////
/// Load sound into buffer
////////////////////////////////////////////////////////////
void SoundBufferLoad(struct Sound * SoundStruct, char * File)
{
	UInt32 MinorTime = 0; // Minor time means the most old file
	UInt32 Dimension = 0; // Dimension found
	Int32 i = 0;

	// Search if the sound is loaded
	for (i = 0; i < SOUND_BUFFER_SIZE; i++)
	{
		if (SoundData[i].File != NULL)
		{
			if (strcmp(SoundData[i].File, File) == 0)
			{
				// The sound is loaded.. just play it
				SoundStruct = &SoundData[i];
				return;
			}
		}
	}

	// Search free sound
	for (i = 0; i < SOUND_BUFFER_SIZE; i++)
	{
		if (SoundData[i].Buffer == 0)
		{
			// Load sound
			if (SOUND_FROM_MEMORY)
			{
				char * BufferData;
				UInt32 BufferSize;

				// Load buffer from pack
				// if (!PackLoadData(File, BufferData, &BufferSize))
				// {
				//	return;
				// }

				// Load buffer data from memory
				if (SoundFileOpenReadFromMemory(SoundStruct, BufferData, BufferSize))
				{
					// Destroy data
					Delete(BufferData);
					return;
				}
			}
			else
			{
				if (SoundFileOpenReadFromFile(SoundStruct, File))
				{
					strcpy(SoundStruct->File, File);
					return;
				}
			}
		}
	}

	// Search last used
	for (i = 0; i < SOUND_BUFFER_SIZE; i++)
	{
		if (SoundStatus(&SoundData[i]) == Stopped)
		{
			if (SoundData[i].Time < MinorTime)
			{
				MinorTime = SoundData[i].Time;
				Dimension = i;
			}
		}
	}

	if (MinorTime != 0)
	{
		if (SoundData[Dimension].Buffer != 0)
		{
			// Remove data from the previous sound
			ALCheck(alDeleteBuffers(1, &SoundData[Dimension].Buffer));

			// Delete source
			ALCheck(alDeleteSources(1, &SoundData[Dimension].Source));
		}

		// Return last used
		SoundStruct = &SoundData[Dimension];
	}
	else
	{
		// There isn't sounds available
		SoundStruct = NULL;
	}
}
Exemple #27
0
/*
 * void KillALData()
 *
 *	We have allocated memory for our buffers and sources which needs
 *	to be returned to the system. This function frees that memory.
 */
void KillALData()
{
    alDeleteBuffers(1, &Buffer);
    alDeleteSources(1, &Source);
    alutExit();
}
Exemple #28
0
void dll_al_DeleteBuffers(ALsizei n, ALuint *buffers) { alDeleteBuffers(n, buffers); }
Exemple #29
0
	bool SoundBuffer::Create(AudioFormat format, unsigned int sampleCount, unsigned int sampleRate, const Int16* samples)
	{
		Destroy();

		#if NAZARA_AUDIO_SAFE
		if (!IsFormatSupported(format))
		{
			NazaraError("Audio format is not supported");
			return false;
		}

		if (sampleCount == 0)
		{
			NazaraError("Sample rate must be different from zero");
			return false;
		}

		if (sampleRate == 0)
		{
			NazaraError("Sample rate must be different from zero");
			return false;
		}

		if (!samples)
		{
			NazaraError("Invalid sample source");
			return false;
		}
		#endif

		// On vide le stack d'erreurs
		while (alGetError() != AL_NO_ERROR);

		ALuint buffer;
		alGenBuffers(1, &buffer);

		if (alGetError() != AL_NO_ERROR)
		{
			NazaraError("Failed to create OpenAL buffer");
			return false;
		}

		alBufferData(buffer, OpenAL::AudioFormat[format], samples, sampleCount*sizeof(Int16), sampleRate);

		if (alGetError() != AL_NO_ERROR)
		{
			alDeleteBuffers(1, &buffer);

			NazaraError("Failed to set OpenAL buffer");
			return false;
		}

		m_impl = new SoundBufferImpl;
		m_impl->buffer = buffer;
		m_impl->duration = (1000*sampleCount / (format * sampleRate));
		m_impl->format = format;
		m_impl->sampleCount = sampleCount;
		m_impl->sampleRate = sampleRate;
		m_impl->samples.reset(new Int16[sampleCount]);
		std::memcpy(&m_impl->samples[0], samples, sampleCount*sizeof(Int16));

		return true;
	}
Exemple #30
0
/// Initialize OpenAl and return true on success.
// TODO rewrite with std::unique_ptr and custom deleter to remove long
// chain of "destructor" code.
void Sound::Impl::InitOpenAL() {
    ALCcontext *context;
    ALCdevice *device;
    ALenum error_code;
    ALboolean status;

    device = alcOpenDevice(nullptr);

    if (!device) {
        ErrorLogger() << "Unable to initialise default OpenAL device.";
        m_initialized = false;
        return;
    }

    context = alcCreateContext(device, nullptr);
    if (!context) {
        error_code = alGetError();
        ErrorLogger() << "Unable to create OpenAL context: " << alGetString(error_code) << "\n";
        alcCloseDevice(device);
        m_initialized = false;
        return;
    }

    status = alcMakeContextCurrent(context);
    error_code = alGetError();
    if (status != AL_TRUE || error_code != AL_NO_ERROR) {
        ErrorLogger() << "Unable to make OpenAL context current: " << alGetString(error_code) << "\n";
        alcDestroyContext(context);
        alcCloseDevice(device);
        m_initialized = false;
        return;
    }

    alListenerf(AL_GAIN, 1.0);
    error_code = alGetError();
    if (error_code != AL_NO_ERROR) {
        ErrorLogger() << "Unable to create OpenAL listener: " << alGetString(error_code) << "\n" << "Disabling OpenAL sound system!\n";
        alcMakeContextCurrent(nullptr);
        alcDestroyContext(context);
        alcCloseDevice(device);
        m_initialized = false;
        return;
    }

    alGenSources(NUM_SOURCES, m_sources);
    error_code = alGetError();
    if (error_code != AL_NO_ERROR) {
        ErrorLogger() << "Unable to create OpenAL sources: " << alGetString(error_code) << "\n" << "Disabling OpenAL sound system!\n";
        alcMakeContextCurrent(nullptr);
        alcDestroyContext(context);
        alcCloseDevice(device);
        m_initialized = false;
        return;
    }

    alGenBuffers(NUM_MUSIC_BUFFERS, m_music_buffers);
    error_code = alGetError();
    if (error_code != AL_NO_ERROR) {
        ErrorLogger() << "Unable to create OpenAL buffers: " << alGetString(error_code) << "\n" << "Disabling OpenAL sound system!\n";
        alDeleteSources(NUM_SOURCES, m_sources);
        alcMakeContextCurrent(nullptr);
        alcDestroyContext(context);
        alcCloseDevice(device);
        m_initialized = false;
        return;
    }

    for (int i = 0; i < NUM_SOURCES; ++i) {
        alSourcei(m_sources[i], AL_SOURCE_RELATIVE, AL_TRUE);
        error_code = alGetError();
        if (error_code != AL_NO_ERROR) {
            ErrorLogger() << "Unable to set OpenAL source to relative: " << alGetString(error_code) << "\n" << "Disabling OpenAL sound system!\n";
            alDeleteBuffers(NUM_MUSIC_BUFFERS, m_music_buffers);
            alDeleteSources(NUM_SOURCES, m_sources);
            alcMakeContextCurrent(nullptr);
            alcDestroyContext(context);
            alcCloseDevice(device);
            m_initialized = false;
            return;
        }
    }
    DebugLogger() << "OpenAL initialized. Version "
                  << alGetString(AL_VERSION)
                  << " Renderer "
                  << alGetString(AL_RENDERER)
                  << " Vendor "
                  << alGetString(AL_VENDOR) << "\n"
                  << " Extensions: "
                  << alGetString(AL_EXTENSIONS) << "\n";
    m_initialized = true;
}