mirror of
https://github.com/godotengine/godot
synced 2024-09-05 19:19:43 +00:00
407 lines
12 KiB
C++
407 lines
12 KiB
C++
![]() |
/**************************************************************************/
|
||
|
/* audio_stream_playlist.cpp */
|
||
|
/**************************************************************************/
|
||
|
/* This file is part of: */
|
||
|
/* GODOT ENGINE */
|
||
|
/* https://godotengine.org */
|
||
|
/**************************************************************************/
|
||
|
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
|
||
|
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
|
||
|
/* */
|
||
|
/* 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 "audio_stream_playlist.h"
|
||
|
|
||
|
#include "core/math/math_funcs.h"
|
||
|
#include "core/string/print_string.h"
|
||
|
|
||
|
Ref<AudioStreamPlayback> AudioStreamPlaylist::instantiate_playback() {
|
||
|
Ref<AudioStreamPlaybackPlaylist> playback_playlist;
|
||
|
playback_playlist.instantiate();
|
||
|
playback_playlist->playlist = Ref<AudioStreamPlaylist>(this);
|
||
|
playback_playlist->_update_playback_instances();
|
||
|
playbacks.insert(playback_playlist.operator->());
|
||
|
return playback_playlist;
|
||
|
}
|
||
|
|
||
|
String AudioStreamPlaylist::get_stream_name() const {
|
||
|
return "Playlist";
|
||
|
}
|
||
|
|
||
|
void AudioStreamPlaylist::set_list_stream(int p_stream_index, Ref<AudioStream> p_stream) {
|
||
|
ERR_FAIL_COND(p_stream == this);
|
||
|
ERR_FAIL_INDEX(p_stream_index, MAX_STREAMS);
|
||
|
|
||
|
AudioServer::get_singleton()->lock();
|
||
|
audio_streams[p_stream_index] = p_stream;
|
||
|
for (AudioStreamPlaybackPlaylist *E : playbacks) {
|
||
|
E->_update_playback_instances();
|
||
|
}
|
||
|
AudioServer::get_singleton()->unlock();
|
||
|
}
|
||
|
|
||
|
Ref<AudioStream> AudioStreamPlaylist::get_list_stream(int p_stream_index) const {
|
||
|
ERR_FAIL_INDEX_V(p_stream_index, MAX_STREAMS, Ref<AudioStream>());
|
||
|
|
||
|
return audio_streams[p_stream_index];
|
||
|
}
|
||
|
|
||
|
double AudioStreamPlaylist::get_bpm() const {
|
||
|
for (int i = 0; i < stream_count; i++) {
|
||
|
if (audio_streams[i].is_valid()) {
|
||
|
double bpm = audio_streams[i]->get_bpm();
|
||
|
if (bpm != 0.0) {
|
||
|
return bpm;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return 0.0;
|
||
|
}
|
||
|
|
||
|
double AudioStreamPlaylist::get_length() const {
|
||
|
double total_length = 0.0;
|
||
|
for (int i = 0; i < stream_count; i++) {
|
||
|
if (audio_streams[i].is_valid()) {
|
||
|
double bpm = audio_streams[i]->get_bpm();
|
||
|
int beat_count = audio_streams[i]->get_beat_count();
|
||
|
if (bpm > 0.0 && beat_count > 0) {
|
||
|
total_length += beat_count * 60.0 / bpm;
|
||
|
} else {
|
||
|
total_length += audio_streams[i]->get_length();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return total_length;
|
||
|
}
|
||
|
|
||
|
void AudioStreamPlaylist::set_stream_count(int p_count) {
|
||
|
ERR_FAIL_COND(p_count < 0 || p_count > MAX_STREAMS);
|
||
|
AudioServer::get_singleton()->lock();
|
||
|
stream_count = p_count;
|
||
|
AudioServer::get_singleton()->unlock();
|
||
|
notify_property_list_changed();
|
||
|
}
|
||
|
|
||
|
int AudioStreamPlaylist::get_stream_count() const {
|
||
|
return stream_count;
|
||
|
}
|
||
|
|
||
|
void AudioStreamPlaylist::set_fade_time(float p_time) {
|
||
|
fade_time = p_time;
|
||
|
}
|
||
|
|
||
|
float AudioStreamPlaylist::get_fade_time() const {
|
||
|
return fade_time;
|
||
|
}
|
||
|
|
||
|
void AudioStreamPlaylist::set_shuffle(bool p_shuffle) {
|
||
|
shuffle = p_shuffle;
|
||
|
}
|
||
|
|
||
|
bool AudioStreamPlaylist::get_shuffle() const {
|
||
|
return shuffle;
|
||
|
}
|
||
|
|
||
|
void AudioStreamPlaylist::set_loop(bool p_loop) {
|
||
|
loop = p_loop;
|
||
|
}
|
||
|
|
||
|
bool AudioStreamPlaylist::has_loop() const {
|
||
|
return loop;
|
||
|
}
|
||
|
|
||
|
void AudioStreamPlaylist::_validate_property(PropertyInfo &r_property) const {
|
||
|
String prop = r_property.name;
|
||
|
if (prop != "stream_count" && prop.begins_with("stream_")) {
|
||
|
int stream = prop.get_slicec('/', 0).get_slicec('_', 1).to_int();
|
||
|
if (stream >= stream_count) {
|
||
|
r_property.usage = PROPERTY_USAGE_INTERNAL;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void AudioStreamPlaylist::_bind_methods() {
|
||
|
ClassDB::bind_method(D_METHOD("set_stream_count", "stream_count"), &AudioStreamPlaylist::set_stream_count);
|
||
|
ClassDB::bind_method(D_METHOD("get_stream_count"), &AudioStreamPlaylist::get_stream_count);
|
||
|
|
||
|
ClassDB::bind_method(D_METHOD("get_bpm"), &AudioStreamPlaylist::get_bpm);
|
||
|
|
||
|
ClassDB::bind_method(D_METHOD("set_list_stream", "stream_index", "audio_stream"), &AudioStreamPlaylist::set_list_stream);
|
||
|
ClassDB::bind_method(D_METHOD("get_list_stream", "stream_index"), &AudioStreamPlaylist::get_list_stream);
|
||
|
|
||
|
ClassDB::bind_method(D_METHOD("set_shuffle", "shuffle"), &AudioStreamPlaylist::set_shuffle);
|
||
|
ClassDB::bind_method(D_METHOD("get_shuffle"), &AudioStreamPlaylist::get_shuffle);
|
||
|
|
||
|
ClassDB::bind_method(D_METHOD("set_fade_time", "dec"), &AudioStreamPlaylist::set_fade_time);
|
||
|
ClassDB::bind_method(D_METHOD("get_fade_time"), &AudioStreamPlaylist::get_fade_time);
|
||
|
|
||
|
ClassDB::bind_method(D_METHOD("set_loop", "loop"), &AudioStreamPlaylist::set_loop);
|
||
|
ClassDB::bind_method(D_METHOD("has_loop"), &AudioStreamPlaylist::has_loop);
|
||
|
|
||
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "shuffle"), "set_shuffle", "get_shuffle");
|
||
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "loop"), "set_loop", "has_loop");
|
||
|
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fade_time", PROPERTY_HINT_RANGE, "0,1,0.01,suffix:s"), "set_fade_time", "get_fade_time");
|
||
|
|
||
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "stream_count", PROPERTY_HINT_RANGE, "0," + itos(MAX_STREAMS), PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_ARRAY, "Streams,stream_,unfoldable,page_size=999,add_button_text=" + String(RTR("Add Stream"))), "set_stream_count", "get_stream_count");
|
||
|
|
||
|
for (int i = 0; i < MAX_STREAMS; i++) {
|
||
|
ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "stream_" + itos(i), PROPERTY_HINT_RESOURCE_TYPE, "AudioStream", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_INTERNAL), "set_list_stream", "get_list_stream", i);
|
||
|
}
|
||
|
|
||
|
BIND_CONSTANT(MAX_STREAMS);
|
||
|
}
|
||
|
|
||
|
//////////////////////
|
||
|
//////////////////////
|
||
|
|
||
|
AudioStreamPlaybackPlaylist::~AudioStreamPlaybackPlaylist() {
|
||
|
if (playlist.is_valid()) {
|
||
|
playlist->playbacks.erase(this);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void AudioStreamPlaybackPlaylist::stop() {
|
||
|
active = false;
|
||
|
for (int i = 0; i < playlist->stream_count; i++) {
|
||
|
if (playback[i].is_valid()) {
|
||
|
playback[i]->stop();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void AudioStreamPlaybackPlaylist::_update_order() {
|
||
|
for (int i = 0; i < playlist->stream_count; i++) {
|
||
|
play_order[i] = i;
|
||
|
}
|
||
|
|
||
|
if (playlist->shuffle) {
|
||
|
for (int i = 0; i < playlist->stream_count; i++) {
|
||
|
int swap_with = Math::rand() % uint32_t(playlist->stream_count);
|
||
|
SWAP(play_order[i], play_order[swap_with]);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void AudioStreamPlaybackPlaylist::start(double p_from_pos) {
|
||
|
if (active) {
|
||
|
stop();
|
||
|
}
|
||
|
|
||
|
p_from_pos = MAX(0, p_from_pos);
|
||
|
|
||
|
float pl_length = playlist->get_length();
|
||
|
if (p_from_pos >= pl_length) {
|
||
|
if (!playlist->loop) {
|
||
|
return; // No loop, end.
|
||
|
}
|
||
|
p_from_pos = Math::fmod((float)p_from_pos, (float)pl_length);
|
||
|
}
|
||
|
|
||
|
_update_order();
|
||
|
|
||
|
play_index = -1;
|
||
|
|
||
|
double play_ofs = p_from_pos;
|
||
|
for (int i = 0; i < playlist->stream_count; i++) {
|
||
|
int idx = play_order[i];
|
||
|
if (playlist->audio_streams[idx].is_valid()) {
|
||
|
double bpm = playlist->audio_streams[idx]->get_bpm();
|
||
|
int beat_count = playlist->audio_streams[idx]->get_beat_count();
|
||
|
double length;
|
||
|
if (bpm > 0.0 && beat_count > 0) {
|
||
|
length = beat_count * 60.0 / bpm;
|
||
|
} else {
|
||
|
length = playlist->audio_streams[idx]->get_length();
|
||
|
}
|
||
|
if (play_ofs < length) {
|
||
|
play_index = i;
|
||
|
stream_todo = length - play_ofs;
|
||
|
break;
|
||
|
} else {
|
||
|
play_ofs -= length;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (play_index == -1) {
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
playback[play_order[play_index]]->start(play_ofs);
|
||
|
fade_index = -1;
|
||
|
loop_count = 0;
|
||
|
|
||
|
active = true;
|
||
|
}
|
||
|
|
||
|
void AudioStreamPlaybackPlaylist::seek(double p_time) {
|
||
|
stop();
|
||
|
start(p_time);
|
||
|
}
|
||
|
|
||
|
int AudioStreamPlaybackPlaylist::mix(AudioFrame *p_buffer, float p_rate_scale, int p_frames) {
|
||
|
if (!active) {
|
||
|
for (int i = 0; i < p_frames; i++) {
|
||
|
p_buffer[i] = AudioFrame(0.0, 0.0);
|
||
|
}
|
||
|
return p_frames;
|
||
|
}
|
||
|
|
||
|
double time_dec = (1.0 / AudioServer::get_singleton()->get_mix_rate());
|
||
|
double fade_dec = (1.0 / playlist->fade_time) / AudioServer::get_singleton()->get_mix_rate();
|
||
|
|
||
|
int todo = p_frames;
|
||
|
|
||
|
while (todo) {
|
||
|
int to_mix = MIN(todo, MIX_BUFFER_SIZE);
|
||
|
|
||
|
playback[play_order[play_index]]->mix(mix_buffer, 1.0, to_mix);
|
||
|
if (fade_index != -1) {
|
||
|
playback[fade_index]->mix(fade_buffer, 1.0, to_mix);
|
||
|
}
|
||
|
|
||
|
offset += time_dec * to_mix;
|
||
|
|
||
|
for (int i = 0; i < to_mix; i++) {
|
||
|
*p_buffer = mix_buffer[i];
|
||
|
stream_todo -= time_dec;
|
||
|
if (stream_todo < 0) {
|
||
|
//find next stream.
|
||
|
int prev = play_order[play_index];
|
||
|
|
||
|
for (int j = 0; j < playlist->stream_count; j++) {
|
||
|
play_index++;
|
||
|
if (play_index >= playlist->stream_count) {
|
||
|
// No loop, exit.
|
||
|
if (!playlist->loop) {
|
||
|
for (int k = i; k < todo - i; k++) {
|
||
|
p_buffer[k] = AudioFrame(0, 0);
|
||
|
}
|
||
|
todo = to_mix;
|
||
|
active = false;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
_update_order();
|
||
|
play_index = 0;
|
||
|
loop_count++;
|
||
|
offset = time_dec * (to_mix - i);
|
||
|
}
|
||
|
if (playback[play_order[play_index]].is_valid()) {
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (!active) {
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
if (!playback[play_order[play_index]].is_valid()) {
|
||
|
todo = to_mix; // Weird error.
|
||
|
active = false;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
bool restart = true;
|
||
|
if (prev == play_order[play_index]) {
|
||
|
// Went back to the same one, continue loop (if it loops) or restart if it does not.
|
||
|
if (playlist->audio_streams[prev]->has_loop()) {
|
||
|
restart = false;
|
||
|
}
|
||
|
fade_index = -1;
|
||
|
} else {
|
||
|
// Move current mixed data to fade buffer.
|
||
|
for (int j = i; j < to_mix; j++) {
|
||
|
fade_buffer[j] = mix_buffer[j];
|
||
|
}
|
||
|
|
||
|
fade_index = prev;
|
||
|
fade_volume = 1.0;
|
||
|
}
|
||
|
|
||
|
int idx = play_order[play_index];
|
||
|
|
||
|
if (restart) {
|
||
|
playback[idx]->start(0); // No loop, just cold-restart.
|
||
|
playback[idx]->mix(mix_buffer + i, 1.0, to_mix - i); // Fill rest of mix buffer
|
||
|
}
|
||
|
|
||
|
// Update fade todo.
|
||
|
double bpm = playlist->audio_streams[idx]->get_bpm();
|
||
|
int beat_count = playlist->audio_streams[idx]->get_beat_count();
|
||
|
|
||
|
if (bpm > 0.0 && beat_count > 0) {
|
||
|
stream_todo = beat_count * 60.0 / bpm;
|
||
|
} else {
|
||
|
stream_todo = playlist->audio_streams[idx]->get_length();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (fade_index != -1) {
|
||
|
*p_buffer += fade_buffer[i] * fade_volume;
|
||
|
fade_volume -= fade_dec;
|
||
|
if (fade_volume <= 0.0) {
|
||
|
playback[fade_index]->stop();
|
||
|
fade_index = -1;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
p_buffer++;
|
||
|
}
|
||
|
|
||
|
todo -= to_mix;
|
||
|
}
|
||
|
|
||
|
return p_frames;
|
||
|
}
|
||
|
|
||
|
void AudioStreamPlaybackPlaylist::tag_used_streams() {
|
||
|
if (active) {
|
||
|
playlist->audio_streams[play_order[play_index]]->tag_used(playback[play_order[play_index]]->get_playback_position());
|
||
|
}
|
||
|
|
||
|
playlist->tag_used(0);
|
||
|
}
|
||
|
|
||
|
int AudioStreamPlaybackPlaylist::get_loop_count() const {
|
||
|
return loop_count;
|
||
|
}
|
||
|
|
||
|
double AudioStreamPlaybackPlaylist::get_playback_position() const {
|
||
|
return offset;
|
||
|
}
|
||
|
|
||
|
bool AudioStreamPlaybackPlaylist::is_playing() const {
|
||
|
return active;
|
||
|
}
|
||
|
|
||
|
void AudioStreamPlaybackPlaylist::_update_playback_instances() {
|
||
|
stop();
|
||
|
|
||
|
for (int i = 0; i < playlist->stream_count; i++) {
|
||
|
if (playlist->audio_streams[i].is_valid()) {
|
||
|
playback[i] = playlist->audio_streams[i]->instantiate_playback();
|
||
|
} else {
|
||
|
playback[i].unref();
|
||
|
}
|
||
|
}
|
||
|
}
|