Music and Sound Effect loading and playing

almost working music loading

music list sent to godot

wav loading not working

mp3 metadata

load wav initial

load and play title theme first

fix errors not related to nodetools

working wav define loading and music playlists

fixup error handling and playlist

load song chances

code style progress

switch mp3 metadata addon to MusicMetadata

add id3v1 mp3 metadata handling to MusicMetadata

remove commented code from id3v1

sounds gd styling

fix dataloader conflicts

clean up commented code

move MusicChance to dataloader

remove reference to old addon

move sfx defines loader

add self to credits

feedback on soundSingleton

include subfolders in sound singleton sfx map

replace space tabs

replace std_view_to_godot_string with std_to_godot_string

revise singleton files

revise gd side sound

final revisions

1 files changed, 413 insertions, 0 deletions

diff --git a/extension/src/openvic-extension/singletons/SoundSingleton.cpp b/extension/src/openvic-extension/singletons/SoundSingleton.cpp
new file mode 100644
index 0000000..a32d9fe
--- /dev/null
+++ b/extension/src/openvic-extension/singletons/SoundSingleton.cpp
@@ -0,0 +1,413 @@
+#include "SoundSingleton.hpp"
+
+#include <string_view>
+#include <vector>
+
+#include <godot_cpp/core/error_macros.hpp>
+#include <godot_cpp/variant/string.hpp>
+#include <godot_cpp/classes/dir_access.hpp>
+#include <godot_cpp/classes/file_access.hpp>
+#include <godot_cpp/classes/stream_peer_buffer.hpp>
+
+#include "openvic-simulation/utility/StringUtils.hpp"
+#include <openvic-extension/utility/Utilities.hpp>
+#include <openvic-extension/utility/ClassBindings.hpp>
+#include <openvic-extension/singletons/GameSingleton.hpp>
+#include <openvic-dataloader/v2script/AbstractSyntaxTree.hpp>
+#include <openvic-simulation/dataloader/Dataloader.hpp>
+#include <openvic-simulation/dataloader/NodeTools.hpp>
+
+using OpenVic::Utilities::godot_to_std_string;
+using OpenVic::Utilities::std_to_godot_string;
+
+using namespace godot;
+using namespace OpenVic;
+using namespace OpenVic::NodeTools;
+
+//ov_bind_method is used to make a method visible to godot
+void SoundSingleton::_bind_methods() {
+	OV_BIND_METHOD(SoundSingleton::load_music);
+	OV_BIND_METHOD(SoundSingleton::get_song, {"song_name"});
+	OV_BIND_METHOD(SoundSingleton::get_song_list);
+	
+	ADD_PROPERTY(PropertyInfo(
+		Variant::ARRAY,
+		 "song_list", PROPERTY_HINT_ARRAY_TYPE,
+		 "AudioStreamMP3"),
+	"", "get_song_list");
+
+	OV_BIND_METHOD(SoundSingleton::load_sounds);
+	OV_BIND_METHOD(SoundSingleton::get_sound_stream, {"sound_name"});
+	OV_BIND_METHOD(SoundSingleton::get_sound_base_volume, {"sound_name"});
+	OV_BIND_METHOD(SoundSingleton::get_sound_list);
+	
+	ADD_PROPERTY(PropertyInfo(
+		Variant::ARRAY,
+		"sound_list", 
+		PROPERTY_HINT_ARRAY_TYPE,
+		"AudioStreamWAV"),
+	"", "get_sound_list");
+	
+	OV_BIND_METHOD(SoundSingleton::load_title_theme);
+	OV_BIND_METHOD(SoundSingleton::get_title_theme);
+	
+	ADD_PROPERTY(PropertyInfo(
+		Variant::STRING,
+		"title_theme"),
+	"", "get_title_theme"); 
+
+}
+
+SoundSingleton* SoundSingleton::get_singleton() {
+	return _singleton;
+}
+
+SoundSingleton::SoundSingleton() {
+	ERR_FAIL_COND(_singleton != nullptr);
+	_singleton = this;
+}
+
+SoundSingleton::~SoundSingleton() {
+	ERR_FAIL_COND(_singleton != this);
+	_singleton = nullptr;
+}
+
+
+//Load a sound from the path 
+Ref<AudioStreamMP3> SoundSingleton::_load_godot_mp3(String const& path) const {
+	const Ref<FileAccess> file = FileAccess::open(path, FileAccess::ModeFlags::READ);
+	
+	Error err = FileAccess::get_open_error();
+	ERR_FAIL_COND_V_MSG(
+		err != OK || file.is_null(), nullptr,
+		vformat("Failed to open mp3 file %s", path) //named %s, path, 
+	);
+
+	const PackedByteArray data = file->get_buffer(file->get_length());
+
+	Ref<AudioStreamMP3> sound = Ref<AudioStreamMP3>();
+	sound.instantiate();
+	sound->set_data(data);
+
+	return sound;
+}
+
+//slices a path down to after the base_folder, keeps the extension
+//this is because the defines refer to audio files using this format, 
+//so we might as well use this form as the key for the "name"->audiostream map
+String SoundSingleton::to_define_file_name(String const& path, std::string_view const& base_folder) const {
+	String name = path.replace("\\","/");
+	return name.get_slice(base_folder.data(),1); //get file name with extension
+}
+
+//Load a sound from the cache, or directly if its not in the cache
+//take in a path, extract just the file name for the cache (and defines)
+Ref<AudioStreamMP3> SoundSingleton::get_song(String const& path){
+	String name = to_define_file_name(path, music_folder);
+
+	const song_asset_map_t::const_iterator it = tracks.find(name);
+	if (it != tracks.end()) { //it->first = key, it->second = value
+		return it->second;
+	}
+
+	const Ref<AudioStreamMP3> song = _load_godot_mp3(path);
+
+	ERR_FAIL_NULL_V_MSG(
+		song, nullptr,
+		vformat("Failed to load music file: %s", path)
+	);
+	tracks.emplace(std::move(name), song);
+
+	return song;
+
+}
+
+//loading music is actually one of the slower things to do, and we want the title theme
+//playing the whole time. Solution: load it first and separately
+bool SoundSingleton::load_title_theme(){
+	GameSingleton const* game_singleton = GameSingleton::get_singleton();
+	ERR_FAIL_NULL_V_MSG(game_singleton, false, vformat("Error retrieving GameSingleton"));
+
+	static constexpr std::string_view music_directory = "music";
+	bool ret = false;
+
+	Dataloader::path_vector_t music_files = game_singleton->get_dataloader()
+		.lookup_files_in_dir_recursive(music_directory, ".mp3");
+	
+	if(music_files.size() < 1){
+		Logger::error("failed to load title theme: no files in music directory");
+	}
+
+	for(std::filesystem::path const& file_name : music_files) {
+		//the path
+		String file = std_to_godot_string(file_name.string());
+		//file name
+		String file_stem = to_define_file_name(file,music_folder);
+
+		if(file_stem == title_theme_name.data()){
+			if(!get_song(file).is_valid()){
+				Logger::error("failed to load title theme song at path ",file_name);
+				break; //don't try to append a null pointer to the list
+			}
+			else{
+				String name = to_define_file_name(file,music_folder);
+				title_theme = name;
+				ret = true;
+				break;
+			}
+		}
+
+	}
+
+	if(!ret) Logger::error("Failed to load title theme!");
+	
+	return ret;
+}
+
+bool SoundSingleton::load_music() {
+
+	GameSingleton const* game_singleton = GameSingleton::get_singleton();
+	ERR_FAIL_NULL_V_MSG(game_singleton, false, vformat("Error retrieving GameSingleton"));
+	
+	static constexpr std::string_view music_directory = "music";
+	bool ret = true;
+
+	Dataloader::path_vector_t music_files = game_singleton->get_dataloader()
+		.lookup_files_in_dir_recursive(music_directory, ".mp3");
+	
+	if(music_files.size() < 1){
+		Logger::error("failed to load music: no files in music directory");
+		ret = false;
+	}
+
+	for(std::filesystem::path const& file_name : music_files) {
+		String file = std_to_godot_string(file_name.string());
+		String name = to_define_file_name(file,music_folder);
+		if(name == title_theme_name.data()) continue;
+
+		if(!get_song(file).is_valid()){
+			Logger::error("failed to load song at path ",file_name);
+			ret = false;
+			continue; //don't try to append a null pointer to the list
+		}
+		song_list.append(name);
+		
+	}
+
+	return ret;
+}
+
+//Load a sound into the sound cache, accessed via its file path
+Ref<AudioStreamWAV> SoundSingleton::get_sound(String const& path){
+	String name = to_define_file_name(path, sound_folder);
+
+	const sfx_asset_map_t::const_iterator it = sfx.find(name);
+	if (it != sfx.end()) { //it->first = key, it->second = value
+		return it->second;
+	}
+
+	const Ref<AudioStreamWAV> sound = _load_godot_wav(path);
+
+	ERR_FAIL_NULL_V_MSG(
+		sound, nullptr,
+		vformat("Failed to load sound file %s", path) //named %s, path, 
+	);
+
+	sfx.emplace(std::move(name), sound);
+	return sound;
+}
+
+//Get a sound by its define name
+Ref<AudioStreamWAV> SoundSingleton::get_sound_stream(String const& path) {
+	if(sfx_define[path].audioStream.has_value()){
+		return sfx_define[path].audioStream.value();
+	}
+
+	ERR_FAIL_V_MSG(
+		nullptr,
+		vformat("Attempted to retrieve sound stream at invalid index ", path)
+	);
+
+}
+
+//get the base volume of a sound from its define name
+float SoundSingleton::get_sound_base_volume(String const& path) {
+	if(sfx_define[path].volume.has_value()){
+		return sfx_define[path].volume.value().to_float();
+	}
+	return 1.0;
+}
+
+//Requires the sound defines to already be loaded by the dataloader
+//then build the define map (define_identifier->{audiostream,volume})
+bool SoundSingleton::load_sounds() {
+	static constexpr std::string_view sound_directory = "sound";
+	bool ret = true;
+
+	GameSingleton const* game_singleton = GameSingleton::get_singleton();
+	ERR_FAIL_NULL_V_MSG(game_singleton, false, vformat("Error retrieving GameSingleton"));
+
+	SoundEffectManager const& sound_manager = game_singleton->get_definition_manager().get_sound_effect_manager();
+
+	if(sound_manager.sound_effects_empty()){
+		Logger::error("failed to load music: no identifiers in sounds.sfx");
+		ret = false;
+	}
+
+	for(SoundEffect const& sound_inst : sound_manager.get_sound_effects()){
+		std::string folder_path = StringUtils::append_string_views(sound_directory, "/", sound_inst.get_file());
+		fs::path full_path = game_singleton->get_dataloader().lookup_file(folder_path, false);
+		
+		//UI_Cavalry_Selected.wav doesn't exist (paradox mistake, UI_Cavalry_Select.wav does), just keep going
+		//the define its associated with also isn't used in game
+		if(full_path.empty()){
+			Logger::warning("The sound define ",sound_inst.get_identifier()," points to an non-existing file ", folder_path);
+			continue;
+		}
+		
+		Ref<AudioStreamWAV> stream = get_sound(std_to_godot_string(full_path.string()));
+		if(stream.is_null()){
+			Logger::error("failed to load sound ",sound_inst.get_identifier()," at path ",full_path);
+			ret = false;
+			continue; //don't try to append a null pointer to the list
+		}
+
+		String name = to_define_file_name(std_to_godot_string(full_path.string()), sound_folder);
+
+		StringName define_gd_name = std_to_godot_string(sound_inst.get_identifier());
+		sfx_define[define_gd_name].audioStream = get_sound(name);
+		sfx_define[define_gd_name].volume = sound_inst.get_volume();
+
+		sound_list.append(define_gd_name);
+	}
+
+	return ret;
+
+}
+
+Ref<AudioStreamWAV> SoundSingleton::_load_godot_wav(String const& path) const {
+	const Ref<FileAccess> file = FileAccess::open(path, FileAccess::ModeFlags::READ);
+	
+	Error err = FileAccess::get_open_error();
+	ERR_FAIL_COND_V_MSG(
+		err != OK || file.is_null(), nullptr,
+		vformat("Failed to open wav file %s", path)
+	);
+
+
+	Ref<AudioStreamWAV> sound = Ref<AudioStreamWAV>();
+	sound.instantiate();
+
+	//RIFF file header
+	String riff_id = read_riff_str(file); //RIFF
+	int riff_size = std::min(static_cast<uint64_t>(file->get_32()), file->get_length());
+	String form_type = read_riff_str(file); //WAVE
+
+
+	//ie. 16, 24, 32 bit audio
+	int bits_per_sample = 0;
+
+	//godot audiostreamwav has: data,format,loop_begin,loop_end,loop_mode,mix_rate,stereo
+
+	//RIFF reader
+	while(file->get_position() < riff_size){
+		String id = read_riff_str(file);
+		int size = file->get_32();
+		if(id=="LIST"){
+			String list_type = read_riff_str(file);
+		}
+		else if(id=="JUNK"){
+			const PackedByteArray junk = file->get_buffer(size);
+		}
+		else if(id=="fmt "){
+			//what fields to read depends on the fmt chunk variant (can be 16, 18, or 40 bytes long)
+			//basic fields
+
+			//2bytes: type of format can be 1=PCM, 3=IEEE float, 6=8bit Alaw, 7=8bit mu-law, FFFE=go by subformat
+			int formatTag = file->get_16();
+			int channels = file->get_16();
+			int samplesPerSec = file->get_32();
+			int avgBytesPerSec = file->get_32();
+			int blockAlign = file->get_16();
+			
+			bits_per_sample = file->get_16();
+			ERR_FAIL_COND_V_MSG(
+				bits_per_sample == 24 || bits_per_sample == 32, nullptr,
+				vformat("Unsupported wav file sample rate %s", bits_per_sample)
+			);
+			
+			if(size > 16){
+				int extensionSize = file->get_16();
+			}
+			if(size > 18){
+				//extensible format
+				int validBitsPerSample = file->get_16();
+				int channelMask = file->get_32();
+
+				//16 byte subformat
+				int subFormat = file->get_16();
+				String subFormatString = read_riff_str(file,14);
+			}
+
+			//set godot properties
+			sound->set_stereo(channels==2);
+			switch(formatTag){ //TODO: verify, looks from 1 doc like these should be 0x0101, 0x102, ...
+				case 0:{
+					sound->set_format(sound->FORMAT_8_BITS);
+					break;
+				}
+				case 1:{
+					sound->set_format(sound->FORMAT_16_BITS);
+					break;
+				}
+				case 2:{
+					sound->set_format(sound->FORMAT_IMA_ADPCM);
+					break;
+				}
+				default:{
+					Logger::warning("unknown WAV format tag %x",formatTag);
+					sound->set_format(sound->FORMAT_16_BITS);
+					break;
+				}
+			}
+			
+			sound->set_mix_rate(samplesPerSec);
+			
+		}
+		else if(id=="data"){
+			PackedByteArray audio_data = file->get_buffer(size);
+			
+			if(bits_per_sample == 24 || bits_per_sample == 32){
+				//sound->set_data(to_16bit_wav_data(audio_data,bits_per_sample));
+				Logger::error("WAV file ",godot_to_std_string(path), " uses an unsupported sample rate ", bits_per_sample);
+			}
+			else{
+				sound->set_data(audio_data);
+			}
+		}
+		else if(id=="fact"){ //for compressed formats that aren't PCM
+			//TODO: Handle these other cases
+			int sampleLen = file->get_32(); //# samples/channel
+			Logger::warning("WAV fact header, indicates likely unhandled case");
+		}
+		else{
+			//Logger::warning("skipping Unhandled RIFF chunk of id ",godot_to_std_string(id));
+			//known chunks that cause this: "smpl", "labl", "cue ", "ltxt", info chunks (IART, ICOP, IENG, ...)
+			//these don't seem to be needed for our uses
+			const PackedByteArray junk = file->get_buffer(size); //just try and skip this chunk
+
+		}
+		if(file->get_position() % 2 != 0){ //align to even bytes
+			file->get_8();
+		}
+
+	}
+
+	sound->set_loop_end(file->get_length()/4);
+	return sound;
+}
+
+//set size if its an info string, otherwise leaving
+String SoundSingleton::read_riff_str(Ref<FileAccess> const& file, int size) const {
+	return file->get_buffer(size).get_string_from_ascii();
+}
\ No newline at end of file