26 #include <SDL2/SDL_mixer.h> 33 #define DBG_AUDIO LOG_STREAM(debug, log_audio) 34 #define LOG_AUDIO LOG_STREAM(info, log_audio) 35 #define ERR_AUDIO LOG_STREAM(err, log_audio) 37 #if (MIX_MAJOR_VERSION < 1) || (MIX_MAJOR_VERSION == 1) && ((MIX_MINOR_VERSION < 2) || (MIX_MINOR_VERSION == 2) && (MIX_PATCHLEVEL <= 11)) 38 #error "Please upgrade to SDL mixer version >= 1.2.12, we don't support older versions anymore." 54 int music_start_time = 0;
55 unsigned music_refresh = 0;
56 unsigned music_refresh_rate = 20;
57 bool want_new_music =
false;
58 int fadingout_time = 5000;
59 bool no_fading =
false;
60 bool unload_music =
false;
63 const std::size_t n_of_channels = 32;
66 const std::size_t bell_channel = 0;
67 const std::size_t timer_channel = 1;
70 const std::size_t source_channels = 8;
71 const std::size_t source_channel_start = timer_channel + 1;
72 const std::size_t source_channel_last = source_channel_start + source_channels - 1;
73 const std::size_t UI_sound_channels = 2;
74 const std::size_t UI_sound_channel_start = source_channel_last + 1;
75 const std::size_t UI_sound_channel_last = UI_sound_channel_start + UI_sound_channels - 1;
76 const std::size_t n_reserved_channels = UI_sound_channel_last + 1;
80 unsigned max_cached_chunks = 256;
82 std::map<Mix_Chunk*, int> chunk_usage;
97 assert(this_usage != chunk_usage.end());
98 if(--(this_usage->second) == 0) {
100 chunk_usage.erase(this_usage);
106 class sound_cache_chunk
109 sound_cache_chunk(
const std::string&
f)
115 sound_cache_chunk(
const sound_cache_chunk& scc)
131 void set_data(Mix_Chunk*
d)
138 Mix_Chunk* get_data()
const 143 bool operator==(
const sound_cache_chunk& scc)
const 145 return file == scc.file;
148 bool operator!=(
const sound_cache_chunk& scc)
const 153 sound_cache_chunk& operator=(
const sound_cache_chunk& scc)
157 set_data(scc.get_data());
165 std::list<sound_cache_chunk> sound_cache;
167 std::map<std::string, std::shared_ptr<Mix_Music>> music_cache;
169 std::vector<std::string> played_before;
179 std::vector<std::shared_ptr<sound::music_track>> current_track_list;
180 std::shared_ptr<sound::music_track> current_track;
181 unsigned int current_track_index = 0;
182 std::shared_ptr<sound::music_track> previous_track;
184 std::vector<std::shared_ptr<sound::music_track>>::const_iterator find_track(
const sound::music_track& track)
186 return std::find_if(current_track_list.begin(), current_track_list.end(),
187 [&track](
const std::shared_ptr<const sound::music_track>& ptr) {
return *ptr == track; }
203 if(current_track_index >= current_track_list.size()){
206 return current_track_index;
210 return current_track;
214 return previous_track;
218 previous_track = track;
223 return current_track_list.size();
228 if(i < current_track_list.size()) {
229 return current_track_list[
i];
232 if(i == current_track_list.size()) {
233 return current_track;
239 void set_track(
unsigned int i,
const std::shared_ptr<music_track>& to)
241 if(i < current_track_list.size() && find_track(*to) != current_track_list.end()) {
242 current_track_list[
i] = std::make_shared<music_track>(*to);
248 if(i >= current_track_list.size()) {
252 if(i == current_track_index) {
255 current_track->set_play_once(
true);
258 current_track_index = current_track_list.size() - 1;
259 }
else if(i < current_track_index) {
260 current_track_index--;
263 current_track_list.erase(current_track_list.begin() +
i);
270 LOG_AUDIO <<
"Considering " <<
id <<
"\n";
278 if(
id == current_track->file_path()) {
282 if(current_track_list.size() <= 3) {
294 unsigned int num_played = 0;
295 std::set<std::string> played;
296 std::vector<std::string>::reverse_iterator
i;
298 for(i = played_before.rbegin(); i != played_before.rend(); ++
i) {
301 if(num_played == 2) {
310 if(num_played == 2 && played.size() != current_track_list.size() - 1) {
311 LOG_AUDIO <<
"Played twice with only " << played.size() <<
" tracks between\n";
316 i = played_before.rbegin();
317 if(i != played_before.rend()) {
319 if(i != played_before.rend()) {
321 LOG_AUDIO <<
"Played just before previous\n";
332 assert(!current_track_list.empty());
334 if(current_track_index >= current_track_list.size()) {
335 current_track_index = 0;
338 if(current_track_list[current_track_index]->
shuffle()) {
339 unsigned int track = 0;
341 if(current_track_list.size() > 1) {
344 }
while(!
track_ok(current_track_list[track]->file_path()));
347 current_track_index = track;
350 DBG_AUDIO <<
"Next track will be " << current_track_list[current_track_index]->file_path() <<
"\n";
351 played_before.push_back(current_track_list[current_track_index]->file_path());
352 return current_track_list[current_track_index];
355 static std::string
pick_one(
const std::string& files)
363 if(ids.size() == 1) {
368 static std::map<std::string, unsigned int> prev_choices;
371 if(prev_choices.find(files) != prev_choices.end()) {
373 if(choice >= prev_choices[files]) {
377 prev_choices[files] = choice;
380 prev_choices.emplace(files, choice);
414 const char*
const drvname = SDL_GetCurrentAudioDriver();
415 return drvname ? drvname :
"<not initialized>";
420 std::vector<std::string> res;
421 int num_drivers = SDL_GetNumVideoDrivers();
423 for(
int n = 0;
n < num_drivers; ++
n) {
424 const char* drvname = SDL_GetAudioDriver(
n);
425 res.emplace_back(drvname ? drvname :
"<invalid driver>");
436 Mix_QuerySpec(&res.frequency, &res.format, &res.channels);
446 if(SDL_WasInit(SDL_INIT_AUDIO) == 0) {
447 if(SDL_InitSubSystem(SDL_INIT_AUDIO) == -1) {
455 ERR_AUDIO <<
"Could not initialize audio: " << Mix_GetError() << std::endl;
460 Mix_AllocateChannels(n_of_channels);
461 Mix_ReserveChannels(n_reserved_channels);
469 Mix_GroupChannels(source_channel_start, source_channel_last,
SOUND_SOURCES);
470 Mix_GroupChannels(UI_sound_channel_start, UI_sound_channel_last,
SOUND_UI);
471 Mix_GroupChannels(n_reserved_channels, n_of_channels - 1,
SOUND_FX);
482 DBG_AUDIO <<
"Channel layout: " << n_of_channels <<
" channels (" << n_reserved_channels <<
" reserved)\n" 483 <<
" " << bell_channel <<
" - bell\n" 484 <<
" " << timer_channel <<
" - timer\n" 485 <<
" " << source_channel_start <<
".." << source_channel_last <<
" - sound sources\n" 486 <<
" " << UI_sound_channel_start <<
".." << UI_sound_channel_last <<
" - UI\n" 487 <<
" " << UI_sound_channel_last + 1 <<
".." << n_of_channels - 1 <<
" - sound effects\n";
497 int frequency, channels;
508 int numtimesopened = Mix_QuerySpec(&frequency, &format, &channels);
509 if(numtimesopened == 0) {
510 ERR_AUDIO <<
"Error closing audio device: " << Mix_GetError() << std::endl;
513 while(numtimesopened) {
519 if(SDL_WasInit(SDL_INIT_AUDIO) != 0) {
520 SDL_QuitSubSystem(SDL_INIT_AUDIO);
533 if(music || sound || bell || UI_sound) {
536 ERR_AUDIO <<
"Error initializing audio device: " << Mix_GetError() << std::endl;
560 Mix_FadeOutMusic(500);
561 Mix_HookMusicFinished([]() { unload_music =
true; });
571 sound_cache.remove_if([](
const sound_cache_chunk&
c) {
586 sound_cache.remove_if([](
const sound_cache_chunk&
c) {
597 sound_cache.remove_if([](
const sound_cache_chunk&
c) {
606 current_track = std::make_shared<music_track>(file);
607 current_track->set_play_once(
true);
608 current_track_index = current_track_list.size();
614 current_track_list.clear();
623 music_start_time = 1;
624 want_new_music =
true;
626 fadingout_time = previous_track !=
nullptr ? previous_track->ms_after() : 0;
632 if(i >= current_track_list.size()) {
635 current_track_index =
i;
636 current_track = current_track_list[
i];
643 music_start_time = 0;
644 want_new_music =
true;
651 const std::string& filename = localized.empty() ? current_track->file_path() : localized;
653 auto itor = music_cache.find(filename);
654 if(itor == music_cache.end()) {
655 LOG_AUDIO <<
"attempting to insert track '" << filename <<
"' into cache\n";
659 const std::shared_ptr<Mix_Music> music(Mix_LoadMUSType_RW(rwops.release(), MUS_NONE,
true), &Mix_FreeMusic);
661 if(music ==
nullptr) {
662 ERR_AUDIO <<
"Could not load music file '" << filename <<
"': " << Mix_GetError() <<
"\n";
666 itor = music_cache.emplace(filename, music).first;
669 LOG_AUDIO <<
"Playing track '" << filename <<
"'\n";
670 int fading_time = current_track->ms_before();
675 const int res = Mix_FadeInMusic(itor->second.get(), 1, fading_time);
677 ERR_AUDIO <<
"Could not play music: " << Mix_GetError() <<
" " << filename <<
" " << std::endl;
680 want_new_music =
false;
690 current_track_list.clear();
691 current_track_list.emplace_back(
new music_track(
id));
693 std::shared_ptr<music_track> last_track = current_track;
694 current_track = current_track_list.back();
695 current_track_index = 0;
698 if(!last_track || !current_track || *last_track != *current_track) {
716 if(!track.
valid() && !track.
id().empty()) {
717 ERR_AUDIO <<
"cannot open track '" << track.
id() <<
"'; disabled in this playlist." << std::endl;
723 current_track = std::make_shared<music_track>(track);
724 current_track_index = current_track_list.size();
731 current_track_list.clear();
738 auto iter = find_track(track);
742 if(iter == current_track_list.end()) {
743 if(i < 0 || static_cast<std::size_t>(i) >= current_track_list.size()) {
744 current_track_list.emplace_back(
new music_track(track));
745 iter = current_track_list.end() - 1;
747 iter = current_track_list.emplace(current_track_list.begin() + 1,
new music_track(track));
748 if(current_track_index >= static_cast<std::size_t>(i)) {
749 current_track_index++;
753 ERR_AUDIO <<
"tried to add duplicate track '" << track.
file_path() <<
"'" << std::endl;
759 current_track = *iter;
760 current_track_index = iter - current_track_list.begin();
762 }
else if(!track.
append() && !allow_interrupt_current_track && current_track) {
764 current_track->set_play_once(
true);
771 if(!music_start_time && !current_track_list.empty() && !Mix_PlayingMusic()) {
775 music_start_time = info.
ticks();
780 if(music_start_time && info.
ticks(&music_refresh, music_refresh_rate) >= music_start_time - fadingout_time) {
781 want_new_music =
true;
785 if(Mix_PlayingMusic()) {
786 Mix_FadeOutMusic(fadingout_time);
789 unload_music =
false;
798 Mix_HookMusicFinished(
nullptr);
800 unload_music =
false;
805 :
events::sdl_handler(false)
813 if(event.window.event == SDL_WINDOWEVENT_FOCUS_GAINED) {
815 }
else if(event.window.event == SDL_WINDOWEVENT_FOCUS_LOST) {
816 if(Mix_PlayingMusic()) {
825 played_before.clear();
829 if(current_track->play_once()) {
834 for(
auto m : current_track_list) {
835 if(*current_track == *m) {
842 if(current_track_list.empty()) {
856 for(
auto m : current_track_list) {
857 m->write(snapshot, append);
865 for(
unsigned ch = 0; ch <
channel_ids.size(); ++ch) {
873 Mix_SetDistance(ch, distance);
895 sound_cache_iterator it_bgn, it_end;
896 sound_cache_iterator it;
898 sound_cache_chunk temp_chunk(file);
899 it_bgn = sound_cache.begin();
900 it_end = sound_cache.end();
901 it = std::find(it_bgn, it_end, temp_chunk);
904 if(it->group != group) {
910 sound_cache.splice(it_bgn, sound_cache, it);
913 bool cache_full = (sound_cache.size() == max_cached_chunks);
914 while(cache_full && it != it_bgn) {
917 if(std::find(
channel_chunks.begin(), ch_end, (--it)->get_data()) == ch_end) {
918 sound_cache.erase(it);
924 LOG_AUDIO <<
"Maximum sound cache size reached and all are busy, skipping.\n";
928 temp_chunk.group = group;
932 if(!filename.empty()) {
934 temp_chunk.set_data(Mix_LoadWAV_RW(rwops.release(),
true));
936 ERR_AUDIO <<
"Could not load sound file '" << file <<
"'." << std::endl;
940 if(temp_chunk.get_data() ==
nullptr) {
941 ERR_AUDIO <<
"Could not load sound file '" << filename <<
"': " << Mix_GetError() <<
"\n";
945 sound_cache.push_front(temp_chunk);
948 return sound_cache.begin()->get_data();
953 unsigned int repeats = 0,
954 unsigned int distance = 0,
957 int fadein_ticks = 0)
966 int channel = Mix_GroupAvailable(group);
968 LOG_AUDIO <<
"All channels dedicated to sound group(" << group <<
") are busy, skipping.\n";
987 Mix_SetDistance(channel, distance);
992 if(fadein_ticks > 0) {
993 res = Mix_FadeInChannelTimed(channel, chunk, -1, fadein_ticks, loop_ticks);
995 res = Mix_PlayChannel(channel, chunk, -1);
999 Mix_ExpireChannel(channel, loop_ticks);
1002 if(fadein_ticks > 0) {
1003 res = Mix_FadeInChannel(channel, chunk, repeats, fadein_ticks);
1005 res = Mix_PlayChannel(channel, chunk, repeats);
1010 ERR_AUDIO <<
"error playing sound effect: " << Mix_GetError() << std::endl;
1044 void play_timer(
const std::string& files,
int loop_ticks,
int fadein_ticks)
1062 return Mix_VolumeMusic(-1);
1070 if(mix_ok && vol >= 0) {
1071 if(vol > MIX_MAX_VOLUME) {
1072 vol = MIX_MAX_VOLUME;
1075 Mix_VolumeMusic(vol);
1083 return Mix_Volume(source_channel_start, -1);
1090 if(mix_ok && vol >= 0) {
1091 if(vol > MIX_MAX_VOLUME) {
1092 vol = MIX_MAX_VOLUME;
1096 for(
unsigned i = 0;
i < n_of_channels; ++
i) {
1097 if(!(
i >= UI_sound_channel_start &&
i <= UI_sound_channel_last) &&
i != bell_channel
1098 &&
i != timer_channel) {
1110 if(mix_ok && vol >= 0) {
1111 if(vol > MIX_MAX_VOLUME) {
1112 vol = MIX_MAX_VOLUME;
1115 Mix_Volume(bell_channel, vol);
1116 Mix_Volume(timer_channel, vol);
1122 if(mix_ok && vol >= 0) {
1123 if(vol > MIX_MAX_VOLUME) {
1124 vol = MIX_MAX_VOLUME;
1127 for(
unsigned i = UI_sound_channel_start;
i <= UI_sound_channel_last; ++
i) {
unsigned int get_num_tracks()
const std::string & id() const
bool is_sound_playing(int id)
void play_sound_positioned(const std::string &files, int id, int repeats, unsigned int distance)
std::string current_driver()
std::shared_ptr< music_track > get_current_track()
void set_UI_volume(int vol)
int ticks(unsigned *refresh_counter=nullptr, unsigned refresh_rate=1)
rwops_ptr make_read_RWops(const std::string &path)
static void play_new_music()
void remove_track(unsigned int i)
std::shared_ptr< music_track > get_previous_music_track()
unsigned int sample_rate()
std::string get_binary_file_location(const std::string &type, const std::string &filename)
Returns a complete path to the actual file of a given type or an empty string if the file isn't prese...
Audio output for sound and music.
void play_music_once(const std::string &file)
static lg::log_domain log_audio("audio")
bool operator!=(const config &a, const config &b)
void write_music_play_list(config &snapshot)
Definitions for the interface to Wesnoth Markup Language (WML).
void reposition_sound(int id, unsigned int distance)
void play_sound(const std::string &files, channel_group group, unsigned int repeats)
static bool track_ok(const std::string &id)
static void play_sound_internal(const std::string &files, channel_group group, unsigned int repeats=0, unsigned int distance=0, int id=-1, int loop_ticks=0, int fadein_ticks=0)
void set_bell_volume(int vol)
static void channel_finished_hook(int channel)
static std::string pick_one(const std::string &files)
void set_previous_track(std::shared_ptr< music_track > track)
static Mix_Chunk * load_chunk(const std::string &file, channel_group group)
void set_sound_volume(int vol)
void set_music_volume(int vol)
std::string id
Text to match against addon_info.tags()
static std::vector< Mix_Chunk * > channel_chunks
void process(events::pump_info &info)
bool stop_music_in_background()
bool operator==(const config &a, const config &b)
Internal representation of music tracks.
Declarations for File-IO.
std::unique_ptr< SDL_RWops, void(*)(SDL_RWops *)> rwops_ptr
int get_random_int(int min, int max)
This helper method provides a random int from the underlying generator, using results of next_random...
std::string get_localized_path(const std::string &file, const std::string &suff)
Returns the localized version of the given filename, if it exists.
static void increment_chunk_usage(Mix_Chunk *mcp)
std::size_t sound_buffer_size()
Handling of system events.
const std::string & file_path() const
void play_bell(const std::string &files)
static std::vector< int > channel_ids
void play_timer(const std::string &files, int loop_ticks, int fadein_ticks)
void play_music_config(const config &music_node, bool allow_interrupt_current_track, int i)
std::optional< unsigned int > get_current_track_index()
void play_music_repeatedly(const std::string &id)
void play_UI_sound(const std::string &files)
Standard logging facilities (interface).
void handle_window_event(const SDL_Event &event) override
std::vector< game_tip > shuffle(const std::vector< game_tip > &tips)
Shuffles the tips.
void commit_music_changes()
void set_track(unsigned int i, const std::shared_ptr< music_track > &to)
static driver_status query()
A config object defines a single node in a WML file, with access to child nodes.
std::vector< std::string > enumerate_drivers()
void play_track(unsigned int i)
static map_location::DIRECTION n
static std::shared_ptr< sound::music_track > choose_track()
static void decrement_chunk_usage(Mix_Chunk *mcp)
static rng & default_instance()
virtual void join_global()
std::string::const_iterator iterator
std::shared_ptr< music_track > get_track(unsigned int i)
std::vector< std::string > square_parenthetical_split(const std::string &val, const char separator, const std::string &left, const std::string &right, const int flags)
Similar to parenthetical_split, but also expands embedded square brackets.