Merge f87641b into e71916d

mltony · web-flow · commit 9a8fbb01d5f3 · 2024-01-26T17:47:27.000-08:00
diff --git a/nvdaHelper/local/nvdaHelperLocal.def b/nvdaHelper/local/nvdaHelperLocal.def
@@ -81,3 +81,6 @@ EXPORTS
 	wasPlay_resume
 	wasPlay_setChannelVolume
 	wasPlay_startup
+	wasSilence_init
+	wasSilence_playFor
+	wasSilence_terminate
diff --git a/nvdaHelper/local/wasapi.cpp b/nvdaHelper/local/wasapi.cpp
@@ -12,6 +12,7 @@ This license can be found at:
 http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 */
 
+#include <thread>
 #include <vector>
 #include <windows.h>
 #include <atlbase.h>
@@ -22,16 +23,18 @@ This license can be found at:
 #include <Functiondiscoverykeys_devpkey.h>
 #include <mmdeviceapi.h>
 #include <common/log.h>
+#include <random>
 
 /**
  * Support for audio playback using WASAPI.
  * Most of the core work happens in the WasapiPlayer class. Because Python
  * ctypes can't call C++ classes, NVDA interfaces with this using the wasPlay_*
- * functions.
+ * and wasSilence_* functions.
  */
 
 constexpr REFERENCE_TIME REFTIMES_PER_MILLISEC = 10000;
-constexpr REFERENCE_TIME BUFFER_SIZE = 400 * REFTIMES_PER_MILLISEC;
+constexpr DWORD BUFFER_MS = 400;
+constexpr REFERENCE_TIME BUFFER_SIZE = BUFFER_MS * REFTIMES_PER_MILLISEC;
 
 const CLSID CLSID_MMDeviceEnumerator = __uuidof(MMDeviceEnumerator);
 const IID IID_IMMDeviceEnumerator = __uuidof(IMMDeviceEnumerator);
@@ -187,7 +190,6 @@ class WasapiPlayer {
 	HRESULT pause();
 	HRESULT resume();
 	HRESULT setChannelVolume(unsigned int channel, float level);
-
 	private:
 	void maybeFireCallback();
 
@@ -385,8 +387,13 @@ HRESULT WasapiPlayer::feed(unsigned char* data, unsigned int size,
 		if (FAILED(hr)) {
 			return hr;
 		}
-		memcpy(buffer, data, sendBytes);
-		hr = render->ReleaseBuffer(sendFrames, 0);
+		if (data) {
+			memcpy(buffer, data, sendBytes);
+			hr = render->ReleaseBuffer(sendFrames, 0);
+		} else {
+			// Null data means play silence.
+			hr = render->ReleaseBuffer(sendFrames, AUDCLNT_BUFFERFLAGS_SILENT);
+		}
 		if (FAILED(hr)) {
 			return hr;
 		}
@@ -403,7 +410,9 @@ HRESULT WasapiPlayer::feed(unsigned char* data, unsigned int size,
 			playState = PlayState::playing;
 		}
 		maybeFireCallback();
-		data += sendBytes;
+		if (data) {
+			data += sendBytes;
+		}
 		size -= sendBytes;
 		remainingFrames -= sendFrames;
 		sentFrames += sendFrames;
@@ -624,9 +633,128 @@ HRESULT WasapiPlayer::setChannelVolume(unsigned int channel, float level) {
 	return volume->SetChannelVolume(channel, level);
 }
 
+/**
+ * Asynchronously play silence for requested durations.
+ * Silence is played in a background thread. The duration can be adjusted from
+ * any thread.
+ */
+class SilencePlayer {
+	public:
+	SilencePlayer(wchar_t* deviceName);
+	HRESULT init();
+	// Play silence for the specified duration.
+	void playFor(DWORD ms, float volume);
+	void terminate();
+
+	private:
+	static WAVEFORMATEX getFormat();
+	void generateWhiteNoise(float volume);
+	// The code which is run in the silence thread.
+	void run();
+
+	static constexpr DWORD SAMPLES_PER_SEC = 48000;
+	// How many bytes of silence in each buffer.
+	static constexpr unsigned int SILENCE_BYTES = SAMPLES_PER_SEC * 2 * BUFFER_MS
+		/ 1000;
+	WasapiPlayer player;
+	AutoHandle wakeEvent;
+	// The time (not duration) at which silence should end.
+	ULONGLONG endTime = 0;
+	std::thread silenceThread;
+	float volume;
+	std::vector<INT16> whiteNoiseData;
+};
+
+SilencePlayer::SilencePlayer(wchar_t* deviceName):
+player(deviceName, getFormat(), nullptr),
+whiteNoiseData(
+	SILENCE_BYTES  / (
+		sizeof(INT16) / sizeof(unsigned char)
+	)
+),
+volume(-1) {
+	wakeEvent = CreateEvent(nullptr, false, false, nullptr);
+}
+
+WAVEFORMATEX SilencePlayer::getFormat() {
+	WAVEFORMATEX format;
+	format.wFormatTag = WAVE_FORMAT_PCM;
+	format.nChannels = 1;
+	format.nSamplesPerSec = SAMPLES_PER_SEC;
+	format.wBitsPerSample = 16;
+	format.nBlockAlign = 2;
+	format.nAvgBytesPerSec = SAMPLES_PER_SEC * 2;
+	format.cbSize = 0;
+	return format;
+}
+
+void SilencePlayer::generateWhiteNoise(float volume) {
+	if (volume == 0) {
+		return;
+	}
+	UINT32 n = whiteNoiseData.size();
+	const double mean = 0.0;
+	const double stddev = volume * 256;
+	std::default_random_engine generator;
+	std::normal_distribution<double> dist(mean, stddev);
+	for (UINT32 i = 0; i < n; i++) {
+		whiteNoiseData[i] = (INT16)dist(generator);
+	}
+}
+HRESULT SilencePlayer::init() {
+	HRESULT hr = player.open();
+	if (FAILED(hr)) {
+		return hr;
+	}
+	silenceThread = std::thread(&SilencePlayer::run, this);
+	return S_OK;
+}
+
+void SilencePlayer::run() {
+	for (;;) {
+		// Wait for silence or termination to be requested.
+		WaitForSingleObject(wakeEvent, INFINITE);
+		if (endTime == 0) {
+			// We have been asked to terminate.
+			// std::thread cannot be destroyed while it is attached, so detach it first.
+			silenceThread.detach();
+			delete this;
+			return;
+		}
+		// Play silence until the desired time. This time might increase or decrease
+		// as we're looping. This is fine because we're only pushing BUFFER_MS each
+		// iteration.
+		while (GetTickCount64() < endTime) {
+			unsigned char* whiteNoisePtr = volume > 0
+				? reinterpret_cast<unsigned char*>(&whiteNoiseData[0])
+				: nullptr;
+			player.feed(whiteNoisePtr, SILENCE_BYTES, nullptr);
+		}
+		player.idle();
+	}
+}
+
+void SilencePlayer::playFor(DWORD ms, float volume) {
+	if (volume != this->volume) {
+		generateWhiteNoise(volume);
+		this->volume = volume;
+	}
+	endTime = ms == INFINITE ? ULLONG_MAX : GetTickCount64() + ms;
+	SetEvent(wakeEvent);
+}
+
+void SilencePlayer::terminate() {
+	// 0 signals silenceThread to exit.
+	endTime = 0;
+	// If silenceThread is feeding, this will make feed return early.
+	player.stop();
+	// If silenceThread is waiting, this will wake it up.
+	SetEvent(wakeEvent);
+}
+
 /*
  * NVDA calls the functions below. Most of these just wrap calls to
- * WasapiPlayer, with the exception of wasPlay_startup.
+ * WasapiPlayer or SilencePlayer, with the exception of wasPlay_startup.
  */
 
 WasapiPlayer* wasPlay_create(wchar_t* deviceName, WAVEFORMATEX format,
@@ -690,3 +818,23 @@ HRESULT wasPlay_startup() {
 	notificationClient = new NotificationClient();
 	return enumerator->RegisterEndpointNotificationCallback(notificationClient);
 }
+
+SilencePlayer* silence = nullptr;
+
+HRESULT wasSilence_init(wchar_t* deviceName) {
+	assert(!silence);
+	silence = new SilencePlayer(deviceName);
+	return silence->init();
+}
+
+void wasSilence_playFor(DWORD ms, float volume) {
+	assert(silence);
+	silence->playFor(ms, volume);
+}
+
+void wasSilence_terminate() {
+	assert(silence);
+	silence->terminate();
+	// silence will delete itself once the thread terminates.
+	silence = nullptr;
+}
diff --git a/source/config/configSpec.py b/source/config/configSpec.py
@@ -54,6 +54,8 @@
 	WASAPI = featureFlag(optionsEnum="BoolFlag", behaviorOfDefault="enabled")
 	soundVolumeFollowsVoice = boolean(default=false)
 	soundVolume = integer(default=100, min=0, max=100)
+	silenceTimeSeconds = integer(default=30,min=0,max=3600)
+	whiteNoiseVolume = integer(default=0, min=0, max=100)
 
 # Braille settings
 [braille]
diff --git a/source/core.py b/source/core.py
@@ -906,7 +906,6 @@ def _doPostNvdaStartupAction():
 	_terminate(bdDetect)
 	_terminate(hwIo)
 	_terminate(addonHandler)
-	_terminate(nvwave)
 	_terminate(garbageHandler)
 	# DMP is only started if needed.
 	# Terminate manually (and let it write to the log if necessary)
@@ -925,6 +924,7 @@ def _doPostNvdaStartupAction():
 			)
 		except:
 			pass
+	_terminate(nvwave)
 	# #5189: Destroy the message window as late as possible
 	# so new instances of NVDA can find this one even if it freezes during exit.
 	messageWindow.destroy()
diff --git a/source/gui/settingsDialogs.py b/source/gui/settingsDialogs.py
@@ -3295,6 +3295,40 @@ def __init__(self, parent):
 
 		self.Layout()
 
+		silenceDurationLabelText = _(
+			# Translators: The label for a setting in advanced panel to change silence duration
+			"Duration in seconds of silence or white noise played to keep audio device open (or 0 to disable)"
+		)
+		minDuration = int(config.conf.getConfigValidation(
+			("audio", "silenceTimeSeconds")
+		).kwargs["min"])
+		maxDuration = int(config.conf.getConfigValidation(("audio", "silenceTimeSeconds")).kwargs["max"])
+		self.silenceDurationEdit = sHelper.addLabeledControl(
+			silenceDurationLabelText,
+			nvdaControls.SelectOnFocusSpinCtrl,
+			min=minDuration,
+			max=maxDuration,
+			initial=config.conf["audio"]["silenceTimeSeconds"]
+		)
+		self.bindHelpEvent("silenceDuration", self.silenceDurationEdit)
+		self.silenceDurationEdit.Bind(wx.EVT_TEXT, self._onSilenceDurationChanged)
+
+		# Translators: This is the label for a slider control in the
+		# advanced settings panel.
+		label = _("White noise Volume - or set to 0 for silence")
+		self.whiteNoiseVolSlider: nvdaControls.EnhancedInputSlider = sHelper.addLabeledControl(
+			label,
+			nvdaControls.EnhancedInputSlider,
+			minValue=0,
+			maxValue=100
+		)
+		self.bindHelpEvent("whiteNoiseVolume", self.whiteNoiseVolSlider)
+		self.whiteNoiseVolSlider.SetValue(config.conf["audio"]["whiteNoiseVolume"])
+		self._onSilenceDurationChanged(None)
+
+	def _onSilenceDurationChanged(self, event: wx.Event) -> None:
+		self.whiteNoiseVolSlider.Enable(self.silenceDurationEdit.GetValue() > 0)
+
 	def onOpenScratchpadDir(self,evt):
 		path=config.getScratchpadDir(ensureExists=True)
 		os.startfile(path)
@@ -3394,6 +3428,8 @@ def onSave(self):
 		for index,key in enumerate(self.logCategories):
 			config.conf['debugLog'][key]=self.logCategoriesList.IsChecked(index)
 		config.conf["featureFlag"]["playErrorSound"] = self.playErrorSoundCombo.GetSelection()
+		config.conf["audio"]["silenceTimeSeconds"] = self.silenceDurationEdit.GetValue()
+		config.conf["audio"]["whiteNoiseVolume"] = self.whiteNoiseVolSlider.GetValue()
 
 
 class AdvancedPanel(SettingsPanel):
diff --git a/source/nvwave.py b/source/nvwave.py
@@ -779,6 +779,8 @@ class WasapiWavePlayer(garbageHandler.TrackedObject):
 	_isIdleCheckPending: bool = False
 	#: Use the default device, this is the configSpec default value.
 	DEFAULT_DEVICE_KEY = "default"
+	#: The silence output device, None if not initialized.
+	_silenceDevice: typing.Optional[str] = None
 
 	def __init__(
 			self,
@@ -832,6 +834,13 @@ def __init__(
 		self.open()
 		self._lastActiveTime: typing.Optional[float] = None
 		self._isPaused: bool = False
+		if config.conf["audio"]["silenceTimeSeconds"] > 0 and WasapiWavePlayer._silenceDevice != outputDevice:
+			# The output device has changed. (Re)initialize silence.
+			if self._silenceDevice is not None:
+				NVDAHelper.localLib.wasSilence_terminate()
+			if config.conf["audio"]["silenceTimeSeconds"] > 0:
+				NVDAHelper.localLib.wasSilence_init(outputDevice)
+				WasapiWavePlayer._silenceDevice = outputDevice
 
 	@wasPlay_callback
 	def _callback(cppPlayer, feedId):
@@ -912,6 +921,11 @@ def feed(
 			self._doneCallbacks[feedId.value] = onDone
 		self._lastActiveTime = time.time()
 		self._scheduleIdleCheck()
+		if config.conf["audio"]["silenceTimeSeconds"] > 0:
+			NVDAHelper.localLib.wasSilence_playFor(
+				1000 * config.conf["audio"]["silenceTimeSeconds"],
+				c_float(config.conf["audio"]["whiteNoiseVolume"] / 100.0),
+			)
 
 	def sync(self):
 		"""Synchronise with playback.
@@ -1063,6 +1077,7 @@ def initialize():
 		NVDAHelper.localLib.wasPlay_pause,
 		NVDAHelper.localLib.wasPlay_resume,
 		NVDAHelper.localLib.wasPlay_setChannelVolume,
+		NVDAHelper.localLib.wasSilence_init,
 	):
 		func.restype = HRESULT
 		func.errcheck = _wasPlay_errcheck
@@ -1071,6 +1086,8 @@ def initialize():
 
 
 def terminate() -> None:
+	if WasapiWavePlayer._silenceDevice is not None:
+		NVDAHelper.localLib.wasSilence_terminate()
 	getOnErrorSoundRequested().unregister(playErrorSound)
 
 
diff --git a/user_docs/en/changes.t2t b/user_docs/en/changes.t2t
@@ -7,6 +7,7 @@ What's New in NVDA
 
 == New Features ==
 - In Windows 11, NVDA will announce alerts from voice typing and suggested actions including the top suggestion when copying data such as phone numbers to the clipboard (Windows 11 2022 Update and later). (#16009, @josephsl)
+- Playing silence after every utterance in order to keep audio device open (#14386, @jcsteh, @mltony)
 -
 
 
diff --git a/user_docs/en/userGuide.t2t b/user_docs/en/userGuide.t2t
@@ -2594,6 +2594,16 @@ This option allows you to specify if NVDA will play an error sound in case an er
 Choosing Only in test versions (default) makes NVDA play error sounds only if the current NVDA version is a test version (alpha, beta or run from source).
 Choosing Yes allows to enable error sounds whatever your current NVDA version is.
 
+==== Silence duration ====[silenceDuration]
+
+This edit box specifies how long NVDA plays silence after every utterance. We play silence to keep audio device open and avoid certain glitches like dropped parts of utterances, that happen due to audio devices (especially Bluetooth and wireless devices) entering stand by mode.
+
+You can specify silence duration to be 0 in order to disable this feature.
+
+==== White noise volume slider ====[whiteNoiseVolume]
+
+When you set white noise volume to any value above zero, then instead of silence NVDA would playh white noise in order to keep audio device open. This feature is useful for debugging audio issues.
+
 ++ miscellaneous Settings ++[MiscSettings]
 Besides the [NVDA Settings #NVDASettings] dialog, The Preferences sub-menu of the NVDA Menu contains several other items which are outlined below.
 

Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@ What's New in NVDA`
`7`	`7`
`8`	`8`	`== New Features ==`
`9`	`9`	`- In Windows 11, NVDA will announce alerts from voice typing and suggested actions including the top suggestion when copying data such as phone numbers to the clipboard (Windows 11 2022 Update and later). (#16009, @josephsl)`
	`10`	`+- Playing silence after every utterance in order to keep audio device open (#14386, @jcsteh, @mltony)`
`10`	`11`	`-`
`11`	`12`
`12`	`13`