Fixed the native audio playback

native/serverconnection/src/audio/AudioOutput.cpp

@@ -270,7 +270,7 @@ ssize_t AudioOutputSource::enqueue_samples_no_interleave(const void *source_buff
 bool AudioOutputSource::set_max_buffered_samples(size_t samples) {
     samples = std::max(samples, (size_t) this->fadein_frame_samples_);
     if(samples > this->max_supported_buffering()) {
-        return false;
+        samples = this->max_supported_buffering();
     }
 
     std::lock_guard buffer_lock{this->buffer_mutex};

native/serverconnection/src/audio/sounds/SoundPlayer.cpp

@@ -87,8 +87,9 @@ namespace tc::audio::sounds {
                     this->file_handle = std::make_unique<file::WAVReader>(this->settings_.file);
                     std::string error{};
                     if(auto err{this->file_handle->open_file(error)}; err != file::OPEN_RESULT_SUCCESS) {
-                        if(auto callback{this->settings_.callback}; callback)
+                        if(auto callback{this->settings_.callback}; callback) {
                             callback(PlaybackResult::FILE_OPEN_ERROR, error);
+                        }
                         this->finalize(false);
                         return;
                     }
@@ -175,21 +176,27 @@ namespace tc::audio::sounds {
                 auto weak_this = this->weak_from_this();
                 this->output_source->on_underflow = [weak_this](size_t sample_count){
                     auto self = weak_this.lock();
-                    if(!self) return false;
+                    if(!self) {
+                        return false;
+                    }
 
-                    if(self->state_ == PLAYER_STATE_PLAYING)
+                    if(self->state_ == PLAYER_STATE_PLAYING) {
                         log_warn(category::audio, tr("Having an audio underflow while playing a sound."));
-                    else if(self->state_ == PLAYER_STATE_AWAIT_FINISH)
+                    } else if(self->state_ == PLAYER_STATE_AWAIT_FINISH) {
                         self->state_ = PLAYER_STATE_FINISHED;
+                    }
                     audio::decode_event_loop->schedule(self);
                     return false;
                 };
                 this->output_source->on_read = [weak_this] {
                     auto self = weak_this.lock();
-                    if(!self) return;
+                    if(!self) {
+                        return;
+                    }
 
-                    if(self->could_enqueue_next_buffer() && self->state_ == PLAYER_STATE_PLAYING)
+                    if(self->could_enqueue_next_buffer() && self->state_ == PLAYER_STATE_PLAYING) {
                         audio::decode_event_loop->schedule(self);
+                    }
                 };
 
                 this->output_source->on_overflow = [weak_this](size_t count) {
@@ -205,7 +212,9 @@ namespace tc::audio::sounds {
             }
 
             [[nodiscard]] inline bool could_enqueue_next_buffer() const {
-                if(!this->output_source) return false;
+                if(!this->output_source) {
+                    return false;
+                }
 
                 const auto current_size = this->output_source->currently_buffered_samples();
                 const auto max_size = this->output_source->max_buffered_samples();
@@ -233,8 +242,9 @@ namespace tc::audio::sounds {
         auto player = std::make_shared<FilePlayer>(settings);
         file_players.push_back(player);
         if(!player->play()) {
-            if(auto callback{settings.callback}; callback)
+            if(auto callback{settings.callback}; callback) {
                 callback(PlaybackResult::PLAYBACK_ERROR, "failed to start playback.");
+            }
             return 0;
         }
         fplock.unlock();
@@ -244,7 +254,9 @@ namespace tc::audio::sounds {
     void cancel_playback(const sound_playback_id& id) {
         std::unique_lock fplock{file_player_mutex};
         auto player_it = std::find_if(file_players.begin(), file_players.end(), [&](const auto& player) { return (sound_playback_id) &*player == id; });
-        if(player_it == file_players.end()) return;
+        if(player_it == file_players.end()) {
+            return;
+        }
 
         auto player = *player_it;
         file_players.erase(player_it);