void Quit()
{
StopMusic();
alureUpdateInterval(0);
alureSleep(0.1f);
alureShutdownDevice();
}
ALuint AsyncPlayFunc(ALvoid*)
{
EnterCriticalSection(&cs_StreamPlay);
while(CurrentInterval > 0.0f)
{
alureUpdate();
ALfloat interval = CurrentInterval;
LeaveCriticalSection(&cs_StreamPlay);
alureSleep(interval);
EnterCriticalSection(&cs_StreamPlay);
}
LeaveCriticalSection(&cs_StreamPlay);
return 0;
}
void Sound::run() {
QFile audio_file(mResourcePath);
if(audio_file.open(QIODevice::ReadOnly)) {
QByteArray audio_data = audio_file.readAll();
audio_file.close();
ALuint src, buf;
buf = alureCreateBufferFromMemory((const unsigned char*)audio_data.constData(), audio_data.size());
alGenSources(1, &src);
if(alGetError() != AL_NO_ERROR) {
qDebug() << "Failed to create OpenAL source!";
}
if(!buf) {
qDebug() << "Could not load sound: " << alureGetErrorString();
alDeleteSources(1, &src);
}
alSourcei(src, AL_BUFFER, buf);
alSourcef(src, AL_GAIN, 0.8f * mVolume);
if(alurePlaySource(src, eos_callback, this) == AL_FALSE) {
qDebug() << "Failed to start source!";
alDeleteSources(1, &src);
alDeleteBuffers(1, &buf);
}
while(!mIsDone) {
alureSleep(0.125);
alureUpdate();
}
alDeleteSources(1, &src);
alDeleteBuffers(1, &buf);
}
}
int main () {
if (!alureInitDevice(NULL, NULL)) {
std::fprintf(stderr, "Failed to open OpenAL device: %s\n", alureGetErrorString());
return 1;
}
alGenSources(1, &src);
if (alGetError() != AL_NO_ERROR) {
std::fprintf(stderr, "Failed to create OpenAL source!\n");
alureShutdownDevice();
return 1;
}
// Seeting Blip Buffer
synth.treble_eq( -18.0f );
synth.volume (0.80);
synth.output (&blipbuf);
// Init Blip Buffer with a buffer of 250ms (second paramter is time in ms)
if ( blipbuf.set_sample_rate( SR, 1000 / 4 ) ) {
std::fprintf(stderr, "Failed to create Blip Buffer! Our of Memory\n");
alureShutdownDevice();
return 1;
}
blipbuf.clock_rate( blipbuf.sample_rate() );
blipbuf.bass_freq(300); // Equalization like a TV speaker
stream = alureCreateStreamFromCallback (StreamCB, nullptr, AL_FORMAT_MONO16, SR, SR/2, 0, nullptr);
if(!stream) {
std::fprintf(stderr, "Error creating stream! %s\n", alureGetErrorString());
alDeleteSources(1, &src);
alureShutdownDevice();
return 1;
}
if (!alurePlaySourceStream(src, stream, 4, 0, eos_callback, NULL)) {
std::fprintf(stderr, "Failed to play stream: %s\n", alureGetErrorString());
isdone = 1;
}
alureUpdateInterval(0.005f); // Should be a independint thread playing the stream
while(!isdone) {
freq -= 1;
if (freq < 1) {
freq = 600;
}
alureSleep(0.02f);
}
alureStopSource(src, AL_FALSE);
alDeleteSources(1, &src);
alureDestroyStream(stream, 0, NULL);
alureShutdownDevice();
return 0;
}
ALuint AsyncPlayFunc(ALvoid*)
{
while(1)
{
EnterCriticalSection(&cs_StreamPlay);
if(AsyncPlayList.size() == 0)
{
StopThread(PlayThreadHandle);
PlayThreadHandle = NULL;
LeaveCriticalSection(&cs_StreamPlay);
break;
}
std::list<AsyncPlayEntry>::iterator i = AsyncPlayList.begin(),
end = AsyncPlayList.end();
while(i != end)
{
ALuint buf;
ALint processed;
ALint queued;
ALint state;
if(i->stream == NULL)
{
alGetSourcei(i->source, AL_SOURCE_STATE, &state);
if(state != AL_PLAYING && state != AL_PAUSED)
{
i->eos_callback(i->user_data, i->source);
i = AsyncPlayList.erase(i);
}
else i++;
continue;
}
alGetSourcei(i->source, AL_SOURCE_STATE, &state);
alGetSourcei(i->source, AL_BUFFERS_QUEUED, &queued);
alGetSourcei(i->source, AL_BUFFERS_PROCESSED, &processed);
while(processed > 0)
{
queued--;
processed--;
alSourceUnqueueBuffers(i->source, 1, &buf);
ALint size, channels, bits;
alGetBufferi(buf, AL_SIZE, &size);
alGetBufferi(buf, AL_CHANNELS, &channels);
alGetBufferi(buf, AL_BITS, &bits);
i->base_time += size / channels * 8 / bits;
i->base_time %= i->max_time;
while(!i->finished)
{
ALint filled = alureBufferDataFromStream(i->stream, 1, &buf);
if(filled > 0)
{
queued++;
alSourceQueueBuffers(i->source, 1, &buf);
if(i->loopcount == 0)
{
alGetBufferi(buf, AL_SIZE, &size);
alGetBufferi(buf, AL_CHANNELS, &channels);
alGetBufferi(buf, AL_BITS, &bits);
i->max_time += size / channels * 8 / bits;
}
break;
}
if(i->loopcount == i->maxloops)
{
i->finished = true;
break;
}
if(i->maxloops != -1)
i->loopcount++;
i->finished = !alureRewindStream(i->stream);
}
}
if(state != AL_PLAYING && state != AL_PAUSED)
{
if(queued == 0)
{
alSourcei(i->source, AL_BUFFER, 0);
alDeleteBuffers(i->buffers.size(), &i->buffers[0]);
if(i->eos_callback)
i->eos_callback(i->user_data, i->source);
i = AsyncPlayList.erase(i);
continue;
}
alSourcePlay(i->source);
}
i++;
}
LeaveCriticalSection(&cs_StreamPlay);
alureSleep(0.0078125f);
}
return 0;
}
