static void BINARYSWAPSPU_APIENTRY
binaryswapspuMakeCurrent(GLint win, GLint nativeWindow, GLint ctx)
{
ContextInfo *context;
WindowInfo *window;
context =
(ContextInfo *) crHashtableSearch(binaryswap_spu.contextTable, ctx);
window = (WindowInfo *) crHashtableSearch(binaryswap_spu.windowTable, win);
if (context && window)
{
CRASSERT(context->superVisBits == window->superVisBits);
CRASSERT(context->childVisBits == window->childVisBits);
SET_CONTEXT(context);
CRASSERT(window);
context->currentWindow = window;
binaryswap_spu.super.MakeCurrent(window->renderWindow,
nativeWindow, context->renderContext);
binaryswap_spu.child.MakeCurrent(window->childWindow,
nativeWindow, context->childContext);
}
else
{
SET_CONTEXT(NULL);
}
}
void update() {
ALint processed;
alGetSourceiv(src_, AL_BUFFERS_PROCESSED, &processed);
std::vector<ALuint> unqueued(processed);
alSourceUnqueueBuffers(src_, processed, &unqueued.front());
int queuing_count = 0;
for (; queuing_count < processed; ++queuing_count) {
if (not loop_play_ and loader_->is_end()) {
loader_.reset();
++queuing_count;
break;
}
if (loader_->is_end()) {
ticks_.push_back(0);
}
buf_sizes_.push_back(loader_->load_buffer(unqueued[queuing_count]));
ticks_.push_back(loader_->midi_ticks());
}
alSourceQueueBuffers(src_, queuing_count, &unqueued.front());
if (fade_milli_ != 0) {
SET_CONTEXT(ctx_);
loop_count_++;
if (fade_ended()) {
alSourceStop(src_);
} else {
alSourcef(src_, AL_GAIN, current_volume());
}
}
}
void ALAudio::SE_Stop() {
SET_CONTEXT(ctx_);
for (source_list::iterator i = se_src_.begin(); i < se_src_.end(); ++i) {
alSourceStop(i->get()->get());
}
se_src_.clear();
}
void set_buffer_loader(EASYRPG_SHARED_PTR<buffer_loader> const &l) {
SET_CONTEXT(ctx_);
alSourceStop(src_);
alSourcei(src_, AL_BUFFER, AL_NONE);
if (not l) {
loader_.reset();
return;
}
ALint unqueuing_count;
alGetSourceiv(src_, AL_BUFFERS_QUEUED, &unqueuing_count);
std::vector<ALuint> unqueued(unqueuing_count);
alSourceUnqueueBuffers(src_, unqueuing_count, &unqueued.front());
loader_ = l;
int queuing_count = 0;
BOOST_ASSERT(not l->is_end());
ticks_.push_back(0);
for (; queuing_count < BUFFER_NUMBER; ++queuing_count) {
buf_sizes_.push_back(loader_->load_buffer(buffers_[queuing_count]));
ticks_.push_back(loader_->midi_ticks());
if (loader_->is_end()) {
queuing_count++;
break;
}
}
alSourceQueueBuffers(src_, queuing_count, buffers_.data());
alSourcePlay(src_);
}
source(EASYRPG_SHARED_PTR<ALCcontext> const& c, ALuint const s)
: ctx_(c), src_(s), loop_count_(0), fade_milli_(0)
, volume_(1.0f), is_fade_in_(false)
{
SET_CONTEXT(c);
BOOST_ASSERT(alIsSource(s) == AL_TRUE);
}
void set_buffer_loader(std::shared_ptr<buffer_loader> const &l) {
SET_CONTEXT(ctx_);
alSourceStop(src_);
alSourcei(src_, AL_BUFFER, AL_NONE);
if (!l) {
loader_.reset();
return;
}
ALint unqueuing_count;
alGetSourceiv(src_, AL_BUFFERS_QUEUED, &unqueuing_count);
std::vector<ALuint> unqueued(unqueuing_count);
alSourceUnqueueBuffers(src_, unqueuing_count, &unqueued.front());
loader_ = l;
int queuing_count = 0;
assert(!l->is_end());
ticks_[0] = 0;
for (; queuing_count < BUFFER_NUMBER; ++queuing_count) {
buf_sizes_[queuing_count] = loader_->load_buffer(buffers_[queuing_count]);
ticks_[queuing_count + 1] = loader_->midi_ticks();
if (loader_->is_end()) {
queuing_count++;
break;
}
}
alSourceQueueBuffers(src_, queuing_count, buffers_.data());
alSourcePlay(src_);
}
void ALAudio::BGS_Play(std::string const &file, int volume, int pitch, int fadein) {
SET_CONTEXT(ctx_);
BGM_Pitch(pitch);
BGM_Volume(volume);
bgm_src_->set_buffer_loader(getSound(*bgm_src_, file));
bgm_src_->fade_in(fadein);
}
void ALAudio::ME_Play(std::string const &file, int volume, int pitch, int fadein) {
SET_CONTEXT(ctx_);
alSourcef(me_src_->get(), AL_PITCH, pitch * 0.01f);
me_src_->set_volume(volume * 0.01f);
me_src_->set_buffer_loader(getMusic(*me_src_, file));
me_src_->fade_in(fadein);
}
void ALAudio::ME_Play(std::string const& file, int volume, int pitch) {
SET_CONTEXT(ctx_);
alSourcef(me_src_->get(), AL_PITCH, pitch * 0.01f);
alSourcei(me_src_->get(), AL_LOOPING, AL_FALSE);
me_src_->set_volume(volume * 0.01f);
me_src_->play_buffer(getMusic(file));
}
void ALAudio::BGS_Play(std::string const& file, int volume, int pitch) {
SET_CONTEXT(ctx_);
alSourcef(bgs_src_->get(), AL_PITCH, pitch * 0.01f);
alSourcei(bgs_src_->get(), AL_LOOPING, AL_TRUE);
bgm_src_->set_volume(volume * 0.01f);
bgm_src_->play_buffer(getSound(file));
}
EASYRPG_SHARED_PTR<ALAudio::buffer> ALAudio::create_buffer() {
SET_CONTEXT(ctx_);
ALuint ret = AL_NONE;
alGenBuffers(1, &ret);
BOOST_ASSERT(ret != AL_NONE);
return EASYRPG_MAKE_SHARED<buffer>(ctx_, ret);
}
EASYRPG_SHARED_PTR<ALAudio::source> ALAudio::create_source(bool loop) const {
SET_CONTEXT(ctx_);
ALuint ret = AL_NONE;
alGenSources(1, &ret);
print_al_error();
BOOST_ASSERT(ret != AL_NONE);
return EASYRPG_MAKE_SHARED<source>(ctx_, ret, loop);
}
std::shared_ptr<ALAudio::source> ALAudio::create_source(bool loop) const {
SET_CONTEXT(ctx_);
ALuint ret = AL_NONE;
alGenSources(1, &ret);
print_al_error();
assert(ret != AL_NONE);
return std::make_shared<source>(ctx_, ret, loop);
}
std::shared_ptr<ALAudio::buffer_loader>
ALAudio::create_loader(source &src, std::string const &filename) const {
SET_CONTEXT(ctx_);
if (filename.empty()) {
Output::Error("Failed loading audio file: %s", filename.c_str());
}
std::shared_ptr<buffer_loader> snd = sndfile_loader::create(filename);
return snd ? snd : std::make_shared<midi_loader>(std::ref(src), filename);
}
EASYRPG_SHARED_PTR<ALAudio::buffer> ALAudio::load_buffer(std::string const& filename) {
SET_CONTEXT(ctx_);
EASYRPG_SHARED_PTR<buffer> const buf = create_buffer();
if(! filename.empty() && load_sndfile(filename, buf)) { return buf; }
Output::Debug("Failed loading audio file: ", filename.c_str());
return EASYRPG_SHARED_PTR<buffer>();
}
void ALAudio::SE_Play(std::string const &file, int volume, int pitch) {
SET_CONTEXT(ctx_);
EASYRPG_SHARED_PTR<source> src = create_source(false);
alSourcef(src->get(), AL_PITCH, pitch * 0.01f);
src->set_volume(volume * 0.01f);
src->set_buffer_loader(getSound(*src, file));
se_src_.push_back(src);
}
EASYRPG_SHARED_PTR<ALAudio::buffer_loader>
ALAudio::create_loader(source &src, std::string const &filename) const {
SET_CONTEXT(ctx_);
if (filename.empty()) {
Output::Error("Failed loading audio file: %s", filename.c_str());
}
EASYRPG_SHARED_PTR<buffer_loader> snd = sndfile_loader::create(filename);
return snd ? snd : EASYRPG_MAKE_SHARED<midi_loader>(boost::ref(src), filename);
}
void update() {
if(fade_milli_ != 0){
SET_CONTEXT(ctx_);
loop_count_++;
if(fade_ended()) {
alSourceStop(src_);
} else {
alSourcef(src_, AL_GAIN, current_volume());
}
}
}
source(std::shared_ptr<ALCcontext> const &c, ALuint const s, bool loop)
: ctx_(c)
, src_(s)
, fade_count_(0)
, fade_milli_(0)
, volume_(1.0f)
, is_fade_in_(false)
, loop_play_(loop)
, ticks_(BUFFER_NUMBER + 1, 0)
, buf_sizes_(BUFFER_NUMBER, 0) {
SET_CONTEXT(c);
assert(alIsSource(s) == AL_TRUE);
alGenBuffers(BUFFER_NUMBER, buffers_.data());
}
source(EASYRPG_SHARED_PTR<ALCcontext> const &c, ALuint const s, bool loop)
: ctx_(c)
, src_(s)
, loop_count_(0)
, fade_milli_(0)
, volume_(1.0f)
, is_fade_in_(false)
, loop_play_(loop)
, ticks_(BUFFER_NUMBER + 1)
, buf_sizes_(BUFFER_NUMBER) {
SET_CONTEXT(c);
BOOST_ASSERT(alIsSource(s) == AL_TRUE);
alGenBuffers(BUFFER_NUMBER, buffers_.data());
}
ALAudio::ALAudio(char const* const dev_name) {
dev_.reset(alcOpenDevice(dev_name), &alcCloseDevice);
BOOST_ASSERT(dev_);
ctx_.reset(alcCreateContext(dev_.get(), NULL), &alcDestroyContext);
BOOST_ASSERT(ctx_);
alcMakeContextCurrent(ctx_.get());
SET_CONTEXT(ctx_);
bgm_src_ = create_source();
bgs_src_ = create_source();
me_src_ = create_source();
}
ALAudio::ALAudio(char const *const dev_name) {
dev_.reset(alcOpenDevice(dev_name), &alcCloseDevice);
assert(dev_);
ctx_.reset(alcCreateContext(dev_.get(), NULL), &alcDestroyContext);
assert(ctx_);
alcMakeContextCurrent(ctx_.get());
SET_CONTEXT(ctx_);
bgm_src_ = create_source(true);
if (!getenv("DEFAULT_SOUNDFONT")) {
Output::Error("Default sound font not found.");
}
}
void ALAudio::source::play_buffer(EASYRPG_SHARED_PTR<buffer> const& buf) {
SET_CONTEXT(ctx_);
buf_ = buf;
ALenum state = AL_INVALID_VALUE;
alGetSourcei(src_, AL_SOURCE_STATE, &state);
if(state != AL_STOPPED) {
alSourceStop(src_);
}
if(buf_) {
alSourcei(src_, AL_BUFFER, buf->get());
alSourcei(src_, AL_SAMPLE_OFFSET, 0);
alSourcePlay(src_);
} else {
alSourcei(src_, AL_BUFFER, AL_NONE);
}
}
void ALAudio::ME_Fade(int fade) {
SET_CONTEXT(ctx_);
me_src_->fade_out(fade);
}
void ALAudio::ME_Stop() {
SET_CONTEXT(ctx_);
alSourceStop(me_src_->get());
}
void ALAudio::BGM_Pitch(int pitch) {
SET_CONTEXT(ctx_);
alSourcef(bgs_src_->get(), AL_PITCH, pitch * 0.01f);
}
void ALAudio::BGM_Volume(int volume) {
SET_CONTEXT(ctx_);
bgm_src_->set_volume(volume * 0.01f);
}
void ALAudio::BGS_Fade(int fade) {
SET_CONTEXT(ctx_);
bgs_src_->fade_out(fade);
}
void ALAudio::BGS_Stop() {
SET_CONTEXT(ctx_);
alSourceStop(bgs_src_->get());
}
void ALAudio::BGM_Resume() {
SET_CONTEXT(ctx_);
alSourcePlay(bgm_src_->get());
}
