813 lines
21 KiB
C++
813 lines
21 KiB
C++
/*************************************************************************/
|
|
/* event_stream_chibi.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
|
|
/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
|
|
/* */
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
/* a copy of this software and associated documentation files (the */
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
/* the following conditions: */
|
|
/* */
|
|
/* The above copyright notice and this permission notice shall be */
|
|
/* included in all copies or substantial portions of the Software. */
|
|
/* */
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
/*************************************************************************/
|
|
#include "event_stream_chibi.h"
|
|
#include "cp_loader_it.h"
|
|
#include "cp_loader_mod.h"
|
|
#include "cp_loader_s3m.h"
|
|
#include "cp_loader_xm.h"
|
|
|
|
static CPSampleManagerImpl *sample_manager;
|
|
static ResourceFormatLoaderChibi *resource_loader;
|
|
|
|
CPSample_ID CPSampleManagerImpl::create(bool p_16bits, bool p_stereo, int32_t p_len) {
|
|
|
|
AudioServer::SampleFormat sf = p_16bits ? AudioServer::SAMPLE_FORMAT_PCM16 : AudioServer::SAMPLE_FORMAT_PCM8;
|
|
|
|
SampleData *sd = memnew(SampleData);
|
|
sd->rid = AudioServer::get_singleton()->sample_create(sf, p_stereo, p_len);
|
|
sd->stereo = p_stereo;
|
|
sd->len = p_len;
|
|
sd->is16 = p_16bits;
|
|
sd->mixfreq = 44100;
|
|
sd->loop_begin = 0;
|
|
sd->loop_end = 0;
|
|
sd->loop_type = CP_LOOP_NONE;
|
|
sd->locks = 0;
|
|
#ifdef DEBUG_ENABLED
|
|
valid.insert(sd);
|
|
#endif
|
|
CPSample_ID sid;
|
|
sid._private = sd;
|
|
return sid;
|
|
}
|
|
|
|
void CPSampleManagerImpl::recreate(CPSample_ID p_id, bool p_16bits, bool p_stereo, int32_t p_len) {
|
|
|
|
AudioServer::SampleFormat sf = p_16bits ? AudioServer::SAMPLE_FORMAT_PCM16 : AudioServer::SAMPLE_FORMAT_PCM8;
|
|
SampleData *sd = _getsd(p_id);
|
|
#ifdef DEBUG_ENABLED
|
|
ERR_FAIL_COND(!valid.has(sd));
|
|
#endif
|
|
AudioServer::get_singleton()->free(sd->rid);
|
|
sd->rid = AudioServer::get_singleton()->sample_create(sf, p_stereo, p_len);
|
|
sd->stereo = p_stereo;
|
|
sd->len = p_len;
|
|
sd->is16 = p_16bits;
|
|
sd->mixfreq = 44100;
|
|
sd->loop_begin = 0;
|
|
sd->loop_end = 0;
|
|
sd->loop_type = CP_LOOP_NONE;
|
|
}
|
|
void CPSampleManagerImpl::destroy(CPSample_ID p_id) {
|
|
|
|
SampleData *sd = _getsd(p_id);
|
|
#ifdef DEBUG_ENABLED
|
|
ERR_FAIL_COND(!valid.has(sd));
|
|
valid.erase(sd);
|
|
#endif
|
|
AudioServer::get_singleton()->free(sd->rid);
|
|
|
|
memdelete(sd);
|
|
}
|
|
bool CPSampleManagerImpl::check(CPSample_ID p_id) {
|
|
|
|
SampleData *sd = _getsd(p_id);
|
|
#ifdef DEBUG_ENABLED
|
|
return valid.has(sd);
|
|
#else
|
|
return _getsd(p_id) != NULL;
|
|
#endif
|
|
}
|
|
|
|
void CPSampleManagerImpl::set_c5_freq(CPSample_ID p_id, int32_t p_freq) {
|
|
|
|
SampleData *sd = _getsd(p_id);
|
|
#ifdef DEBUG_ENABLED
|
|
ERR_FAIL_COND(!valid.has(sd));
|
|
#endif
|
|
sd->mixfreq = p_freq;
|
|
AudioServer::get_singleton()->sample_set_mix_rate(sd->rid, p_freq);
|
|
}
|
|
void CPSampleManagerImpl::set_loop_begin(CPSample_ID p_id, int32_t p_begin) {
|
|
|
|
SampleData *sd = _getsd(p_id);
|
|
#ifdef DEBUG_ENABLED
|
|
ERR_FAIL_COND(!valid.has(sd));
|
|
#endif
|
|
sd->loop_begin = p_begin;
|
|
AudioServer::get_singleton()->sample_set_loop_begin(sd->rid, p_begin);
|
|
}
|
|
void CPSampleManagerImpl::set_loop_end(CPSample_ID p_id, int32_t p_end) {
|
|
|
|
SampleData *sd = _getsd(p_id);
|
|
#ifdef DEBUG_ENABLED
|
|
ERR_FAIL_COND(!valid.has(sd));
|
|
#endif
|
|
sd->loop_end = p_end;
|
|
AudioServer::get_singleton()->sample_set_loop_end(sd->rid, p_end);
|
|
}
|
|
void CPSampleManagerImpl::set_loop_type(CPSample_ID p_id, CPSample_Loop_Type p_type) {
|
|
|
|
SampleData *sd = _getsd(p_id);
|
|
#ifdef DEBUG_ENABLED
|
|
ERR_FAIL_COND(!valid.has(sd));
|
|
#endif
|
|
|
|
sd->loop_type = p_type;
|
|
AudioServer::get_singleton()->sample_set_loop_format(sd->rid, AudioServer::SampleLoopFormat(p_type));
|
|
}
|
|
void CPSampleManagerImpl::set_chunk(CPSample_ID p_id, int32_t p_index, void *p_data, int p_data_len) {
|
|
|
|
SampleData *sd = _getsd(p_id);
|
|
#ifdef DEBUG_ENABLED
|
|
ERR_FAIL_COND(!valid.has(sd));
|
|
#endif
|
|
|
|
ERR_FAIL();
|
|
}
|
|
|
|
int32_t CPSampleManagerImpl::get_loop_begin(CPSample_ID p_id) {
|
|
|
|
SampleData *sd = _getsd(p_id);
|
|
#ifdef DEBUG_ENABLED
|
|
ERR_FAIL_COND_V(!valid.has(sd), 0);
|
|
#endif
|
|
|
|
return sd->loop_begin;
|
|
}
|
|
int32_t CPSampleManagerImpl::get_loop_end(CPSample_ID p_id) {
|
|
|
|
SampleData *sd = _getsd(p_id);
|
|
#ifdef DEBUG_ENABLED
|
|
ERR_FAIL_COND_V(!valid.has(sd), 0);
|
|
#endif
|
|
|
|
return sd->loop_end;
|
|
}
|
|
CPSample_Loop_Type CPSampleManagerImpl::get_loop_type(CPSample_ID p_id) {
|
|
|
|
SampleData *sd = _getsd(p_id);
|
|
#ifdef DEBUG_ENABLED
|
|
ERR_FAIL_COND_V(!valid.has(sd), CP_LOOP_NONE);
|
|
#endif
|
|
|
|
return sd->loop_type;
|
|
}
|
|
int32_t CPSampleManagerImpl::get_c5_freq(CPSample_ID p_id) {
|
|
|
|
SampleData *sd = _getsd(p_id);
|
|
#ifdef DEBUG_ENABLED
|
|
ERR_FAIL_COND_V(!valid.has(sd), 0);
|
|
#endif
|
|
|
|
return sd->mixfreq;
|
|
}
|
|
int32_t CPSampleManagerImpl::get_size(CPSample_ID p_id) {
|
|
|
|
SampleData *sd = _getsd(p_id);
|
|
#ifdef DEBUG_ENABLED
|
|
ERR_FAIL_COND_V(!valid.has(sd), 0);
|
|
#endif
|
|
|
|
return sd->len;
|
|
}
|
|
bool CPSampleManagerImpl::is_16bits(CPSample_ID p_id) {
|
|
|
|
SampleData *sd = _getsd(p_id);
|
|
#ifdef DEBUG_ENABLED
|
|
ERR_FAIL_COND_V(!valid.has(sd), false);
|
|
#endif
|
|
|
|
return sd->is16;
|
|
}
|
|
bool CPSampleManagerImpl::is_stereo(CPSample_ID p_id) {
|
|
|
|
SampleData *sd = _getsd(p_id);
|
|
#ifdef DEBUG_ENABLED
|
|
ERR_FAIL_COND_V(!valid.has(sd), false);
|
|
#endif
|
|
return sd->stereo;
|
|
}
|
|
bool CPSampleManagerImpl::lock_data(CPSample_ID p_id) {
|
|
|
|
SampleData *sd = _getsd(p_id);
|
|
#ifdef DEBUG_ENABLED
|
|
ERR_FAIL_COND_V(!valid.has(sd), 0);
|
|
#endif
|
|
|
|
sd->locks++;
|
|
if (sd->locks == 1) {
|
|
sd->lock = AudioServer::get_singleton()->sample_get_data(sd->rid);
|
|
sd->w = sd->lock.write();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
void *CPSampleManagerImpl::get_data(CPSample_ID p_id) {
|
|
|
|
SampleData *sd = _getsd(p_id);
|
|
#ifdef DEBUG_ENABLED
|
|
ERR_FAIL_COND_V(!valid.has(sd), 0);
|
|
#endif
|
|
|
|
ERR_FAIL_COND_V(sd->locks == 0, 0);
|
|
return sd->w.ptr();
|
|
}
|
|
|
|
int16_t CPSampleManagerImpl::get_data(CPSample_ID p_id, int p_sample, int p_channel) {
|
|
|
|
SampleData *sd = _getsd(p_id);
|
|
#ifdef DEBUG_ENABLED
|
|
ERR_FAIL_COND_V(!valid.has(sd), 0);
|
|
#endif
|
|
|
|
ERR_FAIL_V(0);
|
|
lock_data(p_id);
|
|
|
|
int sofs = sd->stereo ? 2 : 1;
|
|
uint16_t v = 0;
|
|
if (sd->is16) {
|
|
int16_t *p = (int16_t *)sd->w.ptr();
|
|
v = p[p_sample * sofs + p_channel];
|
|
} else {
|
|
int8_t *p = (int8_t *)sd->w.ptr();
|
|
v = p[p_sample * sofs + p_channel];
|
|
}
|
|
|
|
unlock_data(p_id);
|
|
|
|
return v;
|
|
}
|
|
void CPSampleManagerImpl::set_data(CPSample_ID p_id, int p_sample, int16_t p_data, int p_channel) {
|
|
|
|
SampleData *sd = _getsd(p_id);
|
|
#ifdef DEBUG_ENABLED
|
|
ERR_FAIL_COND(!valid.has(sd));
|
|
#endif
|
|
|
|
ERR_FAIL();
|
|
lock_data(p_id);
|
|
|
|
int sofs = sd->stereo ? 2 : 1;
|
|
if (sd->is16) {
|
|
int16_t *p = (int16_t *)sd->w.ptr();
|
|
p[p_sample * sofs + p_channel] = p_data;
|
|
} else {
|
|
int8_t *p = (int8_t *)sd->w.ptr();
|
|
p[p_sample * sofs + p_channel] = p_data;
|
|
}
|
|
|
|
unlock_data(p_id);
|
|
}
|
|
void CPSampleManagerImpl::unlock_data(CPSample_ID p_id) {
|
|
|
|
SampleData *sd = _getsd(p_id);
|
|
#ifdef DEBUG_ENABLED
|
|
ERR_FAIL_COND(!valid.has(sd));
|
|
#endif
|
|
|
|
ERR_FAIL_COND(sd->locks == 0);
|
|
|
|
sd->locks--;
|
|
if (sd->locks == 0) {
|
|
sd->w = DVector<uint8_t>::Write();
|
|
AudioServer::get_singleton()->sample_set_data(sd->rid, sd->lock);
|
|
sd->lock = DVector<uint8_t>();
|
|
}
|
|
}
|
|
|
|
void CPSampleManagerImpl::get_chunk(CPSample_ID p_id, int32_t p_index, void *p_data, int p_data_len) {
|
|
|
|
SampleData *sd = _getsd(p_id);
|
|
#ifdef DEBUG_ENABLED
|
|
ERR_FAIL_COND(!valid.has(sd));
|
|
#endif
|
|
|
|
ERR_FAIL();
|
|
}
|
|
|
|
/** MIXER **/
|
|
|
|
void CPMixerImpl::set_callback_interval(int p_interval_us) {
|
|
|
|
callback_interval = p_interval_us;
|
|
}
|
|
|
|
void CPMixerImpl::set_callback(void (*p_callback)(void *), void *p_userdata) {
|
|
|
|
callback = p_callback;
|
|
userdata = p_userdata;
|
|
}
|
|
|
|
void CPMixerImpl::setup_voice(int p_voice_index, CPSample_ID p_sample_id, int32_t p_start_index) {
|
|
|
|
Voice &v = voices[p_voice_index];
|
|
if (v.channel != AudioMixer::INVALID_CHANNEL) {
|
|
mixer->channel_free(v.channel);
|
|
}
|
|
v.channel = mixer->channel_alloc(sample_manager->get_rid(p_sample_id));
|
|
v.freq_mult = sample_manager->get_c5_freq(p_sample_id) / 261.6255653006;
|
|
v.sample = p_sample_id;
|
|
}
|
|
|
|
void CPMixerImpl::stop_voice(int p_voice_index) {
|
|
|
|
Voice &v = voices[p_voice_index];
|
|
if (v.channel == AudioMixer::INVALID_CHANNEL)
|
|
return;
|
|
|
|
mixer->channel_free(v.channel);
|
|
v.channel = AudioMixer::INVALID_CHANNEL;
|
|
}
|
|
|
|
void CPMixerImpl::set_voice_frequency(int p_voice_index, int32_t p_freq) {
|
|
|
|
Voice &v = voices[p_voice_index];
|
|
ERR_FAIL_COND(v.channel == AudioMixer::INVALID_CHANNEL);
|
|
float f = p_freq / 256.0;
|
|
f *= pitch_scale;
|
|
mixer->channel_set_mix_rate(v.channel, f * v.freq_mult);
|
|
}
|
|
|
|
void CPMixerImpl::set_voice_panning(int p_voice_index, int p_pan) {
|
|
|
|
Voice &v = voices[p_voice_index];
|
|
ERR_FAIL_COND(v.channel == AudioMixer::INVALID_CHANNEL);
|
|
if (p_pan == CP_PAN_SURROUND)
|
|
p_pan = CP_PAN_CENTER;
|
|
float p = p_pan / 256.0;
|
|
mixer->channel_set_pan(v.channel, p);
|
|
}
|
|
|
|
void CPMixerImpl::set_voice_volume(int p_voice_index, int p_vol) {
|
|
|
|
Voice &v = voices[p_voice_index];
|
|
ERR_FAIL_COND(v.channel == AudioMixer::INVALID_CHANNEL);
|
|
float vol = p_vol / 512.0;
|
|
vol *= voice_scale;
|
|
mixer->channel_set_volume(v.channel, vol);
|
|
mixer->channel_set_reverb(v.channel, reverb_type, vol * v.reverb);
|
|
}
|
|
|
|
void CPMixerImpl::set_voice_filter(int p_voice_index, bool p_enabled, uint8_t p_cutoff, uint8_t p_resonance) {
|
|
|
|
Voice &v = voices[p_voice_index];
|
|
ERR_FAIL_COND(v.channel == AudioMixer::INVALID_CHANNEL);
|
|
}
|
|
|
|
void CPMixerImpl::set_voice_reverb_send(int p_voice_index, int p_reverb) {
|
|
|
|
Voice &v = voices[p_voice_index];
|
|
ERR_FAIL_COND(v.channel == AudioMixer::INVALID_CHANNEL);
|
|
v.reverb = p_reverb / 255.0;
|
|
//mixer->channel_set_reverb(v.channel,reverb_type,p_reverb/255.0);
|
|
}
|
|
|
|
void CPMixerImpl::set_voice_chorus_send(int p_voice_index, int p_chorus) {
|
|
|
|
Voice &v = voices[p_voice_index];
|
|
ERR_FAIL_COND(v.channel == AudioMixer::INVALID_CHANNEL);
|
|
mixer->channel_set_chorus(v.channel, p_chorus / 255.0);
|
|
}
|
|
|
|
void CPMixerImpl::set_reverb_mode(ReverbMode p_mode) {
|
|
|
|
// Voice &v=voices[p_voice_index];
|
|
// ERR_FAIL_COND(v.channel==AudioMixer::INVALID_CHANNEL);
|
|
switch (p_mode) {
|
|
case CPMixer::REVERB_MODE_STUDIO_SMALL: reverb_type = AudioMixer::REVERB_SMALL; break;
|
|
case CPMixer::REVERB_MODE_STUDIO_MEDIUM: reverb_type = AudioMixer::REVERB_MEDIUM; break;
|
|
case CPMixer::REVERB_MODE_STUDIO_LARGE: reverb_type = AudioMixer::REVERB_LARGE; break;
|
|
case CPMixer::REVERB_MODE_HALL: reverb_type = AudioMixer::REVERB_HALL; break;
|
|
default: reverb_type = AudioMixer::REVERB_SMALL; break;
|
|
}
|
|
}
|
|
|
|
void CPMixerImpl::set_chorus_params(unsigned int p_delay_ms, unsigned int p_separation_ms, unsigned int p_depth_ms10, unsigned int p_speed_hz10) {
|
|
|
|
// Voice &v=voices[p_voice_index];
|
|
// ERR_FAIL_COND(v.channel==AudioMixer::INVALID_CHANNEL);
|
|
}
|
|
|
|
/* Info retrieving */
|
|
|
|
int32_t CPMixerImpl::get_voice_sample_pos_index(int p_voice_index) {
|
|
|
|
Voice &v = voices[p_voice_index];
|
|
ERR_FAIL_COND_V(v.channel == AudioMixer::INVALID_CHANNEL, 0);
|
|
return 0;
|
|
}
|
|
|
|
int CPMixerImpl::get_voice_panning(int p_voice_index) {
|
|
|
|
Voice &v = voices[p_voice_index];
|
|
ERR_FAIL_COND_V(!is_voice_active(p_voice_index), 0);
|
|
return mixer->channel_get_pan(v.channel) * CP_PAN_RIGHT;
|
|
}
|
|
|
|
int CPMixerImpl::get_voice_volume(int p_voice_index) {
|
|
|
|
Voice &v = voices[p_voice_index];
|
|
ERR_FAIL_COND_V(!is_voice_active(p_voice_index), 0);
|
|
return mixer->channel_get_volume(v.channel);
|
|
}
|
|
|
|
CPSample_ID CPMixerImpl::get_voice_sample_id(int p_voice_index) {
|
|
|
|
Voice &v = voices[p_voice_index];
|
|
ERR_FAIL_COND_V(v.channel == AudioMixer::INVALID_CHANNEL, CPSample_ID());
|
|
return v.sample;
|
|
}
|
|
|
|
bool CPMixerImpl::is_voice_active(int p_voice_index) {
|
|
|
|
Voice &v = voices[p_voice_index];
|
|
if (v.channel == AudioMixer::INVALID_CHANNEL)
|
|
return false;
|
|
if (!mixer->channel_is_valid(v.channel))
|
|
v.channel = AudioMixer::INVALID_CHANNEL;
|
|
|
|
return v.channel != AudioMixer::INVALID_CHANNEL;
|
|
}
|
|
|
|
void CPMixerImpl::process_usecs(int p_usec, float p_volume, float p_pitch_scale, float p_tempo_scale) {
|
|
|
|
ERR_FAIL_COND(callback_interval == 0);
|
|
//update this somewhere
|
|
pitch_scale = p_pitch_scale;
|
|
tempo_scale = p_tempo_scale;
|
|
voice_scale = AudioServer::get_singleton()->get_event_voice_global_volume_scale() * p_volume;
|
|
while (p_usec) {
|
|
|
|
if (p_usec >= callback_timeout) {
|
|
|
|
p_usec -= callback_timeout;
|
|
callback_timeout = 0;
|
|
if (callback) {
|
|
callback(userdata);
|
|
}
|
|
callback_timeout = callback_interval * (1.0 / p_tempo_scale);
|
|
|
|
} else {
|
|
|
|
callback_timeout -= p_usec;
|
|
p_usec = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
CPMixerImpl::CPMixerImpl(AudioMixer *p_mixer) {
|
|
|
|
callback_interval = 1;
|
|
callback_timeout = 0;
|
|
userdata = 0;
|
|
callback = 0;
|
|
tempo_scale = 1.0;
|
|
pitch_scale = 1.0;
|
|
mixer = p_mixer;
|
|
voice_scale = AudioServer::get_singleton()->get_event_voice_global_volume_scale();
|
|
reverb_type = AudioMixer::REVERB_SMALL;
|
|
}
|
|
|
|
/** FILE ACCESS WRAPPER **/
|
|
|
|
CPFileAccessWrapperImpl::Error CPFileAccessWrapperImpl::open(const char *p_filename, int p_mode_flags) {
|
|
|
|
ERR_FAIL_COND_V(p_mode_flags & WRITE, ERROR_WRITING_FILE);
|
|
close();
|
|
f = FileAccess::open(String::utf8(p_filename), p_mode_flags);
|
|
if (!f)
|
|
return ERROR_FILE_NOT_FOUND;
|
|
return OK;
|
|
}
|
|
|
|
void CPFileAccessWrapperImpl::close() {
|
|
|
|
if (f)
|
|
memdelete(f);
|
|
f = NULL;
|
|
}
|
|
|
|
void CPFileAccessWrapperImpl::seek(uint32_t p_position) {
|
|
|
|
f->seek(p_position);
|
|
}
|
|
void CPFileAccessWrapperImpl::seek_end() {
|
|
|
|
f->seek_end();
|
|
}
|
|
uint32_t CPFileAccessWrapperImpl::get_pos() {
|
|
|
|
return f->get_pos();
|
|
}
|
|
|
|
bool CPFileAccessWrapperImpl::eof_reached() {
|
|
|
|
return f->eof_reached();
|
|
}
|
|
|
|
uint8_t CPFileAccessWrapperImpl::get_byte() {
|
|
|
|
return f->get_8();
|
|
}
|
|
void CPFileAccessWrapperImpl::get_byte_array(uint8_t *p_dest, int p_elements) {
|
|
|
|
f->get_buffer(p_dest, p_elements);
|
|
}
|
|
void CPFileAccessWrapperImpl::get_word_array(uint16_t *p_dest, int p_elements) {
|
|
|
|
for (int i = 0; i < p_elements; i++) {
|
|
p_dest[i] = f->get_16();
|
|
}
|
|
}
|
|
|
|
uint16_t CPFileAccessWrapperImpl::get_word() {
|
|
|
|
return f->get_16();
|
|
}
|
|
uint32_t CPFileAccessWrapperImpl::get_dword() {
|
|
|
|
return f->get_32();
|
|
}
|
|
|
|
void CPFileAccessWrapperImpl::set_endian_conversion(bool p_swap) {
|
|
|
|
f->set_endian_swap(p_swap);
|
|
}
|
|
bool CPFileAccessWrapperImpl::is_open() {
|
|
|
|
return f != NULL;
|
|
}
|
|
|
|
CPFileAccessWrapperImpl::Error CPFileAccessWrapperImpl::get_error() {
|
|
|
|
return (f->get_error() != ::OK) ? ERROR_READING_FILE : OK;
|
|
}
|
|
|
|
void CPFileAccessWrapperImpl::store_byte(uint8_t p_dest) {
|
|
}
|
|
void CPFileAccessWrapperImpl::store_byte_array(const uint8_t *p_dest, int p_elements) {
|
|
}
|
|
|
|
void CPFileAccessWrapperImpl::store_word(uint16_t p_dest) {
|
|
}
|
|
void CPFileAccessWrapperImpl::store_dword(uint32_t p_dest) {
|
|
}
|
|
|
|
////////////////////////////////////////////////
|
|
|
|
Error EventStreamPlaybackChibi::_play() {
|
|
|
|
last_order = 0;
|
|
loops = 0;
|
|
player->play_start_song();
|
|
total_usec = 0;
|
|
|
|
return OK;
|
|
}
|
|
|
|
bool EventStreamPlaybackChibi::_update(AudioMixer *p_mixer, uint64_t p_usec) {
|
|
|
|
total_usec += p_usec;
|
|
mixer.process_usecs(p_usec, volume, pitch_scale, tempo_scale);
|
|
int order = player->get_current_order();
|
|
if (order < last_order) {
|
|
if (!loop) {
|
|
stop();
|
|
} else {
|
|
loops++;
|
|
}
|
|
}
|
|
last_order = order;
|
|
return false;
|
|
}
|
|
void EventStreamPlaybackChibi::_stop() {
|
|
|
|
player->play_stop();
|
|
}
|
|
|
|
void EventStreamPlaybackChibi::set_paused(bool p_paused) {
|
|
}
|
|
bool EventStreamPlaybackChibi::is_paused() const {
|
|
|
|
return false;
|
|
}
|
|
void EventStreamPlaybackChibi::set_loop(bool p_loop) {
|
|
|
|
loop = p_loop;
|
|
}
|
|
bool EventStreamPlaybackChibi::is_loop_enabled() const {
|
|
|
|
return loop;
|
|
}
|
|
|
|
int EventStreamPlaybackChibi::get_loop_count() const {
|
|
|
|
//return player->is
|
|
return loops;
|
|
}
|
|
|
|
float EventStreamPlaybackChibi::get_pos() const {
|
|
|
|
return double(total_usec) / 1000000.0;
|
|
}
|
|
void EventStreamPlaybackChibi::seek_pos(float p_time) {
|
|
|
|
WARN_PRINT("seek_pos unimplemented.");
|
|
}
|
|
|
|
void EventStreamPlaybackChibi::set_volume(float p_volume) {
|
|
|
|
volume = p_volume;
|
|
}
|
|
|
|
float EventStreamPlaybackChibi::get_volume() const {
|
|
|
|
return volume;
|
|
}
|
|
|
|
void EventStreamPlaybackChibi::set_pitch_scale(float p_pitch_scale) {
|
|
|
|
pitch_scale = p_pitch_scale;
|
|
}
|
|
|
|
float EventStreamPlaybackChibi::get_pitch_scale() const {
|
|
|
|
return pitch_scale;
|
|
}
|
|
|
|
void EventStreamPlaybackChibi::set_tempo_scale(float p_tempo_scale) {
|
|
|
|
tempo_scale = p_tempo_scale;
|
|
}
|
|
|
|
float EventStreamPlaybackChibi::get_tempo_scale() const {
|
|
|
|
return tempo_scale;
|
|
}
|
|
|
|
void EventStreamPlaybackChibi::set_channel_volume(int p_channel, float p_volume) {
|
|
|
|
if (p_channel >= 64)
|
|
return;
|
|
player->set_channel_global_volume(p_channel, p_volume * 256);
|
|
}
|
|
|
|
float EventStreamPlaybackChibi::get_channel_volume(int p_channel) const {
|
|
|
|
return player->get_channel_global_volume(p_channel) / 256.0;
|
|
}
|
|
|
|
float EventStreamPlaybackChibi::get_last_note_time(int p_channel) const {
|
|
|
|
double v = (player->get_channel_last_note_time_usec(p_channel)) / 1000000.0;
|
|
if (v < 0)
|
|
v = -1;
|
|
return v;
|
|
}
|
|
|
|
EventStreamPlaybackChibi::EventStreamPlaybackChibi(Ref<EventStreamChibi> p_stream) :
|
|
mixer(_get_mixer()) {
|
|
|
|
stream = p_stream;
|
|
player = memnew(CPPlayer(&mixer, &p_stream->song));
|
|
loop = false;
|
|
last_order = 0;
|
|
loops = 0;
|
|
volume = 1.0;
|
|
pitch_scale = 1.0;
|
|
tempo_scale = 1.0;
|
|
}
|
|
EventStreamPlaybackChibi::~EventStreamPlaybackChibi() {
|
|
|
|
player->play_stop();
|
|
memdelete(player);
|
|
}
|
|
|
|
////////////////////////////////////////////////////
|
|
|
|
Ref<EventStreamPlayback> EventStreamChibi::instance_playback() {
|
|
|
|
return Ref<EventStreamPlayback>(memnew(EventStreamPlaybackChibi(Ref<EventStreamChibi>(this))));
|
|
}
|
|
|
|
String EventStreamChibi::get_stream_name() const {
|
|
|
|
return song.get_name();
|
|
}
|
|
|
|
float EventStreamChibi::get_length() const {
|
|
|
|
return 1;
|
|
}
|
|
|
|
EventStreamChibi::EventStreamChibi() {
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
RES ResourceFormatLoaderChibi::load(const String &p_path, const String &p_original_path, Error *r_error) {
|
|
|
|
if (r_error)
|
|
*r_error = ERR_FILE_CANT_OPEN;
|
|
String el = p_path.extension().to_lower();
|
|
|
|
CPFileAccessWrapperImpl f;
|
|
|
|
if (el == "it") {
|
|
|
|
Ref<EventStreamChibi> esc(memnew(EventStreamChibi));
|
|
CPLoader_IT loader(&f);
|
|
CPLoader::Error err = loader.load_song(p_path.utf8().get_data(), &esc->song, false);
|
|
ERR_FAIL_COND_V(err != CPLoader::FILE_OK, RES());
|
|
if (r_error)
|
|
*r_error = OK;
|
|
|
|
return esc;
|
|
|
|
} else if (el == "xm") {
|
|
|
|
Ref<EventStreamChibi> esc(memnew(EventStreamChibi));
|
|
CPLoader_XM loader(&f);
|
|
CPLoader::Error err = loader.load_song(p_path.utf8().get_data(), &esc->song, false);
|
|
ERR_FAIL_COND_V(err != CPLoader::FILE_OK, RES());
|
|
if (r_error)
|
|
*r_error = OK;
|
|
return esc;
|
|
|
|
} else if (el == "s3m") {
|
|
|
|
Ref<EventStreamChibi> esc(memnew(EventStreamChibi));
|
|
CPLoader_S3M loader(&f);
|
|
CPLoader::Error err = loader.load_song(p_path.utf8().get_data(), &esc->song, false);
|
|
ERR_FAIL_COND_V(err != CPLoader::FILE_OK, RES());
|
|
if (r_error)
|
|
*r_error = OK;
|
|
|
|
return esc;
|
|
|
|
} else if (el == "mod") {
|
|
|
|
Ref<EventStreamChibi> esc(memnew(EventStreamChibi));
|
|
CPLoader_MOD loader(&f);
|
|
CPLoader::Error err = loader.load_song(p_path.utf8().get_data(), &esc->song, false);
|
|
ERR_FAIL_COND_V(err != CPLoader::FILE_OK, RES());
|
|
if (r_error)
|
|
*r_error = OK;
|
|
return esc;
|
|
}
|
|
|
|
return RES();
|
|
}
|
|
|
|
void ResourceFormatLoaderChibi::get_recognized_extensions(List<String> *p_extensions) const {
|
|
|
|
p_extensions->push_back("it");
|
|
p_extensions->push_back("xm");
|
|
p_extensions->push_back("s3m");
|
|
p_extensions->push_back("mod");
|
|
}
|
|
bool ResourceFormatLoaderChibi::handles_type(const String &p_type) const {
|
|
|
|
return (p_type == "EventStreamChibi" || p_type == "EventStream");
|
|
}
|
|
|
|
String ResourceFormatLoaderChibi::get_resource_type(const String &p_path) const {
|
|
String el = p_path.extension().to_lower();
|
|
if (el == "it" || el == "s3m" || el == "xm" || el == "mod")
|
|
return "EventStreamChibi";
|
|
return "";
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////
|
|
void initialize_chibi() {
|
|
|
|
sample_manager = memnew(CPSampleManagerImpl);
|
|
resource_loader = memnew(ResourceFormatLoaderChibi);
|
|
ObjectTypeDB::register_type<EventStreamChibi>();
|
|
ResourceLoader::add_resource_format_loader(resource_loader);
|
|
}
|
|
|
|
void finalize_chibi() {
|
|
|
|
memdelete(sample_manager);
|
|
memdelete(resource_loader);
|
|
}
|