vkatCommon.cpp@ 99568

Last change on this file since 99568 was 98310, checked in by vboxsync, 2 years ago
Audio/VKAT: Added some more verbose (debug) logging for failing playback tests.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 69.7 KB

Line
1	/* $Id: vkatCommon.cpp 98310 2023-01-26 11:00:18Z vboxsync $ */
2	/** @file
3	* Validation Kit Audio Test (VKAT) - Self test code.
4	*/
5
6	/*
7	* Copyright (C) 2021-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* The contents of this file may alternatively be used under the terms
26	* of the Common Development and Distribution License Version 1.0
27	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28	* in the VirtualBox distribution, in which case the provisions of the
29	* CDDL are applicable instead of those of the GPL.
30	*
31	* You may elect to license modified versions of this file under the
32	* terms and conditions of either the GPL or the CDDL or both.
33	*
34	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35	*/
36
37
38	/*********************************************************************************************************************************
39	* Header Files *
40	*********************************************************************************************************************************/
41	#define LOG_GROUP LOG_GROUP_AUDIO_TEST
42	#include <iprt/log.h>
43
44	#ifdef VBOX_WITH_AUDIO_ALSA
45	# include "DrvHostAudioAlsaStubsMangling.h"
46	# include <alsa/asoundlib.h>
47	# include <alsa/control.h> /* For device enumeration. */
48	# include <alsa/version.h>
49	# include "DrvHostAudioAlsaStubs.h"
50	#endif
51	#ifdef VBOX_WITH_AUDIO_OSS
52	# include <errno.h>
53	# include <fcntl.h>
54	# include <sys/ioctl.h>
55	# include <sys/mman.h>
56	# include <sys/soundcard.h>
57	# include <unistd.h>
58	#endif
59	#ifdef RT_OS_WINDOWS
60	# include <iprt/win/windows.h>
61	# include <iprt/win/audioclient.h>
62	# include <endpointvolume.h> /* For IAudioEndpointVolume. */
63	# include <audiopolicy.h> /* For IAudioSessionManager. */
64	# include <AudioSessionTypes.h>
65	# include <Mmdeviceapi.h>
66	#endif
67
68	#include <iprt/ctype.h>
69	#include <iprt/dir.h>
70	#include <iprt/errcore.h>
71	#include <iprt/getopt.h>
72	#include <iprt/message.h>
73	#include <iprt/rand.h>
74	#include <iprt/test.h>
75
76	#include "Audio/AudioHlp.h"
77	#include "Audio/AudioTest.h"
78	#include "Audio/AudioTestService.h"
79	#include "Audio/AudioTestServiceClient.h"
80
81	#include "vkatInternal.h"
82
83
84	/*********************************************************************************************************************************
85	* Defined Constants And Macros *
86	*********************************************************************************************************************************/
87
88
89	/*********************************************************************************************************************************
90	* Internal Functions *
91	*********************************************************************************************************************************/
92	static int audioTestStreamInit(PAUDIOTESTDRVSTACK pDrvStack, PAUDIOTESTSTREAM pStream, PDMAUDIODIR enmDir, PAUDIOTESTIOOPTS pPlayOpt);
93	static int audioTestStreamDestroy(PAUDIOTESTDRVSTACK pDrvStack, PAUDIOTESTSTREAM pStream);
94
95
96	/*********************************************************************************************************************************
97	* Volume handling. *
98	*********************************************************************************************************************************/
99
100	#ifdef VBOX_WITH_AUDIO_ALSA
101	/**
102	* Sets the system's master volume via ALSA, if available.
103	*
104	* @returns VBox status code.
105	* @param uVolPercent Volume (in percent) to set.
106	*/
107	static int audioTestSetMasterVolumeALSA(unsigned uVolPercent)
108	{
109	int rc = audioLoadAlsaLib();
110	if (RT_FAILURE(rc))
111	return rc;
112
113	int err;
114	snd_mixer_t *handle;
115
116	# define ALSA_CHECK_RET(a_Exp, a_Text) \
117	if (!(a_Exp)) \
118	{ \
119	AssertLogRelMsg(a_Exp, a_Text); \
120	if (handle) \
121	snd_mixer_close(handle); \
122	return VERR_GENERAL_FAILURE; \
123	}
124
125	# define ALSA_CHECK_ERR_RET(a_Text) \
126	ALSA_CHECK_RET(err >= 0, a_Text)
127
128	err = snd_mixer_open(&handle, 0 /* Index */);
129	ALSA_CHECK_ERR_RET(("ALSA: Failed to open mixer: %s\n", snd_strerror(err)));
130	err = snd_mixer_attach(handle, "default");
131	ALSA_CHECK_ERR_RET(("ALSA: Failed to attach to default sink: %s\n", snd_strerror(err)));
132	err = snd_mixer_selem_register(handle, NULL, NULL);
133	ALSA_CHECK_ERR_RET(("ALSA: Failed to attach to default sink: %s\n", snd_strerror(err)));
134	err = snd_mixer_load(handle);
135	ALSA_CHECK_ERR_RET(("ALSA: Failed to load mixer: %s\n", snd_strerror(err)));
136
137	snd_mixer_selem_id_t *sid = NULL;
138	snd_mixer_selem_id_alloca(&sid);
139
140	snd_mixer_selem_id_set_index(sid, 0 /* Index */);
141	snd_mixer_selem_id_set_name(sid, "Master");
142
143	snd_mixer_elem_t* elem = snd_mixer_find_selem(handle, sid);
144	ALSA_CHECK_RET(elem != NULL, ("ALSA: Failed to find mixer element: %s\n", snd_strerror(err)));
145
146	long uVolMin, uVolMax;
147	snd_mixer_selem_get_playback_volume_range(elem, &uVolMin, &uVolMax);
148	ALSA_CHECK_ERR_RET(("ALSA: Failed to get playback volume range: %s\n", snd_strerror(err)));
149
150	long const uVol = RT_MIN(uVolPercent, 100) * uVolMax / 100;
151
152	err = snd_mixer_selem_set_playback_volume(elem, SND_MIXER_SCHN_FRONT_LEFT, uVol);
153	ALSA_CHECK_ERR_RET(("ALSA: Failed to set playback volume left: %s\n", snd_strerror(err)));
154	err = snd_mixer_selem_set_playback_volume(elem, SND_MIXER_SCHN_FRONT_RIGHT, uVol);
155	ALSA_CHECK_ERR_RET(("ALSA: Failed to set playback volume right: %s\n", snd_strerror(err)));
156
157	snd_mixer_close(handle);
158
159	return VINF_SUCCESS;
160
161	# undef ALSA_CHECK_RET
162	# undef ALSA_CHECK_ERR_RET
163	}
164	#endif /* VBOX_WITH_AUDIO_ALSA */
165
166	#ifdef VBOX_WITH_AUDIO_OSS
167	/**
168	* Sets the system's master volume via OSS, if available.
169	*
170	* @returns VBox status code.
171	* @param uVolPercent Volume (in percent) to set.
172	*/
173	static int audioTestSetMasterVolumeOSS(unsigned uVolPercent)
174	{
175	int hFile = open("/dev/dsp", O_WRONLY \| O_NONBLOCK, 0);
176	if (hFile == -1)
177	{
178	/* Try opening the mixing device instead. */
179	hFile = open("/dev/mixer", O_RDONLY \| O_NONBLOCK, 0);
180	}
181
182	if (hFile != -1)
183	{
184	/* OSS maps 0 (muted) - 100 (max), so just use uVolPercent unmodified here. */
185	uint16_t uVol = RT_MAKE_U16(uVolPercent, uVolPercent);
186	AssertLogRelMsgReturnStmt(ioctl(hFile, SOUND_MIXER_PCM /* SNDCTL_DSP_SETPLAYVOL */, &uVol) >= 0,
187	("OSS: Failed to set DSP playback volume: %s (%d)\n",
188	strerror(errno), errno), close(hFile), RTErrConvertFromErrno(errno));
189	return VINF_SUCCESS;
190	}
191
192	return VERR_NOT_SUPPORTED;
193	}
194	#endif /* VBOX_WITH_AUDIO_OSS */
195
196	#ifdef RT_OS_WINDOWS
197	static int audioTestSetMasterVolumeWASAPI(unsigned uVolPercent)
198	{
199	HRESULT hr;
200
201	# define WASAPI_CHECK_HR_RET(a_Text) \
202	if (FAILED(hr)) \
203	{ \
204	AssertLogRelMsgFailed(a_Text); \
205	return VERR_GENERAL_FAILURE; \
206	}
207
208	hr = CoInitialize(NULL);
209	WASAPI_CHECK_HR_RET(("CoInitialize() failed, hr=%Rhrc", hr));
210	IMMDeviceEnumerator* pIEnumerator = NULL;
211	hr = CoCreateInstance(__uuidof(MMDeviceEnumerator), NULL, CLSCTX_ALL, __uuidof(IMMDeviceEnumerator), (void **)&pIEnumerator);
212	WASAPI_CHECK_HR_RET(("WASAPI: Unable to create IMMDeviceEnumerator, hr=%Rhrc", hr));
213
214	IMMDevice *pIMMDevice = NULL;
215	hr = pIEnumerator->GetDefaultAudioEndpoint(EDataFlow::eRender, ERole::eConsole, &pIMMDevice);
216	WASAPI_CHECK_HR_RET(("WASAPI: Unable to get audio endpoint, hr=%Rhrc", hr));
217	pIEnumerator->Release();
218
219	IAudioEndpointVolume *pIAudioEndpointVolume = NULL;
220	hr = pIMMDevice->Activate(__uuidof(IAudioEndpointVolume), CLSCTX_ALL, NULL, (void **)&pIAudioEndpointVolume);
221	WASAPI_CHECK_HR_RET(("WASAPI: Unable to activate audio endpoint volume, hr=%Rhrc", hr));
222	pIMMDevice->Release();
223
224	float dbMin, dbMax, dbInc;
225	hr = pIAudioEndpointVolume->GetVolumeRange(&dbMin, &dbMax, &dbInc);
226	WASAPI_CHECK_HR_RET(("WASAPI: Unable to get volume range, hr=%Rhrc", hr));
227
228	float const dbSteps = (dbMax - dbMin) / dbInc;
229	float const dbStepsPerPercent = (dbSteps * dbInc) / 100;
230	float const dbVol = dbMin + (dbStepsPerPercent * (float(RT_MIN(uVolPercent, 100.0))));
231
232	hr = pIAudioEndpointVolume->SetMasterVolumeLevel(dbVol, NULL);
233	WASAPI_CHECK_HR_RET(("WASAPI: Unable to set master volume level, hr=%Rhrc", hr));
234	pIAudioEndpointVolume->Release();
235
236	return VINF_SUCCESS;
237
238	# undef WASAPI_CHECK_HR_RET
239	}
240	#endif /* RT_OS_WINDOWS */
241
242	/**
243	* Sets the system's master volume, if available.
244	*
245	* @returns VBox status code. VERR_NOT_SUPPORTED if not supported.
246	* @param uVolPercent Volume (in percent) to set.
247	*/
248	int audioTestSetMasterVolume(unsigned uVolPercent)
249	{
250	int rc = VINF_SUCCESS;
251
252	#ifdef VBOX_WITH_AUDIO_ALSA
253	rc = audioTestSetMasterVolumeALSA(uVolPercent);
254	if (RT_SUCCESS(rc))
255	return rc;
256	/* else try OSS (if available) below. */
257	#endif /* VBOX_WITH_AUDIO_ALSA */
258
259	#ifdef VBOX_WITH_AUDIO_OSS
260	rc = audioTestSetMasterVolumeOSS(uVolPercent);
261	if (RT_SUCCESS(rc))
262	return rc;
263	#endif /* VBOX_WITH_AUDIO_OSS */
264
265	#ifdef RT_OS_WINDOWS
266	rc = audioTestSetMasterVolumeWASAPI(uVolPercent);
267	if (RT_SUCCESS(rc))
268	return rc;
269	#endif
270
271	RT_NOREF(rc, uVolPercent);
272	/** @todo Port other platforms. */
273	return VERR_NOT_SUPPORTED;
274	}
275
276
277	/*********************************************************************************************************************************
278	* Device enumeration + handling. *
279	*********************************************************************************************************************************/
280
281	/**
282	* Enumerates audio devices and optionally searches for a specific device.
283	*
284	* @returns VBox status code.
285	* @param pDrvStack Driver stack to use for enumeration.
286	* @param pszDev Device name to search for. Can be NULL if the default device shall be used.
287	* @param ppDev Where to return the pointer of the device enumeration of \a pTstEnv when a
288	* specific device was found.
289	*/
290	int audioTestDevicesEnumerateAndCheck(PAUDIOTESTDRVSTACK pDrvStack, const char pszDev, PPDMAUDIOHOSTDEV ppDev)
291	{
292	RTTestSubF(g_hTest, "Enumerating audio devices and checking for device '%s'", pszDev && *pszDev ? pszDev : "[Default]");
293
294	if (!pDrvStack->pIHostAudio->pfnGetDevices)
295	{
296	RTTestSkipped(g_hTest, "Backend does not support device enumeration, skipping");
297	return VINF_NOT_SUPPORTED;
298	}
299
300	Assert(pszDev == NULL \|\| ppDev);
301
302	if (ppDev)
303	*ppDev = NULL;
304
305	int rc = pDrvStack->pIHostAudio->pfnGetDevices(pDrvStack->pIHostAudio, &pDrvStack->DevEnum);
306	if (RT_SUCCESS(rc))
307	{
308	PPDMAUDIOHOSTDEV pDev;
309	RTListForEach(&pDrvStack->DevEnum.LstDevices, pDev, PDMAUDIOHOSTDEV, ListEntry)
310	{
311	char szFlags[PDMAUDIOHOSTDEV_MAX_FLAGS_STRING_LEN];
312	if (pDev->pszId)
313	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Enum: Device '%s' (ID '%s'):\n", pDev->pszName, pDev->pszId);
314	else
315	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Enum: Device '%s':\n", pDev->pszName);
316	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Enum: Usage = %s\n", PDMAudioDirGetName(pDev->enmUsage));
317	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Enum: Flags = %s\n", PDMAudioHostDevFlagsToString(szFlags, pDev->fFlags));
318	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Enum: Input channels = %RU8\n", pDev->cMaxInputChannels);
319	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Enum: Output channels = %RU8\n", pDev->cMaxOutputChannels);
320
321	if ( (pszDev && *pszDev)
322	&& !RTStrCmp(pDev->pszName, pszDev))
323	{
324	*ppDev = pDev;
325	}
326	}
327	}
328	else
329	RTTestFailed(g_hTest, "Enumerating audio devices failed with %Rrc", rc);
330
331	if (RT_SUCCESS(rc))
332	{
333	if ( (pszDev && *pszDev)
334	&& *ppDev == NULL)
335	{
336	RTTestFailed(g_hTest, "Audio device '%s' not found", pszDev);
337	rc = VERR_NOT_FOUND;
338	}
339	}
340
341	RTTestSubDone(g_hTest);
342	return rc;
343	}
344
345	static int audioTestStreamInit(PAUDIOTESTDRVSTACK pDrvStack, PAUDIOTESTSTREAM pStream,
346	PDMAUDIODIR enmDir, PAUDIOTESTIOOPTS pIoOpts)
347	{
348	int rc;
349
350	if (enmDir == PDMAUDIODIR_IN)
351	rc = audioTestDriverStackStreamCreateInput(pDrvStack, &pIoOpts->Props, pIoOpts->cMsBufferSize,
352	pIoOpts->cMsPreBuffer, pIoOpts->cMsSchedulingHint, &pStream->pStream, &pStream->Cfg);
353	else if (enmDir == PDMAUDIODIR_OUT)
354	rc = audioTestDriverStackStreamCreateOutput(pDrvStack, &pIoOpts->Props, pIoOpts->cMsBufferSize,
355	pIoOpts->cMsPreBuffer, pIoOpts->cMsSchedulingHint, &pStream->pStream, &pStream->Cfg);
356	else
357	rc = VERR_NOT_SUPPORTED;
358
359	if (RT_SUCCESS(rc))
360	{
361	if (!pDrvStack->pIAudioConnector)
362	{
363	pStream->pBackend = &((PAUDIOTESTDRVSTACKSTREAM)pStream->pStream)->Backend;
364	}
365	else
366	pStream->pBackend = NULL;
367
368	/*
369	* Automatically enable the mixer if the PCM properties don't match.
370	*/
371	if ( !pIoOpts->fWithMixer
372	&& !PDMAudioPropsAreEqual(&pIoOpts->Props, &pStream->Cfg.Props))
373	{
374	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Enabling stream mixer\n");
375	pIoOpts->fWithMixer = true;
376	}
377
378	rc = AudioTestMixStreamInit(&pStream->Mix, pDrvStack, pStream->pStream,
379	pIoOpts->fWithMixer ? &pIoOpts->Props : NULL, 100 /* ms /); /* @todo Configure mixer buffer? */
380	}
381
382	if (RT_FAILURE(rc))
383	RTTestFailed(g_hTest, "Initializing %s stream failed with %Rrc", enmDir == PDMAUDIODIR_IN ? "input" : "output", rc);
384
385	return rc;
386	}
387
388	/**
389	* Destroys an audio test stream.
390	*
391	* @returns VBox status code.
392	* @param pDrvStack Driver stack the stream belongs to.
393	* @param pStream Audio stream to destroy.
394	*/
395	static int audioTestStreamDestroy(PAUDIOTESTDRVSTACK pDrvStack, PAUDIOTESTSTREAM pStream)
396	{
397	AssertPtrReturn(pStream, VERR_INVALID_POINTER);
398
399	if (pStream->pStream)
400	{
401	/** @todo Anything else to do here, e.g. test if there are left over samples or some such? */
402
403	audioTestDriverStackStreamDestroy(pDrvStack, pStream->pStream);
404	pStream->pStream = NULL;
405	pStream->pBackend = NULL;
406	}
407
408	AudioTestMixStreamTerm(&pStream->Mix);
409
410	return VINF_SUCCESS;
411	}
412
413
414	/*********************************************************************************************************************************
415	* Test Primitives *
416	*********************************************************************************************************************************/
417
418	/**
419	* Initializes test tone parameters (partly with random values).
420
421	* @param pToneParms Test tone parameters to initialize.
422	*/
423	void audioTestToneParmsInit(PAUDIOTESTTONEPARMS pToneParms)
424	{
425	RT_BZERO(pToneParms, sizeof(AUDIOTESTTONEPARMS));
426
427	/**
428	* Set default (randomized) test tone parameters if not set explicitly.
429	*/
430	pToneParms->dbFreqHz = AudioTestToneGetRandomFreq();
431	pToneParms->msDuration = RTRandU32Ex(200, RT_MS_30SEC);
432	pToneParms->uVolumePercent = 100; /* We always go with maximum volume for now. */
433
434	PDMAudioPropsInit(&pToneParms->Props,
435	2 /* 16-bit /, true / fPcmSigned /, 2 / cPcmChannels /, 44100 / uPcmHz */);
436	}
437
438	/**
439	* Initializes I/O options with some sane default values.
440	*
441	* @param pIoOpts I/O options to initialize.
442	*/
443	void audioTestIoOptsInitDefaults(PAUDIOTESTIOOPTS pIoOpts)
444	{
445	RT_BZERO(pIoOpts, sizeof(AUDIOTESTIOOPTS));
446
447	/* Initialize the PCM properties to some sane values. */
448	PDMAudioPropsInit(&pIoOpts->Props,
449	2 /* 16-bit /, true / fPcmSigned /, 2 / cPcmChannels /, 44100 / uPcmHz */);
450
451	pIoOpts->cMsBufferSize = UINT32_MAX;
452	pIoOpts->cMsPreBuffer = UINT32_MAX;
453	pIoOpts->cMsSchedulingHint = UINT32_MAX;
454	pIoOpts->uVolumePercent = 100; /* Use maximum volume by default. */
455	}
456
457	#if 0 /* Unused */
458	/**
459	* Returns a random scheduling hint (in ms).
460	*/
461	DECLINLINE(uint32_t) audioTestEnvGetRandomSchedulingHint(void)
462	{
463	static const unsigned s_aSchedulingHintsMs[] =
464	{
465	10,
466	25,
467	50,
468	100,
469	200,
470	250
471	};
472
473	return s_aSchedulingHintsMs[RTRandU32Ex(0, RT_ELEMENTS(s_aSchedulingHintsMs) - 1)];
474	}
475	#endif
476
477	/**
478	* Plays a test tone on a specific audio test stream.
479	*
480	* @returns VBox status code.
481	* @param pIoOpts I/O options to use.
482	* @param pTstEnv Test environment to use for running the test.
483	* Optional and can be NULL (for simple playback only).
484	* @param pStream Stream to use for playing the tone.
485	* @param pParms Tone parameters to use.
486	*
487	* @note Blocking function.
488	*/
489	int audioTestPlayTone(PAUDIOTESTIOOPTS pIoOpts, PAUDIOTESTENV pTstEnv, PAUDIOTESTSTREAM pStream, PAUDIOTESTTONEPARMS pParms)
490	{
491	uint32_t const idxTest = (uint8_t)pParms->Hdr.idxTest;
492
493	AUDIOTESTTONE TstTone;
494	AudioTestToneInit(&TstTone, &pStream->Cfg.Props, pParms->dbFreqHz);
495
496	char const *pcszPathOut = NULL;
497	if (pTstEnv)
498	pcszPathOut = pTstEnv->Set.szPathAbs;
499
500	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test #%RU32: Playing test tone (tone frequency is %RU16Hz, %RU32ms, %RU8%% volume)\n",
501	idxTest, (uint16_t)pParms->dbFreqHz, pParms->msDuration, pParms->uVolumePercent);
502	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test #%RU32: Using %RU32ms stream scheduling hint\n",
503	idxTest, pStream->Cfg.Device.cMsSchedulingHint);
504	if (pcszPathOut)
505	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test #%RU32: Writing to '%s'\n", idxTest, pcszPathOut);
506
507	int rc;
508
509	/** @todo Use .WAV here? */
510	AUDIOTESTOBJ Obj;
511	RT_ZERO(Obj); /* Shut up MSVC. */
512	if (pTstEnv)
513	{
514	rc = AudioTestSetObjCreateAndRegister(&pTstEnv->Set, "guest-tone-play.pcm", &Obj);
515	AssertRCReturn(rc, rc);
516	}
517
518	uint8_t const uVolPercent = pIoOpts->uVolumePercent;
519	int rc2 = audioTestSetMasterVolume(uVolPercent);
520	if (RT_FAILURE(rc2))
521	{
522	if (rc2 == VERR_NOT_SUPPORTED)
523	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Setting system's master volume is not supported on this platform, skipping\n");
524	else
525	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Setting system's master volume failed with %Rrc\n", rc2);
526	}
527	else
528	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Set system's master volume to %RU8%%\n", uVolPercent);
529
530	rc = AudioTestMixStreamEnable(&pStream->Mix);
531	if ( RT_SUCCESS(rc)
532	&& AudioTestMixStreamIsOkay(&pStream->Mix))
533	{
534	uint32_t cbToWriteTotal = PDMAudioPropsMilliToBytes(&pStream->Cfg.Props, pParms->msDuration);
535	AssertStmt(cbToWriteTotal, rc = VERR_INVALID_PARAMETER);
536	uint32_t cbWrittenTotal = 0;
537
538	/* We play a pre + post beacon before + after the actual test tone.
539	* We always start with the pre beacon. */
540	AUDIOTESTTONEBEACON Beacon;
541	AudioTestBeaconInit(&Beacon, (uint8_t)pParms->Hdr.idxTest, AUDIOTESTTONEBEACONTYPE_PLAY_PRE, &pStream->Cfg.Props);
542
543	uint32_t const cbBeacon = AudioTestBeaconGetSize(&Beacon);
544	if (cbBeacon)
545	{
546	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test #%RU32: Playing 2 x %RU32 bytes pre/post beacons\n",
547	idxTest, cbBeacon);
548
549	if (g_uVerbosity >= 2)
550	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test #%RU32: Playing %s beacon ...\n",
551	idxTest, AudioTestBeaconTypeGetName(Beacon.enmType));
552	}
553
554	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test #%RU32: Playing %RU32 bytes total\n", idxTest, cbToWriteTotal);
555
556	AudioTestObjAddMetadataStr(Obj, "test_id=%04RU32\n", pParms->Hdr.idxTest);
557	AudioTestObjAddMetadataStr(Obj, "beacon_type=%RU32\n", (uint32_t)AudioTestBeaconGetType(&Beacon));
558	AudioTestObjAddMetadataStr(Obj, "beacon_pre_bytes=%RU32\n", cbBeacon);
559	AudioTestObjAddMetadataStr(Obj, "beacon_post_bytes=%RU32\n", cbBeacon);
560	AudioTestObjAddMetadataStr(Obj, "stream_to_write_total_bytes=%RU32\n", cbToWriteTotal);
561	AudioTestObjAddMetadataStr(Obj, "stream_period_size_frames=%RU32\n", pStream->Cfg.Backend.cFramesPeriod);
562	AudioTestObjAddMetadataStr(Obj, "stream_buffer_size_frames=%RU32\n", pStream->Cfg.Backend.cFramesBufferSize);
563	AudioTestObjAddMetadataStr(Obj, "stream_prebuf_size_frames=%RU32\n", pStream->Cfg.Backend.cFramesPreBuffering);
564	/* Note: This mostly is provided by backend (e.g. PulseAudio / ALSA / ++) and
565	* has nothing to do with the device emulation scheduling hint. */
566	AudioTestObjAddMetadataStr(Obj, "device_scheduling_hint_ms=%RU32\n", pStream->Cfg.Device.cMsSchedulingHint);
567
568	PAUDIOTESTDRVMIXSTREAM pMix = &pStream->Mix;
569
570	uint32_t const cbPreBuffer = PDMAudioPropsFramesToBytes(pMix->pProps, pStream->Cfg.Backend.cFramesPreBuffering);
571	uint64_t const nsStarted = RTTimeNanoTS();
572	uint64_t nsDonePreBuffering = 0;
573
574	uint64_t offStream = 0;
575	uint64_t nsTimeout = RT_MS_5MIN_64 * RT_NS_1MS;
576	uint64_t nsLastMsgCantWrite = 0; /* Timestamp (in ns) when the last message of an unwritable stream was shown. */
577	uint64_t nsLastWrite = 0;
578
579	AUDIOTESTSTATE enmState = AUDIOTESTSTATE_PRE;
580	uint8_t abBuf[_16K];
581
582	for (;;)
583	{
584	uint64_t const nsNow = RTTimeNanoTS();
585	if (!nsLastWrite)
586	nsLastWrite = nsNow;
587
588	/* Pace ourselves a little. */
589	if (offStream >= cbPreBuffer)
590	{
591	if (!nsDonePreBuffering)
592	nsDonePreBuffering = nsNow;
593	uint64_t const cNsWritten = PDMAudioPropsBytesToNano64(pMix->pProps, offStream - cbPreBuffer);
594	uint64_t const cNsElapsed = nsNow - nsStarted;
595	if (cNsWritten > cNsElapsed + RT_NS_10MS)
596	RTThreadSleep((cNsWritten - cNsElapsed - RT_NS_10MS / 2) / RT_NS_1MS);
597	}
598
599	uint32_t cbWritten = 0;
600	uint32_t const cbCanWrite = AudioTestMixStreamGetWritable(&pStream->Mix);
601	if (cbCanWrite)
602	{
603	if (g_uVerbosity >= 4)
604	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test #%RU32: Stream is writable with %RU64ms (%RU32 bytes)\n",
605	idxTest, PDMAudioPropsBytesToMilli(pMix->pProps, cbCanWrite), cbCanWrite);
606
607	switch (enmState)
608	{
609	case AUDIOTESTSTATE_PRE:
610	RT_FALL_THROUGH();
611	case AUDIOTESTSTATE_POST:
612	{
613	if (g_uVerbosity >= 4)
614	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test #%RU32: %RU32 bytes (%RU64ms) beacon data remaining\n",
615	idxTest, AudioTestBeaconGetRemaining(&Beacon),
616	PDMAudioPropsBytesToMilli(&pStream->pStream->Cfg.Props, AudioTestBeaconGetRemaining(&Beacon)));
617
618	bool fGoToNextStage = false;
619
620	if ( AudioTestBeaconGetSize(&Beacon)
621	&& !AudioTestBeaconIsComplete(&Beacon))
622	{
623	bool const fStarted = AudioTestBeaconGetRemaining(&Beacon) == AudioTestBeaconGetSize(&Beacon);
624
625	uint32_t const cbBeaconRemaining = AudioTestBeaconGetRemaining(&Beacon);
626	AssertBreakStmt(cbBeaconRemaining, VERR_WRONG_ORDER);
627
628	/* Limit to exactly one beacon (pre or post). */
629	uint32_t const cbToWrite = RT_MIN(sizeof(abBuf), RT_MIN(cbCanWrite, cbBeaconRemaining));
630
631	rc = AudioTestBeaconWrite(&Beacon, abBuf, cbToWrite);
632	if (RT_SUCCESS(rc))
633	{
634	rc = AudioTestMixStreamPlay(&pStream->Mix, abBuf, cbToWrite, &cbWritten);
635	if ( RT_SUCCESS(rc)
636	&& pTstEnv)
637	{
638	/* Also write the beacon data to the test object.
639	* Note: We use cbPlayed here instead of cbToPlay to know if the data actually was
640	* reported as being played by the audio stack. */
641	rc = AudioTestObjWrite(Obj, abBuf, cbWritten);
642	}
643	}
644
645	if ( fStarted
646	&& g_uVerbosity >= 2)
647	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test #%RU32: Writing %s beacon begin\n",
648	idxTest, AudioTestBeaconTypeGetName(Beacon.enmType));
649	if (AudioTestBeaconIsComplete(&Beacon))
650	{
651	if (g_uVerbosity >= 2)
652	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test #%RU32: Writing %s beacon end\n",
653	idxTest, AudioTestBeaconTypeGetName(Beacon.enmType));
654	fGoToNextStage = true;
655	}
656	}
657	else
658	fGoToNextStage = true;
659
660	if (fGoToNextStage)
661	{
662	if (enmState == AUDIOTESTSTATE_PRE)
663	enmState = AUDIOTESTSTATE_RUN;
664	else if (enmState == AUDIOTESTSTATE_POST)
665	enmState = AUDIOTESTSTATE_DONE;
666	}
667	break;
668	}
669
670	case AUDIOTESTSTATE_RUN:
671	{
672	uint32_t cbToWrite = RT_MIN(sizeof(abBuf), cbCanWrite);
673	cbToWrite = RT_MIN(cbToWrite, cbToWriteTotal - cbWrittenTotal);
674
675	if (g_uVerbosity >= 4)
676	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
677	"Test #%RU32: Playing back %RU32 bytes\n", idxTest, cbToWrite);
678
679	if (cbToWrite)
680	{
681	rc = AudioTestToneGenerate(&TstTone, abBuf, cbToWrite, &cbToWrite);
682	if (RT_SUCCESS(rc))
683	{
684	if (pTstEnv)
685	{
686	/* Write stuff to disk before trying to play it. Helps analysis later. */
687	rc = AudioTestObjWrite(Obj, abBuf, cbToWrite);
688	}
689
690	if (RT_SUCCESS(rc))
691	{
692	rc = AudioTestMixStreamPlay(&pStream->Mix, abBuf, cbToWrite, &cbWritten);
693	if (RT_SUCCESS(rc))
694	{
695	AssertBreakStmt(cbWritten <= cbToWrite, rc = VERR_TOO_MUCH_DATA);
696
697	offStream += cbWritten;
698
699	if (cbWritten != cbToWrite)
700	RTTestFailed(g_hTest, "Test #%RU32: Only played %RU32/%RU32 bytes",
701	idxTest, cbWritten, cbToWrite);
702
703	if (cbWritten)
704	nsLastWrite = nsNow;
705
706	if (g_uVerbosity >= 4)
707	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
708	"Test #%RU32: Played back %RU32 bytes\n", idxTest, cbWritten);
709
710	cbWrittenTotal += cbWritten;
711	}
712	}
713	}
714	}
715
716	if (RT_SUCCESS(rc))
717	{
718	const bool fComplete = cbWrittenTotal >= cbToWriteTotal;
719	if (fComplete)
720	{
721	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test #%RU32: Playing back audio data ended\n", idxTest);
722
723	enmState = AUDIOTESTSTATE_POST;
724
725	/* Re-use the beacon object, but this time it's the post beacon. */
726	AudioTestBeaconInit(&Beacon, (uint8_t)idxTest, AUDIOTESTTONEBEACONTYPE_PLAY_POST,
727	&pStream->Cfg.Props);
728	}
729	}
730	else
731	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test #%RU32: Playing back failed with %Rrc\n", idxTest, rc);
732	break;
733	}
734
735	case AUDIOTESTSTATE_DONE:
736	{
737	/* Handled below. */
738	break;
739	}
740
741	default:
742	AssertFailed();
743	break;
744	}
745
746	if (RT_FAILURE(rc))
747	break;
748
749	if (enmState == AUDIOTESTSTATE_DONE)
750	break;
751
752	nsLastMsgCantWrite = 0;
753	}
754	else if (AudioTestMixStreamIsOkay(&pStream->Mix))
755	{
756	RTMSINTERVAL const msSleep = RT_MIN(RT_MAX(1, pStream->Cfg.Device.cMsSchedulingHint), 256);
757
758	if ( g_uVerbosity >= 3
759	&& ( !nsLastMsgCantWrite
760	\|\| (nsNow - nsLastMsgCantWrite) > RT_NS_10SEC)) /* Don't spam the output too much. */
761	{
762	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test #%RU32: Waiting %RU32ms for stream to be writable again (last write %RU64ns ago) ...\n",
763	idxTest, msSleep, nsNow - nsLastWrite);
764	nsLastMsgCantWrite = nsNow;
765	}
766
767	RTThreadSleep(msSleep);
768	}
769	else
770	AssertFailedBreakStmt(rc = VERR_AUDIO_STREAM_NOT_READY);
771
772	/* Fail-safe in case something screwed up while playing back. */
773	uint64_t const cNsElapsed = nsNow - nsStarted;
774	if (cNsElapsed > nsTimeout)
775	{
776	RTTestFailed(g_hTest, "Test #%RU32: Playback took too long (running %RU64 vs. timeout %RU64), aborting\n",
777	idxTest, cNsElapsed, nsTimeout);
778	rc = VERR_TIMEOUT;
779	}
780
781	if (RT_FAILURE(rc))
782	break;
783	} /* for */
784
785	if (cbWrittenTotal != cbToWriteTotal)
786	RTTestFailed(g_hTest, "Test #%RU32: Playback ended unexpectedly (%RU32/%RU32 played)\n",
787	idxTest, cbWrittenTotal, cbToWriteTotal);
788
789	if (RT_SUCCESS(rc))
790	{
791	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test #%RU32: Draining stream ...\n", idxTest);
792	rc = AudioTestMixStreamDrain(&pStream->Mix, true /fSync/);
793	}
794	}
795	else
796	rc = VERR_AUDIO_STREAM_NOT_READY;
797
798	if (pTstEnv)
799	{
800	rc2 = AudioTestObjClose(Obj);
801	if (RT_SUCCESS(rc))
802	rc = rc2;
803	}
804
805	if (RT_FAILURE(rc))
806	RTTestFailed(g_hTest, "Test #%RU32: Playing tone failed with %Rrc\n", idxTest, rc);
807
808	return rc;
809	}
810
811	/**
812	* Records a test tone from a specific audio test stream.
813	*
814	* @returns VBox status code.
815	* @param pIoOpts I/O options to use.
816	* @param pTstEnv Test environment to use for running the test.
817	* @param pStream Stream to use for recording the tone.
818	* @param pParms Tone parameters to use.
819	*
820	* @note Blocking function.
821	*/
822	static int audioTestRecordTone(PAUDIOTESTIOOPTS pIoOpts, PAUDIOTESTENV pTstEnv, PAUDIOTESTSTREAM pStream, PAUDIOTESTTONEPARMS pParms)
823	{
824	uint32_t const idxTest = (uint8_t)pParms->Hdr.idxTest;
825
826	const char *pcszPathOut = pTstEnv->Set.szPathAbs;
827
828	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test #%RU32: Recording test tone (tone frequency is %RU16Hz, %RU32ms)\n",
829	idxTest, (uint16_t)pParms->dbFreqHz, pParms->msDuration);
830	RTTestPrintf(g_hTest, RTTESTLVL_DEBUG, "Test #%RU32: Writing to '%s'\n", idxTest, pcszPathOut);
831
832	/** @todo Use .WAV here? */
833	AUDIOTESTOBJ Obj;
834	int rc = AudioTestSetObjCreateAndRegister(&pTstEnv->Set, "guest-tone-rec.pcm", &Obj);
835	AssertRCReturn(rc, rc);
836
837	PAUDIOTESTDRVMIXSTREAM pMix = &pStream->Mix;
838
839	rc = AudioTestMixStreamEnable(pMix);
840	if (RT_SUCCESS(rc))
841	{
842	uint32_t cbRecTotal = 0; /* Counts everything, including silence / whatever. */
843	uint32_t cbTestToRec = PDMAudioPropsMilliToBytes(&pStream->Cfg.Props, pParms->msDuration);
844	uint32_t cbTestRec = 0;
845
846	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test #%RU32: Recording %RU32 bytes total\n", idxTest, cbTestToRec);
847
848	/* We expect a pre + post beacon before + after the actual test tone.
849	* We always start with the pre beacon. */
850	AUDIOTESTTONEBEACON Beacon;
851	AudioTestBeaconInit(&Beacon, (uint8_t)pParms->Hdr.idxTest, AUDIOTESTTONEBEACONTYPE_PLAY_PRE, &pStream->Cfg.Props);
852
853	uint32_t const cbBeacon = AudioTestBeaconGetSize(&Beacon);
854	if (cbBeacon)
855	{
856	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test #%RU32: Expecting 2 x %RU32 bytes pre/post beacons\n",
857	idxTest, cbBeacon);
858	if (g_uVerbosity >= 2)
859	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test #%RU32: Waiting for %s beacon ...\n",
860	idxTest, AudioTestBeaconTypeGetName(Beacon.enmType));
861	}
862
863	AudioTestObjAddMetadataStr(Obj, "test_id=%04RU32\n", pParms->Hdr.idxTest);
864	AudioTestObjAddMetadataStr(Obj, "beacon_type=%RU32\n", (uint32_t)AudioTestBeaconGetType(&Beacon));
865	AudioTestObjAddMetadataStr(Obj, "beacon_pre_bytes=%RU32\n", cbBeacon);
866	AudioTestObjAddMetadataStr(Obj, "beacon_post_bytes=%RU32\n", cbBeacon);
867	AudioTestObjAddMetadataStr(Obj, "stream_to_record_bytes=%RU32\n", cbTestToRec);
868	AudioTestObjAddMetadataStr(Obj, "stream_buffer_size_ms=%RU32\n", pIoOpts->cMsBufferSize);
869	AudioTestObjAddMetadataStr(Obj, "stream_prebuf_size_ms=%RU32\n", pIoOpts->cMsPreBuffer);
870	/* Note: This mostly is provided by backend (e.g. PulseAudio / ALSA / ++) and
871	* has nothing to do with the device emulation scheduling hint. */
872	AudioTestObjAddMetadataStr(Obj, "device_scheduling_hint_ms=%RU32\n", pIoOpts->cMsSchedulingHint);
873
874	uint8_t abSamples[16384];
875	uint32_t const cbSamplesAligned = PDMAudioPropsFloorBytesToFrame(pMix->pProps, sizeof(abSamples));
876
877	uint64_t const nsStarted = RTTimeNanoTS();
878
879	uint64_t nsTimeout = RT_MS_5MIN_64 * RT_NS_1MS;
880	uint64_t nsLastMsgCantRead = 0; /* Timestamp (in ns) when the last message of an unreadable stream was shown. */
881
882	AUDIOTESTSTATE enmState = AUDIOTESTSTATE_PRE;
883
884	while (!g_fTerminate)
885	{
886	uint64_t const nsNow = RTTimeNanoTS();
887
888	/*
889	* Anything we can read?
890	*/
891	uint32_t const cbCanRead = AudioTestMixStreamGetReadable(pMix);
892	if (cbCanRead)
893	{
894	if (g_uVerbosity >= 3)
895	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test #%RU32: Stream is readable with %RU64ms (%RU32 bytes)\n",
896	idxTest, PDMAudioPropsBytesToMilli(pMix->pProps, cbCanRead), cbCanRead);
897
898	uint32_t const cbToRead = RT_MIN(cbCanRead, cbSamplesAligned);
899	uint32_t cbRecorded = 0;
900	rc = AudioTestMixStreamCapture(pMix, abSamples, cbToRead, &cbRecorded);
901	if (RT_SUCCESS(rc))
902	{
903	/* Flag indicating whether the whole block we're going to play is silence or not. */
904	bool const fIsAllSilence = PDMAudioPropsIsBufferSilence(&pStream->pStream->Cfg.Props, abSamples, cbRecorded);
905
906	cbRecTotal += cbRecorded; /* Do a bit of accounting. */
907
908	switch (enmState)
909	{
910	case AUDIOTESTSTATE_PRE:
911	RT_FALL_THROUGH();
912	case AUDIOTESTSTATE_POST:
913	{
914	bool fGoToNextStage = false;
915
916	if ( AudioTestBeaconGetSize(&Beacon)
917	&& !AudioTestBeaconIsComplete(&Beacon))
918	{
919	bool const fStarted = AudioTestBeaconGetRemaining(&Beacon) == AudioTestBeaconGetSize(&Beacon);
920
921	size_t uOff;
922	rc = AudioTestBeaconAddConsecutive(&Beacon, abSamples, cbRecorded, &uOff);
923	if (RT_SUCCESS(rc))
924	{
925	/*
926	* When being in the AUDIOTESTSTATE_PRE state, we might get more audio data
927	* than we need for the pre-beacon to complete. In other words, that "more data"
928	* needs to be counted to the actual recorded test tone data then.
929	*/
930	if (enmState == AUDIOTESTSTATE_PRE)
931	cbTestRec += cbRecorded - (uint32_t)uOff;
932	}
933
934	if ( fStarted
935	&& g_uVerbosity >= 3)
936	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
937	"Test #%RU32: Detection of %s beacon started (%RU32ms recorded so far)\n",
938	idxTest, AudioTestBeaconTypeGetName(Beacon.enmType),
939	PDMAudioPropsBytesToMilli(&pStream->pStream->Cfg.Props, cbRecTotal));
940
941	if (AudioTestBeaconIsComplete(&Beacon))
942	{
943	if (g_uVerbosity >= 2)
944	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test #%RU32: Detected %s beacon\n",
945	idxTest, AudioTestBeaconTypeGetName(Beacon.enmType));
946	fGoToNextStage = true;
947	}
948	}
949	else
950	fGoToNextStage = true;
951
952	if (fGoToNextStage)
953	{
954	if (enmState == AUDIOTESTSTATE_PRE)
955	enmState = AUDIOTESTSTATE_RUN;
956	else if (enmState == AUDIOTESTSTATE_POST)
957	enmState = AUDIOTESTSTATE_DONE;
958	}
959	break;
960	}
961
962	case AUDIOTESTSTATE_RUN:
963	{
964	/* Whether we count all silence as recorded data or not.
965	* Currently we don't, as otherwise consequtively played tones will be cut off in the end. */
966	if (!fIsAllSilence)
967	{
968	uint32_t const cbToAddMax = cbTestToRec - cbTestRec;
969
970	/* Don't read more than we're told to.
971	* After the actual test tone data there might come a post beacon which also
972	* needs to be handled in the AUDIOTESTSTATE_POST state then. */
973	if (cbRecorded > cbToAddMax)
974	cbRecorded = cbToAddMax;
975
976	cbTestRec += cbRecorded;
977	}
978
979	if (cbTestToRec - cbTestRec == 0) /* Done recording the test tone? */
980	{
981	enmState = AUDIOTESTSTATE_POST;
982
983	if (g_uVerbosity >= 2)
984	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test #%RU32: Recording tone data done", idxTest);
985
986	if (AudioTestBeaconGetSize(&Beacon))
987	{
988	/* Re-use the beacon object, but this time it's the post beacon. */
989	AudioTestBeaconInit(&Beacon, (uint8_t)pParms->Hdr.idxTest, AUDIOTESTTONEBEACONTYPE_PLAY_POST,
990	&pStream->Cfg.Props);
991	if (g_uVerbosity >= 2)
992	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
993	"Test #%RU32: Waiting for %s beacon ...",
994	idxTest, AudioTestBeaconTypeGetName(Beacon.enmType));
995	}
996	}
997	break;
998	}
999
1000	case AUDIOTESTSTATE_DONE:
1001	{
1002	/* Nothing to do here. */
1003	break;
1004	}
1005
1006	default:
1007	AssertFailed();
1008	break;
1009	}
1010	}
1011
1012	if (cbRecorded)
1013	{
1014	/* Always write (record) everything, no matter if the current audio contains complete silence or not.
1015	* Might be also become handy later if we want to have a look at start/stop timings and so on. */
1016	rc = AudioTestObjWrite(Obj, abSamples, cbRecorded);
1017	AssertRCBreak(rc);
1018	}
1019
1020	if (enmState == AUDIOTESTSTATE_DONE) /* Bail out when in state "done". */
1021	break;
1022	}
1023	else if (AudioTestMixStreamIsOkay(pMix))
1024	{
1025	RTMSINTERVAL const msSleep = RT_MIN(RT_MAX(1, pStream->Cfg.Device.cMsSchedulingHint), 256);
1026
1027	if ( g_uVerbosity >= 3
1028	&& ( !nsLastMsgCantRead
1029	\|\| (nsNow - nsLastMsgCantRead) > RT_NS_10SEC)) /* Don't spam the output too much. */
1030	{
1031	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test #%RU32: Waiting %RU32ms for stream to be readable again ...\n",
1032	idxTest, msSleep);
1033	nsLastMsgCantRead = nsNow;
1034	}
1035
1036	RTThreadSleep(msSleep);
1037	}
1038
1039	/* Fail-safe in case something screwed up while playing back. */
1040	uint64_t const cNsElapsed = nsNow - nsStarted;
1041	if (cNsElapsed > nsTimeout)
1042	{
1043	RTTestFailed(g_hTest, "Test #%RU32: Recording took too long (running %RU64 vs. timeout %RU64), aborting\n",
1044	idxTest, cNsElapsed, nsTimeout);
1045	rc = VERR_TIMEOUT;
1046	}
1047
1048	if (RT_FAILURE(rc))
1049	break;
1050	}
1051
1052	if (g_uVerbosity >= 2)
1053	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test #%RU32: Recorded %RU32 bytes total\n", idxTest, cbRecTotal);
1054	if (cbTestRec != cbTestToRec)
1055	{
1056	RTTestFailed(g_hTest, "Test #%RU32: Recording ended unexpectedly (%RU32/%RU32 recorded)\n",
1057	idxTest, cbTestRec, cbTestToRec);
1058	rc = VERR_WRONG_ORDER; /** @todo Find a better rc. */
1059	}
1060
1061	if (RT_FAILURE(rc))
1062	RTTestFailed(g_hTest, "Test #%RU32: Recording failed (state is '%s')\n", idxTest, AudioTestStateToStr(enmState));
1063
1064	int rc2 = AudioTestMixStreamDisable(pMix);
1065	if (RT_SUCCESS(rc))
1066	rc = rc2;
1067	}
1068
1069	int rc2 = AudioTestObjClose(Obj);
1070	if (RT_SUCCESS(rc))
1071	rc = rc2;
1072
1073	if (RT_FAILURE(rc))
1074	RTTestFailed(g_hTest, "Test #%RU32: Recording tone done failed with %Rrc\n", idxTest, rc);
1075
1076	return rc;
1077	}
1078
1079
1080	/*********************************************************************************************************************************
1081	* ATS Callback Implementations *
1082	*********************************************************************************************************************************/
1083
1084	/** @copydoc ATSCALLBACKS::pfnHowdy
1085	*
1086	* @note Runs as part of the guest ATS.
1087	*/
1088	static DECLCALLBACK(int) audioTestGstAtsHowdyCallback(void const *pvUser)
1089	{
1090	PATSCALLBACKCTX pCtx = (PATSCALLBACKCTX)pvUser;
1091
1092	AssertReturn(pCtx->cClients <= UINT8_MAX - 1, VERR_BUFFER_OVERFLOW);
1093
1094	pCtx->cClients++;
1095
1096	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "New client connected, now %RU8 total\n", pCtx->cClients);
1097
1098	return VINF_SUCCESS;
1099	}
1100
1101	/** @copydoc ATSCALLBACKS::pfnBye
1102	*
1103	* @note Runs as part of the guest ATS.
1104	*/
1105	static DECLCALLBACK(int) audioTestGstAtsByeCallback(void const *pvUser)
1106	{
1107	PATSCALLBACKCTX pCtx = (PATSCALLBACKCTX)pvUser;
1108
1109	AssertReturn(pCtx->cClients, VERR_WRONG_ORDER);
1110	pCtx->cClients--;
1111
1112	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Client wants to disconnect, %RU8 remaining\n", pCtx->cClients);
1113
1114	if (0 == pCtx->cClients) /* All clients disconnected? Tear things down. */
1115	{
1116	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Last client disconnected, terminating server ...\n");
1117	ASMAtomicWriteBool(&g_fTerminate, true);
1118	}
1119
1120	return VINF_SUCCESS;
1121	}
1122
1123	/** @copydoc ATSCALLBACKS::pfnTestSetBegin
1124	*
1125	* @note Runs as part of the guest ATS.
1126	*/
1127	static DECLCALLBACK(int) audioTestGstAtsTestSetBeginCallback(void const pvUser, const char pszTag)
1128	{
1129	PATSCALLBACKCTX pCtx = (PATSCALLBACKCTX)pvUser;
1130	PAUDIOTESTENV pTstEnv = pCtx->pTstEnv;
1131
1132	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Got request for beginning test set '%s' in '%s'\n", pszTag, pTstEnv->szPathTemp);
1133
1134	return AudioTestSetCreate(&pTstEnv->Set, pTstEnv->szPathTemp, pszTag);
1135	}
1136
1137	/** @copydoc ATSCALLBACKS::pfnTestSetEnd
1138	*
1139	* @note Runs as part of the guest ATS.
1140	*/
1141	static DECLCALLBACK(int) audioTestGstAtsTestSetEndCallback(void const pvUser, const char pszTag)
1142	{
1143	PATSCALLBACKCTX pCtx = (PATSCALLBACKCTX)pvUser;
1144	PAUDIOTESTENV pTstEnv = pCtx->pTstEnv;
1145
1146	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Got request for ending test set '%s'\n", pszTag);
1147
1148	/* Pack up everything to be ready for transmission. */
1149	return audioTestEnvPrologue(pTstEnv, true /* fPack */, pCtx->szTestSetArchive, sizeof(pCtx->szTestSetArchive));
1150	}
1151
1152	/** @copydoc ATSCALLBACKS::pfnTonePlay
1153	*
1154	* @note Runs as part of the guest ATS.
1155	*/
1156	static DECLCALLBACK(int) audioTestGstAtsTonePlayCallback(void const *pvUser, PAUDIOTESTTONEPARMS pToneParms)
1157	{
1158	PATSCALLBACKCTX pCtx = (PATSCALLBACKCTX)pvUser;
1159	PAUDIOTESTENV pTstEnv = pCtx->pTstEnv;
1160	PAUDIOTESTIOOPTS pIoOpts = &pTstEnv->IoOpts;
1161
1162	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Got request for playing test tone #%RU32 (%RU16Hz, %RU32ms) ...\n",
1163	pToneParms->Hdr.idxTest, (uint16_t)pToneParms->dbFreqHz, pToneParms->msDuration);
1164
1165	char szTimeCreated[RTTIME_STR_LEN];
1166	RTTimeToString(&pToneParms->Hdr.tsCreated, szTimeCreated, sizeof(szTimeCreated));
1167	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test created (caller UTC): %s\n", szTimeCreated);
1168
1169	const PAUDIOTESTSTREAM pTstStream = &pTstEnv->aStreams[0]; /** @todo Make this dynamic. */
1170
1171	int rc = audioTestStreamInit(pTstEnv->pDrvStack, pTstStream, PDMAUDIODIR_OUT, pIoOpts);
1172	if (RT_SUCCESS(rc))
1173	{
1174	AUDIOTESTPARMS TstParms;
1175	RT_ZERO(TstParms);
1176	TstParms.enmType = AUDIOTESTTYPE_TESTTONE_PLAY;
1177	TstParms.enmDir = PDMAUDIODIR_OUT;
1178	TstParms.TestTone = *pToneParms;
1179
1180	PAUDIOTESTENTRY pTst;
1181	rc = AudioTestSetTestBegin(&pTstEnv->Set, "Playing test tone", &TstParms, &pTst);
1182	if (RT_SUCCESS(rc))
1183	{
1184	rc = audioTestPlayTone(&pTstEnv->IoOpts, pTstEnv, pTstStream, pToneParms);
1185	if (RT_SUCCESS(rc))
1186	{
1187	AudioTestSetTestDone(pTst);
1188	}
1189	else
1190	AudioTestSetTestFailed(pTst, rc, "Playing tone failed");
1191	}
1192
1193	int rc2 = audioTestStreamDestroy(pTstEnv->pDrvStack, pTstStream);
1194	if (RT_SUCCESS(rc))
1195	rc = rc2;
1196	}
1197	else
1198	RTTestFailed(g_hTest, "Error creating output stream, rc=%Rrc\n", rc);
1199
1200	return rc;
1201	}
1202
1203	/** @copydoc ATSCALLBACKS::pfnToneRecord */
1204	static DECLCALLBACK(int) audioTestGstAtsToneRecordCallback(void const *pvUser, PAUDIOTESTTONEPARMS pToneParms)
1205	{
1206	PATSCALLBACKCTX pCtx = (PATSCALLBACKCTX)pvUser;
1207	PAUDIOTESTENV pTstEnv = pCtx->pTstEnv;
1208	PAUDIOTESTIOOPTS pIoOpts = &pTstEnv->IoOpts;
1209
1210	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Got request for recording test tone #%RU32 (%RU32ms) ...\n",
1211	pToneParms->Hdr.idxTest, pToneParms->msDuration);
1212
1213	char szTimeCreated[RTTIME_STR_LEN];
1214	RTTimeToString(&pToneParms->Hdr.tsCreated, szTimeCreated, sizeof(szTimeCreated));
1215	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test created (caller UTC): %s\n", szTimeCreated);
1216
1217	const PAUDIOTESTSTREAM pTstStream = &pTstEnv->aStreams[0]; /** @todo Make this dynamic. */
1218
1219	int rc = audioTestStreamInit(pTstEnv->pDrvStack, pTstStream, PDMAUDIODIR_IN, pIoOpts);
1220	if (RT_SUCCESS(rc))
1221	{
1222	AUDIOTESTPARMS TstParms;
1223	RT_ZERO(TstParms);
1224	TstParms.enmType = AUDIOTESTTYPE_TESTTONE_RECORD;
1225	TstParms.enmDir = PDMAUDIODIR_IN;
1226	TstParms.TestTone = *pToneParms;
1227
1228	PAUDIOTESTENTRY pTst;
1229	rc = AudioTestSetTestBegin(&pTstEnv->Set, "Recording test tone from host", &TstParms, &pTst);
1230	if (RT_SUCCESS(rc))
1231	{
1232	rc = audioTestRecordTone(pIoOpts, pTstEnv, pTstStream, pToneParms);
1233	if (RT_SUCCESS(rc))
1234	{
1235	AudioTestSetTestDone(pTst);
1236	}
1237	else
1238	AudioTestSetTestFailed(pTst, rc, "Recording tone failed");
1239	}
1240
1241	int rc2 = audioTestStreamDestroy(pTstEnv->pDrvStack, pTstStream);
1242	if (RT_SUCCESS(rc))
1243	rc = rc2;
1244	}
1245	else
1246	RTTestFailed(g_hTest, "Error creating input stream, rc=%Rrc\n", rc);
1247
1248	return rc;
1249	}
1250
1251	/** @copydoc ATSCALLBACKS::pfnTestSetSendBegin */
1252	static DECLCALLBACK(int) audioTestGstAtsTestSetSendBeginCallback(void const pvUser, const char pszTag)
1253	{
1254	RT_NOREF(pszTag);
1255
1256	PATSCALLBACKCTX pCtx = (PATSCALLBACKCTX)pvUser;
1257
1258	if (!RTFileExists(pCtx->szTestSetArchive)) /* Has the archive successfully been created yet? */
1259	return VERR_WRONG_ORDER;
1260
1261	int rc = RTFileOpen(&pCtx->hTestSetArchive, pCtx->szTestSetArchive, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE);
1262	if (RT_SUCCESS(rc))
1263	{
1264	uint64_t uSize;
1265	rc = RTFileQuerySize(pCtx->hTestSetArchive, &uSize);
1266	if (RT_SUCCESS(rc))
1267	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Sending test set '%s' (%zu bytes)\n", pCtx->szTestSetArchive, uSize);
1268	}
1269
1270	return rc;
1271	}
1272
1273	/** @copydoc ATSCALLBACKS::pfnTestSetSendRead */
1274	static DECLCALLBACK(int) audioTestGstAtsTestSetSendReadCallback(void const *pvUser,
1275	const char pszTag, void pvBuf, size_t cbBuf, size_t *pcbRead)
1276	{
1277	RT_NOREF(pszTag);
1278
1279	PATSCALLBACKCTX pCtx = (PATSCALLBACKCTX)pvUser;
1280
1281	return RTFileRead(pCtx->hTestSetArchive, pvBuf, cbBuf, pcbRead);
1282	}
1283
1284	/** @copydoc ATSCALLBACKS::pfnTestSetSendEnd */
1285	static DECLCALLBACK(int) audioTestGstAtsTestSetSendEndCallback(void const pvUser, const char pszTag)
1286	{
1287	RT_NOREF(pszTag);
1288
1289	PATSCALLBACKCTX pCtx = (PATSCALLBACKCTX)pvUser;
1290
1291	int rc = RTFileClose(pCtx->hTestSetArchive);
1292	if (RT_SUCCESS(rc))
1293	{
1294	pCtx->hTestSetArchive = NIL_RTFILE;
1295	}
1296
1297	return rc;
1298	}
1299
1300
1301	/*********************************************************************************************************************************
1302	* Implementation of audio test environment handling *
1303	*********************************************************************************************************************************/
1304
1305	/**
1306	* Connects an ATS client via TCP/IP to a peer.
1307	*
1308	* @returns VBox status code.
1309	* @param pTstEnv Test environment to use.
1310	* @param pClient Client to connect.
1311	* @param pszWhat Hint of what to connect to where.
1312	* @param pTcpOpts Pointer to TCP options to use.
1313	*/
1314	int audioTestEnvConnectViaTcp(PAUDIOTESTENV pTstEnv, PATSCLIENT pClient, const char *pszWhat, PAUDIOTESTENVTCPOPTS pTcpOpts)
1315	{
1316	RT_NOREF(pTstEnv);
1317
1318	RTGETOPTUNION Val;
1319	RT_ZERO(Val);
1320
1321	Val.u32 = pTcpOpts->enmConnMode;
1322	int rc = AudioTestSvcClientHandleOption(pClient, ATSTCPOPT_CONN_MODE, &Val);
1323	AssertRCReturn(rc, rc);
1324
1325	if ( pTcpOpts->enmConnMode == ATSCONNMODE_BOTH
1326	\|\| pTcpOpts->enmConnMode == ATSCONNMODE_SERVER)
1327	{
1328	Assert(pTcpOpts->uBindPort); /* Always set by the caller. */
1329	Val.u16 = pTcpOpts->uBindPort;
1330	rc = AudioTestSvcClientHandleOption(pClient, ATSTCPOPT_BIND_PORT, &Val);
1331	AssertRCReturn(rc, rc);
1332
1333	if (pTcpOpts->szBindAddr[0])
1334	{
1335	Val.psz = pTcpOpts->szBindAddr;
1336	rc = AudioTestSvcClientHandleOption(pClient, ATSTCPOPT_BIND_ADDRESS, &Val);
1337	AssertRCReturn(rc, rc);
1338	}
1339	else
1340	{
1341	RTTestFailed(g_hTest, "No bind address specified!\n");
1342	return VERR_INVALID_PARAMETER;
1343	}
1344
1345	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Connecting %s by listening as server at %s:%RU32 ...\n",
1346	pszWhat, pTcpOpts->szBindAddr, pTcpOpts->uBindPort);
1347	}
1348
1349
1350	if ( pTcpOpts->enmConnMode == ATSCONNMODE_BOTH
1351	\|\| pTcpOpts->enmConnMode == ATSCONNMODE_CLIENT)
1352	{
1353	Assert(pTcpOpts->uConnectPort); /* Always set by the caller. */
1354	Val.u16 = pTcpOpts->uConnectPort;
1355	rc = AudioTestSvcClientHandleOption(pClient, ATSTCPOPT_CONNECT_PORT, &Val);
1356	AssertRCReturn(rc, rc);
1357
1358	if (pTcpOpts->szConnectAddr[0])
1359	{
1360	Val.psz = pTcpOpts->szConnectAddr;
1361	rc = AudioTestSvcClientHandleOption(pClient, ATSTCPOPT_CONNECT_ADDRESS, &Val);
1362	AssertRCReturn(rc, rc);
1363	}
1364	else
1365	{
1366	RTTestFailed(g_hTest, "No connect address specified!\n");
1367	return VERR_INVALID_PARAMETER;
1368	}
1369
1370	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Connecting %s by connecting as client to %s:%RU32 ...\n",
1371	pszWhat, pTcpOpts->szConnectAddr, pTcpOpts->uConnectPort);
1372	}
1373
1374	rc = AudioTestSvcClientConnect(pClient);
1375	if (RT_FAILURE(rc))
1376	{
1377	RTTestFailed(g_hTest, "Connecting %s failed with %Rrc\n", pszWhat, rc);
1378	return rc;
1379	}
1380
1381	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Successfully connected %s\n", pszWhat);
1382	return rc;
1383	}
1384
1385	/**
1386	* Configures and starts an ATS TCP/IP server.
1387	*
1388	* @returns VBox status code.
1389	* @param pSrv ATS server instance to configure and start.
1390	* @param pCallbacks ATS callback table to use.
1391	* @param pszDesc Hint of server type which is being started.
1392	* @param pTcpOpts TCP options to use.
1393	*/
1394	int audioTestEnvConfigureAndStartTcpServer(PATSSERVER pSrv, PCATSCALLBACKS pCallbacks, const char *pszDesc,
1395	PAUDIOTESTENVTCPOPTS pTcpOpts)
1396	{
1397	RTGETOPTUNION Val;
1398	RT_ZERO(Val);
1399
1400	int rc = AudioTestSvcInit(pSrv, pCallbacks);
1401	if (RT_FAILURE(rc))
1402	return rc;
1403
1404	Val.u32 = pTcpOpts->enmConnMode;
1405	rc = AudioTestSvcHandleOption(pSrv, ATSTCPOPT_CONN_MODE, &Val);
1406	AssertRCReturn(rc, rc);
1407
1408	if ( pTcpOpts->enmConnMode == ATSCONNMODE_BOTH
1409	\|\| pTcpOpts->enmConnMode == ATSCONNMODE_SERVER)
1410	{
1411	Assert(pTcpOpts->uBindPort); /* Always set by the caller. */
1412	Val.u16 = pTcpOpts->uBindPort;
1413	rc = AudioTestSvcHandleOption(pSrv, ATSTCPOPT_BIND_PORT, &Val);
1414	AssertRCReturn(rc, rc);
1415
1416	if (pTcpOpts->szBindAddr[0])
1417	{
1418	Val.psz = pTcpOpts->szBindAddr;
1419	rc = AudioTestSvcHandleOption(pSrv, ATSTCPOPT_BIND_ADDRESS, &Val);
1420	AssertRCReturn(rc, rc);
1421	}
1422	else
1423	{
1424	RTTestFailed(g_hTest, "No bind address specified!\n");
1425	return VERR_INVALID_PARAMETER;
1426	}
1427
1428	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Starting server for %s at %s:%RU32 ...\n",
1429	pszDesc, pTcpOpts->szBindAddr, pTcpOpts->uBindPort);
1430	}
1431
1432
1433	if ( pTcpOpts->enmConnMode == ATSCONNMODE_BOTH
1434	\|\| pTcpOpts->enmConnMode == ATSCONNMODE_CLIENT)
1435	{
1436	Assert(pTcpOpts->uConnectPort); /* Always set by the caller. */
1437	Val.u16 = pTcpOpts->uConnectPort;
1438	rc = AudioTestSvcHandleOption(pSrv, ATSTCPOPT_CONNECT_PORT, &Val);
1439	AssertRCReturn(rc, rc);
1440
1441	if (pTcpOpts->szConnectAddr[0])
1442	{
1443	Val.psz = pTcpOpts->szConnectAddr;
1444	rc = AudioTestSvcHandleOption(pSrv, ATSTCPOPT_CONNECT_ADDRESS, &Val);
1445	AssertRCReturn(rc, rc);
1446	}
1447	else
1448	{
1449	RTTestFailed(g_hTest, "No connect address specified!\n");
1450	return VERR_INVALID_PARAMETER;
1451	}
1452
1453	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Starting server for %s by connecting as client to %s:%RU32 ...\n",
1454	pszDesc, pTcpOpts->szConnectAddr, pTcpOpts->uConnectPort);
1455	}
1456
1457	if (RT_SUCCESS(rc))
1458	{
1459	rc = AudioTestSvcStart(pSrv);
1460	if (RT_FAILURE(rc))
1461	RTTestFailed(g_hTest, "Starting server for %s failed with %Rrc\n", pszDesc, rc);
1462	}
1463
1464	return rc;
1465	}
1466
1467	/**
1468	* Initializes an audio test environment.
1469	*
1470	* @param pTstEnv Audio test environment to initialize.
1471	*/
1472	void audioTestEnvInit(PAUDIOTESTENV pTstEnv)
1473	{
1474	RT_BZERO(pTstEnv, sizeof(AUDIOTESTENV));
1475
1476	audioTestIoOptsInitDefaults(&pTstEnv->IoOpts);
1477	audioTestToneParmsInit(&pTstEnv->ToneParms);
1478	}
1479
1480	/**
1481	* Creates an audio test environment.
1482	*
1483	* @returns VBox status code.
1484	* @param pTstEnv Audio test environment to create.
1485	* @param pDrvStack Driver stack to use.
1486	*/
1487	int audioTestEnvCreate(PAUDIOTESTENV pTstEnv, PAUDIOTESTDRVSTACK pDrvStack)
1488	{
1489	AssertReturn(PDMAudioPropsAreValid(&pTstEnv->IoOpts.Props), VERR_WRONG_ORDER);
1490
1491	int rc = VINF_SUCCESS;
1492
1493	pTstEnv->pDrvStack = pDrvStack;
1494
1495	/*
1496	* Set sane defaults if not already set.
1497	*/
1498	if (!RTStrNLen(pTstEnv->szTag, sizeof(pTstEnv->szTag)))
1499	{
1500	rc = AudioTestGenTag(pTstEnv->szTag, sizeof(pTstEnv->szTag));
1501	AssertRCReturn(rc, rc);
1502	}
1503
1504	if (!RTStrNLen(pTstEnv->szPathTemp, sizeof(pTstEnv->szPathTemp)))
1505	{
1506	rc = AudioTestPathGetTemp(pTstEnv->szPathTemp, sizeof(pTstEnv->szPathTemp));
1507	AssertRCReturn(rc, rc);
1508	}
1509
1510	if (!RTStrNLen(pTstEnv->szPathOut, sizeof(pTstEnv->szPathOut)))
1511	{
1512	rc = RTPathJoin(pTstEnv->szPathOut, sizeof(pTstEnv->szPathOut), pTstEnv->szPathTemp, "vkat-temp");
1513	AssertRCReturn(rc, rc);
1514	}
1515
1516	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Initializing environment for mode '%s'\n", pTstEnv->enmMode == AUDIOTESTMODE_HOST ? "host" : "guest");
1517	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Using tag '%s'\n", pTstEnv->szTag);
1518	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Output directory is '%s'\n", pTstEnv->szPathOut);
1519	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Temp directory is '%s'\n", pTstEnv->szPathTemp);
1520
1521	char szPathTemp[RTPATH_MAX];
1522	if ( !strlen(pTstEnv->szPathTemp)
1523	\|\| !strlen(pTstEnv->szPathOut))
1524	rc = RTPathTemp(szPathTemp, sizeof(szPathTemp));
1525
1526	if ( RT_SUCCESS(rc)
1527	&& !strlen(pTstEnv->szPathTemp))
1528	rc = RTPathJoin(pTstEnv->szPathTemp, sizeof(pTstEnv->szPathTemp), szPathTemp, "vkat-temp");
1529
1530	if (RT_SUCCESS(rc))
1531	{
1532	rc = RTDirCreate(pTstEnv->szPathTemp, RTFS_UNIX_IRWXU, 0 /* fFlags */);
1533	if (rc == VERR_ALREADY_EXISTS)
1534	rc = VINF_SUCCESS;
1535	}
1536
1537	if ( RT_SUCCESS(rc)
1538	&& !strlen(pTstEnv->szPathOut))
1539	rc = RTPathJoin(pTstEnv->szPathOut, sizeof(pTstEnv->szPathOut), szPathTemp, "vkat");
1540
1541	if (RT_SUCCESS(rc))
1542	{
1543	rc = RTDirCreate(pTstEnv->szPathOut, RTFS_UNIX_IRWXU, 0 /* fFlags */);
1544	if (rc == VERR_ALREADY_EXISTS)
1545	rc = VINF_SUCCESS;
1546	}
1547
1548	if (RT_FAILURE(rc))
1549	return rc;
1550
1551	/**
1552	* For NAT'ed VMs we use (default):
1553	* - client mode (uConnectAddr / uConnectPort) on the guest.
1554	* - server mode (uBindAddr / uBindPort) on the host.
1555	*/
1556	if ( !pTstEnv->TcpOpts.szConnectAddr[0]
1557	&& !pTstEnv->TcpOpts.szBindAddr[0])
1558	RTStrCopy(pTstEnv->TcpOpts.szBindAddr, sizeof(pTstEnv->TcpOpts.szBindAddr), "0.0.0.0");
1559
1560	/*
1561	* Determine connection mode based on set variables.
1562	*/
1563	if ( pTstEnv->TcpOpts.szBindAddr[0]
1564	&& pTstEnv->TcpOpts.szConnectAddr[0])
1565	{
1566	pTstEnv->TcpOpts.enmConnMode = ATSCONNMODE_BOTH;
1567	}
1568	else if (pTstEnv->TcpOpts.szBindAddr[0])
1569	pTstEnv->TcpOpts.enmConnMode = ATSCONNMODE_SERVER;
1570	else /* "Reversed mode", i.e. used for NATed VMs. */
1571	pTstEnv->TcpOpts.enmConnMode = ATSCONNMODE_CLIENT;
1572
1573	/* Set a back reference to the test environment for the callback context. */
1574	pTstEnv->CallbackCtx.pTstEnv = pTstEnv;
1575
1576	ATSCALLBACKS Callbacks;
1577	RT_ZERO(Callbacks);
1578	Callbacks.pvUser = &pTstEnv->CallbackCtx;
1579
1580	if (pTstEnv->enmMode == AUDIOTESTMODE_GUEST)
1581	{
1582	Callbacks.pfnHowdy = audioTestGstAtsHowdyCallback;
1583	Callbacks.pfnBye = audioTestGstAtsByeCallback;
1584	Callbacks.pfnTestSetBegin = audioTestGstAtsTestSetBeginCallback;
1585	Callbacks.pfnTestSetEnd = audioTestGstAtsTestSetEndCallback;
1586	Callbacks.pfnTonePlay = audioTestGstAtsTonePlayCallback;
1587	Callbacks.pfnToneRecord = audioTestGstAtsToneRecordCallback;
1588	Callbacks.pfnTestSetSendBegin = audioTestGstAtsTestSetSendBeginCallback;
1589	Callbacks.pfnTestSetSendRead = audioTestGstAtsTestSetSendReadCallback;
1590	Callbacks.pfnTestSetSendEnd = audioTestGstAtsTestSetSendEndCallback;
1591
1592	if (!pTstEnv->TcpOpts.uBindPort)
1593	pTstEnv->TcpOpts.uBindPort = ATS_TCP_DEF_BIND_PORT_GUEST;
1594
1595	if (!pTstEnv->TcpOpts.uConnectPort)
1596	pTstEnv->TcpOpts.uConnectPort = ATS_TCP_DEF_CONNECT_PORT_GUEST;
1597
1598	pTstEnv->pSrv = (PATSSERVER)RTMemAlloc(sizeof(ATSSERVER));
1599	AssertPtrReturn(pTstEnv->pSrv, VERR_NO_MEMORY);
1600
1601	/*
1602	* Start the ATS (Audio Test Service) on the guest side.
1603	* That service then will perform playback and recording operations on the guest, triggered from the host.
1604	*
1605	* When running this in self-test mode, that service also can be run on the host if nothing else is specified.
1606	* Note that we have to bind to "0.0.0.0" by default so that the host can connect to it.
1607	*/
1608	rc = audioTestEnvConfigureAndStartTcpServer(pTstEnv->pSrv, &Callbacks, "guest", &pTstEnv->TcpOpts);
1609	}
1610	else /* Host mode */
1611	{
1612	if (!pTstEnv->TcpOpts.uBindPort)
1613	pTstEnv->TcpOpts.uBindPort = ATS_TCP_DEF_BIND_PORT_HOST;
1614
1615	if (!pTstEnv->TcpOpts.uConnectPort)
1616	pTstEnv->TcpOpts.uConnectPort = ATS_TCP_DEF_CONNECT_PORT_HOST_PORT_FWD;
1617
1618	/**
1619	* Note: Don't set pTstEnv->TcpOpts.szTcpConnectAddr by default here, as this specifies what connection mode
1620	* (client / server / both) we use on the host.
1621	*/
1622
1623	/* We need to start a server on the host so that VMs configured with NAT networking
1624	* can connect to it as well. */
1625	rc = AudioTestSvcClientCreate(&pTstEnv->u.Host.AtsClGuest);
1626	if (RT_SUCCESS(rc))
1627	rc = audioTestEnvConnectViaTcp(pTstEnv, &pTstEnv->u.Host.AtsClGuest,
1628	"host -> guest", &pTstEnv->TcpOpts);
1629	if (RT_SUCCESS(rc))
1630	{
1631	AUDIOTESTENVTCPOPTS ValKitTcpOpts;
1632	RT_ZERO(ValKitTcpOpts);
1633
1634	/* We only connect as client to the Validation Kit audio driver ATS. */
1635	ValKitTcpOpts.enmConnMode = ATSCONNMODE_CLIENT;
1636
1637	/* For now we ASSUME that the Validation Kit audio driver ATS runs on the same host as VKAT (this binary) runs on. */
1638	ValKitTcpOpts.uConnectPort = ATS_TCP_DEF_CONNECT_PORT_VALKIT; /** @todo Make this dynamic. */
1639	RTStrCopy(ValKitTcpOpts.szConnectAddr, sizeof(ValKitTcpOpts.szConnectAddr), ATS_TCP_DEF_CONNECT_HOST_ADDR_STR); /** @todo Ditto. */
1640
1641	rc = AudioTestSvcClientCreate(&pTstEnv->u.Host.AtsClValKit);
1642	if (RT_SUCCESS(rc))
1643	{
1644	rc = audioTestEnvConnectViaTcp(pTstEnv, &pTstEnv->u.Host.AtsClValKit,
1645	"host -> valkit", &ValKitTcpOpts);
1646	if (RT_FAILURE(rc))
1647	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Unable to connect to the Validation Kit audio driver!\n"
1648	"There could be multiple reasons:\n\n"
1649	" - Wrong host being used\n"
1650	" - VirtualBox host version is too old\n"
1651	" - Audio debug mode is not enabled\n"
1652	" - Support for Validation Kit audio driver is not included\n"
1653	" - Firewall / network configuration problem\n");
1654	}
1655	}
1656	}
1657
1658	return rc;
1659	}
1660
1661	/**
1662	* Destroys an audio test environment.
1663	*
1664	* @param pTstEnv Audio test environment to destroy.
1665	*/
1666	void audioTestEnvDestroy(PAUDIOTESTENV pTstEnv)
1667	{
1668	if (!pTstEnv)
1669	return;
1670
1671	/* When in host mode, we need to destroy our ATS clients in order to also let
1672	* the ATS server(s) know we're going to quit. */
1673	if (pTstEnv->enmMode == AUDIOTESTMODE_HOST)
1674	{
1675	AudioTestSvcClientDestroy(&pTstEnv->u.Host.AtsClValKit);
1676	AudioTestSvcClientDestroy(&pTstEnv->u.Host.AtsClGuest);
1677	}
1678
1679	if (pTstEnv->pSrv)
1680	{
1681	int rc2 = AudioTestSvcDestroy(pTstEnv->pSrv);
1682	AssertRC(rc2);
1683
1684	RTMemFree(pTstEnv->pSrv);
1685	pTstEnv->pSrv = NULL;
1686	}
1687
1688	for (unsigned i = 0; i < RT_ELEMENTS(pTstEnv->aStreams); i++)
1689	{
1690	int rc2 = audioTestStreamDestroy(pTstEnv->pDrvStack, &pTstEnv->aStreams[i]);
1691	if (RT_FAILURE(rc2))
1692	RTTestFailed(g_hTest, "Stream destruction for stream #%u failed with %Rrc\n", i, rc2);
1693	}
1694
1695	/* Try cleaning up a bit. */
1696	RTDirRemove(pTstEnv->szPathTemp);
1697	RTDirRemove(pTstEnv->szPathOut);
1698
1699	pTstEnv->pDrvStack = NULL;
1700	}
1701
1702	/**
1703	* Closes, packs up and destroys a test environment.
1704	*
1705	* @returns VBox status code.
1706	* @param pTstEnv Test environment to handle.
1707	* @param fPack Whether to pack the test set up before destroying / wiping it.
1708	* @param pszPackFile Where to store the packed test set file on success. Can be NULL if \a fPack is \c false.
1709	* @param cbPackFile Size (in bytes) of \a pszPackFile. Can be 0 if \a fPack is \c false.
1710	*/
1711	int audioTestEnvPrologue(PAUDIOTESTENV pTstEnv, bool fPack, char *pszPackFile, size_t cbPackFile)
1712	{
1713	/* Close the test set first. */
1714	AudioTestSetClose(&pTstEnv->Set);
1715
1716	int rc = VINF_SUCCESS;
1717
1718	if (fPack)
1719	{
1720	/* Before destroying the test environment, pack up the test set so
1721	* that it's ready for transmission. */
1722	rc = AudioTestSetPack(&pTstEnv->Set, pTstEnv->szPathOut, pszPackFile, cbPackFile);
1723	if (RT_SUCCESS(rc))
1724	RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Test set packed up to '%s'\n", pszPackFile);
1725	}
1726
1727	if (!g_fDrvAudioDebug) /* Don't wipe stuff when debugging. Can be useful for introspecting data. */
1728	/* ignore rc */ AudioTestSetWipe(&pTstEnv->Set);
1729
1730	AudioTestSetDestroy(&pTstEnv->Set);
1731
1732	if (RT_FAILURE(rc))
1733	RTTestFailed(g_hTest, "Test set prologue failed with %Rrc\n", rc);
1734
1735	return rc;
1736	}
1737
1738	/**
1739	* Initializes an audio test parameters set.
1740	*
1741	* @param pTstParms Test parameters set to initialize.
1742	*/
1743	void audioTestParmsInit(PAUDIOTESTPARMS pTstParms)
1744	{
1745	RT_ZERO(*pTstParms);
1746	}
1747
1748	/**
1749	* Destroys an audio test parameters set.
1750	*
1751	* @param pTstParms Test parameters set to destroy.
1752	*/
1753	void audioTestParmsDestroy(PAUDIOTESTPARMS pTstParms)
1754	{
1755	if (!pTstParms)
1756	return;
1757
1758	return;
1759	}
1760

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/ValidationKit/utils/audio/vkatCommon.cpp@ 99568

Download in other formats: