diff options
Diffstat (limited to 'scene/audio/audio_stream_player_internal.cpp')
| -rw-r--r-- | scene/audio/audio_stream_player_internal.cpp | 321 |
1 files changed, 321 insertions, 0 deletions
diff --git a/scene/audio/audio_stream_player_internal.cpp b/scene/audio/audio_stream_player_internal.cpp new file mode 100644 index 0000000000..d5f6f91c88 --- /dev/null +++ b/scene/audio/audio_stream_player_internal.cpp @@ -0,0 +1,321 @@ +/**************************************************************************/ +/* audio_stream_player_internal.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_player_internal.h" + +#include "scene/main/node.h" +#include "scene/scene_string_names.h" +#include "servers/audio/audio_stream.h" + +void AudioStreamPlayerInternal::_set_process(bool p_enabled) { + if (physical) { + node->set_physics_process_internal(p_enabled); + } else { + node->set_process(p_enabled); + } +} + +void AudioStreamPlayerInternal::_update_stream_parameters() { + if (stream.is_null()) { + return; + } + + List<AudioStream::Parameter> parameters; + stream->get_parameter_list(¶meters); + for (const AudioStream::Parameter &K : parameters) { + const PropertyInfo &pi = K.property; + StringName key = PARAM_PREFIX + pi.name; + if (!playback_parameters.has(key)) { + ParameterData pd; + pd.path = pi.name; + pd.value = K.default_value; + playback_parameters.insert(key, pd); + } + } +} + +void AudioStreamPlayerInternal::process() { + Vector<Ref<AudioStreamPlayback>> playbacks_to_remove; + for (Ref<AudioStreamPlayback> &playback : stream_playbacks) { + if (playback.is_valid() && !AudioServer::get_singleton()->is_playback_active(playback) && !AudioServer::get_singleton()->is_playback_paused(playback)) { + playbacks_to_remove.push_back(playback); + } + } + // Now go through and remove playbacks that have finished. Removing elements from a Vector in a range based for is asking for trouble. + for (Ref<AudioStreamPlayback> &playback : playbacks_to_remove) { + stream_playbacks.erase(playback); + } + if (!playbacks_to_remove.is_empty() && stream_playbacks.is_empty()) { + // This node is no longer actively playing audio. + active.clear(); + _set_process(false); + } + if (!playbacks_to_remove.is_empty()) { + node->emit_signal(SNAME("finished")); + } +} + +void AudioStreamPlayerInternal::ensure_playback_limit() { + while (stream_playbacks.size() > max_polyphony) { + AudioServer::get_singleton()->stop_playback_stream(stream_playbacks[0]); + stream_playbacks.remove_at(0); + } +} + +void AudioStreamPlayerInternal::notification(int p_what) { + switch (p_what) { + case Node::NOTIFICATION_ENTER_TREE: { + if (autoplay && !Engine::get_singleton()->is_editor_hint()) { + play_callable.call(0.0); + } + set_stream_paused(!node->can_process()); + } break; + + case Node::NOTIFICATION_EXIT_TREE: { + set_stream_paused(true); + } break; + + case Node::NOTIFICATION_INTERNAL_PROCESS: { + process(); + } break; + + case Node::NOTIFICATION_PREDELETE: { + for (Ref<AudioStreamPlayback> &playback : stream_playbacks) { + AudioServer::get_singleton()->stop_playback_stream(playback); + } + stream_playbacks.clear(); + } break; + + case Node::NOTIFICATION_PAUSED: { + if (!node->can_process()) { + // Node can't process so we start fading out to silence + set_stream_paused(true); + } + } break; + + case Node::NOTIFICATION_UNPAUSED: { + set_stream_paused(false); + } break; + } +} + +Ref<AudioStreamPlayback> AudioStreamPlayerInternal::play_basic() { + Ref<AudioStreamPlayback> stream_playback; + if (stream.is_null()) { + return stream_playback; + } + ERR_FAIL_COND_V_MSG(!node->is_inside_tree(), stream_playback, "Playback can only happen when a node is inside the scene tree"); + if (stream->is_monophonic() && is_playing()) { + stop(); + } + stream_playback = stream->instantiate_playback(); + ERR_FAIL_COND_V_MSG(stream_playback.is_null(), stream_playback, "Failed to instantiate playback."); + + for (const KeyValue<StringName, ParameterData> &K : playback_parameters) { + stream_playback->set_parameter(K.value.path, K.value.value); + } + + stream_playbacks.push_back(stream_playback); + active.set(); + _set_process(true); + return stream_playback; +} + +void AudioStreamPlayerInternal::set_stream_paused(bool p_pause) { + // TODO this does not have perfect recall, fix that maybe? If there are zero playbacks registered with the AudioServer, this bool isn't persisted. + for (Ref<AudioStreamPlayback> &playback : stream_playbacks) { + AudioServer::get_singleton()->set_playback_paused(playback, p_pause); + } +} + +bool AudioStreamPlayerInternal::get_stream_paused() const { + // There's currently no way to pause some playback streams but not others. Check the first and don't bother looking at the rest. + if (!stream_playbacks.is_empty()) { + return AudioServer::get_singleton()->is_playback_paused(stream_playbacks[0]); + } + return false; +} + +void AudioStreamPlayerInternal::validate_property(PropertyInfo &p_property) const { + if (p_property.name == "bus") { + String options; + for (int i = 0; i < AudioServer::get_singleton()->get_bus_count(); i++) { + if (i > 0) { + options += ","; + } + String name = AudioServer::get_singleton()->get_bus_name(i); + options += name; + } + + p_property.hint_string = options; + } +} + +bool AudioStreamPlayerInternal::set(const StringName &p_name, const Variant &p_value) { + ParameterData *pd = playback_parameters.getptr(p_name); + if (!pd) { + return false; + } + pd->value = p_value; + for (Ref<AudioStreamPlayback> &playback : stream_playbacks) { + playback->set_parameter(pd->path, pd->value); + } + return true; +} + +bool AudioStreamPlayerInternal::get(const StringName &p_name, Variant &r_ret) const { + const ParameterData *pd = playback_parameters.getptr(p_name); + if (!pd) { + return false; + } + r_ret = pd->value; + return true; +} + +void AudioStreamPlayerInternal::get_property_list(List<PropertyInfo> *p_list) const { + if (stream.is_null()) { + return; + } + List<AudioStream::Parameter> parameters; + stream->get_parameter_list(¶meters); + for (const AudioStream::Parameter &K : parameters) { + PropertyInfo pi = K.property; + pi.name = PARAM_PREFIX + pi.name; + + const ParameterData *pd = playback_parameters.getptr(pi.name); + if (pd && pd->value == K.default_value) { + pi.usage &= ~PROPERTY_USAGE_STORAGE; + } + + p_list->push_back(pi); + } +} + +void AudioStreamPlayerInternal::set_stream(Ref<AudioStream> p_stream) { + if (stream.is_valid()) { + stream->disconnect(SNAME("parameter_list_changed"), callable_mp(this, &AudioStreamPlayerInternal::_update_stream_parameters)); + } + stop(); + stream = p_stream; + _update_stream_parameters(); + if (stream.is_valid()) { + stream->connect(SNAME("parameter_list_changed"), callable_mp(this, &AudioStreamPlayerInternal::_update_stream_parameters)); + } + node->notify_property_list_changed(); +} + +void AudioStreamPlayerInternal::seek(float p_seconds) { + if (is_playing()) { + stop(); + play_callable.call(p_seconds); + } +} + +void AudioStreamPlayerInternal::stop() { + for (Ref<AudioStreamPlayback> &playback : stream_playbacks) { + AudioServer::get_singleton()->stop_playback_stream(playback); + } + stream_playbacks.clear(); + active.clear(); + _set_process(false); +} + +bool AudioStreamPlayerInternal::is_playing() const { + for (const Ref<AudioStreamPlayback> &playback : stream_playbacks) { + if (AudioServer::get_singleton()->is_playback_active(playback)) { + return true; + } + } + return false; +} + +float AudioStreamPlayerInternal::get_playback_position() { + // Return the playback position of the most recently started playback stream. + if (!stream_playbacks.is_empty()) { + return AudioServer::get_singleton()->get_playback_position(stream_playbacks[stream_playbacks.size() - 1]); + } + return 0; +} + +void AudioStreamPlayerInternal::set_playing(bool p_enable) { + if (p_enable) { + play_callable.call(0.0); + } else { + stop(); + } +} + +bool AudioStreamPlayerInternal::is_active() const { + return active.is_set(); +} + +void AudioStreamPlayerInternal::set_pitch_scale(float p_pitch_scale) { + ERR_FAIL_COND(p_pitch_scale <= 0.0); + pitch_scale = p_pitch_scale; + + for (Ref<AudioStreamPlayback> &playback : stream_playbacks) { + AudioServer::get_singleton()->set_playback_pitch_scale(playback, pitch_scale); + } +} + +void AudioStreamPlayerInternal::set_max_polyphony(int p_max_polyphony) { + if (p_max_polyphony > 0) { + max_polyphony = p_max_polyphony; + } +} + +bool AudioStreamPlayerInternal::has_stream_playback() { + return !stream_playbacks.is_empty(); +} + +Ref<AudioStreamPlayback> AudioStreamPlayerInternal::get_stream_playback() { + ERR_FAIL_COND_V_MSG(stream_playbacks.is_empty(), Ref<AudioStreamPlayback>(), "Player is inactive. Call play() before requesting get_stream_playback()."); + return stream_playbacks[stream_playbacks.size() - 1]; +} + +StringName AudioStreamPlayerInternal::get_bus() const { + const String bus_name = bus; + for (int i = 0; i < AudioServer::get_singleton()->get_bus_count(); i++) { + if (AudioServer::get_singleton()->get_bus_name(i) == bus_name) { + return bus; + } + } + return SceneStringNames::get_singleton()->Master; +} + +AudioStreamPlayerInternal::AudioStreamPlayerInternal(Node *p_node, const Callable &p_play_callable, bool p_physical) { + node = p_node; + play_callable = p_play_callable; + physical = p_physical; + bus = SceneStringNames::get_singleton()->Master; + + AudioServer::get_singleton()->connect("bus_layout_changed", callable_mp((Object *)node, &Object::notify_property_list_changed)); + AudioServer::get_singleton()->connect("bus_renamed", callable_mp((Object *)node, &Object::notify_property_list_changed).unbind(3)); +} |