vkatCommon.cpp@ 92241

Last change on this file since 92241 was 92234, checked in by vboxsync, 3 years ago
Audio/Validation Kit: More code for audio data beacon handling. Now has dedicated beacons for recording / playback tests. bugref:10008
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 63.0 KB

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

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

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

Download in other formats: