Attempt to shrink repetition even further.

Outputs/Speaker/Implementation/LowpassSpeaker.hpp

@@ -418,4 +418,7 @@ private:
 	}
 };
 
+template <typename GeneratorT>
+using PullLowpassSpeakerQueue = SpeakerQueue<Outputs::Speaker::PullLowpass<GeneratorT>, GeneratorT>;
+
 }

Outputs/Speaker/SpeakerQueue.hpp

@@ -16,16 +16,20 @@ using TaskQueue = Concurrency::AsyncTaskQueue<false, true, true>;
 
 template <typename SpeakerT, typename GeneratorT>
 struct SpeakerQueue: private Concurrency::EnqueueDelegate {
-private:
-	TaskQueue queue_;
-
-public:
-	SpeakerQueue(const Cycles divider) : generator(queue_), speaker(generator), divider_(divider) {
+	constexpr SpeakerQueue(const Cycles divider) noexcept :
+		generator_(queue_), speaker_(generator_), divider_(divider)
+	{
 		queue_.set_enqueue_delegate(this);
 	}
 
-	GeneratorT generator;
-	SpeakerT speaker;
+	constexpr SpeakerQueue(const float input_rate, const Cycles divider, const float high_cutoff = -1.0f) noexcept :
+		SpeakerQueue(divider)
+	{
+		speaker_.set_input_rate(input_rate);
+		if(high_cutoff >= 0.0) {
+			speaker_.set_high_frequency_cutoff(high_cutoff);
+		}
+	}
 
 	void operator += (const Cycles &duration) {
 		cycles_since_update_ += duration;
@@ -41,12 +45,24 @@ public:
 		queue_.perform();
 	}
 
+	SpeakerT &speaker() {
+		return speaker_;
+	}
+
+	GeneratorT *operator ->() {
+		return &generator_;
+	}
+
 private:
+	TaskQueue queue_;
+	GeneratorT generator_;
+	SpeakerT speaker_;
 	Cycles divider_;
 	Cycles cycles_since_update_;
 
-	std::function<void(void)> prepare_enqueue() {
-		return speaker.update_for(cycles_since_update_.divide(divider_));
+	std::function<void(void)> prepare_enqueue() final {
+		return speaker_.update_for(cycles_since_update_.divide(divider_));
 	}
 };
+
 }