rework sounds

Author: malytomas

sources/include/cage-engine/speaker.h

@@ -16,7 +16,7 @@ namespace cage
 		void stop();
 		bool running() const;
 
-		void process(uint64 timeStamp);
+		void process(uint64 timeStamp, uint64 expectedPeriod);
 	};
 
 	struct CAGE_ENGINE_API SpeakerCreateConfig

sources/libengine/sound/speaker.cpp

@@ -16,6 +16,7 @@
 	#include <Objbase.h>
 #endif // CAGE_SYSTEM_WINDOWS
 
+#define GCHL_RINGBUFFER_LOGGING
 //#define GCHL_CUBEB_LOGGING
 #ifdef GCHL_CUBEB_LOGGING
 	#include <cstdarg>
@@ -127,29 +128,49 @@ namespace cage
 			lock_free_audio_ring_buffer<float> ring;
 			Delegate<void(const SoundCallbackData &)> callback;
 			std::vector<float> buffer;
-			uint64 lastTime = 0;
+			uint64 lastTime = m;
 			const uint32 channels = 0;
 			const uint32 sampleRate = 0;
 
 			RingBuffer(uint32 channels, uint32 sampleRate, Delegate<void(const SoundCallbackData &)> callback) : ring(channels, sampleRate / 2), callback(callback), channels(channels), sampleRate(sampleRate) {}
 
-			void process(uint64 currentTime)
+			void process(uint64 currentTime, uint64 expectedPeriod)
 			{
-				if (lastTime == 0 || currentTime <= lastTime)
+				if (currentTime <= lastTime)
 				{
 					lastTime = currentTime;
 					return;
 				}
 
-				const uint64 request = sampleRate * (currentTime - lastTime) / 1000000;
+				uint32 request = numeric_cast<uint32>((currentTime - lastTime) * sampleRate / 1'000'000);
+
+				{ // maintain more consistent delay
+					const uint32 assumedOccupied = ring.capacity() - ring.available_write();
+					const uint32 intendedOccupied = expectedPeriod * 2 * sampleRate / 1'000'000;
+					const uint32 toFill = intendedOccupied > assumedOccupied ? intendedOccupied - assumedOccupied : 0;
+					const uint32 threshold = expectedPeriod * 2 / 3 * sampleRate / 1'000'000;
+					const uint32 diff = request > toFill ? request - toFill : toFill - request;
+					if (diff > threshold)
+					{
+						// reset timing
+#ifdef GCHL_RINGBUFFER_LOGGING
+						CAGE_LOG(SeverityEnum::Warning, "speaker", "sound ringbuffer resets timing");
+#endif // GCHL_RINGBUFFER_LOGGING
+						request = toFill;
+						lastTime = currentTime - request * 1'000'000 / sampleRate;
+					}
+				}
+
 				SoundCallbackData data;
-				data.frames = numeric_cast<uint32>(min(request, numeric_cast<uint64>(ring.available_write())));
+				data.frames = min(request, numeric_cast<uint32>(ring.available_write()));
 				data.time = lastTime; // it must correspond to the beginning of the buffer, otherwise varying number of frames would skew it
-				lastTime += request * 1000000 / sampleRate;
+				lastTime += request * 1'000'000 / sampleRate;
 				if (request > data.frames)
 				{
 					// sound buffer overflow
-					// nothing to do
+#ifdef GCHL_RINGBUFFER_LOGGING
+					CAGE_LOG(SeverityEnum::Warning, "speaker", "sound ringbuffer overflow");
+#endif // GCHL_RINGBUFFER_LOGGING
 				}
 				if (data.frames == 0)
 					return;
@@ -159,7 +180,8 @@ namespace cage
 				data.channels = channels;
 				data.sampleRate = sampleRate;
 				callback(data);
-				ring.enqueue(buffer.data(), data.frames);
+				const auto wrt = ring.enqueue(buffer.data(), data.frames);
+				CAGE_ASSERT(wrt == data.frames);
 			}
 
 			void speaker(const SoundCallbackData &data)
@@ -178,6 +200,9 @@ namespace cage
 				float *buff = data.buffer.data() + r * channels;
 				const uint32 remaining = data.frames - r;
 				detail::memset(buff, 0, sizeof(float) * remaining * channels);
+#ifdef GCHL_RINGBUFFER_LOGGING
+				CAGE_LOG(SeverityEnum::Warning, "speaker", "sound ringbuffer underflow");
+#endif // GCHL_RINGBUFFER_LOGGING
 			}
 		};
 
@@ -290,10 +315,10 @@ namespace cage
 				cageCheckCubebError(cubeb_stream_stop(stream));
 			}
 
-			void process(uint64 currentTime)
+			void process(uint64 currentTime, uint64 expectedPeriod)
 			{
 				if (ringBuffer)
-					ringBuffer->process(currentTime);
+					ringBuffer->process(currentTime, expectedPeriod);
 			}
 
 			void dataCallback(float *output_buffer, uint32 nframes)
@@ -366,10 +391,10 @@ namespace cage
 		return impl->started;
 	}
 
-	void Speaker::process(uint64 timeStamp)
+	void Speaker::process(uint64 timeStamp, uint64 expectedPeriod)
 	{
 		SpeakerImpl *impl = (SpeakerImpl *)this;
-		impl->process(timeStamp);
+		impl->process(timeStamp, expectedPeriod);
 	}
 
 	Holder<Speaker> newSpeaker(const SpeakerCreateConfig &config)

sources/libsimple/engine.h

@@ -20,9 +20,8 @@ namespace cage
 	void soundCreate(const EngineCreateConfig &config);
 	void soundDestroy();
 	void soundFinalize();
-	void soundEmit(uint64 time);
-	void soundTick(uint64 time);
-	void soundDispatch();
+	void soundEmit(); // control thread
+	void soundDispatch(uint64 time); // sound thread
 
 	extern EntityComponent *transformHistoryComponent;
 }

sources/libsimple/gameloop.cpp

@@ -295,13 +295,9 @@ namespace cage
 					ProfilingScope profiling("sound callback");
 					soundThread().sound.dispatch();
 				}
-				{
-					ProfilingScope profiling("sound run");
-					soundTick(soundUpdateSchedule->time());
-				}
 				{
 					ProfilingScope profiling("sound dispatch");
-					soundDispatch();
+					soundDispatch(soundUpdateSchedule->time());
 				}
 			}
 
@@ -378,7 +374,7 @@ namespace cage
 				}
 				{
 					ProfilingScope profiling("sound emit");
-					soundEmit(controlTime);
+					soundEmit();
 				}
 				{
 					ProfilingScope profiling("graphics emit");