1783 lines
32 KiB
C++
1783 lines
32 KiB
C++
/*
|
|
** audio.cpp
|
|
**
|
|
** This file is part of mkxp.
|
|
**
|
|
** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
|
|
**
|
|
** mkxp is free software: you can redistribute it and/or modify
|
|
** it under the terms of the GNU General Public License as published by
|
|
** the Free Software Foundation, either version 2 of the License, or
|
|
** (at your option) any later version.
|
|
**
|
|
** mkxp is distributed in the hope that it will be useful,
|
|
** but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
** GNU General Public License for more details.
|
|
**
|
|
** You should have received a copy of the GNU General Public License
|
|
** along with mkxp. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "audio.h"
|
|
|
|
#include "sharedstate.h"
|
|
#include "util.h"
|
|
#include "intrulist.h"
|
|
#include "filesystem.h"
|
|
#include "exception.h"
|
|
#include "al-util.h"
|
|
#include "boost-hash.h"
|
|
#include "debugwriter.h"
|
|
|
|
#include <vector>
|
|
#include <string>
|
|
#include <assert.h>
|
|
|
|
#include <SDL_audio.h>
|
|
#include <SDL_thread.h>
|
|
#include <SDL_endian.h>
|
|
#include <SDL_timer.h>
|
|
#include <SDL_sound.h>
|
|
|
|
#ifdef RGSS2
|
|
#define OV_EXCLUDE_STATIC_CALLBACKS
|
|
#include <vorbis/vorbisfile.h>
|
|
#endif
|
|
|
|
#include <alc.h>
|
|
|
|
#define AUDIO_SLEEP 10
|
|
#define SE_SOURCES 6
|
|
#define SE_CACHE_MEM (10*1024*1024) // 10 MB
|
|
|
|
static uint8_t formatSampleSize(int sdlFormat)
|
|
{
|
|
switch (sdlFormat)
|
|
{
|
|
case AUDIO_U8 :
|
|
case AUDIO_S8 :
|
|
return 1;
|
|
|
|
case AUDIO_U16LSB :
|
|
case AUDIO_U16MSB :
|
|
case AUDIO_S16LSB :
|
|
case AUDIO_S16MSB :
|
|
return 2;
|
|
|
|
default:
|
|
Debug() << "Unhandled sample format";
|
|
abort();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static ALenum chooseALFormat(int sampleSize, int channelCount)
|
|
{
|
|
switch (sampleSize)
|
|
{
|
|
case 1 :
|
|
switch (channelCount)
|
|
{
|
|
case 1 : return AL_FORMAT_MONO8;
|
|
case 2 : return AL_FORMAT_STEREO8;
|
|
default: abort();
|
|
}
|
|
case 2 :
|
|
switch (channelCount)
|
|
{
|
|
case 1 : return AL_FORMAT_MONO16;
|
|
case 2 : return AL_FORMAT_STEREO16;
|
|
default : abort();
|
|
}
|
|
default : abort();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const int streamBufSize = 32768;
|
|
|
|
struct SoundBuffer
|
|
{
|
|
/* Uniquely identifies this or equal buffer */
|
|
std::string key;
|
|
|
|
AL::Buffer::ID alBuffer;
|
|
|
|
/* Link into the buffer cache priority list */
|
|
IntruListLink<SoundBuffer> link;
|
|
|
|
/* Buffer byte count */
|
|
uint32_t bytes;
|
|
|
|
/* Reference count */
|
|
uint8_t refCount;
|
|
|
|
SoundBuffer()
|
|
: link(this),
|
|
refCount(1)
|
|
|
|
{
|
|
alBuffer = AL::Buffer::gen();
|
|
}
|
|
|
|
static SoundBuffer *ref(SoundBuffer *buffer)
|
|
{
|
|
++buffer->refCount;
|
|
|
|
return buffer;
|
|
}
|
|
|
|
static void deref(SoundBuffer *buffer)
|
|
{
|
|
if (--buffer->refCount == 0)
|
|
delete buffer;
|
|
}
|
|
|
|
private:
|
|
~SoundBuffer()
|
|
{
|
|
AL::Buffer::del(alBuffer);
|
|
}
|
|
};
|
|
|
|
struct SoundEmitter
|
|
{
|
|
typedef BoostHash<std::string, SoundBuffer*> BufferHash;
|
|
|
|
IntruList<SoundBuffer> buffers;
|
|
BufferHash bufferHash;
|
|
|
|
/* Byte count sum of all cached / playing buffers */
|
|
uint32_t bufferBytes;
|
|
|
|
AL::Source::ID alSrcs[SE_SOURCES];
|
|
SoundBuffer *atchBufs[SE_SOURCES];
|
|
/* Index of next source to be used */
|
|
int srcIndex;
|
|
|
|
SoundEmitter()
|
|
: bufferBytes(0),
|
|
srcIndex(0)
|
|
{
|
|
for (int i = 0; i < SE_SOURCES; ++i)
|
|
{
|
|
alSrcs[i] = AL::Source::gen();
|
|
atchBufs[i] = 0;
|
|
}
|
|
}
|
|
|
|
~SoundEmitter()
|
|
{
|
|
for (int i = 0; i < SE_SOURCES; ++i)
|
|
{
|
|
AL::Source::stop(alSrcs[i]);
|
|
AL::Source::del(alSrcs[i]);
|
|
|
|
if (atchBufs[i])
|
|
SoundBuffer::deref(atchBufs[i]);
|
|
}
|
|
|
|
BufferHash::const_iterator iter;
|
|
for (iter = bufferHash.cbegin(); iter != bufferHash.cend(); ++iter)
|
|
SoundBuffer::deref(iter->second);
|
|
}
|
|
|
|
void play(const std::string &filename,
|
|
int volume,
|
|
int pitch)
|
|
{
|
|
float _volume = clamp<int>(volume, 0, 100) / 100.f;
|
|
float _pitch = clamp<int>(pitch, 50, 150) / 100.f;
|
|
|
|
SoundBuffer *buffer = allocateBuffer(filename);
|
|
|
|
int soundIndex = srcIndex++;
|
|
if (srcIndex > SE_SOURCES-1)
|
|
srcIndex = 0;
|
|
|
|
AL::Source::ID src = alSrcs[soundIndex];
|
|
AL::Source::stop(src);
|
|
AL::Source::detachBuffer(src);
|
|
|
|
SoundBuffer *old = atchBufs[soundIndex];
|
|
|
|
if (old)
|
|
SoundBuffer::deref(old);
|
|
|
|
atchBufs[soundIndex] = SoundBuffer::ref(buffer);
|
|
|
|
AL::Source::attachBuffer(src, buffer->alBuffer);
|
|
|
|
AL::Source::setVolume(src, _volume);
|
|
AL::Source::setPitch(src, _pitch);
|
|
|
|
AL::Source::play(src);
|
|
}
|
|
|
|
void stop()
|
|
{
|
|
for (int i = 0; i < SE_SOURCES; i++)
|
|
AL::Source::stop(alSrcs[i]);
|
|
}
|
|
|
|
private:
|
|
SoundBuffer *allocateBuffer(const std::string &filename)
|
|
{
|
|
SoundBuffer *buffer = bufferHash.value(filename, 0);
|
|
|
|
if (buffer)
|
|
{
|
|
/* Buffer still in cashe.
|
|
* Move to front of priority list */
|
|
buffers.remove(buffer->link);
|
|
buffers.append(buffer->link);
|
|
|
|
return buffer;
|
|
}
|
|
else
|
|
{
|
|
/* Buffer not in cashe, needs to be loaded */
|
|
SDL_RWops dataSource;
|
|
const char *extension;
|
|
|
|
shState->fileSystem().openRead(dataSource, filename.c_str(),
|
|
FileSystem::Audio, false, &extension);
|
|
|
|
Sound_Sample *sampleHandle = Sound_NewSample(&dataSource, extension, 0, streamBufSize);
|
|
|
|
if (!sampleHandle)
|
|
{
|
|
SDL_RWclose(&dataSource);
|
|
throw Exception(Exception::SDLError, "SDL_sound: %s", Sound_GetError());
|
|
}
|
|
|
|
uint32_t decBytes = Sound_DecodeAll(sampleHandle);
|
|
uint8_t sampleSize = formatSampleSize(sampleHandle->actual.format);
|
|
uint32_t sampleCount = decBytes / sampleSize;
|
|
|
|
buffer = new SoundBuffer;
|
|
buffer->key = filename;
|
|
buffer->bytes = sampleSize * sampleCount;
|
|
|
|
ALenum alFormat = chooseALFormat(sampleSize, sampleHandle->actual.channels);
|
|
|
|
AL::Buffer::uploadData(buffer->alBuffer, alFormat, sampleHandle->buffer,
|
|
buffer->bytes, sampleHandle->actual.rate);
|
|
|
|
Sound_FreeSample(sampleHandle);
|
|
|
|
uint32_t wouldBeBytes = bufferBytes + buffer->bytes;
|
|
|
|
/* If memory limit is reached, delete lowest priority buffer
|
|
* until there is room or no buffers left */
|
|
while (wouldBeBytes > SE_CACHE_MEM && !buffers.isEmpty())
|
|
{
|
|
SoundBuffer *last = buffers.tail();
|
|
bufferHash.erase(last->key);
|
|
buffers.remove(last->link);
|
|
|
|
wouldBeBytes -= last->bytes;
|
|
|
|
SoundBuffer::deref(last);
|
|
}
|
|
|
|
bufferHash.insert(filename, buffer);
|
|
buffers.prepend(buffer->link);
|
|
|
|
bufferBytes = wouldBeBytes;
|
|
|
|
return buffer;
|
|
}
|
|
}
|
|
};
|
|
|
|
static const int streamBufs = 3;
|
|
|
|
struct ALDataSource
|
|
{
|
|
enum Status
|
|
{
|
|
NoError,
|
|
EndOfStream,
|
|
WrapAround,
|
|
Error
|
|
};
|
|
|
|
virtual ~ALDataSource() {}
|
|
|
|
/* Read/process next chunk of data, and attach it
|
|
* to provided AL buffer */
|
|
virtual Status fillBuffer(AL::Buffer::ID alBuffer) = 0;
|
|
|
|
virtual int sampleRate() = 0;
|
|
|
|
virtual void seekToOffset(float seconds) = 0;
|
|
|
|
/* Seek back to start */
|
|
virtual void reset() = 0;
|
|
|
|
/* The frame count right after wrap around */
|
|
virtual uint32_t loopStartFrames() = 0;
|
|
};
|
|
|
|
struct SDLSoundSource : ALDataSource
|
|
{
|
|
Sound_Sample *sample;
|
|
SDL_RWops &srcOps;
|
|
uint8_t sampleSize;
|
|
bool looped;
|
|
|
|
ALenum alFormat;
|
|
ALsizei alFreq;
|
|
|
|
SDLSoundSource(SDL_RWops &ops,
|
|
const char *extension,
|
|
uint32_t maxBufSize,
|
|
bool looped)
|
|
: srcOps(ops),
|
|
looped(looped)
|
|
{
|
|
sample = Sound_NewSample(&srcOps, extension, 0, maxBufSize);
|
|
|
|
if (!sample)
|
|
{
|
|
SDL_RWclose(&ops);
|
|
throw Exception(Exception::SDLError, "SDL_sound: %s", Sound_GetError());
|
|
}
|
|
|
|
sampleSize = formatSampleSize(sample->actual.format);
|
|
|
|
alFormat = chooseALFormat(sampleSize, sample->actual.channels);
|
|
alFreq = sample->actual.rate;
|
|
}
|
|
|
|
~SDLSoundSource()
|
|
{
|
|
/* This also closes 'srcOps' */
|
|
Sound_FreeSample(sample);
|
|
}
|
|
|
|
Status fillBuffer(AL::Buffer::ID alBuffer)
|
|
{
|
|
uint32_t decoded = Sound_Decode(sample);
|
|
|
|
if (sample->flags & SOUND_SAMPLEFLAG_EAGAIN)
|
|
{
|
|
/* Try to decode one more time on EAGAIN */
|
|
decoded = Sound_Decode(sample);
|
|
|
|
/* Give up */
|
|
if (sample->flags & SOUND_SAMPLEFLAG_EAGAIN)
|
|
return ALDataSource::Error;
|
|
}
|
|
|
|
if (sample->flags & SOUND_SAMPLEFLAG_ERROR)
|
|
return ALDataSource::Error;
|
|
|
|
AL::Buffer::uploadData(alBuffer, alFormat, sample->buffer, decoded, alFreq);
|
|
|
|
if (sample->flags & SOUND_SAMPLEFLAG_EOF)
|
|
{
|
|
if (looped)
|
|
{
|
|
Sound_Rewind(sample);
|
|
return ALDataSource::WrapAround;
|
|
}
|
|
else
|
|
{
|
|
return ALDataSource::EndOfStream;
|
|
}
|
|
}
|
|
|
|
return ALDataSource::NoError;
|
|
}
|
|
|
|
int sampleRate()
|
|
{
|
|
return sample->actual.rate;
|
|
}
|
|
|
|
void seekToOffset(float seconds)
|
|
{
|
|
Sound_Seek(sample, static_cast<uint32_t>(seconds * 1000));
|
|
}
|
|
|
|
void reset()
|
|
{
|
|
Sound_Rewind(sample);
|
|
}
|
|
|
|
uint32_t loopStartFrames()
|
|
{
|
|
/* Loops from the beginning of the file */
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
#ifdef RGSS2
|
|
static size_t vfRead(void *ptr, size_t size, size_t nmemb, void *ops)
|
|
{
|
|
return SDL_RWread(static_cast<SDL_RWops*>(ops), ptr, size, nmemb);
|
|
}
|
|
|
|
static int vfSeek(void *ops, ogg_int64_t offset, int whence)
|
|
{
|
|
return SDL_RWseek(static_cast<SDL_RWops*>(ops), offset, whence);
|
|
}
|
|
|
|
static long vfTell(void *ops)
|
|
{
|
|
return SDL_RWtell(static_cast<SDL_RWops*>(ops));
|
|
}
|
|
|
|
static ov_callbacks OvCallbacks =
|
|
{
|
|
vfRead,
|
|
vfSeek,
|
|
0,
|
|
vfTell
|
|
};
|
|
|
|
|
|
struct VorbisSource : ALDataSource
|
|
{
|
|
SDL_RWops &src;
|
|
|
|
OggVorbis_File vf;
|
|
|
|
uint32_t currentFrame;
|
|
|
|
struct
|
|
{
|
|
uint32_t start;
|
|
uint32_t length;
|
|
uint32_t end;
|
|
bool valid;
|
|
bool requested;
|
|
} loop;
|
|
|
|
struct
|
|
{
|
|
int channels;
|
|
int rate;
|
|
int frameSize;
|
|
ALenum alFormat;
|
|
} info;
|
|
|
|
std::vector<int16_t> sampleBuf;
|
|
|
|
VorbisSource(SDL_RWops &ops,
|
|
bool looped)
|
|
: src(ops),
|
|
currentFrame(0)
|
|
{
|
|
int error = ov_open_callbacks(&src, &vf, 0, 0, OvCallbacks);
|
|
|
|
if (error)
|
|
{
|
|
SDL_RWclose(&src);
|
|
throw Exception(Exception::MKXPError,
|
|
"Vorbisfile: Cannot read ogg file");
|
|
}
|
|
|
|
/* Extract bitstream info */
|
|
info.channels = vf.vi->channels;
|
|
info.rate = vf.vi->rate;
|
|
|
|
if (info.channels > 2)
|
|
{
|
|
ov_clear(&vf);
|
|
SDL_RWclose(&src);
|
|
throw Exception(Exception::MKXPError,
|
|
"Cannot handle audio with more than 2 channels");
|
|
}
|
|
|
|
info.alFormat = chooseALFormat(sizeof(int16_t), info.channels);
|
|
info.frameSize = sizeof(int16_t) * info.channels;
|
|
|
|
sampleBuf.resize(streamBufSize);
|
|
|
|
loop.requested = looped;
|
|
loop.valid = false;
|
|
loop.start = loop.length = 0;
|
|
|
|
if (!loop.requested)
|
|
return;
|
|
|
|
/* Try to extract loop info */
|
|
for (int i = 0; i < vf.vc->comments; ++i)
|
|
{
|
|
char *comment = vf.vc->user_comments[i];
|
|
char *sep = strstr(comment, "=");
|
|
|
|
/* No '=' found */
|
|
if (!sep)
|
|
continue;
|
|
|
|
/* Empty value */
|
|
if (!*(sep+1))
|
|
continue;
|
|
|
|
*sep = '\0';
|
|
|
|
if (!strcmp(comment, "LOOPSTART"))
|
|
loop.start = strtol(sep+1, 0, 10);
|
|
|
|
if (!strcmp(comment, "LOOPLENGTH"))
|
|
loop.length = strtol(sep+1, 0, 10);
|
|
|
|
*sep = '=';
|
|
}
|
|
|
|
loop.end = loop.start + loop.length;
|
|
loop.valid = (loop.start && loop.length);
|
|
}
|
|
|
|
~VorbisSource()
|
|
{
|
|
ov_clear(&vf);
|
|
SDL_RWclose(&src);
|
|
}
|
|
|
|
int sampleRate()
|
|
{
|
|
return info.rate;
|
|
}
|
|
|
|
void seekToOffset(float seconds)
|
|
{
|
|
currentFrame = seconds * info.rate;
|
|
|
|
if (loop.valid && currentFrame > loop.end)
|
|
currentFrame = loop.start;
|
|
|
|
/* If seeking fails, just seek back to start */
|
|
if (ov_pcm_seek(&vf, currentFrame) != 0)
|
|
ov_raw_seek(&vf, 0);
|
|
}
|
|
|
|
Status fillBuffer(AL::Buffer::ID alBuffer)
|
|
{
|
|
void *bufPtr = sampleBuf.data();
|
|
int availBuf = sampleBuf.size();
|
|
int bufUsed = 0;
|
|
|
|
int canRead = availBuf;
|
|
|
|
Status retStatus = ALDataSource::NoError;
|
|
|
|
bool readAgain = false;
|
|
|
|
if (loop.valid)
|
|
{
|
|
int tilLoopEnd = loop.end * info.frameSize;
|
|
|
|
canRead = std::min(availBuf, tilLoopEnd);
|
|
}
|
|
|
|
while (canRead > 16)
|
|
{
|
|
long res = ov_read(&vf, static_cast<char*>(bufPtr),
|
|
canRead, 0, sizeof(int16_t), 1, 0);
|
|
|
|
if (res < 0)
|
|
{
|
|
/* Read error */
|
|
retStatus = ALDataSource::Error;
|
|
|
|
break;
|
|
}
|
|
|
|
if (res == 0)
|
|
{
|
|
/* EOF */
|
|
if (loop.requested)
|
|
{
|
|
retStatus = ALDataSource::WrapAround;
|
|
reset();
|
|
}
|
|
else
|
|
{
|
|
retStatus = ALDataSource::EndOfStream;
|
|
}
|
|
|
|
/* If we sought right to the end of the file,
|
|
* we might be EOF without actually having read
|
|
* any data at all yet (which mustn't happen),
|
|
* so we try to continue reading some data. */
|
|
if (bufUsed > 0)
|
|
break;
|
|
|
|
if (readAgain)
|
|
{
|
|
/* We're still not getting data though.
|
|
* Just error out to prevent an endless loop */
|
|
retStatus = ALDataSource::Error;
|
|
break;
|
|
}
|
|
|
|
readAgain = true;
|
|
}
|
|
|
|
bufUsed += (res / sizeof(int16_t));
|
|
bufPtr = &sampleBuf[bufUsed];
|
|
currentFrame += (res / info.frameSize);
|
|
|
|
if (loop.valid && currentFrame >= loop.end)
|
|
{
|
|
/* Determine how many frames we're
|
|
* over the loop end */
|
|
int discardFrames = currentFrame - loop.end;
|
|
bufUsed -= discardFrames * info.channels;
|
|
|
|
retStatus = ALDataSource::WrapAround;
|
|
|
|
/* Seek to loop start */
|
|
currentFrame = loop.start;
|
|
if (ov_pcm_seek(&vf, currentFrame) != 0)
|
|
retStatus = ALDataSource::Error;
|
|
|
|
break;
|
|
}
|
|
|
|
canRead -= res;
|
|
}
|
|
|
|
if (retStatus != ALDataSource::Error)
|
|
AL::Buffer::uploadData(alBuffer, info.alFormat, sampleBuf.data(),
|
|
bufUsed*sizeof(int16_t), info.rate);
|
|
|
|
return retStatus;
|
|
}
|
|
|
|
void reset()
|
|
{
|
|
ov_raw_seek(&vf, 0);
|
|
currentFrame = 0;
|
|
}
|
|
|
|
uint32_t loopStartFrames()
|
|
{
|
|
if (loop.valid)
|
|
return loop.start;
|
|
else
|
|
return 0;
|
|
}
|
|
};
|
|
#endif
|
|
|
|
/* State-machine like audio playback stream.
|
|
* This class is NOT thread safe */
|
|
struct ALStream
|
|
{
|
|
enum State
|
|
{
|
|
Closed,
|
|
Stopped,
|
|
Playing,
|
|
Paused
|
|
};
|
|
|
|
bool looped;
|
|
State state;
|
|
|
|
ALDataSource *source;
|
|
SDL_Thread *thread;
|
|
|
|
std::string threadName;
|
|
|
|
SDL_mutex *pauseMut;
|
|
bool preemptPause;
|
|
|
|
/* When this flag isn't set and alSrc is
|
|
* in 'STOPPED' state, stream isn't over
|
|
* (it just hasn't started yet) */
|
|
bool streamInited;
|
|
bool sourceExhausted;
|
|
|
|
bool threadTermReq;
|
|
|
|
bool needsRewind;
|
|
float startOffset;
|
|
|
|
AL::Source::ID alSrc;
|
|
AL::Buffer::ID alBuf[streamBufs];
|
|
|
|
uint64_t procFrames;
|
|
AL::Buffer::ID lastBuf;
|
|
|
|
SDL_RWops srcOps;
|
|
|
|
struct
|
|
{
|
|
ALenum format;
|
|
ALsizei freq;
|
|
} stream;
|
|
|
|
enum LoopMode
|
|
{
|
|
Looped,
|
|
NotLooped
|
|
};
|
|
|
|
ALStream(LoopMode loopMode,
|
|
const std::string &threadId)
|
|
: looped(loopMode == Looped),
|
|
state(Closed),
|
|
source(0),
|
|
thread(0),
|
|
preemptPause(false),
|
|
streamInited(false),
|
|
needsRewind(false)
|
|
{
|
|
alSrc = AL::Source::gen();
|
|
|
|
AL::Source::setVolume(alSrc, 1.0);
|
|
AL::Source::setPitch(alSrc, 1.0);
|
|
AL::Source::detachBuffer(alSrc);
|
|
|
|
for (int i = 0; i < streamBufs; ++i)
|
|
alBuf[i] = AL::Buffer::gen();
|
|
|
|
pauseMut = SDL_CreateMutex();
|
|
|
|
threadName = std::string("al_stream (") + threadId + ")";
|
|
}
|
|
|
|
~ALStream()
|
|
{
|
|
close();
|
|
|
|
clearALQueue();
|
|
|
|
AL::Source::del(alSrc);
|
|
|
|
for (int i = 0; i < streamBufs; ++i)
|
|
AL::Buffer::del(alBuf[i]);
|
|
|
|
SDL_DestroyMutex(pauseMut);
|
|
}
|
|
|
|
void close()
|
|
{
|
|
checkStopped();
|
|
|
|
switch (state)
|
|
{
|
|
case Playing:
|
|
case Paused:
|
|
stopStream();
|
|
case Stopped:
|
|
closeSource();
|
|
state = Closed;
|
|
case Closed:
|
|
return;
|
|
}
|
|
}
|
|
|
|
void open(const std::string &filename)
|
|
{
|
|
checkStopped();
|
|
|
|
switch (state)
|
|
{
|
|
case Playing:
|
|
case Paused:
|
|
stopStream();
|
|
case Stopped:
|
|
closeSource();
|
|
case Closed:
|
|
openSource(filename);
|
|
}
|
|
|
|
state = Stopped;
|
|
}
|
|
|
|
void stop()
|
|
{
|
|
checkStopped();
|
|
|
|
switch (state)
|
|
{
|
|
case Closed:
|
|
case Stopped:
|
|
return;
|
|
case Playing:
|
|
case Paused:
|
|
stopStream();
|
|
}
|
|
|
|
state = Stopped;
|
|
}
|
|
|
|
void play(float offset = 0)
|
|
{
|
|
checkStopped();
|
|
|
|
switch (state)
|
|
{
|
|
case Closed:
|
|
case Playing:
|
|
return;
|
|
case Stopped:
|
|
startStream(offset);
|
|
break;
|
|
case Paused :
|
|
resumeStream();
|
|
}
|
|
|
|
state = Playing;
|
|
}
|
|
|
|
void pause()
|
|
{
|
|
checkStopped();
|
|
|
|
switch (state)
|
|
{
|
|
case Closed:
|
|
case Stopped:
|
|
case Paused:
|
|
return;
|
|
case Playing:
|
|
pauseStream();
|
|
}
|
|
|
|
state = Paused;
|
|
}
|
|
|
|
void setVolume(float value)
|
|
{
|
|
AL::Source::setVolume(alSrc, value);
|
|
}
|
|
|
|
void setPitch(float value)
|
|
{
|
|
AL::Source::setPitch(alSrc, value);
|
|
}
|
|
|
|
State queryState()
|
|
{
|
|
checkStopped();
|
|
|
|
return state;
|
|
}
|
|
|
|
float queryOffset()
|
|
{
|
|
if (state == Closed)
|
|
return 0;
|
|
|
|
float procOffset = static_cast<float>(procFrames) / source->sampleRate();
|
|
|
|
return procOffset + AL::Source::getSecOffset(alSrc);
|
|
}
|
|
|
|
private:
|
|
void closeSource()
|
|
{
|
|
delete source;
|
|
}
|
|
|
|
void openSource(const std::string &filename)
|
|
{
|
|
const char *ext;
|
|
shState->fileSystem().openRead(srcOps, filename.c_str(), FileSystem::Audio, false, &ext);
|
|
|
|
#ifdef RGSS2
|
|
/* Try to read ogg file signature */
|
|
char sig[5];
|
|
memset(sig, '\0', sizeof(sig));
|
|
SDL_RWread(&srcOps, sig, 1, 4);
|
|
SDL_RWseek(&srcOps, 0, RW_SEEK_SET);
|
|
|
|
if (!strcmp(sig, "OggS"))
|
|
source = new VorbisSource(srcOps, looped);
|
|
else
|
|
source = new SDLSoundSource(srcOps, ext, streamBufSize, looped);
|
|
#else
|
|
source = new SDLSoundSource(srcOps, ext, streamBufSize, looped);
|
|
#endif
|
|
|
|
needsRewind = false;
|
|
}
|
|
|
|
void stopStream()
|
|
{
|
|
threadTermReq = true;
|
|
|
|
AL::Source::stop(alSrc);
|
|
|
|
if (thread)
|
|
{
|
|
SDL_WaitThread(thread, 0);
|
|
thread = 0;
|
|
needsRewind = true;
|
|
}
|
|
|
|
procFrames = 0;
|
|
}
|
|
|
|
void startStream(float offset)
|
|
{
|
|
clearALQueue();
|
|
|
|
preemptPause = false;
|
|
streamInited = false;
|
|
sourceExhausted = false;
|
|
threadTermReq = false;
|
|
|
|
startOffset = offset;
|
|
procFrames = offset * source->sampleRate();
|
|
|
|
thread = SDL_CreateThread(streamDataFun, threadName.c_str(), this);
|
|
}
|
|
|
|
void pauseStream()
|
|
{
|
|
SDL_LockMutex(pauseMut);
|
|
|
|
if (AL::Source::getState(alSrc) != AL_PLAYING)
|
|
preemptPause = true;
|
|
else
|
|
AL::Source::pause(alSrc);
|
|
|
|
SDL_UnlockMutex(pauseMut);
|
|
}
|
|
|
|
void resumeStream()
|
|
{
|
|
SDL_LockMutex(pauseMut);
|
|
|
|
if (preemptPause)
|
|
preemptPause = false;
|
|
else
|
|
AL::Source::play(alSrc);
|
|
|
|
SDL_UnlockMutex(pauseMut);
|
|
}
|
|
|
|
void checkStopped()
|
|
{
|
|
/* This only concerns the scenario where
|
|
* state is still 'Playing', but the stream
|
|
* has already ended on its own (EOF, Error) */
|
|
if (state != Playing)
|
|
return;
|
|
|
|
/* If streaming thread hasn't queued up
|
|
* buffers yet there's not point in querying
|
|
* the AL source */
|
|
if (!streamInited)
|
|
return;
|
|
|
|
/* If alSrc isn't playing, but we haven't
|
|
* exhausted the data source yet, we're just
|
|
* having a buffer underrun */
|
|
if (!sourceExhausted)
|
|
return;
|
|
|
|
if (AL::Source::getState(alSrc) == AL_PLAYING)
|
|
return;
|
|
|
|
stopStream();
|
|
state = Stopped;
|
|
}
|
|
|
|
void clearALQueue()
|
|
{
|
|
/* Unqueue all buffers */
|
|
ALint queuedBufs = AL::Source::getProcBufferCount(alSrc);
|
|
|
|
while (queuedBufs--)
|
|
AL::Source::unqueueBuffer(alSrc);
|
|
}
|
|
|
|
/* thread func */
|
|
void streamData()
|
|
{
|
|
/* Fill up queue */
|
|
bool firstBuffer = true;
|
|
ALDataSource::Status status;
|
|
|
|
if (needsRewind)
|
|
{
|
|
if (startOffset > 0)
|
|
source->seekToOffset(startOffset);
|
|
else
|
|
source->reset();
|
|
}
|
|
|
|
for (int i = 0; i < streamBufs; ++i)
|
|
{
|
|
AL::Buffer::ID buf = alBuf[i];
|
|
|
|
status = source->fillBuffer(buf);
|
|
|
|
if (status == ALDataSource::Error)
|
|
return;
|
|
|
|
AL::Source::queueBuffer(alSrc, buf);
|
|
|
|
if (firstBuffer)
|
|
{
|
|
resumeStream();
|
|
|
|
firstBuffer = false;
|
|
streamInited = true;
|
|
}
|
|
|
|
if (threadTermReq)
|
|
return;
|
|
|
|
if (status == ALDataSource::EndOfStream)
|
|
{
|
|
sourceExhausted = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Wait for buffers to be consumed, then
|
|
* refill and queue them up again */
|
|
while (true)
|
|
{
|
|
ALint procBufs = AL::Source::getProcBufferCount(alSrc);
|
|
|
|
while (procBufs--)
|
|
{
|
|
if (threadTermReq)
|
|
break;
|
|
|
|
AL::Buffer::ID buf = AL::Source::unqueueBuffer(alSrc);
|
|
|
|
/* If something went wrong, try again later */
|
|
if (buf == AL::Buffer::ID(0))
|
|
break;
|
|
|
|
if (buf == lastBuf)
|
|
{
|
|
/* Reset the processed sample count so
|
|
* querying the playback offset returns 0.0 again */
|
|
procFrames = source->loopStartFrames();
|
|
lastBuf = AL::Buffer::ID(0);
|
|
}
|
|
else
|
|
{
|
|
/* Add the frame count contained in this
|
|
* buffer to the total count */
|
|
ALint bits = AL::Buffer::getBits(buf);
|
|
ALint size = AL::Buffer::getSize(buf);
|
|
ALint chan = AL::Buffer::getChannels(buf);
|
|
|
|
if (bits != 0 && chan != 0)
|
|
procFrames += ((size / (bits / 8)) / chan);
|
|
}
|
|
|
|
if (sourceExhausted)
|
|
continue;
|
|
|
|
status = source->fillBuffer(buf);
|
|
|
|
if (status == ALDataSource::Error)
|
|
{
|
|
sourceExhausted = true;
|
|
return;
|
|
}
|
|
|
|
AL::Source::queueBuffer(alSrc, buf);
|
|
|
|
/* In case of buffer underrun,
|
|
* start playing again */
|
|
if (AL::Source::getState(alSrc) == AL_STOPPED)
|
|
AL::Source::play(alSrc);
|
|
|
|
/* If this was the last buffer before the data
|
|
* source loop wrapped around again, mark it as
|
|
* such so we can catch it and reset the processed
|
|
* sample count once it gets unqueued */
|
|
if (status == ALDataSource::WrapAround)
|
|
lastBuf = buf;
|
|
|
|
if (status == ALDataSource::EndOfStream)
|
|
sourceExhausted = true;
|
|
}
|
|
|
|
if (threadTermReq)
|
|
break;
|
|
|
|
SDL_Delay(AUDIO_SLEEP);
|
|
}
|
|
}
|
|
|
|
static int streamDataFun(void *_self)
|
|
{
|
|
ALStream &self = *static_cast<ALStream*>(_self);
|
|
self.streamData();
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
struct AudioStream
|
|
{
|
|
struct
|
|
{
|
|
std::string filename;
|
|
float volume;
|
|
float pitch;
|
|
} current;
|
|
|
|
/* Volume set with 'play()' */
|
|
float baseVolume;
|
|
|
|
/* Volume set by external threads,
|
|
* such as for fade-in/out.
|
|
* Multiplied with intVolume for final
|
|
* playback volume.
|
|
* fadeVolume: used by fade-out thread.
|
|
* extVolume: used by MeWatch. */
|
|
float fadeVolume;
|
|
float extVolume;
|
|
|
|
/* Note that 'extPaused' and 'noResumeStop' are
|
|
* effectively only used with the AudioStream
|
|
* instance representing the BGM */
|
|
|
|
/* Flag indicating that the MeWatch paused this
|
|
* (BGM) stream because a ME started playing.
|
|
* While this flag is set, calls to 'play()'
|
|
* might open another file, but will not start
|
|
* the playback stream (the MeWatch will start
|
|
* it as soon as the ME finished playing). */
|
|
bool extPaused;
|
|
|
|
/* Flag indicating that this stream shouldn't be
|
|
* started by the MeWatch when it is in stopped
|
|
* state (eg. because the BGM stream was explicitly
|
|
* stopped by the user script while the ME was playing.
|
|
* When a new BGM is started (via 'play()') while an ME
|
|
* is playing, the file will be loaded without starting
|
|
* the stream, but we want the MeWatch to start it as
|
|
* soon as the ME ends, so we unset this flag. */
|
|
bool noResumeStop;
|
|
|
|
ALStream stream;
|
|
SDL_mutex *streamMut;
|
|
|
|
struct
|
|
{
|
|
/* Fade is in progress */
|
|
bool active;
|
|
|
|
/* Request fade thread to finish and
|
|
* cleanup (like it normally would) */
|
|
bool reqFini;
|
|
|
|
/* Request fade thread to terminate
|
|
* immediately */
|
|
bool reqTerm;
|
|
|
|
SDL_Thread *thread;
|
|
std::string threadName;
|
|
|
|
/* Amount of reduced absolute volume
|
|
* per ms of fade time */
|
|
float msStep;
|
|
|
|
/* Ticks at start of fade */
|
|
uint32_t startTicks;
|
|
} fade;
|
|
|
|
AudioStream(ALStream::LoopMode loopMode,
|
|
const std::string &threadId)
|
|
: baseVolume(1.0),
|
|
fadeVolume(1.0),
|
|
extVolume(1.0),
|
|
extPaused(false),
|
|
noResumeStop(false),
|
|
stream(loopMode, threadId)
|
|
{
|
|
current.volume = 1.0;
|
|
current.pitch = 1.0;
|
|
|
|
fade.active = false;
|
|
fade.thread = 0;
|
|
fade.threadName = std::string("audio_fade (") + threadId + ")";
|
|
|
|
streamMut = SDL_CreateMutex();
|
|
}
|
|
|
|
~AudioStream()
|
|
{
|
|
if (fade.thread)
|
|
{
|
|
fade.reqTerm = true;
|
|
SDL_WaitThread(fade.thread, 0);
|
|
}
|
|
|
|
lockStream();
|
|
|
|
stream.stop();
|
|
stream.close();
|
|
|
|
unlockStream();
|
|
|
|
SDL_DestroyMutex(streamMut);
|
|
}
|
|
|
|
void play(const std::string &filename,
|
|
int volume,
|
|
int pitch,
|
|
float offset = 0)
|
|
{
|
|
finiFadeInt();
|
|
|
|
lockStream();
|
|
|
|
float _volume = clamp<int>(volume, 0, 100) / 100.f;
|
|
float _pitch = clamp<int>(pitch, 50, 150) / 100.f;
|
|
|
|
ALStream::State sState = stream.queryState();
|
|
|
|
/* If all parameters match the current ones and we're
|
|
* still playing, there's nothing to do */
|
|
if (filename == current.filename
|
|
&& _volume == current.volume
|
|
&& _pitch == current.pitch
|
|
&& (sState == ALStream::Playing || sState == ALStream::Paused))
|
|
{
|
|
unlockStream();
|
|
return;
|
|
}
|
|
|
|
/* If all parameters except volume match the current ones,
|
|
* we update the volume and continue streaming */
|
|
if (filename == current.filename
|
|
&& _pitch == current.pitch
|
|
&& (sState == ALStream::Playing || sState == ALStream::Paused))
|
|
{
|
|
setBaseVolume(_volume);
|
|
current.volume = _volume;
|
|
unlockStream();
|
|
return;
|
|
}
|
|
|
|
/* Requested audio file is different from current one */
|
|
bool diffFile = (filename != current.filename);
|
|
|
|
switch (sState)
|
|
{
|
|
case ALStream::Paused :
|
|
case ALStream::Playing :
|
|
stream.stop();
|
|
case ALStream::Stopped :
|
|
if (diffFile)
|
|
stream.close();
|
|
case ALStream::Closed :
|
|
if (diffFile)
|
|
{
|
|
try
|
|
{
|
|
/* This will throw on errors while
|
|
* opening the data source */
|
|
stream.open(filename);
|
|
}
|
|
catch (const Exception &e)
|
|
{
|
|
unlockStream();
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
setBaseVolume(_volume);
|
|
stream.setPitch(_pitch);
|
|
|
|
current.filename = filename;
|
|
current.volume = _volume;
|
|
current.pitch = _pitch;
|
|
|
|
if (!extPaused)
|
|
stream.play(offset);
|
|
else
|
|
noResumeStop = false;
|
|
|
|
unlockStream();
|
|
}
|
|
|
|
void stop()
|
|
{
|
|
finiFadeInt();
|
|
|
|
lockStream();
|
|
|
|
noResumeStop = true;
|
|
|
|
stream.stop();
|
|
|
|
unlockStream();
|
|
}
|
|
|
|
void fadeOut(int duration)
|
|
{
|
|
lockStream();
|
|
|
|
ALStream::State sState = stream.queryState();
|
|
|
|
if (fade.active)
|
|
{
|
|
unlockStream();
|
|
|
|
return;
|
|
}
|
|
|
|
if (sState == ALStream::Paused)
|
|
{
|
|
stream.stop();
|
|
unlockStream();
|
|
|
|
return;
|
|
}
|
|
|
|
if (sState != ALStream::Playing)
|
|
{
|
|
unlockStream();
|
|
|
|
return;
|
|
}
|
|
|
|
if (fade.thread)
|
|
{
|
|
fade.reqFini = true;
|
|
SDL_WaitThread(fade.thread, 0);
|
|
fade.thread = 0;
|
|
}
|
|
|
|
fade.active = true;
|
|
fade.msStep = (1.0) / duration;
|
|
fade.reqFini = false;
|
|
fade.reqTerm = false;
|
|
fade.startTicks = SDL_GetTicks();
|
|
|
|
fade.thread = SDL_CreateThread(fadeThreadFun, fade.threadName.c_str(), this);
|
|
|
|
unlockStream();
|
|
}
|
|
|
|
/* Any access to this classes 'stream' member,
|
|
* whether state query or modification, must be
|
|
* protected by a 'lock'/'unlock' pair */
|
|
void lockStream()
|
|
{
|
|
SDL_LockMutex(streamMut);
|
|
}
|
|
|
|
void unlockStream()
|
|
{
|
|
SDL_UnlockMutex(streamMut);
|
|
}
|
|
|
|
void setFadeVolume(float value)
|
|
{
|
|
fadeVolume = value;
|
|
updateVolume();
|
|
}
|
|
|
|
void setExtVolume1(float value)
|
|
{
|
|
extVolume = value;
|
|
updateVolume();
|
|
}
|
|
|
|
float playingOffset()
|
|
{
|
|
return stream.queryOffset();
|
|
}
|
|
|
|
private:
|
|
void finiFadeInt()
|
|
{
|
|
if (!fade.thread)
|
|
return;
|
|
|
|
fade.reqFini = true;
|
|
SDL_WaitThread(fade.thread, 0);
|
|
fade.thread = 0;
|
|
}
|
|
|
|
void updateVolume()
|
|
{
|
|
stream.setVolume(baseVolume * fadeVolume * extVolume);
|
|
}
|
|
|
|
void setBaseVolume(float value)
|
|
{
|
|
baseVolume = value;
|
|
updateVolume();
|
|
}
|
|
|
|
void fadeThread()
|
|
{
|
|
while (true)
|
|
{
|
|
/* Just immediately terminate on request */
|
|
if (fade.reqTerm)
|
|
break;
|
|
|
|
lockStream();
|
|
|
|
uint32_t curDur = SDL_GetTicks() - fade.startTicks;
|
|
float resVol = 1.0 - (curDur*fade.msStep);
|
|
|
|
ALStream::State state = stream.queryState();
|
|
|
|
if (state != ALStream::Playing
|
|
|| resVol < 0
|
|
|| fade.reqFini)
|
|
{
|
|
if (state != ALStream::Paused)
|
|
stream.stop();
|
|
|
|
setFadeVolume(1.0);
|
|
unlockStream();
|
|
|
|
break;
|
|
}
|
|
|
|
setFadeVolume(resVol);
|
|
|
|
unlockStream();
|
|
|
|
SDL_Delay(AUDIO_SLEEP);
|
|
}
|
|
|
|
fade.active = false;
|
|
}
|
|
|
|
static int fadeThreadFun(void *self)
|
|
{
|
|
static_cast<AudioStream*>(self)->fadeThread();
|
|
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
struct AudioPrivate
|
|
{
|
|
AudioStream bgm;
|
|
AudioStream bgs;
|
|
AudioStream me;
|
|
|
|
SoundEmitter se;
|
|
|
|
/* The 'MeWatch' is responsible for detecting
|
|
* a playing ME, quickly fading out the BGM and
|
|
* keeping it paused/stopped while the ME plays,
|
|
* and unpausing/fading the BGM back in again
|
|
* afterwards */
|
|
enum MeWatchState
|
|
{
|
|
MeNotPlaying,
|
|
BgmFadingOut,
|
|
MePlaying,
|
|
BgmFadingIn
|
|
};
|
|
|
|
struct
|
|
{
|
|
SDL_Thread *thread;
|
|
bool active;
|
|
bool termReq;
|
|
MeWatchState state;
|
|
} meWatch;
|
|
|
|
AudioPrivate()
|
|
: bgm(ALStream::Looped, "bgm"),
|
|
bgs(ALStream::Looped, "bgs"),
|
|
me(ALStream::NotLooped, "me")
|
|
{
|
|
meWatch.active = false;
|
|
meWatch.termReq = false;
|
|
meWatch.state = MeNotPlaying;
|
|
meWatch.thread = SDL_CreateThread(meWatchFun, "audio_mewatch", this);
|
|
}
|
|
|
|
~AudioPrivate()
|
|
{
|
|
meWatch.termReq = true;
|
|
SDL_WaitThread(meWatch.thread, 0);
|
|
}
|
|
|
|
void meWatchFunInt()
|
|
{
|
|
const float fadeOutStep = 1.f / (200 / AUDIO_SLEEP);
|
|
const float fadeInStep = 1.f / (1000 / AUDIO_SLEEP);
|
|
|
|
while (true)
|
|
{
|
|
if (meWatch.termReq)
|
|
return;
|
|
|
|
switch (meWatch.state)
|
|
{
|
|
case MeNotPlaying:
|
|
{
|
|
me.lockStream();
|
|
|
|
if (me.stream.queryState() == ALStream::Playing)
|
|
{
|
|
/* ME playing detected. -> FadeOutBGM */
|
|
bgm.extPaused = true;
|
|
meWatch.state = BgmFadingOut;
|
|
}
|
|
|
|
me.unlockStream();
|
|
|
|
break;
|
|
}
|
|
|
|
case BgmFadingOut :
|
|
{
|
|
me.lockStream();
|
|
|
|
if (me.stream.queryState() != ALStream::Playing)
|
|
{
|
|
/* ME has ended while fading OUT BGM. -> FadeInBGM */
|
|
me.unlockStream();
|
|
meWatch.state = BgmFadingIn;
|
|
|
|
break;
|
|
}
|
|
|
|
bgm.lockStream();
|
|
|
|
float vol = bgm.extVolume;
|
|
vol -= fadeOutStep;
|
|
|
|
if (vol < 0 || bgm.stream.queryState() != ALStream::Playing)
|
|
{
|
|
/* Either BGM has fully faded out, or stopped midway. -> MePlaying */
|
|
bgm.setExtVolume1(0);
|
|
bgm.stream.pause();
|
|
meWatch.state = MePlaying;
|
|
bgm.unlockStream();
|
|
me.unlockStream();
|
|
|
|
break;
|
|
}
|
|
|
|
bgm.setExtVolume1(vol);
|
|
bgm.unlockStream();
|
|
me.unlockStream();
|
|
|
|
break;
|
|
}
|
|
|
|
case MePlaying :
|
|
{
|
|
me.lockStream();
|
|
|
|
if (me.stream.queryState() != ALStream::Playing)
|
|
{
|
|
/* ME has ended */
|
|
bgm.lockStream();
|
|
|
|
bgm.extPaused = false;
|
|
|
|
ALStream::State sState = bgm.stream.queryState();
|
|
|
|
if (sState == ALStream::Paused)
|
|
{
|
|
/* BGM is paused. -> FadeInBGM */
|
|
bgm.stream.play();
|
|
meWatch.state = BgmFadingIn;
|
|
}
|
|
else
|
|
{
|
|
/* BGM is stopped. -> MeNotPlaying */
|
|
bgm.setExtVolume1(1.0);
|
|
|
|
if (!bgm.noResumeStop)
|
|
bgm.stream.play();
|
|
|
|
meWatch.state = MeNotPlaying;
|
|
}
|
|
|
|
bgm.unlockStream();
|
|
}
|
|
|
|
me.unlockStream();
|
|
|
|
break;
|
|
}
|
|
|
|
case BgmFadingIn :
|
|
{
|
|
bgm.lockStream();
|
|
|
|
if (bgm.stream.queryState() == ALStream::Stopped)
|
|
{
|
|
/* BGM stopped midway fade in. -> MeNotPlaying */
|
|
bgm.setExtVolume1(1.0);
|
|
meWatch.state = MeNotPlaying;
|
|
bgm.unlockStream();
|
|
|
|
break;
|
|
}
|
|
|
|
me.lockStream();
|
|
|
|
if (me.stream.queryState() == ALStream::Playing)
|
|
{
|
|
/* ME started playing midway BGM fade in. -> FadeOutBGM */
|
|
bgm.extPaused = true;
|
|
meWatch.state = BgmFadingOut;
|
|
me.unlockStream();
|
|
bgm.unlockStream();
|
|
|
|
break;
|
|
}
|
|
|
|
float vol = bgm.extVolume;
|
|
vol += fadeInStep;
|
|
|
|
if (vol >= 1)
|
|
{
|
|
/* BGM fully faded in. -> MeNotPlaying */
|
|
vol = 1.0;
|
|
meWatch.state = MeNotPlaying;
|
|
}
|
|
|
|
bgm.setExtVolume1(vol);
|
|
|
|
me.unlockStream();
|
|
bgm.unlockStream();
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
SDL_Delay(AUDIO_SLEEP);
|
|
}
|
|
}
|
|
|
|
static int meWatchFun(void *self)
|
|
{
|
|
static_cast<AudioPrivate*>(self)->meWatchFunInt();
|
|
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
Audio::Audio()
|
|
: p(new AudioPrivate)
|
|
{}
|
|
|
|
|
|
void Audio::bgmPlay(const char *filename,
|
|
int volume,
|
|
int pitch
|
|
#ifdef RGSS3
|
|
,float pos
|
|
#endif
|
|
)
|
|
{
|
|
#ifdef RGSS3
|
|
p->bgm.play(filename, volume, pitch, pos);
|
|
#else
|
|
p->bgm.play(filename, volume, pitch);
|
|
#endif
|
|
}
|
|
|
|
void Audio::bgmStop()
|
|
{
|
|
p->bgm.stop();
|
|
}
|
|
|
|
void Audio::bgmFade(int time)
|
|
{
|
|
p->bgm.fadeOut(time);
|
|
}
|
|
|
|
|
|
void Audio::bgsPlay(const char *filename,
|
|
int volume,
|
|
int pitch
|
|
#ifdef RGSS3
|
|
,float pos
|
|
#endif
|
|
)
|
|
{
|
|
#ifdef RGSS3
|
|
p->bgs.play(filename, volume, pitch, pos);
|
|
#else
|
|
p->bgs.play(filename, volume, pitch);
|
|
#endif
|
|
}
|
|
|
|
void Audio::bgsStop()
|
|
{
|
|
p->bgs.stop();
|
|
}
|
|
|
|
void Audio::bgsFade(int time)
|
|
{
|
|
p->bgs.fadeOut(time);
|
|
}
|
|
|
|
|
|
void Audio::mePlay(const char *filename,
|
|
int volume,
|
|
int pitch)
|
|
{
|
|
p->me.play(filename, volume, pitch);
|
|
}
|
|
|
|
void Audio::meStop()
|
|
{
|
|
p->me.stop();
|
|
}
|
|
|
|
void Audio::meFade(int time)
|
|
{
|
|
p->me.fadeOut(time);
|
|
}
|
|
|
|
|
|
void Audio::sePlay(const char *filename,
|
|
int volume,
|
|
int pitch)
|
|
{
|
|
p->se.play(filename, volume, pitch);
|
|
}
|
|
|
|
void Audio::seStop()
|
|
{
|
|
p->se.stop();
|
|
}
|
|
|
|
#ifdef RGSS3
|
|
|
|
void Audio::setupMidi()
|
|
{
|
|
|
|
}
|
|
|
|
float Audio::bgmPos()
|
|
{
|
|
return p->bgm.playingOffset();
|
|
}
|
|
|
|
float Audio::bgsPos()
|
|
{
|
|
return p->bgs.playingOffset();
|
|
}
|
|
|
|
#endif
|
|
|
|
Audio::~Audio() { delete p; }
|