diff --git a/Concurrency/AsyncTaskQueue.hpp b/Concurrency/AsyncTaskQueue.hpp index 5968f962d..dbd24804f 100644 --- a/Concurrency/AsyncTaskQueue.hpp +++ b/Concurrency/AsyncTaskQueue.hpp @@ -135,7 +135,7 @@ public: if(thread_.joinable()) { enqueue([this] { - should_quit_.test_and_set(); + should_quit_ = true; }); if constexpr (!perform_automatically) { perform(); @@ -201,11 +201,11 @@ private: ActionVector actions; // Continue until told to quit. - while(!should_quit_.test(std::memory_order::relaxed)) { + while(!should_quit_) { // Wait for new actions to be signalled, and grab them. std::unique_lock lock(condition_mutex_); condition_.wait(lock, [&] { - return !actions_.empty() || should_quit_.test(std::memory_order::relaxed); + return !actions_.empty() || should_quit_; }); std::swap(actions, actions_); lock.unlock(); @@ -229,7 +229,7 @@ private: ActionVector actions_; // Necessary synchronisation parts. - std::atomic_flag should_quit_; + bool should_quit_ = false; mutable std::mutex condition_mutex_; std::condition_variable condition_; diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm index 05e005edd..69e035bcf 100644 --- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm +++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm @@ -956,9 +956,11 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget; } [commandBuffer presentDrawable:view.currentDrawable]; + __weak CSScanTarget *weakSelf = self; [commandBuffer addCompletedHandler:^(id _Nonnull) { - self->_isDrawing.clear(); - self->_scanTarget.display_metrics_.announce_draw_status(true); + CSScanTarget *strongSelf = weakSelf; + strongSelf->_isDrawing.clear(); + strongSelf->_scanTarget.display_metrics_.announce_draw_status(true); }]; [commandBuffer commit]; } diff --git a/Outputs/Speaker/Implementation/LowpassSpeaker.hpp b/Outputs/Speaker/Implementation/LowpassSpeaker.hpp index e75fc71c6..16a5a1864 100644 --- a/Outputs/Speaker/Implementation/LowpassSpeaker.hpp +++ b/Outputs/Speaker/Implementation/LowpassSpeaker.hpp @@ -78,7 +78,10 @@ private: // Implemented as per Speaker. void set_computed_output_rate(const float cycles_per_second, const int buffer_size, bool) final { std::lock_guard lock_guard(filter_parameters_mutex_); - if(filter_parameters_.output_cycles_per_second == cycles_per_second && size_t(buffer_size) == output_buffer_.size()) { + if( + filter_parameters_.output_cycles_per_second == cycles_per_second && + size_t(buffer_size) == output_buffer_.size() + ) { return; } @@ -135,9 +138,14 @@ private: // If input and output rates exactly match, and no additional cut-off has been specified, // just accumulate results and pass on. conversion_ = Conversion::Copy; - } else if( filter_parameters.input_cycles_per_second > filter_parameters.output_cycles_per_second || - (filter_parameters.input_cycles_per_second == filter_parameters.output_cycles_per_second && filter_parameters.high_frequency_cutoff >= 0.0)) { - // If the output rate is less than the input rate, or an additional cut-off has been specified, use the filter. + } else if( + filter_parameters.input_cycles_per_second > filter_parameters.output_cycles_per_second || + ( + filter_parameters.input_cycles_per_second == filter_parameters.output_cycles_per_second && + filter_parameters.high_frequency_cutoff >= 0.0 + ) + ) { + // If the output rate is less than the input rate, or an additional cut-off has been specified, filter. conversion_ = Conversion::ResampleSmaller; } else { conversion_ = Conversion::ResampleLarger; @@ -183,14 +191,16 @@ private: // Apply scale, if supplied, clamping appropriately. if(scale != 65536) { - #define SCALE(x) x = int16_t(std::clamp((int(x) * scale) >> 16, -32768, 32767)) + const auto scale_clamp = [&](int16_t &x) { + x = int16_t(std::clamp((int(x) * scale) >> 16, -32768, 32767)); + }; + if constexpr (is_stereo) { - SCALE(output_buffer_[output_buffer_pointer_ - 2]); - SCALE(output_buffer_[output_buffer_pointer_ - 1]); + scale_clamp(output_buffer_[output_buffer_pointer_ - 2]); + scale_clamp(output_buffer_[output_buffer_pointer_ - 1]); } else { - SCALE(output_buffer_[output_buffer_pointer_ - 1]); + scale_clamp(output_buffer_[output_buffer_pointer_ - 1]); } - #undef SCALE } // Announce to delegate if full. @@ -251,8 +261,12 @@ protected: switch(conversion_) { case Conversion::Copy: while(length) { - const auto samples_to_read = std::min((output_buffer_.size() - output_buffer_pointer_) / (1 + is_stereo), length); - static_cast(this)->get_samples(samples_to_read, &output_buffer_[output_buffer_pointer_ ]); + const auto samples_to_read = + std::min((output_buffer_.size() - output_buffer_pointer_) / (1 + is_stereo), length); + static_cast(this)->get_samples( + samples_to_read, + &output_buffer_[output_buffer_pointer_] + ); output_buffer_pointer_ += samples_to_read * (1 + is_stereo); // TODO: apply scale. @@ -269,7 +283,8 @@ protected: case Conversion::ResampleSmaller: while(length) { - const auto cycles_to_read = std::min((input_buffer_.size() - input_buffer_depth_) / (1 + is_stereo), length); + const auto cycles_to_read = + std::min((input_buffer_.size() - input_buffer_depth_) / (1 + is_stereo), length); static_cast(this)->get_samples(cycles_to_read, &input_buffer_[input_buffer_depth_]); input_buffer_depth_ += cycles_to_read * (1 + is_stereo); @@ -293,7 +308,8 @@ protected: /*! Provides a low-pass speaker to which blocks of samples are pushed. */ -template class PushLowpass: public LowpassBase, is_stereo> { +template +class PushLowpass: public LowpassBase, is_stereo> { private: using BaseT = LowpassBase, is_stereo>; friend BaseT; @@ -343,13 +359,68 @@ public: } }; +template +class AsyncPushLowpass { +public: + /*! + @returns The underlying speaker. + */ + PushLowpass &speaker() { + return speaker_; + } + + /*! + @c std::swap's the contents of @c buffer with whatever buffer was previously posted, + asynchronously enqueues the new data for processing and clears @c buffer. Blocks on completion of + processing the previous samples if required. + + This is intentionally safe for a single caller only. This cannot be called simultaneously from multiple threads. + */ + void push_swap(std::vector &buffer) { + enqueued_.busy.wait(true, std::memory_order::acquire); + std::swap(enqueued_.data, buffer); + + enqueued_.busy.test_and_set(std::memory_order::relaxed); // The enqueue below provides a suitable + // memory barrier; no need for two. + + queue_.enqueue([this] { + speaker_.push(enqueued_.data.data(), enqueued_.data.size() / (1 + is_stereo)); + enqueued_.busy.clear(std::memory_order::release); + enqueued_.busy.notify_one(); + }); + buffer.clear(); + } + + /*! + Performs @c function asynchronously, giving it a reference to the embedded speaker. + This function returns immediately; it does not wait for the function to complete. + */ + template + void push(FuncT &&function) { + queue_.enqueue([&] { + function(speaker_); + }); + } + +private: + struct { + std::vector data; + std::atomic_flag busy{}; + } enqueued_; + PushLowpass speaker_; + + // Ensure the queue destructs first; tasks posted to it depend on the state above. + Concurrency::AsyncTaskQueue queue_; +}; + /*! The low-pass speaker expects an Outputs::Speaker::SampleSource-derived template class, and uses the instance supplied to its constructor as the source of a high-frequency stream of audio which it filters down to a lower-frequency output. */ -template class PullLowpass: public LowpassBase, SampleSource::is_stereo> { +template +class PullLowpass: public LowpassBase, SampleSource::is_stereo> { public: PullLowpass(SampleSource &sample_source) : sample_source_(sample_source) { // Propagate an initial volume level.