yet more sounds improvements

Author: malytomas

sources/include/cage-engine/speaker.h

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

sources/libengine/sound/speaker.cpp

@@ -128,43 +128,23 @@ namespace cage
 			lock_free_audio_ring_buffer<float> ring;
 			Delegate<void(const SoundCallbackData &)> callback;
 			std::vector<float> buffer;
-			uint64 lastTime = m;
+			uint64 playbackTime = applicationTime();
 			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, uint64 expectedPeriod)
+			void process(uint64 expectedPeriod)
 			{
-				if (currentTime <= lastTime)
-				{
-					lastTime = currentTime;
-					return;
-				}
-
-				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;
-					}
-				}
+				// maintain consistent delay
+				const uint32 assumedOccupied = ring.capacity() - ring.available_write();
+				const uint32 intendedOccupied = expectedPeriod * 2 * sampleRate / 1'000'000;
+				const uint32 request = intendedOccupied > assumedOccupied ? intendedOccupied - assumedOccupied : 0;
 
 				SoundCallbackData data;
 				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 * 1'000'000 / sampleRate;
+				data.time = playbackTime; // it must correspond to the beginning of the buffer, otherwise varying number of frames would skew it
+				playbackTime += request * 1'000'000 / sampleRate;
 				if (request > data.frames)
 				{
 					// sound buffer overflow
@@ -315,10 +295,10 @@ namespace cage
 				cageCheckCubebError(cubeb_stream_stop(stream));
 			}
 
-			void process(uint64 currentTime, uint64 expectedPeriod)
+			void process(uint64 expectedPeriod)
 			{
 				if (ringBuffer)
-					ringBuffer->process(currentTime, expectedPeriod);
+					ringBuffer->process(expectedPeriod);
 			}
 
 			void dataCallback(float *output_buffer, uint32 nframes)
@@ -391,10 +371,10 @@ namespace cage
 		return impl->started;
 	}
 
-	void Speaker::process(uint64 timeStamp, uint64 expectedPeriod)
+	void Speaker::process(uint64 expectedPeriod)
 	{
 		SpeakerImpl *impl = (SpeakerImpl *)this;
-		impl->process(timeStamp, expectedPeriod);
+		impl->process(expectedPeriod);
 	}
 
 	Holder<Speaker> newSpeaker(const SpeakerCreateConfig &config)

sources/libsimple/sound.cpp

@@ -51,16 +51,32 @@ namespace cage
 		{
 			Holder<VoicesMixer> mixer;
 			Holder<Voice> chaining; // register this mixer in the engine scene mixer
+			ankerl::unordered_dense::map<uintPtr, Holder<Voice>> voicesMapping; // must be destroyed before the mixer
+			sint64 lastTime = 0;
+			sint64 dispatchTime = 0;
 
-			ankerl::unordered_dense::map<uintPtr, Holder<Voice>> voicesMapping;
+			void process(const SoundCallbackData &data)
+			{
+				CAGE_ASSERT(mixer);
+				// correction for time drift
+				const sint64 period = controlThread().updatePeriod();
+				const sint64 duration = sint64(data.frames) * 1'000'000 / data.sampleRate;
+				if (abs(lastTime - dispatchTime) > period)
+					lastTime = dispatchTime; // reset time
+				SoundCallbackData clb = data;
+				clb.time = lastTime;
+				lastTime += duration;
+				dispatchTime += duration;
+				mixer->process(clb);
+			}
 		};
 
 		struct SoundPrepareImpl
 		{
 			Holder<Mutex> mut = newMutex();
 			std::vector<EmitListener> listeners;
 			std::vector<EmitSound> sounds;
-			ankerl::unordered_dense::map<uintPtr, PrepareListener> listenersMapping;
+			ankerl::unordered_dense::map<uintPtr, Holder<PrepareListener>> listenersMapping; // requires stable pointers
 
 			explicit SoundPrepareImpl(const EngineCreateConfig &config) {}
 
@@ -138,20 +154,21 @@ namespace cage
 				v->loop = e.sound.loop;
 			}
 
-			void prepare(PrepareListener &l, const EmitListener &e)
+			void prepare(PrepareListener &l, const EmitListener &e, uint64 dispatchTime)
 			{
 				{ // listener
 					if (!l.mixer)
 					{
 						l.mixer = newVoicesMixer();
 						l.chaining = engineSceneMixer()->newVoice();
-						l.chaining->callback.bind<VoicesMixer, &VoicesMixer::process>(+l.mixer);
+						l.chaining->callback.bind<PrepareListener, &PrepareListener::process>(&l);
 					}
 					l.mixer->orientation = e.transform.orientation;
 					l.mixer->position = e.transform.position;
 					l.mixer->maxActiveSounds = e.listener.maxSounds;
 					l.mixer->maxGainThreshold = e.listener.maxGainThreshold;
 					l.mixer->gain = e.listener.gain;
+					l.dispatchTime = dispatchTime;
 				}
 
 				{ // remove obsolete
@@ -168,7 +185,7 @@ namespace cage
 						prepare(l, l.voicesMapping[s.id], s);
 			}
 
-			void dispatch(uint64 time)
+			void dispatch(uint64 dispatchTime)
 			{
 				auto lock = ScopeLock(mut);
 
@@ -181,11 +198,16 @@ namespace cage
 				}
 
 				for (const EmitListener &e : listeners)
-					prepare(listenersMapping[e.id], e);
+				{
+					Holder<PrepareListener> &h = listenersMapping[e.id];
+					if (!h)
+						h = systemMemory().createHolder<PrepareListener>();
+					prepare(*h, e, dispatchTime);
+				}
 
 				{
 					ProfilingScope profiling("speaker process");
-					engineSpeaker()->process(time, controlThread().updatePeriod());
+					engineSpeaker()->process(controlThread().updatePeriod());
 				}
 			}
 		};
@@ -198,9 +220,9 @@ namespace cage
 		soundPrepare->emit();
 	}
 
-	void soundDispatch(uint64 time)
+	void soundDispatch(uint64 dispatchTime)
 	{
-		soundPrepare->dispatch(time);
+		soundPrepare->dispatch(dispatchTime);
 	}
 
 	void soundFinalize()