Finally found what was eating all the RAM :D

Re-enabled the tone key selector in Soundboard
Soundboard now uses OutputStream, like Replay
Constexpr'd a bunch of consts which were going to BSS section
Exiting an app now goes back to main menu
Cleaned up Message array

firmware/baseband/proc_audiotx.cpp

@@ -29,70 +29,94 @@
 #include <cstdint>
 
 void AudioTXProcessor::execute(const buffer_c8_t& buffer){
-
-	// This is called at 1536000/2048 = 750Hz
 	
 	if (!configured) return;
-
-	for (size_t i = 0; i<buffer.count; i++) {
+	
+	if( stream ) {
+		const size_t bytes_to_read = (buffer.count / 32);	// /32 (oversampling) should be == 64
+		bytes_read += stream->read(audio_buffer.p, bytes_to_read);
+	}
+	
+	// Fill and "stretch"
+	for (size_t i = 0; i < buffer.count; i++) {
+		if (!(i & 31))
+			audio_sample = audio_buffer.p[i >> 5] - 0x80;
 		
-		// Audio preview sample generation @ 1536000/divider
-		if (!as) {
-			as = divider;
-			audio_fifo.out(out_sample);
-			sample = (int32_t)out_sample;
-			//preview_audio_buffer.p[ai++] = sample << 8;
-			
-			if ((audio_fifo.len() < 512) && (asked == false)) {
-				// Ask application to fill up fifo
-				shared_memory.application_queue.push(sig_message);
-				asked = true;
-			}
-		} else {
-			as--;
-		}
-		
-		sample = tone_gen.process(sample);
+		sample = tone_gen.process(audio_sample);
 		
 		// FM
 		delta = sample * fm_delta;
 		
 		phase += delta;
 		sphase = phase + (64 << 24);
-
+		
 		re = (sine_table_i8[(sphase & 0xFF000000U) >> 24]);
 		im = (sine_table_i8[(phase & 0xFF000000U) >> 24]);
 		
-		buffer.p[i] = {re, im};
+		buffer.p[i] = { (int8_t)re, (int8_t)im };
+	}
+	
+	spectrum_samples += buffer.count;
+	if( spectrum_samples >= spectrum_interval_samples ) {
+		spectrum_samples -= spectrum_interval_samples;
+		
+		txprogress_message.progress = bytes_read;	// Inform UI about progress
+		txprogress_message.done = false;
+		shared_memory.application_queue.push(txprogress_message);
 	}
 	
 	//AudioOutput::fill_audio_buffer(preview_audio_buffer, true);
 }
 
-void AudioTXProcessor::on_message(const Message* const msg) {
-	const auto message = *reinterpret_cast<const AudioTXConfigMessage*>(msg);
-	
-	switch(msg->id) {
+void AudioTXProcessor::on_message(const Message* const message) {
+	switch(message->id) {
 		case Message::ID::AudioTXConfig:
-			fm_delta = message.deviation_hz * (0xFFFFFFULL / baseband_fs);
-			divider = message.divider;
-			as = 0;
-			
-			tone_gen.configure(message.tone_key_delta, message.tone_key_mix_weight);
+			audio_config(*reinterpret_cast<const AudioTXConfigMessage*>(message));
+			break;
 
-			configured = true;
+		case Message::ID::ReplayConfig:
+			configured = false;
+			bytes_read = 0;
+			replay_config(*reinterpret_cast<const ReplayConfigMessage*>(message));
+			break;
+		
+		case Message::ID::SamplerateConfig:
+			samplerate_config(*reinterpret_cast<const SamplerateConfigMessage*>(message));
 			break;
 		
 		case Message::ID::FIFOData:
-			audio_fifo.in(static_cast<const FIFODataMessage*>(msg)->data, 512);
-			asked = false;
+			configured = true;
 			break;
-
+		
 		default:
 			break;
 	}
 }
 
+void AudioTXProcessor::audio_config(const AudioTXConfigMessage& message) {
+	fm_delta = message.deviation_hz * (0xFFFFFFULL / baseband_fs);
+	
+	tone_gen.configure(message.tone_key_delta, message.tone_key_mix_weight);
+}
+
+void AudioTXProcessor::samplerate_config(const SamplerateConfigMessage& message) {
+	baseband_fs = message.sample_rate;
+	baseband_thread.set_sampling_rate(baseband_fs);
+	spectrum_interval_samples = baseband_fs / 20;
+}
+
+void AudioTXProcessor::replay_config(const ReplayConfigMessage& message) {
+	if( message.config ) {
+		
+		stream = std::make_unique<StreamOutput>(message.config);
+		
+		// Tell application that the buffers and FIFO pointers are ready, prefill
+		shared_memory.application_queue.push(sig_message);
+	} else {
+		stream.reset();
+	}
+}
+
 int main() {
 	EventDispatcher event_dispatcher { std::make_unique<AudioTXProcessor>() };
 	event_dispatcher.run();

firmware/baseband/proc_audiotx.hpp

@@ -23,10 +23,10 @@
 #ifndef __PROC_AUDIOTX_H__
 #define __PROC_AUDIOTX_H__
 
-#include "fifo.hpp"
 #include "baseband_processor.hpp"
 #include "baseband_thread.hpp"
 #include "tone_gen.hpp"
+#include "stream_output.hpp"
 
 class AudioTXProcessor : public BasebandProcessor {
 public:
@@ -35,27 +35,29 @@ public:
 	void on_message(const Message* const msg) override;
 
 private:
-	static constexpr size_t baseband_fs = 1536000U;
-	
-	bool configured = false;
+	size_t baseband_fs = 0;
 	
 	BasebandThread baseband_thread { baseband_fs, this, NORMALPRIO + 20, baseband::Direction::Transmit };
 	
-	int8_t audio_fifo_data[2048] { };
-	FIFO<int8_t> audio_fifo = { audio_fifo_data, 11 };	// 43ms @ 48000Hz
+	std::array<uint8_t, 64> audio { };
+	const buffer_t<uint8_t> audio_buffer {
+		audio.data(),
+		audio.size(),
+		baseband_fs / 8
+	};
+	
+	std::unique_ptr<StreamOutput> stream { };
 	
 	ToneGen tone_gen { };
 	
 	uint32_t fm_delta { 0 };
-	uint32_t divider { };
-	uint32_t as { 0 };
 	uint32_t phase { 0 }, sphase { 0 };
 	int8_t out_sample { };
-	int32_t sample { 0 }, delta { };
-	
+	int32_t sample { 0 }, audio_sample { 0 }, delta { };
 	int8_t re { 0 }, im { 0 };
 	
-	bool asked { false };
+	size_t spectrum_interval_samples = 0;
+	size_t spectrum_samples = 0;
 
 	//int16_t audio_data[64];
 	/*const buffer_s16_t preview_audio_buffer {
@@ -63,6 +65,14 @@ private:
 		sizeof(int16_t)*64
 	};*/
 	
+	bool configured { false };
+	uint32_t bytes_read { 0 };
+	
+	void samplerate_config(const SamplerateConfigMessage& message);
+	void audio_config(const AudioTXConfigMessage& message);
+	void replay_config(const ReplayConfigMessage& message);
+	
+	TXProgressMessage txprogress_message { };
 	RequestSignalMessage sig_message { RequestSignalMessage::Signal::FillRequest };
 };