AudioTest.cpp@ 93956

Last change on this file since 93956 was 93307, checked in by vboxsync, 3 years ago
Devices: VC++ 19.2 update 11 build adjustments (lossy floating point conversions). bugref:8489
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 126.8 KB

Line
1	/* $Id: AudioTest.cpp 93307 2022-01-18 11:31:09Z vboxsync $ */
2	/** @file
3	* Audio testing routines.
4	*
5	* Common code which is being used by the ValidationKit and the
6	* debug / ValdikationKit audio driver(s).
7	*/
8
9	/*
10	* Copyright (C) 2021-2022 Oracle Corporation
11	*
12	* This file is part of VirtualBox Open Source Edition (OSE), as
13	* available from http://www.virtualbox.org. This file is free software;
14	* you can redistribute it and/or modify it under the terms of the GNU
15	* General Public License (GPL) as published by the Free Software
16	* Foundation, in version 2 as it comes in the "COPYING" file of the
17	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
18	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
19	*/
20
21
22	/*********************************************************************************************************************************
23	* Header Files *
24	*********************************************************************************************************************************/
25	#include <package-generated.h>
26	#include "product-generated.h"
27
28	#include <iprt/buildconfig.h>
29	#include <iprt/cdefs.h>
30	#include <iprt/dir.h>
31	#include <iprt/env.h>
32	#include <iprt/file.h>
33	#include <iprt/formats/riff.h>
34	#include <iprt/inifile.h>
35	#include <iprt/list.h>
36	#include <iprt/message.h> /** @todo Get rid of this once we have own log hooks. */
37	#include <iprt/rand.h>
38	#include <iprt/stream.h>
39	#include <iprt/system.h>
40	#include <iprt/uuid.h>
41	#include <iprt/vfs.h>
42	#include <iprt/zip.h>
43
44	#define _USE_MATH_DEFINES
45	#include <math.h> /* sin, M_PI */
46
47	#define LOG_GROUP LOG_GROUP_AUDIO_TEST
48	#include <VBox/log.h>
49
50	#include <VBox/version.h>
51	#include <VBox/vmm/pdmaudioifs.h>
52	#include <VBox/vmm/pdmaudioinline.h>
53
54	#include "AudioTest.h"
55
56
57	/*********************************************************************************************************************************
58	* Defines *
59	*********************************************************************************************************************************/
60	/** The test manifest file name. */
61	#define AUDIOTEST_MANIFEST_FILE_STR "vkat_manifest.ini"
62	/** The current test manifest version. */
63	#define AUDIOTEST_MANIFEST_VER 1
64	/** Audio test archive default suffix.
65	* According to IPRT terminology this always contains the dot. */
66	#define AUDIOTEST_ARCHIVE_SUFF_STR ".tar.gz"
67
68	/** Test manifest header name. */
69	#define AUDIOTEST_SEC_HDR_STR "header"
70	/** Maximum section name length (in UTF-8 characters). */
71	#define AUDIOTEST_MAX_SEC_LEN 128
72	/** Maximum object name length (in UTF-8 characters). */
73	#define AUDIOTEST_MAX_OBJ_LEN 128
74
75
76	/*********************************************************************************************************************************
77	* Structures and Typedefs *
78	*********************************************************************************************************************************/
79	/**
80	* Enumeration for an audio test object type.
81	*/
82	typedef enum AUDIOTESTOBJTYPE
83	{
84	/** Unknown / invalid, do not use. */
85	AUDIOTESTOBJTYPE_UNKNOWN = 0,
86	/** The test object is a file. */
87	AUDIOTESTOBJTYPE_FILE,
88	/** The usual 32-bit hack. */
89	AUDIOTESTOBJTYPE_32BIT_HACK = 0x7fffffff
90	} AUDIOTESTOBJTYPE;
91
92	/**
93	* Structure for keeping an audio test object file.
94	*/
95	typedef struct AUDIOTESTOBJFILE
96	{
97	/** File handle. */
98	RTFILE hFile;
99	/** Total size (in bytes). */
100	size_t cbSize;
101	} AUDIOTESTOBJFILE;
102	/** Pointer to an audio test object file. */
103	typedef AUDIOTESTOBJFILE *PAUDIOTESTOBJFILE;
104
105	/**
106	* Enumeration for an audio test object meta data type.
107	*/
108	typedef enum AUDIOTESTOBJMETADATATYPE
109	{
110	/** Unknown / invalid, do not use. */
111	AUDIOTESTOBJMETADATATYPE_INVALID = 0,
112	/** Meta data is an UTF-8 string. */
113	AUDIOTESTOBJMETADATATYPE_STRING,
114	/** The usual 32-bit hack. */
115	AUDIOTESTOBJMETADATATYPE_32BIT_HACK = 0x7fffffff
116	} AUDIOTESTOBJMETADATATYPE;
117
118	/**
119	* Structure for keeping a meta data block.
120	*/
121	typedef struct AUDIOTESTOBJMETA
122	{
123	/** List node. */
124	RTLISTNODE Node;
125	/** Meta data type. */
126	AUDIOTESTOBJMETADATATYPE enmType;
127	/** Meta data block. */
128	void *pvMeta;
129	/** Size (in bytes) of \a pvMeta. */
130	size_t cbMeta;
131	} AUDIOTESTOBJMETA;
132	/** Pointer to an audio test object file. */
133	typedef AUDIOTESTOBJMETA *PAUDIOTESTOBJMETA;
134
135	/**
136	* Structure for keeping a single audio test object.
137	*
138	* A test object is data which is needed in order to perform and verify one or
139	* more audio test case(s).
140	*/
141	typedef struct AUDIOTESTOBJINT
142	{
143	/** List node. */
144	RTLISTNODE Node;
145	/** Pointer to test set this handle is bound to. */
146	PAUDIOTESTSET pSet;
147	/** As we only support .INI-style files for now, this only has the object's section name in it. */
148	/** @todo Make this more generic (union, ++). */
149	char szSec[AUDIOTEST_MAX_SEC_LEN];
150	/** The UUID of the object.
151	* Used to identify an object within a test set. */
152	RTUUID Uuid;
153	/** Number of references to this test object. */
154	uint32_t cRefs;
155	/** Name of the test object.
156	* Must not contain a path and has to be able to serialize to disk. */
157	char szName[256];
158	/** The test type. */
159	AUDIOTESTTYPE enmTestType;
160	/** The object type. */
161	AUDIOTESTOBJTYPE enmType;
162	/** Meta data list. */
163	RTLISTANCHOR lstMeta;
164	/** Union for holding the object type-specific data. */
165	union
166	{
167	AUDIOTESTOBJFILE File;
168	};
169	} AUDIOTESTOBJINT;
170	/** Pointer to an audio test object. */
171	typedef AUDIOTESTOBJINT *PAUDIOTESTOBJINT;
172
173	/**
174	* Structure for keeping an audio test verification job.
175	*/
176	typedef struct AUDIOTESTVERIFYJOB
177	{
178	/** Pointer to set A. */
179	PAUDIOTESTSET pSetA;
180	/** Pointer to set B. */
181	PAUDIOTESTSET pSetB;
182	/** Pointer to the error description to use. */
183	PAUDIOTESTERRORDESC pErr;
184	/** Zero-based index of current test being verified. */
185	uint32_t idxTest;
186	/** The verification options to use. */
187	AUDIOTESTVERIFYOPTS Opts;
188	/** PCM properties to use for verification. */
189	PDMAUDIOPCMPROPS PCMProps;
190	} AUDIOTESTVERIFYJOB;
191	/** Pointer to an audio test verification job. */
192	typedef AUDIOTESTVERIFYJOB *PAUDIOTESTVERIFYJOB;
193
194
195	/*********************************************************************************************************************************
196	* Global Variables *
197	*********************************************************************************************************************************/
198	/** Well-known frequency selection test tones. */
199	static const double s_aAudioTestToneFreqsHz[] =
200	{
201	349.2282 /F4/,
202	440.0000 /A4/,
203	523.2511 /C5/,
204	698.4565 /F5/,
205	880.0000 /A5/,
206	1046.502 /C6/,
207	1174.659 /D6/,
208	1396.913 /F6/,
209	1760.0000 /A6/
210	};
211
212
213	/*********************************************************************************************************************************
214	* Internal Functions *
215	*********************************************************************************************************************************/
216	static int audioTestObjClose(PAUDIOTESTOBJINT pObj);
217	static void audioTestObjFinalize(PAUDIOTESTOBJINT pObj);
218	static void audioTestObjInit(PAUDIOTESTOBJINT pObj);
219	static bool audioTestObjIsOpen(PAUDIOTESTOBJINT pObj);
220
221
222	/**
223	* Initializes a test tone with a specific frequency (in Hz).
224	*
225	* @returns Used tone frequency (in Hz).
226	* @param pTone Pointer to test tone to initialize.
227	* @param pProps PCM properties to use for the test tone.
228	* @param dbFreq Frequency (in Hz) to initialize tone with.
229	* When set to 0.0, a random frequency will be chosen.
230	*/
231	double AudioTestToneInit(PAUDIOTESTTONE pTone, PPDMAUDIOPCMPROPS pProps, double dbFreq)
232	{
233	if (dbFreq == 0.0)
234	dbFreq = AudioTestToneGetRandomFreq();
235
236	pTone->rdFreqHz = dbFreq;
237	pTone->rdFixed = 2.0 * M_PI * pTone->rdFreqHz / PDMAudioPropsHz(pProps);
238	pTone->uSample = 0;
239
240	memcpy(&pTone->Props, pProps, sizeof(PDMAUDIOPCMPROPS));
241
242	pTone->enmType = AUDIOTESTTONETYPE_SINE; /* Only type implemented so far. */
243
244	return dbFreq;
245	}
246
247	/**
248	* Initializes a test tone by picking a random but well-known frequency (in Hz).
249	*
250	* @returns Randomly picked tone frequency (in Hz).
251	* @param pTone Pointer to test tone to initialize.
252	* @param pProps PCM properties to use for the test tone.
253	*/
254	double AudioTestToneInitRandom(PAUDIOTESTTONE pTone, PPDMAUDIOPCMPROPS pProps)
255	{
256	return AudioTestToneInit(pTone, pProps,
257	/* Pick a frequency from our selection, so that every time a recording starts
258	* we'll hopfully generate a different note. */
259	0.0);
260	}
261
262	/**
263	* Writes (and iterates) a given test tone to an output buffer.
264	*
265	* @returns VBox status code.
266	* @param pTone Pointer to test tone to write.
267	* @param pvBuf Pointer to output buffer to write test tone to.
268	* @param cbBuf Size (in bytes) of output buffer.
269	* @param pcbWritten How many bytes were written on success.
270	*/
271	int AudioTestToneGenerate(PAUDIOTESTTONE pTone, void pvBuf, uint32_t cbBuf, uint32_t pcbWritten)
272	{
273	/*
274	* Clear the buffer first so we don't need to think about additional channels.
275	*/
276	uint32_t cFrames = PDMAudioPropsBytesToFrames(&pTone->Props, cbBuf);
277
278	/* Input cbBuf not necessarily is aligned to the frames, so re-calculate it. */
279	const uint32_t cbToWrite = PDMAudioPropsFramesToBytes(&pTone->Props, cFrames);
280
281	PDMAudioPropsClearBuffer(&pTone->Props, pvBuf, cbBuf, cFrames);
282
283	/*
284	* Generate the select sin wave in the first channel:
285	*/
286	uint32_t const cbFrame = PDMAudioPropsFrameSize(&pTone->Props);
287	double const rdFixed = pTone->rdFixed;
288	uint64_t iSrcFrame = pTone->uSample;
289	switch (PDMAudioPropsSampleSize(&pTone->Props))
290	{
291	case 1:
292	/* untested */
293	if (PDMAudioPropsIsSigned(&pTone->Props))
294	{
295	int8_t piSample = (int8_t )pvBuf;
296	while (cFrames-- > 0)
297	{
298	piSample = (int8_t)(126 /Amplitude/ sin(rdFixed * (double)iSrcFrame));
299	iSrcFrame++;
300	piSample += cbFrame;
301	}
302	}
303	else
304	{
305	/* untested */
306	uint8_t pbSample = (uint8_t )pvBuf;
307	while (cFrames-- > 0)
308	{
309	pbSample = (uint8_t)(126 /Amplitude/ sin(rdFixed * (double)iSrcFrame) + 0x80);
310	iSrcFrame++;
311	pbSample += cbFrame;
312	}
313	}
314	break;
315
316	case 2:
317	if (PDMAudioPropsIsSigned(&pTone->Props))
318	{
319	int16_t piSample = (int16_t )pvBuf;
320	while (cFrames-- > 0)
321	{
322	piSample = (int16_t)(32760 /Amplitude/ sin(rdFixed * (double)iSrcFrame));
323	iSrcFrame++;
324	piSample = (int16_t )((uint8_t )piSample + cbFrame);
325	}
326	}
327	else
328	{
329	/* untested */
330	uint16_t puSample = (uint16_t )pvBuf;
331	while (cFrames-- > 0)
332	{
333	puSample = (uint16_t)(32760 /Amplitude/ sin(rdFixed * (double)iSrcFrame) + 0x8000);
334	iSrcFrame++;
335	puSample = (uint16_t )((uint8_t )puSample + cbFrame);
336	}
337	}
338	break;
339
340	case 4:
341	/* untested */
342	if (PDMAudioPropsIsSigned(&pTone->Props))
343	{
344	int32_t piSample = (int32_t )pvBuf;
345	while (cFrames-- > 0)
346	{
347	piSample = (int32_t)((32760 << 16) /Amplitude/ sin(rdFixed * (double)iSrcFrame));
348	iSrcFrame++;
349	piSample = (int32_t )((uint8_t )piSample + cbFrame);
350	}
351	}
352	else
353	{
354	uint32_t puSample = (uint32_t )pvBuf;
355	while (cFrames-- > 0)
356	{
357	puSample = (uint32_t)((32760 << 16) /Amplitude/ sin(rdFixed * (double)iSrcFrame) + UINT32_C(0x80000000));
358	iSrcFrame++;
359	puSample = (uint32_t )((uint8_t )puSample + cbFrame);
360	}
361	}
362	break;
363
364	default:
365	AssertFailedReturn(VERR_NOT_SUPPORTED);
366	}
367
368	pTone->uSample = iSrcFrame;
369
370	if (pcbWritten)
371	*pcbWritten = cbToWrite;
372
373	return VINF_SUCCESS;
374	}
375
376	/**
377	* Returns a random test tone frequency.
378	*/
379	double AudioTestToneGetRandomFreq(void)
380	{
381	return s_aAudioTestToneFreqsHz[RTRandU32Ex(0, RT_ELEMENTS(s_aAudioTestToneFreqsHz) - 1)];
382	}
383
384	/**
385	* Finds the next audible or silent audio sample and returns its offset.
386	*
387	* @returns Offset (in bytes) of the next found sample, or \a cbMax if not found / invalid parameters.
388	* @param hFile File handle of file to search in.
389	* @param fFindSilence Whether to search for a silent sample or not (i.e. audible).
390	* What a silent sample is depends on \a pToneParms PCM parameters.
391	* @param uOff Absolute offset (in bytes) to start searching from.
392	* @param cbMax Maximum amount of bytes to process.
393	* @param pToneParms Tone parameters to use.
394	* @param cbWindow Search window size (in bytes).
395	*/
396	static uint64_t audioTestToneFileFind(RTFILE hFile, bool fFindSilence, uint64_t uOff, uint64_t cbMax,
397	PAUDIOTESTTONEPARMS pToneParms, size_t cbWindow)
398	{
399	int rc = RTFileSeek(hFile, uOff, RTFILE_SEEK_BEGIN, NULL);
400	AssertRCReturn(rc, UINT64_MAX);
401
402	uint64_t offFound = 0;
403	uint8_t abBuf[_64K];
404
405	size_t const cbFrame = PDMAudioPropsFrameSize(&pToneParms->Props);
406	AssertReturn(cbFrame, UINT64_MAX);
407
408	AssertReturn(PDMAudioPropsIsSizeAligned(&pToneParms->Props, (uint32_t)cbWindow), UINT64_MAX);
409
410	size_t cbRead;
411	for (;;)
412	{
413	rc = RTFileRead(hFile, &abBuf, RT_MIN(cbWindow, sizeof(abBuf)), &cbRead);
414	if ( RT_FAILURE(rc)
415	\|\| !cbRead)
416	break;
417
418	AssertReturn(PDMAudioPropsIsSizeAligned(&pToneParms->Props, (uint32_t)cbRead), UINT64_MAX);
419	AssertReturn(cbRead % cbFrame == 0, UINT64_MAX);
420
421	/** @todo Do we need to have a sliding window here? */
422
423	for (size_t i = 0; i < cbRead; i += cbWindow) /** @todo Slow as heck, but works for now. */
424	{
425	bool const fIsSilence = PDMAudioPropsIsBufferSilence(&pToneParms->Props, (const uint8_t *)abBuf + i, cbWindow);
426	if (fIsSilence != fFindSilence)
427	{
428	AssertReturn(PDMAudioPropsIsSizeAligned(&pToneParms->Props, offFound), 0);
429	return offFound;
430	}
431	offFound += cbWindow;
432	}
433	}
434
435	return cbMax;
436	}
437
438	/**
439	* Generates a tag.
440	*
441	* @returns VBox status code.
442	* @param pszTag The output buffer.
443	* @param cbTag The size of the output buffer.
444	* AUDIOTEST_TAG_MAX is a good size.
445	*/
446	int AudioTestGenTag(char *pszTag, size_t cbTag)
447	{
448	RTUUID UUID;
449	int rc = RTUuidCreate(&UUID);
450	AssertRCReturn(rc, rc);
451	rc = RTUuidToStr(&UUID, pszTag, cbTag);
452	AssertRCReturn(rc, rc);
453	return rc;
454	}
455
456	/**
457	* Return the tag to use in the given buffer, generating one if needed.
458	*
459	* @returns VBox status code.
460	* @param pszTag The output buffer.
461	* @param cbTag The size of the output buffer.
462	* AUDIOTEST_TAG_MAX is a good size.
463	* @param pszTagUser User specified tag, optional.
464	*/
465	static int audioTestCopyOrGenTag(char pszTag, size_t cbTag, const char pszTagUser)
466	{
467	if (pszTagUser && *pszTagUser)
468	return RTStrCopy(pszTag, cbTag, pszTagUser);
469	return AudioTestGenTag(pszTag, cbTag);
470	}
471
472
473	/**
474	* Creates a new path (directory) for a specific audio test set tag.
475	*
476	* @returns VBox status code.
477	* @param pszPath On input, specifies the absolute base path where to create the test set path.
478	* On output this specifies the absolute path created.
479	* @param cbPath Size (in bytes) of \a pszPath.
480	* @param pszTag Tag to use for path creation.
481	*
482	* @note Can be used multiple times with the same tag; a sub directory with an ISO time string will be used
483	* on each call.
484	*/
485	int AudioTestPathCreate(char pszPath, size_t cbPath, const char pszTag)
486	{
487	char szTag[AUDIOTEST_TAG_MAX];
488	int rc = audioTestCopyOrGenTag(szTag, sizeof(szTag), pszTag);
489	AssertRCReturn(rc, rc);
490
491	char szName[RT_ELEMENTS(AUDIOTEST_PATH_PREFIX_STR) + AUDIOTEST_TAG_MAX + 4];
492	if (RTStrPrintf2(szName, sizeof(szName), "%s-%s", AUDIOTEST_PATH_PREFIX_STR, szTag) < 0)
493	AssertFailedReturn(VERR_BUFFER_OVERFLOW);
494
495	rc = RTPathAppend(pszPath, cbPath, szName);
496	AssertRCReturn(rc, rc);
497
498	#ifndef DEBUG /* Makes debugging easier to have a deterministic directory. */
499	char szTime[64];
500	RTTIMESPEC time;
501	if (!RTTimeSpecToString(RTTimeNow(&time), szTime, sizeof(szTime)))
502	return VERR_BUFFER_UNDERFLOW;
503
504	/* Colons aren't allowed in windows filenames, so change to dashes. */
505	char *pszColon;
506	while ((pszColon = strchr(szTime, ':')) != NULL)
507	*pszColon = '-';
508
509	rc = RTPathAppend(pszPath, cbPath, szTime);
510	AssertRCReturn(rc, rc);
511	#endif
512
513	return RTDirCreateFullPath(pszPath, RTFS_UNIX_IRWXU);
514	}
515
516	DECLINLINE(int) audioTestManifestWriteData(PAUDIOTESTSET pSet, const void *pvData, size_t cbData)
517	{
518	/** @todo Use RTIniFileWrite once its implemented. */
519	return RTFileWrite(pSet->f.hFile, pvData, cbData, NULL);
520	}
521
522	/**
523	* Writes string data to a test set manifest.
524	*
525	* @returns VBox status code.
526	* @param pSet Test set to write manifest for.
527	* @param pszFormat Format string to write.
528	* @param args Variable arguments for \a pszFormat.
529	*/
530	static int audioTestManifestWriteV(PAUDIOTESTSET pSet, const char *pszFormat, va_list args)
531	{
532	/** @todo r=bird: Use RTStrmOpen + RTStrmPrintf instead of this slow
533	* do-it-all-yourself stuff. */
534	char *psz = NULL;
535	if (RTStrAPrintfV(&psz, pszFormat, args) == -1)
536	return VERR_NO_MEMORY;
537	AssertPtrReturn(psz, VERR_NO_MEMORY);
538
539	int rc = audioTestManifestWriteData(pSet, psz, strlen(psz));
540	AssertRC(rc);
541
542	RTStrFree(psz);
543
544	return rc;
545	}
546
547	/**
548	* Writes a string to a test set manifest.
549	* Convenience function.
550	*
551	* @returns VBox status code.
552	* @param pSet Test set to write manifest for.
553	* @param pszFormat Format string to write.
554	* @param ... Variable arguments for \a pszFormat. Optional.
555	*/
556	static int audioTestManifestWrite(PAUDIOTESTSET pSet, const char *pszFormat, ...)
557	{
558	va_list va;
559	va_start(va, pszFormat);
560
561	int rc = audioTestManifestWriteV(pSet, pszFormat, va);
562	AssertRC(rc);
563
564	va_end(va);
565
566	return rc;
567	}
568
569	/**
570	* Returns the current read/write offset (in bytes) of the opened manifest file.
571	*
572	* @returns Current read/write offset (in bytes).
573	* @param pSet Set to return offset for.
574	* Must have an opened manifest file.
575	*/
576	DECLINLINE(uint64_t) audioTestManifestGetOffsetAbs(PAUDIOTESTSET pSet)
577	{
578	AssertReturn(RTFileIsValid(pSet->f.hFile), 0);
579	return RTFileTell(pSet->f.hFile);
580	}
581
582	/**
583	* Writes a section header to a test set manifest.
584	*
585	* @returns VBox status code.
586	* @param pSet Test set to write manifest for.
587	* @param pszSection Format string of section to write.
588	* @param ... Variable arguments for \a pszSection. Optional.
589	*/
590	static int audioTestManifestWriteSectionHdr(PAUDIOTESTSET pSet, const char *pszSection, ...)
591	{
592	va_list va;
593	va_start(va, pszSection);
594
595	/** @todo Keep it as simple as possible for now. Improve this later. */
596	int rc = audioTestManifestWrite(pSet, "[%N]\n", pszSection, &va);
597
598	va_end(va);
599
600	return rc;
601	}
602
603	/**
604	* Initializes an audio test set, internal function.
605	*
606	* @param pSet Test set to initialize.
607	*/
608	static void audioTestSetInitInternal(PAUDIOTESTSET pSet)
609	{
610	pSet->f.hFile = NIL_RTFILE;
611
612	RTListInit(&pSet->lstObj);
613	pSet->cObj = 0;
614
615	RTListInit(&pSet->lstTest);
616	pSet->cTests = 0;
617	pSet->cTestsRunning = 0;
618	pSet->offTestCount = 0;
619	pSet->pTestCur = NULL;
620	pSet->cObj = 0;
621	pSet->offObjCount = 0;
622	pSet->cTotalFailures = 0;
623	}
624
625	/**
626	* Returns whether a test set's manifest file is open (and thus ready) or not.
627	*
628	* @returns \c true if open (and ready), or \c false if not.
629	* @retval VERR_
630	* @param pSet Test set to return open status for.
631	*/
632	static bool audioTestManifestIsOpen(PAUDIOTESTSET pSet)
633	{
634	if ( pSet->enmMode == AUDIOTESTSETMODE_TEST
635	&& pSet->f.hFile != NIL_RTFILE)
636	return true;
637	else if ( pSet->enmMode == AUDIOTESTSETMODE_VERIFY
638	&& pSet->f.hIniFile != NIL_RTINIFILE)
639	return true;
640
641	return false;
642	}
643
644	/**
645	* Initializes an audio test error description.
646	*
647	* @param pErr Test error description to initialize.
648	*/
649	static void audioTestErrorDescInit(PAUDIOTESTERRORDESC pErr)
650	{
651	RTListInit(&pErr->List);
652	pErr->cErrors = 0;
653	}
654
655	/**
656	* Destroys an audio test error description.
657	*
658	* @param pErr Test error description to destroy.
659	*/
660	void AudioTestErrorDescDestroy(PAUDIOTESTERRORDESC pErr)
661	{
662	if (!pErr)
663	return;
664
665	PAUDIOTESTERRORENTRY pErrEntry, pErrEntryNext;
666	RTListForEachSafe(&pErr->List, pErrEntry, pErrEntryNext, AUDIOTESTERRORENTRY, Node)
667	{
668	RTListNodeRemove(&pErrEntry->Node);
669
670	RTMemFree(pErrEntry);
671	}
672
673	pErr->cErrors = 0;
674	}
675
676	/**
677	* Returns the the number of errors of an audio test error description.
678	*
679	* @returns Error count.
680	* @param pErr Test error description to return error count for.
681	*/
682	uint32_t AudioTestErrorDescCount(PCAUDIOTESTERRORDESC pErr)
683	{
684	return pErr->cErrors;
685	}
686
687	/**
688	* Returns if an audio test error description contains any errors or not.
689	*
690	* @returns \c true if it contains errors, or \c false if not.
691	* @param pErr Test error description to return error status for.
692	*/
693	bool AudioTestErrorDescFailed(PCAUDIOTESTERRORDESC pErr)
694	{
695	if (pErr->cErrors)
696	{
697	Assert(!RTListIsEmpty(&pErr->List));
698	return true;
699	}
700
701	return false;
702	}
703
704	/**
705	* Adds a single error entry to an audio test error description, va_list version.
706	*
707	* @returns VBox status code.
708	* @param pErr Test error description to add entry for.
709	* @param idxTest Index of failing test (zero-based).
710	* @param rc Result code of entry to add.
711	* @param pszFormat Error description format string to add.
712	* @param va Optional format arguments of \a pszDesc to add.
713	*/
714	static int audioTestErrorDescAddV(PAUDIOTESTERRORDESC pErr, uint32_t idxTest, int rc, const char *pszFormat, va_list va)
715	{
716	PAUDIOTESTERRORENTRY pEntry = (PAUDIOTESTERRORENTRY)RTMemAlloc(sizeof(AUDIOTESTERRORENTRY));
717	AssertPtrReturn(pEntry, VERR_NO_MEMORY);
718
719	char *pszDescTmp;
720	if (RTStrAPrintfV(&pszDescTmp, pszFormat, va) < 0)
721	AssertFailedReturn(VERR_NO_MEMORY);
722
723	const ssize_t cch = RTStrPrintf2(pEntry->szDesc, sizeof(pEntry->szDesc), "Test #%RU32 %s: %s",
724	idxTest, RT_FAILURE(rc) ? "failed" : "info", pszDescTmp);
725	RTStrFree(pszDescTmp);
726	AssertReturn(cch > 0, VERR_BUFFER_OVERFLOW);
727
728	pEntry->rc = rc;
729
730	RTListAppend(&pErr->List, &pEntry->Node);
731
732	if (RT_FAILURE(rc))
733	pErr->cErrors++;
734
735	return VINF_SUCCESS;
736	}
737
738	/**
739	* Adds a single error entry to an audio test error description.
740	*
741	* @returns VBox status code.
742	* @param pErr Test error description to add entry for.
743	* @param idxTest Index of failing test (zero-based).
744	* @param pszFormat Error description format string to add.
745	* @param ... Optional format arguments of \a pszDesc to add.
746	*/
747	static int audioTestErrorDescAddError(PAUDIOTESTERRORDESC pErr, uint32_t idxTest, const char *pszFormat, ...)
748	{
749	va_list va;
750	va_start(va, pszFormat);
751
752	int rc = audioTestErrorDescAddV(pErr, idxTest, VERR_GENERAL_FAILURE /** @todo Fudge! */, pszFormat, va);
753
754	va_end(va);
755	return rc;
756	}
757
758	/**
759	* Adds a single info entry to an audio test error description, va_list version.
760	*
761	* @returns VBox status code.
762	* @param pErr Test error description to add entry for.
763	* @param idxTest Index of failing test (zero-based).
764	* @param pszFormat Error description format string to add.
765	* @param ... Optional format arguments of \a pszDesc to add.
766	*/
767	static int audioTestErrorDescAddInfo(PAUDIOTESTERRORDESC pErr, uint32_t idxTest, const char *pszFormat, ...)
768	{
769	va_list va;
770	va_start(va, pszFormat);
771
772	int rc = audioTestErrorDescAddV(pErr, idxTest, VINF_SUCCESS, pszFormat, va);
773
774	va_end(va);
775	return rc;
776	}
777
778	#if 0
779	static int audioTestErrorDescAddRc(PAUDIOTESTERRORDESC pErr, int rc, const char *pszFormat, ...)
780	{
781	va_list va;
782	va_start(va, pszFormat);
783
784	int rc2 = audioTestErrorDescAddV(pErr, rc, pszFormat, va);
785
786	va_end(va);
787	return rc2;
788	}
789	#endif
790
791	/**
792	* Retrieves the temporary directory.
793	*
794	* @returns VBox status code.
795	* @param pszPath Where to return the absolute path of the created directory on success.
796	* @param cbPath Size (in bytes) of \a pszPath.
797	*/
798	int AudioTestPathGetTemp(char *pszPath, size_t cbPath)
799	{
800	int rc = RTEnvGetEx(RTENV_DEFAULT, "TESTBOX_PATH_SCRATCH", pszPath, cbPath, NULL);
801	if (RT_FAILURE(rc))
802	{
803	rc = RTPathTemp(pszPath, cbPath);
804	AssertRCReturn(rc, rc);
805	}
806
807	return rc;
808	}
809
810	/**
811	* Creates a new temporary directory with a specific (test) tag.
812	*
813	* @returns VBox status code.
814	* @param pszPath Where to return the absolute path of the created directory on success.
815	* @param cbPath Size (in bytes) of \a pszPath.
816	* @param pszTag Tag name to use for directory creation.
817	*
818	* @note Can be used multiple times with the same tag; a sub directory with an ISO time string will be used
819	* on each call.
820	*/
821	int AudioTestPathCreateTemp(char pszPath, size_t cbPath, const char pszTag)
822	{
823	AssertReturn(pszTag && strlen(pszTag) <= AUDIOTEST_TAG_MAX, VERR_INVALID_PARAMETER);
824
825	char szTemp[RTPATH_MAX];
826	int rc = AudioTestPathGetTemp(szTemp, sizeof(szTemp));
827	AssertRCReturn(rc, rc);
828
829	rc = AudioTestPathCreate(szTemp, sizeof(szTemp), pszTag);
830	AssertRCReturn(rc, rc);
831
832	return RTStrCopy(pszPath, cbPath, szTemp);
833	}
834
835	/**
836	* Gets a value as string.
837	*
838	* @returns VBox status code.
839	* @param pObj Object handle to get value for.
840	* @param pszKey Key to get value from.
841	* @param pszVal Where to return the value on success.
842	* @param cbVal Size (in bytes) of \a pszVal.
843	*/
844	static int audioTestObjGetStr(PAUDIOTESTOBJINT pObj, const char pszKey, char pszVal, size_t cbVal)
845	{
846	/** @todo For now we only support .INI-style files. */
847	AssertPtrReturn(pObj->pSet, VERR_WRONG_ORDER);
848	return RTIniFileQueryValue(pObj->pSet->f.hIniFile, pObj->szSec, pszKey, pszVal, cbVal, NULL);
849	}
850
851	/**
852	* Gets a value as boolean.
853	*
854	* @returns VBox status code.
855	* @param pObj Object handle to get value for.
856	* @param pszKey Key to get value from.
857	* @param pbVal Where to return the value on success.
858	*/
859	static int audioTestObjGetBool(PAUDIOTESTOBJINT pObj, const char pszKey, bool pbVal)
860	{
861	char szVal[_1K];
862	int rc = audioTestObjGetStr(pObj, pszKey, szVal, sizeof(szVal));
863	if (RT_SUCCESS(rc))
864	*pbVal = (RTStrICmp(szVal, "true") == 0)
865	\|\| (RTStrICmp(szVal, "1") == 0) ? true : false;
866
867	return rc;
868	}
869
870	/**
871	* Gets a value as uint8_t.
872	*
873	* @returns VBox status code.
874	* @param pObj Object handle to get value for.
875	* @param pszKey Key to get value from.
876	* @param puVal Where to return the value on success.
877	*/
878	static int audioTestObjGetUInt8(PAUDIOTESTOBJINT pObj, const char pszKey, uint8_t puVal)
879	{
880	char szVal[_1K];
881	int rc = audioTestObjGetStr(pObj, pszKey, szVal, sizeof(szVal));
882	if (RT_SUCCESS(rc))
883	*puVal = RTStrToUInt8(szVal);
884
885	return rc;
886	}
887
888	/**
889	* Gets a value as uint32_t.
890	*
891	* @returns VBox status code.
892	* @param pObj Object handle to get value for.
893	* @param pszKey Key to get value from.
894	* @param puVal Where to return the value on success.
895	*/
896	static int audioTestObjGetUInt32(PAUDIOTESTOBJINT pObj, const char pszKey, uint32_t puVal)
897	{
898	char szVal[_1K];
899	int rc = audioTestObjGetStr(pObj, pszKey, szVal, sizeof(szVal));
900	if (RT_SUCCESS(rc))
901	*puVal = RTStrToUInt32(szVal);
902
903	return rc;
904	}
905
906	/**
907	* Returns the absolute path of a given audio test set object.
908	*
909	* @returns VBox status code.
910	* @param pSet Test set the object contains.
911	* @param pszPathAbs Where to return the absolute path on success.
912	* @param cbPathAbs Size (in bytes) of \a pszPathAbs.
913	* @param pszObjName Name of the object to create absolute path for.
914	*/
915	DECLINLINE(int) audioTestSetGetObjPath(PAUDIOTESTSET pSet, char pszPathAbs, size_t cbPathAbs, const char pszObjName)
916	{
917	return RTPathJoin(pszPathAbs, cbPathAbs, pSet->szPathAbs, pszObjName);
918	}
919
920	/**
921	* Returns the tag of a test set.
922	*
923	* @returns Test set tag.
924	* @param pSet Test set to return tag for.
925	*/
926	const char *AudioTestSetGetTag(PAUDIOTESTSET pSet)
927	{
928	return pSet->szTag;
929	}
930
931	/**
932	* Returns the total number of registered tests.
933	*
934	* @returns Total number of registered tests.
935	* @param pSet Test set to return value for.
936	*/
937	uint32_t AudioTestSetGetTestsTotal(PAUDIOTESTSET pSet)
938	{
939	return pSet->cTests;
940	}
941
942	/**
943	* Returns the total number of (still) running tests.
944	*
945	* @returns Total number of (still) running tests.
946	* @param pSet Test set to return value for.
947	*/
948	uint32_t AudioTestSetGetTestsRunning(PAUDIOTESTSET pSet)
949	{
950	return pSet->cTestsRunning;
951	}
952
953	/**
954	* Returns the total number of test failures occurred.
955	*
956	* @returns Total number of test failures occurred.
957	* @param pSet Test set to return value for.
958	*/
959	uint32_t AudioTestSetGetTotalFailures(PAUDIOTESTSET pSet)
960	{
961	return pSet->cTotalFailures;
962	}
963
964	/**
965	* Creates a new audio test set.
966	*
967	* @returns VBox status code.
968	* @param pSet Test set to create.
969	* @param pszPath Where to store the set set data. If NULL, the
970	* temporary directory will be used.
971	* @param pszTag Tag name to use for this test set.
972	*/
973	int AudioTestSetCreate(PAUDIOTESTSET pSet, const char pszPath, const char pszTag)
974	{
975	audioTestSetInitInternal(pSet);
976
977	int rc = audioTestCopyOrGenTag(pSet->szTag, sizeof(pSet->szTag), pszTag);
978	AssertRCReturn(rc, rc);
979
980	/*
981	* Test set directory.
982	*/
983	if (pszPath)
984	{
985	rc = RTPathAbs(pszPath, pSet->szPathAbs, sizeof(pSet->szPathAbs));
986	AssertRCReturn(rc, rc);
987
988	rc = AudioTestPathCreate(pSet->szPathAbs, sizeof(pSet->szPathAbs), pSet->szTag);
989	}
990	else
991	rc = AudioTestPathCreateTemp(pSet->szPathAbs, sizeof(pSet->szPathAbs), pSet->szTag);
992	AssertRCReturn(rc, rc);
993
994	/*
995	* Create the manifest file.
996	*/
997	char szTmp[RTPATH_MAX];
998	rc = RTPathJoin(szTmp, sizeof(szTmp), pSet->szPathAbs, AUDIOTEST_MANIFEST_FILE_STR);
999	AssertRCReturn(rc, rc);
1000
1001	rc = RTFileOpen(&pSet->f.hFile, szTmp, RTFILE_O_CREATE \| RTFILE_O_WRITE \| RTFILE_O_DENY_WRITE);
1002	AssertRCReturn(rc, rc);
1003
1004	rc = audioTestManifestWriteSectionHdr(pSet, "header");
1005	AssertRCReturn(rc, rc);
1006
1007	rc = audioTestManifestWrite(pSet, "magic=vkat_ini\n"); /* VKAT Manifest, .INI-style. */
1008	AssertRCReturn(rc, rc);
1009	rc = audioTestManifestWrite(pSet, "ver=%d\n", AUDIOTEST_MANIFEST_VER);
1010	AssertRCReturn(rc, rc);
1011	rc = audioTestManifestWrite(pSet, "tag=%s\n", pSet->szTag);
1012	AssertRCReturn(rc, rc);
1013
1014	AssertCompile(sizeof(szTmp) > RTTIME_STR_LEN);
1015	RTTIMESPEC Now;
1016	rc = audioTestManifestWrite(pSet, "date_created=%s\n", RTTimeSpecToString(RTTimeNow(&Now), szTmp, sizeof(szTmp)));
1017	AssertRCReturn(rc, rc);
1018
1019	RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szTmp, sizeof(szTmp)); /* do NOT return on failure. */
1020	rc = audioTestManifestWrite(pSet, "os_product=%s\n", szTmp);
1021	AssertRCReturn(rc, rc);
1022
1023	RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szTmp, sizeof(szTmp)); /* do NOT return on failure. */
1024	rc = audioTestManifestWrite(pSet, "os_rel=%s\n", szTmp);
1025	AssertRCReturn(rc, rc);
1026
1027	RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, szTmp, sizeof(szTmp)); /* do NOT return on failure. */
1028	rc = audioTestManifestWrite(pSet, "os_ver=%s\n", szTmp);
1029	AssertRCReturn(rc, rc);
1030
1031	rc = audioTestManifestWrite(pSet, "vbox_ver=%s r%u %s (%s %s)\n",
1032	VBOX_VERSION_STRING, RTBldCfgRevision(), RTBldCfgTargetDotArch(), __DATE__, __TIME__);
1033	AssertRCReturn(rc, rc);
1034
1035	rc = audioTestManifestWrite(pSet, "test_count=");
1036	AssertRCReturn(rc, rc);
1037	pSet->offTestCount = audioTestManifestGetOffsetAbs(pSet);
1038	rc = audioTestManifestWrite(pSet, "0000\n"); /* A bit messy, but does the trick for now. */
1039	AssertRCReturn(rc, rc);
1040
1041	rc = audioTestManifestWrite(pSet, "obj_count=");
1042	AssertRCReturn(rc, rc);
1043	pSet->offObjCount = audioTestManifestGetOffsetAbs(pSet);
1044	rc = audioTestManifestWrite(pSet, "0000\n"); /* A bit messy, but does the trick for now. */
1045	AssertRCReturn(rc, rc);
1046
1047	pSet->enmMode = AUDIOTESTSETMODE_TEST;
1048
1049	return rc;
1050	}
1051
1052	/**
1053	* Destroys a test set.
1054	*
1055	* @returns VBox status code.
1056	* @param pSet Test set to destroy.
1057	*/
1058	int AudioTestSetDestroy(PAUDIOTESTSET pSet)
1059	{
1060	if (!pSet)
1061	return VINF_SUCCESS;
1062
1063	/* No more validation (no / still running tests) here -- just pack all stuff we got so far
1064	* and let the verification routine deal with it later. */
1065
1066	int rc = AudioTestSetClose(pSet);
1067	if (RT_FAILURE(rc))
1068	return rc;
1069
1070	PAUDIOTESTOBJINT pObj, pObjNext;
1071	RTListForEachSafe(&pSet->lstObj, pObj, pObjNext, AUDIOTESTOBJINT, Node)
1072	{
1073	rc = audioTestObjClose(pObj);
1074	if (RT_SUCCESS(rc))
1075	{
1076	PAUDIOTESTOBJMETA pMeta, pMetaNext;
1077	RTListForEachSafe(&pObj->lstMeta, pMeta, pMetaNext, AUDIOTESTOBJMETA, Node)
1078	{
1079	switch (pMeta->enmType)
1080	{
1081	case AUDIOTESTOBJMETADATATYPE_STRING:
1082	{
1083	RTStrFree((char *)pMeta->pvMeta);
1084	break;
1085	}
1086
1087	default:
1088	AssertFailed();
1089	break;
1090	}
1091
1092	RTListNodeRemove(&pMeta->Node);
1093	RTMemFree(pMeta);
1094	}
1095
1096	RTListNodeRemove(&pObj->Node);
1097	RTMemFree(pObj);
1098
1099	Assert(pSet->cObj);
1100	pSet->cObj--;
1101	}
1102	else
1103	break;
1104	}
1105
1106	if (RT_FAILURE(rc))
1107	return rc;
1108
1109	Assert(pSet->cObj == 0);
1110
1111	PAUDIOTESTENTRY pEntry, pEntryNext;
1112	RTListForEachSafe(&pSet->lstTest, pEntry, pEntryNext, AUDIOTESTENTRY, Node)
1113	{
1114	RTListNodeRemove(&pEntry->Node);
1115	RTMemFree(pEntry);
1116
1117	Assert(pSet->cTests);
1118	pSet->cTests--;
1119	}
1120
1121	if (RT_FAILURE(rc))
1122	return rc;
1123
1124	Assert(pSet->cTests == 0);
1125
1126	return rc;
1127	}
1128
1129	/**
1130	* Opens an existing audio test set.
1131	*
1132	* @returns VBox status code.
1133	* @param pSet Test set to open.
1134	* @param pszPath Absolute path of the test set to open.
1135	*/
1136	int AudioTestSetOpen(PAUDIOTESTSET pSet, const char *pszPath)
1137	{
1138	audioTestSetInitInternal(pSet);
1139
1140	char szManifest[RTPATH_MAX];
1141	int rc = RTPathJoin(szManifest, sizeof(szManifest), pszPath, AUDIOTEST_MANIFEST_FILE_STR);
1142	AssertRCReturn(rc, rc);
1143
1144	RTVFSFILE hVfsFile;
1145	rc = RTVfsFileOpenNormal(szManifest, RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_DENY_WRITE, &hVfsFile);
1146	if (RT_FAILURE(rc))
1147	return rc;
1148
1149	rc = RTIniFileCreateFromVfsFile(&pSet->f.hIniFile, hVfsFile, RTINIFILE_F_READONLY);
1150	RTVfsFileRelease(hVfsFile);
1151	AssertRCReturn(rc, rc);
1152
1153	rc = RTStrCopy(pSet->szPathAbs, sizeof(pSet->szPathAbs), pszPath);
1154	AssertRCReturn(rc, rc);
1155
1156	pSet->enmMode = AUDIOTESTSETMODE_VERIFY;
1157
1158	return rc;
1159	}
1160
1161	/**
1162	* Closes an opened audio test set.
1163	*
1164	* @returns VBox status code.
1165	* @param pSet Test set to close.
1166	*/
1167	int AudioTestSetClose(PAUDIOTESTSET pSet)
1168	{
1169	AssertPtrReturn(pSet, VERR_INVALID_POINTER);
1170
1171	if (!audioTestManifestIsOpen(pSet))
1172	return VINF_SUCCESS;
1173
1174	int rc;
1175
1176	if (pSet->enmMode == AUDIOTESTSETMODE_TEST)
1177	{
1178	/* Update number of bound test objects. */
1179	PAUDIOTESTENTRY pTest;
1180	uint32_t cTests = 0;
1181	RTListForEach(&pSet->lstTest, pTest, AUDIOTESTENTRY, Node)
1182	{
1183	rc = RTFileSeek(pSet->f.hFile, pTest->offObjCount, RTFILE_SEEK_BEGIN, NULL);
1184	AssertRCReturn(rc, rc);
1185	rc = audioTestManifestWrite(pSet, "%04RU32", pTest->cObj);
1186	AssertRCReturn(rc, rc);
1187	cTests++; /* Sanity checking. */
1188	}
1189
1190	AssertMsgReturn(pSet->cTests == cTests, ("Test count and list don't match"), VERR_INTERNAL_ERROR);
1191
1192	/*
1193	* Update number of total objects.
1194	*/
1195	rc = RTFileSeek(pSet->f.hFile, pSet->offObjCount, RTFILE_SEEK_BEGIN, NULL);
1196	AssertRCReturn(rc, rc);
1197	rc = audioTestManifestWrite(pSet, "%04RU32", pSet->cObj);
1198	AssertRCReturn(rc, rc);
1199
1200	/*
1201	* Update number of total tests.
1202	*/
1203	rc = RTFileSeek(pSet->f.hFile, pSet->offTestCount, RTFILE_SEEK_BEGIN, NULL);
1204	AssertRCReturn(rc, rc);
1205	rc = audioTestManifestWrite(pSet, "%04RU32", pSet->cTests);
1206	AssertRCReturn(rc, rc);
1207
1208	/*
1209	* Serialize all registered test objects.
1210	*/
1211	rc = RTFileSeek(pSet->f.hFile, 0, RTFILE_SEEK_END, NULL);
1212	AssertRCReturn(rc, rc);
1213
1214	PAUDIOTESTOBJINT pObj;
1215	uint32_t cObj = 0;
1216	RTListForEach(&pSet->lstObj, pObj, AUDIOTESTOBJINT, Node)
1217	{
1218	/* First, close the object.
1219	* This also does some needed finalization. */
1220	rc = AudioTestObjClose(pObj);
1221	AssertRCReturn(rc, rc);
1222	rc = audioTestManifestWrite(pSet, "\n");
1223	AssertRCReturn(rc, rc);
1224	char szUuid[AUDIOTEST_MAX_SEC_LEN];
1225	rc = RTUuidToStr(&pObj->Uuid, szUuid, sizeof(szUuid));
1226	AssertRCReturn(rc, rc);
1227	rc = audioTestManifestWriteSectionHdr(pSet, "obj_%s", szUuid);
1228	AssertRCReturn(rc, rc);
1229	rc = audioTestManifestWrite(pSet, "obj_type=%RU32\n", pObj->enmType);
1230	AssertRCReturn(rc, rc);
1231	rc = audioTestManifestWrite(pSet, "obj_name=%s\n", pObj->szName);
1232	AssertRCReturn(rc, rc);
1233
1234	switch (pObj->enmType)
1235	{
1236	case AUDIOTESTOBJTYPE_FILE:
1237	{
1238	rc = audioTestManifestWrite(pSet, "obj_size=%RU64\n", pObj->File.cbSize);
1239	AssertRCReturn(rc, rc);
1240	break;
1241	}
1242
1243	default:
1244	AssertFailed();
1245	break;
1246	}
1247
1248	/*
1249	* Write all meta data.
1250	*/
1251	PAUDIOTESTOBJMETA pMeta;
1252	RTListForEach(&pObj->lstMeta, pMeta, AUDIOTESTOBJMETA, Node)
1253	{
1254	switch (pMeta->enmType)
1255	{
1256	case AUDIOTESTOBJMETADATATYPE_STRING:
1257	{
1258	rc = audioTestManifestWrite(pSet, (const char *)pMeta->pvMeta);
1259	AssertRCReturn(rc, rc);
1260	break;
1261	}
1262
1263	default:
1264	AssertFailed();
1265	break;
1266	}
1267	}
1268
1269	cObj++; /* Sanity checking. */
1270	}
1271
1272	AssertMsgReturn(pSet->cObj == cObj, ("Object count and list don't match"), VERR_INTERNAL_ERROR);
1273
1274	int rc2 = RTFileClose(pSet->f.hFile);
1275	if (RT_SUCCESS(rc2))
1276	pSet->f.hFile = NIL_RTFILE;
1277
1278	if (RT_SUCCESS(rc))
1279	rc = rc2;
1280	}
1281	else if (pSet->enmMode == AUDIOTESTSETMODE_VERIFY)
1282	{
1283	RTIniFileRelease(pSet->f.hIniFile);
1284	pSet->f.hIniFile = NIL_RTINIFILE;
1285
1286	rc = VINF_SUCCESS;
1287	}
1288	else
1289	AssertFailedStmt(rc = VERR_NOT_SUPPORTED);
1290
1291	return rc;
1292	}
1293
1294	/**
1295	* Physically wipes all related test set files off the disk.
1296	*
1297	* @returns VBox status code.
1298	* @param pSet Test set to wipe.
1299	*/
1300	int AudioTestSetWipe(PAUDIOTESTSET pSet)
1301	{
1302	AssertPtrReturn(pSet, VERR_INVALID_POINTER);
1303
1304	int rc = VINF_SUCCESS;
1305	char szFilePath[RTPATH_MAX];
1306
1307	PAUDIOTESTOBJINT pObj;
1308	RTListForEach(&pSet->lstObj, pObj, AUDIOTESTOBJINT, Node)
1309	{
1310	int rc2 = audioTestObjClose(pObj);
1311	if (RT_SUCCESS(rc2))
1312	{
1313	rc2 = audioTestSetGetObjPath(pSet, szFilePath, sizeof(szFilePath), pObj->szName);
1314	if (RT_SUCCESS(rc2))
1315	rc2 = RTFileDelete(szFilePath);
1316	}
1317
1318	if (RT_SUCCESS(rc))
1319	rc = rc2;
1320	/* Keep going. */
1321	}
1322
1323	if (RT_SUCCESS(rc))
1324	{
1325	rc = RTPathJoin(szFilePath, sizeof(szFilePath), pSet->szPathAbs, AUDIOTEST_MANIFEST_FILE_STR);
1326	if (RT_SUCCESS(rc))
1327	rc = RTFileDelete(szFilePath);
1328	}
1329
1330	/* Remove the (hopefully now empty) directory. Otherwise let this fail. */
1331	if (RT_SUCCESS(rc))
1332	rc = RTDirRemove(pSet->szPathAbs);
1333
1334	return rc;
1335	}
1336
1337	/**
1338	* Creates and registers a new audio test object to the current running test.
1339	*
1340	* @returns VBox status code.
1341	* @param pSet Test set to create and register new object for.
1342	* @param pszName Name of new object to create.
1343	* @param pObj Where to return the pointer to the newly created object on success.
1344	*/
1345	int AudioTestSetObjCreateAndRegister(PAUDIOTESTSET pSet, const char *pszName, PAUDIOTESTOBJ pObj)
1346	{
1347	AssertReturn(pSet->cTestsRunning == 1, VERR_WRONG_ORDER); /* No test nesting allowed. */
1348
1349	AssertPtrReturn(pszName, VERR_INVALID_POINTER);
1350
1351	PAUDIOTESTOBJINT pThis = (PAUDIOTESTOBJINT)RTMemAlloc(sizeof(AUDIOTESTOBJINT));
1352	AssertPtrReturn(pThis, VERR_NO_MEMORY);
1353
1354	audioTestObjInit(pThis);
1355
1356	if (RTStrPrintf2(pThis->szName, sizeof(pThis->szName), "%04RU32-%s", pSet->cObj, pszName) <= 0)
1357	AssertFailedReturn(VERR_BUFFER_OVERFLOW);
1358
1359	/** @todo Generalize this function more once we have more object types. */
1360
1361	char szObjPathAbs[RTPATH_MAX];
1362	int rc = audioTestSetGetObjPath(pSet, szObjPathAbs, sizeof(szObjPathAbs), pThis->szName);
1363	if (RT_SUCCESS(rc))
1364	{
1365	rc = RTFileOpen(&pThis->File.hFile, szObjPathAbs, RTFILE_O_CREATE \| RTFILE_O_WRITE \| RTFILE_O_DENY_WRITE);
1366	if (RT_SUCCESS(rc))
1367	{
1368	pThis->enmType = AUDIOTESTOBJTYPE_FILE;
1369	pThis->cRefs = 1; /* Currently only 1:1 mapping. */
1370
1371	RTListAppend(&pSet->lstObj, &pThis->Node);
1372	pSet->cObj++;
1373
1374	/* Generate + set an UUID for the object and assign it to the current test. */
1375	rc = RTUuidCreate(&pThis->Uuid);
1376	AssertRCReturn(rc, rc);
1377	char szUuid[AUDIOTEST_MAX_OBJ_LEN];
1378	rc = RTUuidToStr(&pThis->Uuid, szUuid, sizeof(szUuid));
1379	AssertRCReturn(rc, rc);
1380
1381	rc = audioTestManifestWrite(pSet, "obj%RU32_uuid=%s\n", pSet->pTestCur->cObj, szUuid);
1382	AssertRCReturn(rc, rc);
1383
1384	AssertPtr(pSet->pTestCur);
1385	pSet->pTestCur->cObj++;
1386
1387	*pObj = pThis;
1388	}
1389	}
1390
1391	if (RT_FAILURE(rc))
1392	RTMemFree(pThis);
1393
1394	return rc;
1395	}
1396
1397	/**
1398	* Writes to a created audio test object.
1399	*
1400	* @returns VBox status code.
1401	* @param hObj Handle to the audio test object to write to.
1402	* @param pvBuf Pointer to data to write.
1403	* @param cbBuf Size (in bytes) of \a pvBuf to write.
1404	*/
1405	int AudioTestObjWrite(AUDIOTESTOBJ hObj, const void *pvBuf, size_t cbBuf)
1406	{
1407	AUDIOTESTOBJINT *pThis = hObj;
1408
1409	/** @todo Generalize this function more once we have more object types. */
1410	AssertReturn(pThis->enmType == AUDIOTESTOBJTYPE_FILE, VERR_INVALID_PARAMETER);
1411
1412	return RTFileWrite(pThis->File.hFile, pvBuf, cbBuf, NULL);
1413	}
1414
1415	/**
1416	* Adds meta data to a test object as a string, va_list version.
1417	*
1418	* @returns VBox status code.
1419	* @param pObj Test object to add meta data for.
1420	* @param pszFormat Format string to add.
1421	* @param va Variable arguments list to use for the format string.
1422	*/
1423	static int audioTestObjAddMetadataStrV(PAUDIOTESTOBJINT pObj, const char *pszFormat, va_list va)
1424	{
1425	PAUDIOTESTOBJMETA pMeta = (PAUDIOTESTOBJMETA)RTMemAlloc(sizeof(AUDIOTESTOBJMETA));
1426	AssertPtrReturn(pMeta, VERR_NO_MEMORY);
1427
1428	pMeta->pvMeta = RTStrAPrintf2V(pszFormat, va);
1429	AssertPtrReturn(pMeta->pvMeta, VERR_BUFFER_OVERFLOW);
1430	pMeta->cbMeta = RTStrNLen((const char *)pMeta->pvMeta, RTSTR_MAX);
1431
1432	pMeta->enmType = AUDIOTESTOBJMETADATATYPE_STRING;
1433
1434	RTListAppend(&pObj->lstMeta, &pMeta->Node);
1435
1436	return VINF_SUCCESS;
1437	}
1438
1439	/**
1440	* Adds meta data to a test object as a string.
1441	*
1442	* @returns VBox status code.
1443	* @param hObj Handle to the test object to add meta data for.
1444	* @param pszFormat Format string to add.
1445	* @param ... Variable arguments for the format string.
1446	*/
1447	int AudioTestObjAddMetadataStr(AUDIOTESTOBJ hObj, const char *pszFormat, ...)
1448	{
1449	AUDIOTESTOBJINT *pThis = hObj;
1450
1451	va_list va;
1452
1453	va_start(va, pszFormat);
1454	int rc = audioTestObjAddMetadataStrV(pThis, pszFormat, va);
1455	va_end(va);
1456
1457	return rc;
1458	}
1459
1460	/**
1461	* Closes an opened audio test object.
1462	*
1463	* @returns VBox status code.
1464	* @param hObj Handle to the audio test object to close.
1465	*/
1466	int AudioTestObjClose(AUDIOTESTOBJ hObj)
1467	{
1468	AUDIOTESTOBJINT *pThis = hObj;
1469
1470	if (!pThis)
1471	return VINF_SUCCESS;
1472
1473	audioTestObjFinalize(pThis);
1474
1475	return audioTestObjClose(pThis);
1476	}
1477
1478	/**
1479	* Begins a new test of a test set.
1480	*
1481	* @returns VBox status code.
1482	* @param pSet Test set to begin new test for.
1483	* @param pszDesc Test description.
1484	* @param pParms Test parameters to use.
1485	* @param ppEntry Where to return the new test
1486	*/
1487	int AudioTestSetTestBegin(PAUDIOTESTSET pSet, const char pszDesc, PAUDIOTESTPARMS pParms, PAUDIOTESTENTRY ppEntry)
1488	{
1489	AssertReturn(pSet->cTestsRunning == 0, VERR_WRONG_ORDER); /* No test nesting allowed. */
1490
1491	PAUDIOTESTENTRY pEntry = (PAUDIOTESTENTRY)RTMemAllocZ(sizeof(AUDIOTESTENTRY));
1492	AssertPtrReturn(pEntry, VERR_NO_MEMORY);
1493
1494	int rc = RTStrCopy(pEntry->szDesc, sizeof(pEntry->szDesc), pszDesc);
1495	AssertRCReturn(rc, rc);
1496
1497	memcpy(&pEntry->Parms, pParms, sizeof(AUDIOTESTPARMS));
1498
1499	pEntry->pParent = pSet;
1500	pEntry->rc = VERR_IPE_UNINITIALIZED_STATUS;
1501
1502	rc = audioTestManifestWrite(pSet, "\n");
1503	AssertRCReturn(rc, rc);
1504
1505	rc = audioTestManifestWriteSectionHdr(pSet, "test_%04RU32", pSet->cTests);
1506	AssertRCReturn(rc, rc);
1507	rc = audioTestManifestWrite(pSet, "test_desc=%s\n", pszDesc);
1508	AssertRCReturn(rc, rc);
1509	rc = audioTestManifestWrite(pSet, "test_type=%RU32\n", pParms->enmType);
1510	AssertRCReturn(rc, rc);
1511	rc = audioTestManifestWrite(pSet, "test_delay_ms=%RU32\n", pParms->msDelay);
1512	AssertRCReturn(rc, rc);
1513	rc = audioTestManifestWrite(pSet, "audio_direction=%s\n", PDMAudioDirGetName(pParms->enmDir));
1514	AssertRCReturn(rc, rc);
1515
1516	rc = audioTestManifestWrite(pSet, "obj_count=");
1517	AssertRCReturn(rc, rc);
1518	pEntry->offObjCount = audioTestManifestGetOffsetAbs(pSet);
1519	rc = audioTestManifestWrite(pSet, "0000\n"); /* A bit messy, but does the trick for now. */
1520	AssertRCReturn(rc, rc);
1521
1522	switch (pParms->enmType)
1523	{
1524	case AUDIOTESTTYPE_TESTTONE_PLAY:
1525	RT_FALL_THROUGH();
1526	case AUDIOTESTTYPE_TESTTONE_RECORD:
1527	{
1528	rc = audioTestManifestWrite(pSet, "tone_freq_hz=%RU16\n", (uint16_t)pParms->TestTone.dbFreqHz);
1529	AssertRCReturn(rc, rc);
1530	rc = audioTestManifestWrite(pSet, "tone_prequel_ms=%RU32\n", pParms->TestTone.msPrequel);
1531	AssertRCReturn(rc, rc);
1532	rc = audioTestManifestWrite(pSet, "tone_duration_ms=%RU32\n", pParms->TestTone.msDuration);
1533	AssertRCReturn(rc, rc);
1534	rc = audioTestManifestWrite(pSet, "tone_sequel_ms=%RU32\n", pParms->TestTone.msSequel);
1535	AssertRCReturn(rc, rc);
1536	rc = audioTestManifestWrite(pSet, "tone_volume_percent=%RU32\n", pParms->TestTone.uVolumePercent);
1537	AssertRCReturn(rc, rc);
1538	rc = audioTestManifestWrite(pSet, "tone_pcm_hz=%RU32\n", PDMAudioPropsHz(&pParms->TestTone.Props));
1539	AssertRCReturn(rc, rc);
1540	rc = audioTestManifestWrite(pSet, "tone_pcm_channels=%RU8\n", PDMAudioPropsChannels(&pParms->TestTone.Props));
1541	AssertRCReturn(rc, rc);
1542	rc = audioTestManifestWrite(pSet, "tone_pcm_bits=%RU8\n", PDMAudioPropsSampleBits(&pParms->TestTone.Props));
1543	AssertRCReturn(rc, rc);
1544	rc = audioTestManifestWrite(pSet, "tone_pcm_is_signed=%RTbool\n", PDMAudioPropsIsSigned(&pParms->TestTone.Props));
1545	AssertRCReturn(rc, rc);
1546	break;
1547	}
1548
1549	default:
1550	AssertFailed();
1551	break;
1552	}
1553
1554	RTListAppend(&pSet->lstTest, &pEntry->Node);
1555
1556	pSet->cTests++;
1557	pSet->cTestsRunning++;
1558	pSet->pTestCur = pEntry;
1559
1560	*ppEntry = pEntry;
1561
1562	return rc;
1563	}
1564
1565	/**
1566	* Marks a running test as failed.
1567	*
1568	* @returns VBox status code.
1569	* @param pEntry Test to mark.
1570	* @param rc Error code.
1571	* @param pszErr Error description.
1572	*/
1573	int AudioTestSetTestFailed(PAUDIOTESTENTRY pEntry, int rc, const char *pszErr)
1574	{
1575	AssertReturn(pEntry->pParent->cTestsRunning == 1, VERR_WRONG_ORDER); /* No test nesting allowed. */
1576	AssertReturn(pEntry->rc == VERR_IPE_UNINITIALIZED_STATUS, VERR_WRONG_ORDER);
1577
1578	pEntry->rc = rc;
1579
1580	int rc2 = audioTestManifestWrite(pEntry->pParent, "error_rc=%RI32\n", rc);
1581	AssertRCReturn(rc2, rc2);
1582	rc2 = audioTestManifestWrite(pEntry->pParent, "error_desc=%s\n", pszErr);
1583	AssertRCReturn(rc2, rc2);
1584
1585	pEntry->pParent->cTestsRunning--;
1586	pEntry->pParent->pTestCur = NULL;
1587
1588	return rc2;
1589	}
1590
1591	/**
1592	* Marks a running test as successfully done.
1593	*
1594	* @returns VBox status code.
1595	* @param pEntry Test to mark.
1596	*/
1597	int AudioTestSetTestDone(PAUDIOTESTENTRY pEntry)
1598	{
1599	AssertReturn(pEntry->pParent->cTestsRunning == 1, VERR_WRONG_ORDER); /* No test nesting allowed. */
1600	AssertReturn(pEntry->rc == VERR_IPE_UNINITIALIZED_STATUS, VERR_WRONG_ORDER);
1601
1602	pEntry->rc = VINF_SUCCESS;
1603
1604	int rc2 = audioTestManifestWrite(pEntry->pParent, "error_rc=%RI32\n", VINF_SUCCESS);
1605	AssertRCReturn(rc2, rc2);
1606
1607	pEntry->pParent->cTestsRunning--;
1608	pEntry->pParent->pTestCur = NULL;
1609
1610	return rc2;
1611	}
1612
1613	/**
1614	* Returns whether a test is still running or not.
1615	*
1616	* @returns \c true if test is still running, or \c false if not.
1617	* @param pEntry Test to get running status for.
1618	*/
1619	bool AudioTestSetTestIsRunning(PAUDIOTESTENTRY pEntry)
1620	{
1621	return (pEntry->rc == VERR_IPE_UNINITIALIZED_STATUS);
1622	}
1623
1624	/**
1625	* Packs a closed audio test so that it's ready for transmission.
1626	*
1627	* @returns VBox status code.
1628	* @param pSet Test set to pack.
1629	* @param pszOutDir Directory where to store the packed test set.
1630	* @param pszFileName Where to return the final name of the packed test set. Optional and can be NULL.
1631	* @param cbFileName Size (in bytes) of \a pszFileName.
1632	*/
1633	int AudioTestSetPack(PAUDIOTESTSET pSet, const char pszOutDir, char pszFileName, size_t cbFileName)
1634	{
1635	AssertPtrReturn(pSet, VERR_INVALID_POINTER);
1636	AssertReturn(!pszFileName \|\| cbFileName, VERR_INVALID_PARAMETER);
1637	AssertReturn(!audioTestManifestIsOpen(pSet), VERR_WRONG_ORDER);
1638
1639	/* No more validation (no / still running tests) here -- just pack all stuff we got so far
1640	* and let the verification routine deal with it later. */
1641
1642	/** @todo Check and deny if \a pszOutDir is part of the set's path. */
1643
1644	int rc = RTDirCreateFullPath(pszOutDir, 0755);
1645	if (RT_FAILURE(rc))
1646	return rc;
1647
1648	char szOutName[RT_ELEMENTS(AUDIOTEST_PATH_PREFIX_STR) + AUDIOTEST_TAG_MAX + 16];
1649	if (RTStrPrintf2(szOutName, sizeof(szOutName), "%s-%s%s",
1650	AUDIOTEST_PATH_PREFIX_STR, pSet->szTag, AUDIOTEST_ARCHIVE_SUFF_STR) <= 0)
1651	AssertFailedReturn(VERR_BUFFER_OVERFLOW);
1652
1653	char szOutPath[RTPATH_MAX];
1654	rc = RTPathJoin(szOutPath, sizeof(szOutPath), pszOutDir, szOutName);
1655	AssertRCReturn(rc, rc);
1656
1657	const char *apszArgs[10];
1658	unsigned cArgs = 0;
1659
1660	apszArgs[cArgs++] = "vkat";
1661	apszArgs[cArgs++] = "--create";
1662	apszArgs[cArgs++] = "--gzip";
1663	apszArgs[cArgs++] = "--directory";
1664	apszArgs[cArgs++] = pSet->szPathAbs;
1665	apszArgs[cArgs++] = "--file";
1666	apszArgs[cArgs++] = szOutPath;
1667	apszArgs[cArgs++] = ".";
1668
1669	RTEXITCODE rcExit = RTZipTarCmd(cArgs, (char **)apszArgs);
1670	if (rcExit != RTEXITCODE_SUCCESS)
1671	rc = VERR_GENERAL_FAILURE; /** @todo Fudge! */
1672
1673	if (RT_SUCCESS(rc))
1674	{
1675	if (pszFileName)
1676	rc = RTStrCopy(pszFileName, cbFileName, szOutPath);
1677	}
1678
1679	return rc;
1680	}
1681
1682	/**
1683	* Returns whether a test set archive is packed (as .tar.gz by default) or
1684	* a plain directory.
1685	*
1686	* @returns \c true if packed (as .tar.gz), or \c false if not (directory).
1687	* @param pszPath Path to return packed staus for.
1688	*/
1689	bool AudioTestSetIsPacked(const char *pszPath)
1690	{
1691	/** @todo Improve this, good enough for now. */
1692	return (RTStrIStr(pszPath, AUDIOTEST_ARCHIVE_SUFF_STR) != NULL);
1693	}
1694
1695	/**
1696	* Returns whether a test set has running (active) tests or not.
1697	*
1698	* @returns \c true if it has running tests, or \c false if not.
1699	* @param pSet Test set to return status for.
1700	*/
1701	bool AudioTestSetIsRunning(PAUDIOTESTSET pSet)
1702	{
1703	return (pSet->cTestsRunning > 0);
1704	}
1705
1706	/**
1707	* Unpacks a formerly packed audio test set.
1708	*
1709	* @returns VBox status code.
1710	* @param pszFile Test set file to unpack. Must contain the absolute path.
1711	* @param pszOutDir Directory where to unpack the test set into.
1712	* If the directory does not exist it will be created.
1713	*/
1714	int AudioTestSetUnpack(const char pszFile, const char pszOutDir)
1715	{
1716	AssertReturn(pszFile && pszOutDir, VERR_INVALID_PARAMETER);
1717
1718	int rc = VINF_SUCCESS;
1719
1720	if (!RTDirExists(pszOutDir))
1721	{
1722	rc = RTDirCreateFullPath(pszOutDir, 0755);
1723	if (RT_FAILURE(rc))
1724	return rc;
1725	}
1726
1727	const char *apszArgs[8];
1728	unsigned cArgs = 0;
1729
1730	apszArgs[cArgs++] = "vkat";
1731	apszArgs[cArgs++] = "--extract";
1732	apszArgs[cArgs++] = "--gunzip";
1733	apszArgs[cArgs++] = "--directory";
1734	apszArgs[cArgs++] = pszOutDir;
1735	apszArgs[cArgs++] = "--file";
1736	apszArgs[cArgs++] = pszFile;
1737
1738	RTEXITCODE rcExit = RTZipTarCmd(cArgs, (char **)apszArgs);
1739	if (rcExit != RTEXITCODE_SUCCESS)
1740	rc = VERR_GENERAL_FAILURE; /** @todo Fudge! */
1741
1742	return rc;
1743	}
1744
1745	/**
1746	* Retrieves an object handle of a specific test set section.
1747	*
1748	* @returns VBox status code.
1749	* @param pSet Test set the section contains.
1750	* @param pszSec Name of section to retrieve object handle for.
1751	* @param phSec Where to store the object handle on success.
1752	*/
1753	static int audioTestSetGetSection(PAUDIOTESTSET pSet, const char *pszSec, PAUDIOTESTOBJINT phSec)
1754	{
1755	int rc = RTStrCopy(phSec->szSec, sizeof(phSec->szSec), pszSec);
1756	if (RT_FAILURE(rc))
1757	return rc;
1758
1759	phSec->pSet = pSet;
1760
1761	/** @todo Check for section existence. */
1762	RT_NOREF(pSet);
1763
1764	return VINF_SUCCESS;
1765	}
1766
1767	/**
1768	* Retrieves an object handle of a specific test.
1769	*
1770	* @returns VBox status code.
1771	* @param pSet Test set the test contains.
1772	* @param idxTst Index of test to retrieve the object handle for.
1773	* @param phTst Where to store the object handle on success.
1774	*/
1775	static int audioTestSetGetTest(PAUDIOTESTSET pSet, uint32_t idxTst, PAUDIOTESTOBJINT phTst)
1776	{
1777	char szSec[AUDIOTEST_MAX_SEC_LEN];
1778	if (RTStrPrintf2(szSec, sizeof(szSec), "test_%04RU32", idxTst) <= 0)
1779	return VERR_BUFFER_OVERFLOW;
1780
1781	return audioTestSetGetSection(pSet, szSec, phTst);
1782	}
1783
1784	/**
1785	* Initializes a test object.
1786	*
1787	* @param pObj Object to initialize.
1788	*/
1789	static void audioTestObjInit(PAUDIOTESTOBJINT pObj)
1790	{
1791	RT_BZERO(pObj, sizeof(AUDIOTESTOBJINT));
1792
1793	pObj->cRefs = 1;
1794
1795	RTListInit(&pObj->lstMeta);
1796	}
1797
1798	/**
1799	* Retrieves a child object of a specific parent object.
1800	*
1801	* @returns VBox status code.
1802	* @param pParent Parent object the child object contains.
1803	* @param idxObj Index of object to retrieve the object handle for.
1804	* @param pObj Where to store the object handle on success.
1805	*/
1806	static int audioTestObjGetChild(PAUDIOTESTOBJINT pParent, uint32_t idxObj, PAUDIOTESTOBJINT pObj)
1807	{
1808	char szObj[AUDIOTEST_MAX_SEC_LEN];
1809	if (RTStrPrintf2(szObj, sizeof(szObj), "obj%RU32_uuid", idxObj) <= 0)
1810	AssertFailedReturn(VERR_BUFFER_OVERFLOW);
1811
1812	char szUuid[AUDIOTEST_MAX_SEC_LEN];
1813	int rc = audioTestObjGetStr(pParent, szObj, szUuid, sizeof(szUuid));
1814	if (RT_SUCCESS(rc))
1815	{
1816	audioTestObjInit(pObj);
1817
1818	AssertReturn(RTStrPrintf2(pObj->szSec, sizeof(pObj->szSec), "obj_%s", szUuid) > 0, VERR_BUFFER_OVERFLOW);
1819
1820	/** @todo Check test section existence. */
1821
1822	pObj->pSet = pParent->pSet;
1823	}
1824
1825	return rc;
1826	}
1827
1828	/**
1829	* Verifies a value of a test verification job.
1830	*
1831	* @returns VBox status code.
1832	* @returns Error if the verification failed and test verification job has fKeepGoing not set.
1833	* @param pVerJob Verification job to verify value for.
1834	* @param pObjA Object handle A to verify value for.
1835	* @param pObjB Object handle B to verify value for.
1836	* @param pszKey Key to verify.
1837	* @param pszVal Value to verify.
1838	* @param pszErrFmt Error format string in case the verification failed.
1839	* @param ... Variable aruments for error format string.
1840	*/
1841	static int audioTestVerifyValue(PAUDIOTESTVERIFYJOB pVerJob,
1842	PAUDIOTESTOBJINT pObjA, PAUDIOTESTOBJINT pObjB, const char pszKey, const char pszVal, const char *pszErrFmt, ...)
1843	{
1844	va_list va;
1845	va_start(va, pszErrFmt);
1846
1847	char szValA[_1K];
1848	int rc = audioTestObjGetStr(pObjA, pszKey, szValA, sizeof(szValA));
1849	if (RT_SUCCESS(rc))
1850	{
1851	char szValB[_1K];
1852	rc = audioTestObjGetStr(pObjB, pszKey, szValB, sizeof(szValB));
1853	if (RT_SUCCESS(rc))
1854	{
1855	if (RTStrCmp(szValA, szValB))
1856	{
1857	int rc2 = audioTestErrorDescAddError(pVerJob->pErr, pVerJob->idxTest,
1858	"Values are not equal ('%s' vs. '%s')", szValA, szValB);
1859	AssertRC(rc2);
1860	rc = VERR_WRONG_TYPE; /** @todo Fudge! */
1861	}
1862
1863	if (pszVal)
1864	{
1865	if (RTStrCmp(szValA, pszVal))
1866	{
1867	int rc2 = audioTestErrorDescAddError(pVerJob->pErr, pVerJob->idxTest,
1868	"Values don't match expected value (got '%s', expected '%s')", szValA, pszVal);
1869	AssertRC(rc2);
1870	rc = VERR_WRONG_TYPE; /** @todo Fudge! */
1871	}
1872	}
1873	}
1874	}
1875
1876	if (RT_FAILURE(rc))
1877	{
1878	int rc2 = audioTestErrorDescAddV(pVerJob->pErr, pVerJob->idxTest, rc, pszErrFmt, va);
1879	AssertRC(rc2);
1880	}
1881
1882	va_end(va);
1883
1884	return pVerJob->Opts.fKeepGoing ? VINF_SUCCESS : rc;
1885	}
1886
1887	/**
1888	* Opens a test object which is a regular file.
1889	*
1890	* @returns VBox status code.
1891	* @param pObj Test object to open.
1892	* @param pszFile Absolute file path of file to open.
1893	*/
1894	static int audioTestObjOpenFile(PAUDIOTESTOBJINT pObj, const char *pszFile)
1895	{
1896	int rc = RTFileOpen(&pObj->File.hFile, pszFile, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE);
1897	if (RT_SUCCESS(rc))
1898	{
1899	int rc2 = RTStrCopy(pObj->szName, sizeof(pObj->szName), pszFile);
1900	AssertRC(rc2);
1901
1902	pObj->enmType = AUDIOTESTOBJTYPE_FILE;
1903	}
1904
1905	return rc;
1906	}
1907
1908	/**
1909	* Opens an existing audio test object.
1910	*
1911	* @returns VBox status code.
1912	* @param pObj Object to open.
1913	*/
1914	static int audioTestObjOpen(PAUDIOTESTOBJINT pObj)
1915	{
1916	AssertReturn(pObj->enmType == AUDIOTESTOBJTYPE_UNKNOWN, VERR_WRONG_ORDER);
1917
1918	char szFileName[AUDIOTEST_MAX_SEC_LEN];
1919	int rc = audioTestObjGetStr(pObj, "obj_name", szFileName, sizeof(szFileName));
1920	if (RT_SUCCESS(rc))
1921	{
1922	char szFilePath[RTPATH_MAX];
1923	rc = RTPathJoin(szFilePath, sizeof(szFilePath), pObj->pSet->szPathAbs, szFileName);
1924	if (RT_SUCCESS(rc))
1925	{
1926	/** @todo Check "obj_type". */
1927	rc = audioTestObjOpenFile(pObj, szFilePath);
1928	}
1929	}
1930	return rc;
1931	}
1932
1933	/**
1934	* Closes an audio test set object.
1935	*
1936	* @returns VBox status code.
1937	* @param pObj Object to close.
1938	*/
1939	static int audioTestObjClose(PAUDIOTESTOBJINT pObj)
1940	{
1941	if (!audioTestObjIsOpen(pObj))
1942	return VINF_SUCCESS;
1943
1944	int rc;
1945
1946	/** @todo Generalize this function more once we have more object types. */
1947
1948	if (RTFileIsValid(pObj->File.hFile))
1949	{
1950	rc = RTFileClose(pObj->File.hFile);
1951	if (RT_SUCCESS(rc))
1952	pObj->File.hFile = NIL_RTFILE;
1953	}
1954	else
1955	rc = VINF_SUCCESS;
1956
1957	return rc;
1958	}
1959
1960	/**
1961	* Returns whether a test set object is in opened state or not.
1962	*
1963	* @returns \c true if open, or \c false if not.
1964	* @param pObj Object to return status for.
1965	*/
1966	static bool audioTestObjIsOpen(PAUDIOTESTOBJINT pObj)
1967	{
1968	return pObj->enmType != AUDIOTESTOBJTYPE_UNKNOWN;
1969	}
1970
1971	/**
1972	* Finalizes an audio test set object.
1973	*
1974	* @param pObj Test object to finalize.
1975	*/
1976	static void audioTestObjFinalize(PAUDIOTESTOBJINT pObj)
1977	{
1978	/** @todo Generalize this function more once we have more object types. */
1979	AssertReturnVoid(pObj->enmType == AUDIOTESTOBJTYPE_FILE);
1980
1981	if (RTFileIsValid(pObj->File.hFile))
1982	pObj->File.cbSize = RTFileTell(pObj->File.hFile);
1983	}
1984
1985	/**
1986	* Retrieves tone PCM properties of an object.
1987	*
1988	* @returns VBox status code.
1989	* @param pObj Object to retrieve PCM properties for.
1990	* @param pProps Where to store the PCM properties on success.
1991	*/
1992	static int audioTestObjGetTonePcmProps(PAUDIOTESTOBJINT pObj, PPDMAUDIOPCMPROPS pProps)
1993	{
1994	int rc;
1995	uint32_t uHz;
1996	rc = audioTestObjGetUInt32(pObj, "tone_pcm_hz", &uHz);
1997	AssertRCReturn(rc, rc);
1998	uint8_t cBits;
1999	rc = audioTestObjGetUInt8(pObj, "tone_pcm_bits", &cBits);
2000	AssertRCReturn(rc, rc);
2001	uint8_t cChan;
2002	rc = audioTestObjGetUInt8(pObj, "tone_pcm_channels", &cChan);
2003	AssertRCReturn(rc, rc);
2004	bool fSigned;
2005	rc = audioTestObjGetBool(pObj, "tone_pcm_is_signed", &fSigned);
2006	AssertRCReturn(rc, rc);
2007
2008	PDMAudioPropsInit(pProps, (cBits / 8), fSigned, cChan, uHz);
2009
2010	return VINF_SUCCESS;
2011	}
2012
2013	/**
2014	* Normalizes PCM audio data.
2015	* Only supports 16 bit stereo PCM data for now.
2016	*
2017	* @returns VBox status code.
2018	* @param hFileSrc Source file handle of audio data to normalize.
2019	* @param pProps PCM properties to use for normalization.
2020	* @param cbSize Size (in bytes) of audio data to normalize.
2021	* @param dbNormalizePercent Normalization (percent) to achieve.
2022	* @param hFileDst Destiation file handle (must be open) where to write the normalized audio data to.
2023	* @param pdbRatio Where to store the normalization ratio used on success. Optional and can be NULL.
2024	* A ration of exactly 1 means no normalization.
2025	*
2026	* @note The source file handle must point at the beginning of the PCM audio data to normalize.
2027	*/
2028	static int audioTestFileNormalizePCM(RTFILE hFileSrc, PCPDMAUDIOPCMPROPS pProps, uint64_t cbSize,
2029	double dbNormalizePercent, RTFILE hFileDst, double *pdbRatio)
2030	{
2031	if ( !pProps->fSigned
2032	\|\| pProps->cbSampleX != 2) /* Fend-off non-supported stuff first. */
2033	return VERR_NOT_SUPPORTED;
2034
2035	int rc = VINF_SUCCESS; /* Shut up MSVC. */
2036
2037	if (!cbSize)
2038	{
2039	rc = RTFileQuerySize(hFileSrc, &cbSize);
2040	AssertRCReturn(rc, rc);
2041	}
2042	else
2043	AssertReturn(PDMAudioPropsIsSizeAligned(pProps, (uint32_t)cbSize), VERR_INVALID_PARAMETER);
2044
2045	uint64_t offStart = RTFileTell(hFileSrc);
2046	size_t cbToRead = cbSize;
2047
2048	/* Find minimum and maximum peaks. */
2049	int16_t iMin = 0;
2050	int16_t iMax = 0;
2051	double dbRatio = 0.0;
2052
2053	uint8_t auBuf[_64K];
2054	while (cbToRead)
2055	{
2056	size_t const cbChunk = RT_MIN(cbToRead, sizeof(auBuf));
2057	size_t cbRead = 0;
2058	rc = RTFileRead(hFileSrc, auBuf, cbChunk, &cbRead);
2059	if (rc == VERR_EOF)
2060	break;
2061	AssertRCBreak(rc);
2062
2063	AssertBreak(PDMAudioPropsIsSizeAligned(pProps, (uint32_t)cbRead));
2064
2065	switch (pProps->cbSampleX)
2066	{
2067	case 2: /* 16 bit signed */
2068	{
2069	int16_t pi16Src = (int16_t )auBuf;
2070	for (size_t i = 0; i < cbRead / pProps->cbSampleX; i += pProps->cbSampleX)
2071	{
2072	if (*pi16Src < iMin)
2073	iMin = *pi16Src;
2074	if (*pi16Src > iMax)
2075	iMax = *pi16Src;
2076	pi16Src++;
2077	}
2078	break;
2079	}
2080
2081	default:
2082	AssertMsgFailedBreakStmt(("Invalid bytes per sample: %RU8\n", pProps->cbSampleX), rc = VERR_NOT_SUPPORTED);
2083	}
2084
2085	Assert(cbToRead >= cbRead);
2086	cbToRead -= cbRead;
2087	}
2088
2089	if (RT_FAILURE(rc))
2090	return rc;
2091
2092	/* Now rewind and do the actual gain / attenuation. */
2093	rc = RTFileSeek(hFileSrc, offStart, RTFILE_SEEK_BEGIN, NULL /* poffActual */);
2094	AssertRCReturn(rc, rc);
2095	cbToRead = cbSize;
2096
2097	switch (pProps->cbSampleX)
2098	{
2099	case 2: /* 16 bit signed */
2100	{
2101	if (iMin == INT16_MIN)
2102	iMin = INT16_MIN + 1;
2103	if ((-iMin) > iMax)
2104	iMax = -iMin;
2105
2106	dbRatio = iMax == 0 ? 1.0 : ((double)INT16_MAX * dbNormalizePercent) / ((double)iMax * 100.0);
2107
2108	while (cbToRead)
2109	{
2110	size_t const cbChunk = RT_MIN(cbToRead, sizeof(auBuf));
2111	size_t cbRead;
2112	rc = RTFileRead(hFileSrc, auBuf, cbChunk, &cbRead);
2113	if (rc == VERR_EOF)
2114	break;
2115	AssertRCBreak(rc);
2116
2117	int16_t pi16Src = (int16_t )auBuf;
2118	for (size_t i = 0; i < cbRead / pProps->cbSampleX; i += pProps->cbSampleX)
2119	{
2120	/** @todo Optimize this -- use a lookup table for sample indices? */
2121	if ((pi16Src dbRatio) > INT16_MAX)
2122	*pi16Src = INT16_MAX;
2123	else if ((pi16Src dbRatio) < INT16_MIN)
2124	*pi16Src = INT16_MIN;
2125	else
2126	pi16Src = (int16_t)(pi16Src * dbRatio);
2127	pi16Src++;
2128	}
2129
2130	size_t cbWritten;
2131	rc = RTFileWrite(hFileDst, auBuf, cbChunk, &cbWritten);
2132	AssertRCBreak(rc);
2133	Assert(cbWritten == cbChunk);
2134
2135	Assert(cbToRead >= cbRead);
2136	cbToRead -= cbRead;
2137	}
2138	break;
2139	}
2140
2141	default:
2142	AssertMsgFailedBreakStmt(("Invalid bytes per sample: %RU8\n", pProps->cbSampleX), rc = VERR_NOT_SUPPORTED);
2143	}
2144
2145	if (RT_SUCCESS(rc))
2146	{
2147	if (pdbRatio)
2148	*pdbRatio = dbRatio;
2149	}
2150
2151	return rc;
2152	}
2153
2154	/**
2155	* Normalizes a test set audio object's audio data, extended version.
2156	*
2157	* @returns VBox status code. On success the test set object will point to the (temporary) normalized file data.
2158	* @param pVerJob Verification job that contains \a pObj.
2159	* @param pObj Test set object to normalize.
2160	* @param pProps PCM properties to use for normalization.
2161	* @param cbSize Size (in bytes) of audio data to normalize.
2162	* @param dbNormalizePercent Normalization to achieve (in percent).
2163	*
2164	* @note The test set's file pointer must point to beginning of PCM data to normalize.
2165	*/
2166	static int audioTestObjFileNormalizeEx(PAUDIOTESTVERIFYJOB pVerJob,
2167	PAUDIOTESTOBJINT pObj, PPDMAUDIOPCMPROPS pProps, uint64_t cbSize, double dbNormalizePercent)
2168	{
2169	/* Store normalized file into a temporary file. */
2170	char szFileDst[RTPATH_MAX];
2171	int rc = RTPathTemp(szFileDst, sizeof(szFileDst));
2172	AssertRCReturn(rc, rc);
2173
2174	rc = RTPathAppend(szFileDst, sizeof(szFileDst), "VBoxAudioTest-normalized-XXX.pcm");
2175	AssertRCReturn(rc, rc);
2176
2177	rc = RTFileCreateTemp(szFileDst, 0600);
2178	AssertRCReturn(rc, rc);
2179
2180	RTFILE hFileDst;
2181	rc = RTFileOpen(&hFileDst, szFileDst, RTFILE_O_OPEN \| RTFILE_O_WRITE \| RTFILE_O_DENY_WRITE);
2182	AssertRCReturn(rc, rc);
2183
2184	double dbRatio = 0.0;
2185	rc = audioTestFileNormalizePCM(pObj->File.hFile, pProps, cbSize, dbNormalizePercent, hFileDst, &dbRatio);
2186	if (RT_SUCCESS(rc))
2187	{
2188	int rc2 = audioTestErrorDescAddInfo(pVerJob->pErr, pVerJob->idxTest, "Normalized '%s' -> '%s' (ratio is %u.%02u%%)\n",
2189	pObj->szName, szFileDst, (unsigned)dbRatio, (unsigned)(dbRatio * 100) % 100);
2190	AssertRC(rc2);
2191	}
2192
2193	int rc2 = RTFileClose(hFileDst);
2194	if (RT_SUCCESS(rc))
2195	rc = rc2;
2196
2197	if (RT_SUCCESS(rc))
2198	{
2199	/* Close the original test set object and use the (temporary) normalized file instead now. */
2200	rc = audioTestObjClose(pObj);
2201	if (RT_SUCCESS(rc))
2202	rc = audioTestObjOpenFile(pObj, szFileDst);
2203	}
2204
2205	return rc;
2206	}
2207
2208	/**
2209	* Normalizes a test set audio object's audio data.
2210	*
2211	* @returns VBox status code.
2212	* @param pVerJob Verification job that contains \a pObj.
2213	* @param pObj Test set object to normalize.
2214	* @param pProps PCM properties to use for normalization.
2215	*
2216	* @note The test set's file pointer must point to beginning of PCM data to normalize.
2217	*/
2218	static int audioTestObjFileNormalize(PAUDIOTESTVERIFYJOB pVerJob, PAUDIOTESTOBJINT pObj, PPDMAUDIOPCMPROPS pProps)
2219	{
2220	return audioTestObjFileNormalizeEx(pVerJob,
2221	pObj, pProps, 0 /* cbSize, 0 means all /, 100.0 / dbNormalizePercent */);
2222	}
2223
2224	/**
2225	* Structure for keeping file comparison parameters for one file.
2226	*/
2227	typedef struct AUDIOTESTFILECMPPARMS
2228	{
2229	/** File name for logging purposes. */
2230	const char *pszName;
2231	/** File handle to file to compare. */
2232	RTFILE hFile;
2233	/** Absolute offset (in bytes) to start comparing.
2234	* Ignored when set to 0. */
2235	uint64_t offStart;
2236	/** Size (in bytes) of area to compare.
2237	* Starts at \a offStart. */
2238	uint64_t cbSize;
2239	} AUDIOTESTFILECMPPARMS;
2240	/** Pointer to file comparison parameters for one file. */
2241	typedef AUDIOTESTFILECMPPARMS *PAUDIOTESTFILECMPPARMS;
2242
2243	/**
2244	* Determines if a given file chunk contains all silence (i.e. non-audible audio data) or not.
2245	*
2246	* What "silence" means depends on the given PCM parameters.
2247	*
2248	* @returns VBox status code.
2249	* @param phFile File handle of file to determine silence for.
2250	* @param pProps PCM properties to use.
2251	* @param offStart Start offset (absolute, in bytes) to start at.
2252	* @param cbSize Size (in bytes) to process.
2253	* @param pfIsSilence Where to return the result.
2254	*
2255	* @note Does not modify the file's current position.
2256	*/
2257	static int audioTestFileChunkIsSilence(PRTFILE phFile, PPDMAUDIOPCMPROPS pProps, uint64_t offStart, size_t cbSize,
2258	bool *pfIsSilence)
2259	{
2260	bool fIsSilence = true;
2261
2262	int rc = RTFileSeek(*phFile, offStart, RTFILE_SEEK_BEGIN, NULL);
2263	AssertRCReturn(rc, rc);
2264
2265	uint8_t auBuf[_64K];
2266	while (cbSize)
2267	{
2268	size_t cbRead;
2269	rc = RTFileRead(*phFile, auBuf, RT_MIN(cbSize, sizeof(auBuf)), &cbRead);
2270	AssertRC(rc);
2271
2272	if (!PDMAudioPropsIsBufferSilence(pProps, auBuf, cbRead))
2273	{
2274	fIsSilence = false;
2275	break;
2276	}
2277
2278	AssertBreak(cbSize >= cbRead);
2279	cbSize -= cbRead;
2280	}
2281
2282	if (RT_SUCCESS(rc))
2283	*pfIsSilence = fIsSilence;
2284
2285	return RTFileSeek(*phFile, offStart, RTFILE_SEEK_BEGIN, NULL);
2286	}
2287
2288	/**
2289	* Finds differences in two audio test files by binary comparing chunks.
2290	*
2291	* @returns Number of differences. 0 means they are equal (but not necessarily identical).
2292	* @param pVerJob Verification job to verify PCM data for.
2293	* @param pCmpA File comparison parameters to file A to compare file B with.
2294	* @param pCmpB File comparison parameters to file B to compare file A with.
2295	* @param pToneParms Tone parameters to use for comparison.
2296	*/
2297	static uint32_t audioTestFilesFindDiffsBinary(PAUDIOTESTVERIFYJOB pVerJob,
2298	PAUDIOTESTFILECMPPARMS pCmpA, PAUDIOTESTFILECMPPARMS pCmpB,
2299	PAUDIOTESTTONEPARMS pToneParms)
2300	{
2301	uint8_t auBufA[_4K];
2302	uint8_t auBufB[_4K];
2303
2304	int rc = RTFileSeek(pCmpA->hFile, pCmpA->offStart, RTFILE_SEEK_BEGIN, NULL);
2305	AssertRC(rc);
2306
2307	rc = RTFileSeek(pCmpB->hFile, pCmpB->offStart, RTFILE_SEEK_BEGIN, NULL);
2308	AssertRC(rc);
2309
2310	uint32_t cDiffs = 0;
2311	uint64_t cbDiffs = 0;
2312
2313	uint32_t const cbChunkSize = PDMAudioPropsFrameSize(&pToneParms->Props); /* Use the audio frame size as chunk size. */
2314
2315	uint64_t offCur = 0;
2316	uint64_t offDiffStart = 0;
2317	bool fInDiff = false;
2318	uint64_t cbSize = RT_MIN(pCmpA->cbSize, pCmpB->cbSize);
2319	uint64_t cbToCompare = cbSize;
2320
2321	while (cbToCompare)
2322	{
2323	size_t cbReadA;
2324	rc = RTFileRead(pCmpA->hFile, auBufA, RT_MIN(cbToCompare, cbChunkSize), &cbReadA);
2325	AssertRCBreak(rc);
2326	size_t cbReadB;
2327	rc = RTFileRead(pCmpB->hFile, auBufB, RT_MIN(cbToCompare, cbChunkSize), &cbReadB);
2328	AssertRCBreak(rc);
2329	AssertBreakStmt(cbReadA == cbReadB, rc = VERR_INVALID_PARAMETER); /** @todo Find a better rc. */
2330
2331	const size_t cbToCmp = RT_MIN(cbReadA, cbReadB);
2332	if (memcmp(auBufA, auBufB, cbToCmp) != 0)
2333	{
2334	if (!fInDiff) /* No consequitive different chunk? Count as new then. */
2335	{
2336	cDiffs++;
2337	offDiffStart = offCur;
2338	fInDiff = true;
2339	}
2340	}
2341	else /* Reset and count next difference as new then. */
2342	{
2343	if (fInDiff)
2344	{
2345	bool fIsAllSilenceA;
2346	rc = audioTestFileChunkIsSilence(&pCmpA->hFile, &pToneParms->Props,
2347	pCmpA->offStart + offDiffStart, offCur - offDiffStart, &fIsAllSilenceA);
2348	AssertRCBreak(rc);
2349
2350	bool fIsAllSilenceB;
2351	rc = audioTestFileChunkIsSilence(&pCmpB->hFile, &pToneParms->Props,
2352	pCmpB->offStart + offDiffStart, offCur - offDiffStart, &fIsAllSilenceB);
2353	AssertRCBreak(rc);
2354
2355	uint32_t const cbDiff = offCur - offDiffStart;
2356	int rc2 = audioTestErrorDescAddInfo(pVerJob->pErr, pVerJob->idxTest, "Chunks differ: '%s' @ %#x [%08RU64-%08RU64] vs. '%s' @ %#x [%08RU64-%08RU64] (%RU64 bytes, %RU64ms)",
2357	pCmpA->pszName, pCmpA->offStart + offDiffStart, pCmpA->offStart + offDiffStart, pCmpA->offStart + offCur,
2358	pCmpB->pszName, pCmpB->offStart + offDiffStart, pCmpB->offStart + offDiffStart, pCmpB->offStart + offCur,
2359	cbDiff, PDMAudioPropsBytesToMilli(&pToneParms->Props, cbDiff));
2360	AssertRC(rc2);
2361	if ( fIsAllSilenceA
2362	\|\| fIsAllSilenceB)
2363	{
2364	rc2 = audioTestErrorDescAddInfo(pVerJob->pErr, pVerJob->idxTest, "Chunk %s @ %#x (%RU64 bytes, %RU64ms) is all silence",
2365	fIsAllSilenceA ? pCmpA->pszName : pCmpB->pszName,
2366	offDiffStart, cbDiff, PDMAudioPropsBytesToMilli(&pToneParms->Props, cbDiff));
2367	AssertRC(rc2);
2368	}
2369
2370	cbDiffs += cbDiff;
2371	}
2372	fInDiff = false;
2373	}
2374
2375	AssertBreakStmt(cbToCompare >= cbReadA, VERR_INTERNAL_ERROR);
2376	cbToCompare -= cbReadA;
2377	offCur += cbReadA;
2378	}
2379
2380	/* If we didn't mention the last diff yet, do so now. */
2381	if (fInDiff)
2382	{
2383	uint32_t const cbDiff = offCur - offDiffStart;
2384	int rc2 = audioTestErrorDescAddInfo(pVerJob->pErr, pVerJob->idxTest, "Chunks differ: '%s' @ %#x [%08RU64-%08RU64] vs. '%s' @ %#x [%08RU64-%08RU64] (%RU64 bytes, %RU64ms)",
2385	pCmpA->pszName, pCmpA->offStart + offDiffStart, pCmpA->offStart + offDiffStart, pCmpA->offStart + offCur,
2386	pCmpB->pszName, pCmpB->offStart + offDiffStart, pCmpB->offStart + offDiffStart, pCmpB->offStart + offCur,
2387	cbDiff, PDMAudioPropsBytesToMilli(&pToneParms->Props, cbDiff));
2388	AssertRC(rc2);
2389
2390	cbDiffs += cbDiff;
2391	}
2392
2393	if ( cbSize
2394	&& cbDiffs)
2395	{
2396	uint8_t const uDiffPercent = cbDiffs / (cbSize * 100);
2397	if (uDiffPercent > pVerJob->Opts.uMaxDiffPercent)
2398	{
2399	int rc2 = audioTestErrorDescAddInfo(pVerJob->pErr, pVerJob->idxTest, "Files binary-differ too much (expected maximum %RU8%%, got %RU8%%)",
2400	pVerJob->Opts.uMaxDiffPercent, uDiffPercent);
2401	AssertRC(rc2);
2402	}
2403	}
2404
2405	return cDiffs;
2406	}
2407
2408	/**
2409	* Initializes a audio test audio beacon.
2410	*
2411	* @returns VBox status code.
2412	* @param pBeacon Audio test beacon to (re-)initialize.
2413	* @param uTest Test number to set beacon to.
2414	* @param enmType Beacon type to set.
2415	* @param pProps PCM properties to use for producing audio beacon data.
2416	*/
2417	void AudioTestBeaconInit(PAUDIOTESTTONEBEACON pBeacon, uint8_t uTest, AUDIOTESTTONEBEACONTYPE enmType, PPDMAUDIOPCMPROPS pProps)
2418	{
2419	AssertReturnVoid(PDMAudioPropsFrameSize(pProps) == 4); /** @todo Make this more dynamic. */
2420
2421	RT_BZERO(pBeacon, sizeof(AUDIOTESTTONEBEACON));
2422
2423	pBeacon->uTest = uTest;
2424	pBeacon->enmType = enmType;
2425	memcpy(&pBeacon->Props, pProps, sizeof(PDMAUDIOPCMPROPS));
2426
2427	pBeacon->cbSize = PDMAudioPropsFramesToBytes(&pBeacon->Props, AUDIOTEST_BEACON_SIZE_FRAMES);
2428	}
2429
2430	/**
2431	* Returns the beacon byte of a beacon type.
2432	*
2433	* @returns Beacon byte if found, 0 otherwise.
2434	* @param uTest Test number to get beacon byte for.
2435	* @param enmType Beacon type to get beacon byte for.
2436	*/
2437	DECLINLINE(uint8_t) AudioTestBeaconByteFromType(uint8_t uTest, AUDIOTESTTONEBEACONTYPE enmType)
2438	{
2439	switch (enmType)
2440	{
2441	case AUDIOTESTTONEBEACONTYPE_PLAY_PRE: return AUDIOTEST_BEACON_MAKE_PRE(uTest);
2442	case AUDIOTESTTONEBEACONTYPE_PLAY_POST: return AUDIOTEST_BEACON_MAKE_POST(uTest);
2443	case AUDIOTESTTONEBEACONTYPE_REC_PRE: return AUDIOTEST_BEACON_MAKE_PRE(uTest);
2444	case AUDIOTESTTONEBEACONTYPE_REC_POST: return AUDIOTEST_BEACON_MAKE_POST(uTest);
2445	default: break;
2446	}
2447
2448	AssertFailed();
2449	return 0;
2450	}
2451
2452	/**
2453	* Returns the total expected (total) size of an audio beacon (in bytes).
2454	*
2455	* @returns Beacon size in bytes.
2456	* @param pBeacon Beacon to get beacon size for.
2457	*/
2458	uint32_t AudioTestBeaconGetSize(PCAUDIOTESTTONEBEACON pBeacon)
2459	{
2460	return pBeacon->cbSize;
2461	}
2462
2463	/**
2464	* Returns the beacon type of an audio beacon.
2465	*
2466	* @returns Beacon type.
2467	* @param pBeacon Beacon to get beacon size for.
2468	*/
2469	AUDIOTESTTONEBEACONTYPE AudioTestBeaconGetType(PCAUDIOTESTTONEBEACON pBeacon)
2470	{
2471	return pBeacon->enmType;
2472	}
2473
2474	/**
2475	* Returns the remaining bytes (to be complete) of an audio beacon.
2476	*
2477	* @returns Remaining bytes.
2478	* @param pBeacon Beacon to get remaining size for.
2479	*/
2480	uint32_t AudioTestBeaconGetRemaining(PCAUDIOTESTTONEBEACON pBeacon)
2481	{
2482	return pBeacon->cbSize - pBeacon->cbUsed;
2483	}
2484
2485	/**
2486	* Returns the already used (received) bytes (to be complete) of an audio beacon.
2487	*
2488	* @returns Used bytes.
2489	* @param pBeacon Beacon to get remaining size for.
2490	*/
2491	uint32_t AudioTestBeaconGetUsed(PCAUDIOTESTTONEBEACON pBeacon)
2492	{
2493	return pBeacon->cbUsed;
2494	}
2495
2496	/**
2497	* Writes audio beacon data to a given buffer.
2498	*
2499	* @returns VBox status code.
2500	* @param pBeacon Beacon to write to buffer.
2501	* @param pvBuf Buffer to write to.
2502	* @param cbBuf Size (in bytes) of buffer to write to.
2503	*/
2504	int AudioTestBeaconWrite(PAUDIOTESTTONEBEACON pBeacon, void *pvBuf, uint32_t cbBuf)
2505	{
2506	AssertReturn(pBeacon->cbUsed + cbBuf <= pBeacon->cbSize, VERR_BUFFER_OVERFLOW);
2507
2508	memset(pvBuf, AudioTestBeaconByteFromType(pBeacon->uTest, pBeacon->enmType), cbBuf);
2509
2510	pBeacon->cbUsed += cbBuf;
2511
2512	return VINF_SUCCESS;
2513	}
2514
2515	/**
2516	* Converts an audio beacon type to a string.
2517	*
2518	* @returns Pointer to read-only audio beacon type string on success,
2519	* "illegal" if invalid command value.
2520	* @param enmType The type to convert.
2521	*/
2522	const char *AudioTestBeaconTypeGetName(AUDIOTESTTONEBEACONTYPE enmType)
2523	{
2524	switch (enmType)
2525	{
2526	case AUDIOTESTTONEBEACONTYPE_PLAY_PRE: return "pre-playback";
2527	case AUDIOTESTTONEBEACONTYPE_PLAY_POST: return "post-playback";
2528	case AUDIOTESTTONEBEACONTYPE_REC_PRE: return "pre-recording";
2529	case AUDIOTESTTONEBEACONTYPE_REC_POST: return "post-recording";
2530	default: break;
2531	}
2532	AssertMsgFailedReturn(("Invalid beacon type: #%x\n", enmType), "illegal");
2533	}
2534
2535	/**
2536	* Adds audio data to a given beacon.
2537	*
2538	* @returns VBox status code, VERR_NOT_FOUND if not beacon data was not found.
2539	* @param pBeacon Beacon to add data for.
2540	* @param pauBuf Buffer of audio data to add.
2541	* @param cbBuf Size (in bytes) of \a pauBuf.
2542	* @param pOff Where to return the offset within \a pauBuf where beacon ended on success.
2543	* Optional and can be NULL.
2544	*
2545	* @note The audio data must be a) match the beacon type and b) consecutive, that is, without any gaps,
2546	* to be added as valid to the beacon.
2547	*/
2548	int AudioTestBeaconAddConsecutive(PAUDIOTESTTONEBEACON pBeacon, const uint8_t pauBuf, size_t cbBuf, size_t pOff)
2549	{
2550	AssertPtrReturn(pBeacon, VERR_INVALID_POINTER);
2551	AssertPtrReturn(pauBuf, VERR_INVALID_POINTER);
2552	/* pOff is optional. */
2553
2554	uint64_t offBeacon = UINT64_MAX;
2555	uint32_t const cbFrameSize = PDMAudioPropsFrameSize(&pBeacon->Props); /* Use the audio frame size as chunk size. */
2556
2557	uint8_t const byBeacon = AudioTestBeaconByteFromType(pBeacon->uTest, pBeacon->enmType);
2558	unsigned const cbStep = cbFrameSize;
2559
2560	/* Make sure that we do frame-aligned reads. */
2561	cbBuf = PDMAudioPropsFloorBytesToFrame(&pBeacon->Props, (uint32_t)cbBuf);
2562
2563	for (size_t i = 0; i < cbBuf; i += cbStep)
2564	{
2565	if ( pauBuf[i] == byBeacon
2566	&& pauBuf[i + 1] == byBeacon
2567	&& pauBuf[i + 2] == byBeacon
2568	&& pauBuf[i + 3] == byBeacon)
2569	{
2570	/* Make sure to handle overflows and let beacon start from scratch. */
2571	pBeacon->cbUsed = (pBeacon->cbUsed + cbStep) % pBeacon->cbSize;
2572	if (pBeacon->cbUsed == 0) /* Beacon complete (see module line above)? */
2573	{
2574	pBeacon->cbUsed = pBeacon->cbSize;
2575	offBeacon = i + cbStep; /* Point to data right after the beacon. */
2576	}
2577	}
2578	else
2579	{
2580	/* If beacon is not complete yet, we detected a gap here. Start all over then. */
2581	if (RT_LIKELY(pBeacon->cbUsed != pBeacon->cbSize))
2582	pBeacon->cbUsed = 0;
2583	}
2584	}
2585
2586	if (offBeacon != UINT64_MAX)
2587	{
2588	if (pOff)
2589	*pOff = offBeacon;
2590	}
2591
2592	return offBeacon == UINT64_MAX ? VERR_NOT_FOUND : VINF_SUCCESS;
2593	}
2594
2595	/**
2596	* Returns whether a beacon is considered to be complete or not.
2597	*
2598	* A complete beacon means that all data for it has been retrieved.
2599	*
2600	* @returns \c true if complete, or \c false if not.
2601	* @param pBeacon Beacon to get completion status for.
2602	*/
2603	bool AudioTestBeaconIsComplete(PCAUDIOTESTTONEBEACON pBeacon)
2604	{
2605	AssertReturn(pBeacon->cbUsed <= pBeacon->cbSize, true);
2606	return (pBeacon->cbUsed == pBeacon->cbSize);
2607	}
2608
2609	/**
2610	* Verifies a pre/post beacon of a test tone.
2611	*
2612	* @returns VBox status code, VERR_NOT_FOUND if beacon was not found.
2613	* @param pVerJob Verification job to verify PCM data for.
2614	* @param fIn Set to \c true for recording, \c false for playback.
2615	* @param fPre Set to \c true to verify a pre beacon, or \c false to verify a post beacon.
2616	* @param pCmp File comparison parameters to file to verify beacon for.
2617	* @param pToneParms Tone parameters to use for verification.
2618	* @param puOff Where to return the absolute file offset (in bytes) right after the found beacon on success.
2619	* Optional and can be NULL.
2620	*/
2621	static int audioTestToneVerifyBeacon(PAUDIOTESTVERIFYJOB pVerJob,
2622	bool fIn, bool fPre, PAUDIOTESTFILECMPPARMS pCmp, PAUDIOTESTTONEPARMS pToneParms,
2623	uint64_t *puOff)
2624	{
2625	int rc = RTFileSeek(pCmp->hFile, pCmp->offStart, RTFILE_SEEK_BEGIN, NULL);
2626	AssertRCReturn(rc, rc);
2627
2628	AUDIOTESTTONEBEACON Beacon;
2629	AudioTestBeaconInit(&Beacon, pVerJob->idxTest,
2630	fIn
2631	? (fPre ? AUDIOTESTTONEBEACONTYPE_PLAY_PRE : AUDIOTESTTONEBEACONTYPE_PLAY_POST)
2632	: (fPre ? AUDIOTESTTONEBEACONTYPE_REC_PRE : AUDIOTESTTONEBEACONTYPE_REC_POST), &pToneParms->Props);
2633
2634	uint8_t auBuf[_64K];
2635	uint64_t cbToCompare = pCmp->cbSize;
2636	uint32_t const cbFrameSize = PDMAudioPropsFrameSize(&Beacon.Props);
2637	uint64_t offBeaconLast = UINT64_MAX;
2638
2639	Assert(sizeof(auBuf) % cbFrameSize == 0);
2640
2641	while (cbToCompare)
2642	{
2643	size_t cbRead;
2644	rc = RTFileRead(pCmp->hFile, auBuf, RT_MIN(cbToCompare, sizeof(auBuf)), &cbRead);
2645	AssertRCBreak(rc);
2646
2647	if (cbRead < cbFrameSize)
2648	break;
2649
2650	size_t uOff;
2651	int rc2 = AudioTestBeaconAddConsecutive(&Beacon, auBuf, cbRead, &uOff);
2652	if (RT_SUCCESS(rc2))
2653	{
2654	/* Save the last found (absolute bytes, in file) position of a (partially) found beacon. */
2655	offBeaconLast = RTFileTell(pCmp->hFile) - (cbRead - uOff);
2656	}
2657
2658	Assert(cbToCompare >= cbRead);
2659	cbToCompare -= cbRead;
2660	}
2661
2662	uint32_t const cbBeacon = AudioTestBeaconGetUsed(&Beacon);
2663
2664	if (!AudioTestBeaconIsComplete(&Beacon))
2665	{
2666	int rc2 = audioTestErrorDescAddError(pVerJob->pErr, pVerJob->idxTest, "File '%s': %s beacon %s (got %RU32 bytes, expected %RU32)",
2667	pCmp->pszName,
2668	AudioTestBeaconTypeGetName(Beacon.enmType),
2669	cbBeacon ? "found" : "not found", cbBeacon,
2670	AudioTestBeaconGetSize(&Beacon));
2671	AssertRC(rc2);
2672	return VERR_NOT_FOUND;
2673	}
2674	else
2675	{
2676	AssertReturn(AudioTestBeaconGetRemaining(&Beacon) == 0, VERR_INTERNAL_ERROR);
2677	AssertReturn(offBeaconLast != UINT32_MAX, VERR_INTERNAL_ERROR);
2678	AssertReturn(offBeaconLast >= AudioTestBeaconGetSize(&Beacon), VERR_INTERNAL_ERROR);
2679
2680	int rc2 = audioTestErrorDescAddInfo(pVerJob->pErr, pVerJob->idxTest, "File '%s': %s beacon found at offset %RU64 and valid",
2681	pCmp->pszName, AudioTestBeaconTypeGetName(Beacon.enmType),
2682	offBeaconLast - AudioTestBeaconGetSize(&Beacon));
2683	AssertRC(rc2);
2684
2685	if (puOff)
2686	*puOff = offBeaconLast;
2687	}
2688
2689	return rc;
2690	}
2691
2692	#define CHECK_RC_MAYBE_RET(a_rc, a_pVerJob) \
2693	if (RT_FAILURE(a_rc)) \
2694	{ \
2695	if (!a_pVerJob->Opts.fKeepGoing) \
2696	return VINF_SUCCESS; \
2697	}
2698
2699	#define CHECK_RC_MSG_MAYBE_RET(a_rc, a_pVerJob, a_Msg) \
2700	if (RT_FAILURE(a_rc)) \
2701	{ \
2702	int rc3 = audioTestErrorDescAddError(a_pVerJob->pErr, a_pVerJob->idxTest, a_Msg); \
2703	AssertRC(rc3); \
2704	if (!a_pVerJob->Opts.fKeepGoing) \
2705	return VINF_SUCCESS; \
2706	}
2707
2708	#define CHECK_RC_MSG_VA_MAYBE_RET(a_rc, a_pVerJob, a_Msg, ...) \
2709	if (RT_FAILURE(a_rc)) \
2710	{ \
2711	int rc3 = audioTestErrorDescAddError(a_pVerJob->pErr, a_pVerJob->idxTest, a_Msg, __VA_ARGS__); \
2712	AssertRC(rc3); \
2713	if (!a_pVerJob->Opts.fKeepGoing) \
2714	return VINF_SUCCESS; \
2715
2716	/**
2717	* Does the actual PCM data verification of a test tone.
2718	*
2719	* @returns VBox status code.
2720	* @param pVerJob Verification job to verify PCM data for.
2721	* @param phTestA Test handle A of test to verify PCM data for.
2722	* @param phTestB Test handle B of test to verify PCM data for.
2723	*/
2724	static int audioTestVerifyTestToneData(PAUDIOTESTVERIFYJOB pVerJob, PAUDIOTESTOBJINT phTestA, PAUDIOTESTOBJINT phTestB)
2725	{
2726	int rc;
2727
2728	/** @todo For now ASSUME that we only have one object per test. */
2729
2730	AUDIOTESTOBJINT ObjA;
2731	rc = audioTestObjGetChild(phTestA, 0 /* idxObj */, &ObjA);
2732	CHECK_RC_MSG_MAYBE_RET(rc, pVerJob, "Unable to get object A");
2733
2734	rc = audioTestObjOpen(&ObjA);
2735	CHECK_RC_MSG_MAYBE_RET(rc, pVerJob, "Unable to open object A");
2736
2737	AUDIOTESTOBJINT ObjB;
2738	rc = audioTestObjGetChild(phTestB, 0 /* idxObj */, &ObjB);
2739	CHECK_RC_MSG_MAYBE_RET(rc, pVerJob, "Unable to get object B");
2740
2741	rc = audioTestObjOpen(&ObjB);
2742	CHECK_RC_MSG_MAYBE_RET(rc, pVerJob, "Unable to open object B");
2743
2744	/*
2745	* Start with most obvious methods first.
2746	*/
2747	uint64_t cbFileSizeA, cbFileSizeB;
2748	rc = RTFileQuerySize(ObjA.File.hFile, &cbFileSizeA);
2749	AssertRCReturn(rc, rc);
2750	rc = RTFileQuerySize(ObjB.File.hFile, &cbFileSizeB);
2751	AssertRCReturn(rc, rc);
2752
2753	if (!cbFileSizeA)
2754	{
2755	int rc2 = audioTestErrorDescAddError(pVerJob->pErr, pVerJob->idxTest, "File '%s' is empty", ObjA.szName);
2756	AssertRC(rc2);
2757	}
2758
2759	if (!cbFileSizeB)
2760	{
2761	int rc2 = audioTestErrorDescAddError(pVerJob->pErr, pVerJob->idxTest, "File '%s' is empty", ObjB.szName);
2762	AssertRC(rc2);
2763	}
2764
2765	if (cbFileSizeA != cbFileSizeB)
2766	{
2767	size_t const cbDiffAbs = cbFileSizeA > cbFileSizeB ? cbFileSizeA - cbFileSizeB : cbFileSizeB - cbFileSizeA;
2768
2769	int rc2 = audioTestErrorDescAddInfo(pVerJob->pErr, pVerJob->idxTest, "File '%s': %zu bytes (%RU64ms)",
2770	ObjA.szName, cbFileSizeA, PDMAudioPropsBytesToMilli(&pVerJob->PCMProps, cbFileSizeA));
2771	AssertRC(rc2);
2772	rc2 = audioTestErrorDescAddInfo(pVerJob->pErr, pVerJob->idxTest, "File '%s': %zu bytes (%RU64ms)",
2773	ObjB.szName, cbFileSizeB, PDMAudioPropsBytesToMilli(&pVerJob->PCMProps, cbFileSizeB));
2774	AssertRC(rc2);
2775
2776	uint8_t const uSizeDiffPercentAbs
2777	= cbFileSizeA > cbFileSizeB ? 100 - ((cbFileSizeB * 100) / cbFileSizeA) : 100 - ((cbFileSizeA * 100) / cbFileSizeB);
2778
2779	if (uSizeDiffPercentAbs > pVerJob->Opts.uMaxSizePercent)
2780	{
2781	rc2 = audioTestErrorDescAddError(pVerJob->pErr, pVerJob->idxTest,
2782	"File '%s' is %RU8%% (%zu bytes, %RU64ms) %s than '%s' (threshold is %RU8%%)",
2783	ObjA.szName,
2784	uSizeDiffPercentAbs,
2785	cbDiffAbs, PDMAudioPropsBytesToMilli(&pVerJob->PCMProps, (uint32_t)cbDiffAbs),
2786	cbFileSizeA > cbFileSizeB ? "bigger" : "smaller",
2787	ObjB.szName, pVerJob->Opts.uMaxSizePercent);
2788	AssertRC(rc2);
2789	}
2790	}
2791
2792	/* Do normalization first if enabled. */
2793	if (pVerJob->Opts.fNormalize)
2794	{
2795	rc = audioTestObjFileNormalize(pVerJob, &ObjA, &pVerJob->PCMProps);
2796	if (RT_SUCCESS(rc))
2797	rc = audioTestObjFileNormalize(pVerJob, &ObjB, &pVerJob->PCMProps);
2798	}
2799
2800	/** @todo For now we only support comparison of data which do have identical PCM properties! */
2801
2802	AUDIOTESTTONEPARMS ToneParmsA;
2803	RT_ZERO(ToneParmsA);
2804	ToneParmsA.Props = pVerJob->PCMProps;
2805
2806	size_t cbSearchWindow = PDMAudioPropsMilliToBytes(&ToneParmsA.Props, pVerJob->Opts.msSearchWindow);
2807
2808	AUDIOTESTFILECMPPARMS FileA;
2809	RT_ZERO(FileA);
2810	FileA.pszName = ObjA.szName;
2811	FileA.hFile = ObjA.File.hFile;
2812	FileA.offStart = audioTestToneFileFind(ObjA.File.hFile, true /* fFindSilence */,
2813	0 /* uOff /, cbFileSizeA / cbMax */, &ToneParmsA, cbSearchWindow);
2814	FileA.cbSize = audioTestToneFileFind(ObjA.File.hFile, false /* fFindSilence */,
2815	FileA.offStart /* uOff /, cbFileSizeA - FileA.offStart / cbMax */, &ToneParmsA, cbSearchWindow);
2816	AssertReturn(FileA.offStart + FileA.cbSize <= cbFileSizeA, VERR_INTERNAL_ERROR);
2817
2818	AUDIOTESTTONEPARMS ToneParmsB;
2819	RT_ZERO(ToneParmsB);
2820	ToneParmsB.Props = pVerJob->PCMProps;
2821
2822	AUDIOTESTFILECMPPARMS FileB;
2823	RT_ZERO(FileB);
2824	FileB.pszName = ObjB.szName;
2825	FileB.hFile = ObjB.File.hFile;
2826	FileB.offStart = audioTestToneFileFind(ObjB.File.hFile, true /* fFindSilence */,
2827	0 /* uOff /, cbFileSizeB / cbMax */, &ToneParmsB, cbSearchWindow);
2828	FileB.cbSize = audioTestToneFileFind(ObjB.File.hFile, false /* fFindSilence */,
2829	FileB.offStart /* uOff /, cbFileSizeB - FileB.offStart / cbMax */, &ToneParmsB, cbSearchWindow);
2830	AssertReturn(FileB.offStart + FileB.cbSize <= cbFileSizeB, VERR_INTERNAL_ERROR);
2831
2832	int rc2;
2833
2834	uint64_t offBeaconAbs;
2835	rc = audioTestToneVerifyBeacon(pVerJob, phTestA->enmTestType == AUDIOTESTTYPE_TESTTONE_PLAY /* fIn */,
2836	true /* fPre */, &FileA, &ToneParmsA, &offBeaconAbs);
2837	if (RT_SUCCESS(rc))
2838	{
2839	FileA.offStart = offBeaconAbs;
2840	FileA.cbSize = cbFileSizeA - FileA.offStart;
2841	rc = audioTestToneVerifyBeacon(pVerJob, phTestA->enmTestType == AUDIOTESTTYPE_TESTTONE_PLAY /* fIn */,
2842	false /* fPre */, &FileA, &ToneParmsA, &offBeaconAbs);
2843	if (RT_SUCCESS(rc))
2844	{
2845	/* Adjust the size of the area to compare so that it's within the pre + post beacons. */
2846	Assert(offBeaconAbs >= FileA.offStart);
2847	FileA.cbSize = offBeaconAbs - FileA.offStart;
2848	}
2849	}
2850
2851	rc = audioTestToneVerifyBeacon(pVerJob, phTestB->enmTestType == AUDIOTESTTYPE_TESTTONE_RECORD /* fIn */,
2852	true /* fPre */, &FileB, &ToneParmsB, &offBeaconAbs);
2853	if (RT_SUCCESS(rc))
2854	{
2855	FileB.offStart = offBeaconAbs;
2856	FileB.cbSize = cbFileSizeB - FileB.offStart;
2857	rc = audioTestToneVerifyBeacon(pVerJob, phTestB->enmTestType == AUDIOTESTTYPE_TESTTONE_RECORD /* fIn */,
2858	false /* fPre */, &FileB, &ToneParmsB, &offBeaconAbs);
2859	if (RT_SUCCESS(rc))
2860	{
2861	/* Adjust the size of the area to compare so that it's within the pre + post beacons. */
2862	Assert(offBeaconAbs >= FileB.offStart);
2863	FileB.cbSize = offBeaconAbs - FileB.offStart;
2864	}
2865	}
2866
2867	if (RT_SUCCESS(rc))
2868	{
2869	uint32_t const cDiffs = audioTestFilesFindDiffsBinary(pVerJob, &FileA, &FileB, &ToneParmsA);
2870
2871	if (cDiffs > pVerJob->Opts.cMaxDiff)
2872	{
2873	rc2 = audioTestErrorDescAddError(pVerJob->pErr, pVerJob->idxTest,
2874	"Files '%s' and '%s' have too many different chunks (got %RU32, expected %RU32)",
2875	ObjA.szName, ObjB.szName, cDiffs, pVerJob->Opts.cMaxDiff);
2876	AssertRC(rc2);
2877	}
2878	}
2879
2880	if (AudioTestErrorDescFailed(pVerJob->pErr))
2881	{
2882	rc2 = audioTestErrorDescAddInfo(pVerJob->pErr, pVerJob->idxTest, "Files '%s' and '%s' do not match",
2883	ObjA.szName, ObjB.szName);
2884	AssertRC(rc2);
2885	}
2886
2887	rc = audioTestObjClose(&ObjA);
2888	AssertRCReturn(rc, rc);
2889	rc = audioTestObjClose(&ObjB);
2890	AssertRCReturn(rc, rc);
2891
2892	return rc;
2893	}
2894
2895	/**
2896	* Verifies a test tone test.
2897	*
2898	* @returns VBox status code.
2899	* @returns Error if the verification failed and test verification job has fKeepGoing not set.
2900	* @retval VERR_
2901	* @param pVerJob Verification job to verify test tone for.
2902	* @param phTestA Test handle of test tone A to verify tone B with.
2903	* @param phTestB Test handle of test tone B to verify tone A with.*
2904	*/
2905	static int audioTestVerifyTestTone(PAUDIOTESTVERIFYJOB pVerJob, PAUDIOTESTOBJINT phTestA, PAUDIOTESTOBJINT phTestB)
2906	{
2907	int rc;
2908
2909	/*
2910	* Verify test parameters.
2911	* More important items have precedence.
2912	*/
2913	rc = audioTestVerifyValue(pVerJob, phTestA, phTestB, "error_rc", "0", "Test was reported as failed");
2914	CHECK_RC_MAYBE_RET(rc, pVerJob);
2915	rc = audioTestVerifyValue(pVerJob, phTestA, phTestB, "obj_count", NULL, "Object counts don't match");
2916	CHECK_RC_MAYBE_RET(rc, pVerJob);
2917	rc = audioTestVerifyValue(pVerJob, phTestA, phTestB, "tone_freq_hz", NULL, "Tone frequency doesn't match");
2918	CHECK_RC_MAYBE_RET(rc, pVerJob);
2919	rc = audioTestVerifyValue(pVerJob, phTestA, phTestB, "tone_prequel_ms", NULL, "Tone prequel (ms) doesn't match");
2920	CHECK_RC_MAYBE_RET(rc, pVerJob);
2921	rc = audioTestVerifyValue(pVerJob, phTestA, phTestB, "tone_duration_ms", NULL, "Tone duration (ms) doesn't match");
2922	CHECK_RC_MAYBE_RET(rc, pVerJob);
2923	rc = audioTestVerifyValue(pVerJob, phTestA, phTestB, "tone_sequel_ms", NULL, "Tone sequel (ms) doesn't match");
2924	CHECK_RC_MAYBE_RET(rc, pVerJob);
2925	rc = audioTestVerifyValue(pVerJob, phTestA, phTestB, "tone_volume_percent", NULL, "Tone volume (percent) doesn't match");
2926	CHECK_RC_MAYBE_RET(rc, pVerJob);
2927	rc = audioTestVerifyValue(pVerJob, phTestA, phTestB, "tone_pcm_hz", NULL, "Tone PCM Hz doesn't match");
2928	CHECK_RC_MAYBE_RET(rc, pVerJob);
2929	rc = audioTestVerifyValue(pVerJob, phTestA, phTestB, "tone_pcm_channels", NULL, "Tone PCM channels don't match");
2930	CHECK_RC_MAYBE_RET(rc, pVerJob);
2931	rc = audioTestVerifyValue(pVerJob, phTestA, phTestB, "tone_pcm_bits", NULL, "Tone PCM bits don't match");
2932	CHECK_RC_MAYBE_RET(rc, pVerJob);
2933	rc = audioTestVerifyValue(pVerJob, phTestA, phTestB, "tone_pcm_is_signed", NULL, "Tone PCM signed bit doesn't match");
2934	CHECK_RC_MAYBE_RET(rc, pVerJob);
2935
2936	rc = audioTestObjGetTonePcmProps(phTestA, &pVerJob->PCMProps);
2937	CHECK_RC_MAYBE_RET(rc, pVerJob);
2938
2939	/*
2940	* Now the fun stuff, PCM data analysis.
2941	*/
2942	rc = audioTestVerifyTestToneData(pVerJob, phTestA, phTestB);
2943	if (RT_FAILURE(rc))
2944	{
2945	int rc2 = audioTestErrorDescAddError(pVerJob->pErr, pVerJob->idxTest, "Verififcation of test tone data failed\n");
2946	AssertRC(rc2);
2947	}
2948
2949	return VINF_SUCCESS;
2950	}
2951
2952	/**
2953	* Verifies an opened audio test set, extended version.
2954	*
2955	* @returns VBox status code.
2956	* @param pSetA Test set A to verify.
2957	* @param pSetB Test set to verify test set A with.
2958	* @param pOpts Verification options to use.
2959	* @param pErrDesc Where to return the test verification errors.
2960	*
2961	* @note Test verification errors have to be checked for errors, regardless of the
2962	* actual return code.
2963	* @note Uses the standard verification options. Use AudioTestSetVerifyEx() to specify
2964	* own options.
2965	*/
2966	int AudioTestSetVerifyEx(PAUDIOTESTSET pSetA, PAUDIOTESTSET pSetB, PAUDIOTESTVERIFYOPTS pOpts, PAUDIOTESTERRORDESC pErrDesc)
2967	{
2968	AssertPtrReturn(pSetA, VERR_INVALID_POINTER);
2969	AssertPtrReturn(pSetB, VERR_INVALID_POINTER);
2970	AssertReturn(audioTestManifestIsOpen(pSetA), VERR_WRONG_ORDER);
2971	AssertReturn(audioTestManifestIsOpen(pSetB), VERR_WRONG_ORDER);
2972	AssertPtrReturn(pOpts, VERR_INVALID_POINTER);
2973
2974	/* We ASSUME the caller has not init'd pErrDesc. */
2975	audioTestErrorDescInit(pErrDesc);
2976
2977	AUDIOTESTVERIFYJOB VerJob;
2978	RT_ZERO(VerJob);
2979	VerJob.pErr = pErrDesc;
2980	VerJob.pSetA = pSetA;
2981	VerJob.pSetB = pSetB;
2982
2983	memcpy(&VerJob.Opts, pOpts, sizeof(AUDIOTESTVERIFYOPTS));
2984
2985	PAUDIOTESTVERIFYJOB pVerJob = &VerJob;
2986
2987	int rc;
2988
2989	/*
2990	* Compare obvious values first.
2991	*/
2992	AUDIOTESTOBJINT hHdrA;
2993	rc = audioTestSetGetSection(pVerJob->pSetA, AUDIOTEST_SEC_HDR_STR, &hHdrA);
2994	CHECK_RC_MAYBE_RET(rc, pVerJob);
2995
2996	AUDIOTESTOBJINT hHdrB;
2997	rc = audioTestSetGetSection(pVerJob->pSetB, AUDIOTEST_SEC_HDR_STR, &hHdrB);
2998	CHECK_RC_MAYBE_RET(rc, pVerJob);
2999
3000	rc = audioTestVerifyValue(&VerJob, &hHdrA, &hHdrB, "magic", "vkat_ini", "Manifest magic wrong");
3001	CHECK_RC_MAYBE_RET(rc, pVerJob);
3002	rc = audioTestVerifyValue(&VerJob, &hHdrA, &hHdrB, "ver", "1" , "Manifest version wrong");
3003	CHECK_RC_MAYBE_RET(rc, pVerJob);
3004	rc = audioTestVerifyValue(&VerJob, &hHdrA, &hHdrB, "tag", NULL, "Manifest tags don't match");
3005	CHECK_RC_MAYBE_RET(rc, pVerJob);
3006	rc = audioTestVerifyValue(&VerJob, &hHdrA, &hHdrB, "test_count", NULL, "Test counts don't match");
3007	CHECK_RC_MAYBE_RET(rc, pVerJob);
3008	rc = audioTestVerifyValue(&VerJob, &hHdrA, &hHdrB, "obj_count", NULL, "Object counts don't match");
3009	CHECK_RC_MAYBE_RET(rc, pVerJob);
3010
3011	/*
3012	* Compare ran tests.
3013	*/
3014	uint32_t cTests;
3015	rc = audioTestObjGetUInt32(&hHdrA, "test_count", &cTests);
3016	AssertRCReturn(rc, rc);
3017
3018	for (uint32_t i = 0; i < cTests; i++)
3019	{
3020	VerJob.idxTest = i;
3021
3022	AUDIOTESTOBJINT hTestA;
3023	rc = audioTestSetGetTest(VerJob.pSetA, i, &hTestA);
3024	CHECK_RC_MSG_MAYBE_RET(rc, pVerJob, "Test A not found");
3025
3026	AUDIOTESTOBJINT hTestB;
3027	rc = audioTestSetGetTest(VerJob.pSetB, i, &hTestB);
3028	CHECK_RC_MSG_MAYBE_RET(rc, pVerJob, "Test B not found");
3029
3030	rc = audioTestObjGetUInt32(&hTestA, "test_type", (uint32_t *)&hTestA.enmTestType);
3031	CHECK_RC_MSG_MAYBE_RET(rc, pVerJob, "Test type A not found");
3032
3033	rc = audioTestObjGetUInt32(&hTestB, "test_type", (uint32_t *)&hTestB.enmTestType);
3034	CHECK_RC_MSG_MAYBE_RET(rc, pVerJob, "Test type B not found");
3035
3036	switch (hTestA.enmTestType)
3037	{
3038	case AUDIOTESTTYPE_TESTTONE_PLAY:
3039	{
3040	if (hTestB.enmTestType == AUDIOTESTTYPE_TESTTONE_RECORD)
3041	rc = audioTestVerifyTestTone(&VerJob, &hTestA, &hTestB);
3042	else
3043	rc = audioTestErrorDescAddError(pErrDesc, i, "Playback test types don't match (set A=%#x, set B=%#x)",
3044	hTestA.enmTestType, hTestB.enmTestType);
3045	break;
3046	}
3047
3048	case AUDIOTESTTYPE_TESTTONE_RECORD:
3049	{
3050	if (hTestB.enmTestType == AUDIOTESTTYPE_TESTTONE_PLAY)
3051	rc = audioTestVerifyTestTone(&VerJob, &hTestB, &hTestA);
3052	else
3053	rc = audioTestErrorDescAddError(pErrDesc, i, "Recording test types don't match (set A=%#x, set B=%#x)",
3054	hTestA.enmTestType, hTestB.enmTestType);
3055	break;
3056	}
3057
3058	case AUDIOTESTTYPE_INVALID:
3059	rc = VERR_INVALID_PARAMETER;
3060	break;
3061
3062	default:
3063	rc = VERR_NOT_IMPLEMENTED;
3064	break;
3065	}
3066
3067	AssertRC(rc);
3068	}
3069
3070	/* Only return critical stuff not related to actual testing here. */
3071	return VINF_SUCCESS;
3072	}
3073
3074	/**
3075	* Initializes audio test verification options in a strict manner.
3076	*
3077	* @param pOpts Verification options to initialize.
3078	*/
3079	void AudioTestSetVerifyOptsInitStrict(PAUDIOTESTVERIFYOPTS pOpts)
3080	{
3081	RT_BZERO(pOpts, sizeof(AUDIOTESTVERIFYOPTS));
3082
3083	pOpts->fKeepGoing = true;
3084	pOpts->fNormalize = false; /* Skip normalization by default now, as we now use the OS' master volume to play/record tones. */
3085	pOpts->cMaxDiff = 0; /* By default we're very strict and consider any diff as being erroneous. */
3086	pOpts->uMaxSizePercent = 10; /* 10% is okay for us for now; might be due to any buffering / setup phase.
3087	Anything above this is suspicious and should be reported for further investigation. */
3088	pOpts->msSearchWindow = 10; /* We use a search window of 10ms by default for finding (non-)silent parts. */
3089	}
3090
3091	/**
3092	* Initializes audio test verification options with default values (strict!).
3093	*
3094	* @param pOpts Verification options to initialize.
3095	*/
3096	void AudioTestSetVerifyOptsInit(PAUDIOTESTVERIFYOPTS pOpts)
3097	{
3098	AudioTestSetVerifyOptsInitStrict(pOpts);
3099	}
3100
3101	/**
3102	* Returns whether two audio test verification options are equal.
3103	*
3104	* @returns \c true if equal, or \c false if not.
3105	* @param pOptsA Options A to compare.
3106	* @param pOptsB Options B to compare Options A with.
3107	*/
3108	bool AudioTestSetVerifyOptsAreEqual(PAUDIOTESTVERIFYOPTS pOptsA, PAUDIOTESTVERIFYOPTS pOptsB)
3109	{
3110	if (pOptsA == pOptsB)
3111	return true;
3112
3113	return ( pOptsA->cMaxDiff == pOptsB->cMaxDiff
3114	&& pOptsA->fKeepGoing == pOptsB->fKeepGoing
3115	&& pOptsA->fNormalize == pOptsB->fNormalize
3116	&& pOptsA->uMaxDiffPercent == pOptsB->uMaxDiffPercent
3117	&& pOptsA->uMaxSizePercent == pOptsB->uMaxSizePercent
3118	&& pOptsA->msSearchWindow == pOptsB->msSearchWindow);
3119	}
3120
3121	/**
3122	* Verifies an opened audio test set.
3123	*
3124	* @returns VBox status code.
3125	* @param pSetA Test set A to verify.
3126	* @param pSetB Test set to verify test set A with.
3127	* @param pErrDesc Where to return the test verification errors.
3128	*
3129	* @note Test verification errors have to be checked for errors, regardless of the
3130	* actual return code.
3131	* @note Uses the standard verification options (strict!).
3132	* Use AudioTestSetVerifyEx() to specify own options.
3133	*/
3134	int AudioTestSetVerify(PAUDIOTESTSET pSetA, PAUDIOTESTSET pSetB, PAUDIOTESTERRORDESC pErrDesc)
3135	{
3136	AUDIOTESTVERIFYOPTS Opts;
3137	AudioTestSetVerifyOptsInitStrict(&Opts);
3138
3139	return AudioTestSetVerifyEx(pSetA,pSetB, &Opts, pErrDesc);
3140	}
3141
3142	#undef CHECK_RC_MAYBE_RET
3143	#undef CHECK_RC_MSG_MAYBE_RET
3144
3145	/**
3146	* Converts an audio test state enum value to a string.
3147	*
3148	* @returns Pointer to read-only internal test state string on success,
3149	* "illegal" if invalid command value.
3150	* @param enmState The state to convert.
3151	*/
3152	const char *AudioTestStateToStr(AUDIOTESTSTATE enmState)
3153	{
3154	switch (enmState)
3155	{
3156	case AUDIOTESTSTATE_INIT: return "init";
3157	case AUDIOTESTSTATE_PRE: return "pre";
3158	case AUDIOTESTSTATE_RUN: return "run";
3159	case AUDIOTESTSTATE_POST: return "post";
3160	case AUDIOTESTSTATE_DONE: return "done";
3161	case AUDIOTESTSTATE_32BIT_HACK:
3162	break;
3163	}
3164	AssertMsgFailedReturn(("Invalid test state: #%x\n", enmState), "illegal");
3165	}
3166
3167
3168	/*********************************************************************************************************************************
3169	* WAVE File Reader. *
3170	*********************************************************************************************************************************/
3171
3172	/**
3173	* Counts the number of set bits in @a fMask.
3174	*/
3175	static unsigned audioTestWaveCountBits(uint32_t fMask)
3176	{
3177	unsigned cBits = 0;
3178	while (fMask)
3179	{
3180	if (fMask & 1)
3181	cBits++;
3182	fMask >>= 1;
3183	}
3184	return cBits;
3185	}
3186
3187	/**
3188	* Opens a wave (.WAV) file for reading.
3189	*
3190	* @returns VBox status code.
3191	* @param pszFile The file to open.
3192	* @param pWaveFile The open wave file structure to fill in on success.
3193	* @param pErrInfo Where to return addition error details on failure.
3194	*/
3195	int AudioTestWaveFileOpen(const char *pszFile, PAUDIOTESTWAVEFILE pWaveFile, PRTERRINFO pErrInfo)
3196	{
3197	pWaveFile->u32Magic = AUDIOTESTWAVEFILE_MAGIC_DEAD;
3198	RT_ZERO(pWaveFile->Props);
3199	pWaveFile->hFile = NIL_RTFILE;
3200	int rc = RTFileOpen(&pWaveFile->hFile, pszFile, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE);
3201	if (RT_FAILURE(rc))
3202	return RTErrInfoSet(pErrInfo, rc, "RTFileOpen failed");
3203	uint64_t cbFile = 0;
3204	rc = RTFileQuerySize(pWaveFile->hFile, &cbFile);
3205	if (RT_SUCCESS(rc))
3206	{
3207	union
3208	{
3209	uint8_t ab[512];
3210	struct
3211	{
3212	RTRIFFHDR Hdr;
3213	union
3214	{
3215	RTRIFFWAVEFMTCHUNK Fmt;
3216	RTRIFFWAVEFMTEXTCHUNK FmtExt;
3217	} u;
3218	} Wave;
3219	RTRIFFLIST List;
3220	RTRIFFCHUNK Chunk;
3221	RTRIFFWAVEDATACHUNK Data;
3222	} uBuf;
3223
3224	rc = RTFileRead(pWaveFile->hFile, &uBuf.Wave, sizeof(uBuf.Wave), NULL);
3225	if (RT_SUCCESS(rc))
3226	{
3227	rc = VERR_VFS_UNKNOWN_FORMAT;
3228	if ( uBuf.Wave.Hdr.uMagic == RTRIFFHDR_MAGIC
3229	&& uBuf.Wave.Hdr.uFileType == RTRIFF_FILE_TYPE_WAVE
3230	&& uBuf.Wave.u.Fmt.Chunk.uMagic == RTRIFFWAVEFMT_MAGIC
3231	&& uBuf.Wave.u.Fmt.Chunk.cbChunk >= sizeof(uBuf.Wave.u.Fmt.Data))
3232	{
3233	if (uBuf.Wave.Hdr.cbFile != cbFile - sizeof(RTRIFFCHUNK))
3234	RTErrInfoSetF(pErrInfo, rc, "File size mismatch: %#x, actual %#RX64 (ignored)",
3235	uBuf.Wave.Hdr.cbFile, cbFile - sizeof(RTRIFFCHUNK));
3236	rc = VERR_VFS_BOGUS_FORMAT;
3237	if ( uBuf.Wave.u.Fmt.Data.uFormatTag != RTRIFFWAVEFMT_TAG_PCM
3238	&& uBuf.Wave.u.Fmt.Data.uFormatTag != RTRIFFWAVEFMT_TAG_EXTENSIBLE)
3239	RTErrInfoSetF(pErrInfo, rc, "Unsupported uFormatTag value: %#x (expected %#x or %#x)",
3240	uBuf.Wave.u.Fmt.Data.uFormatTag, RTRIFFWAVEFMT_TAG_PCM, RTRIFFWAVEFMT_TAG_EXTENSIBLE);
3241	else if ( uBuf.Wave.u.Fmt.Data.cBitsPerSample != 8
3242	&& uBuf.Wave.u.Fmt.Data.cBitsPerSample != 16
3243	/* && uBuf.Wave.u.Fmt.Data.cBitsPerSample != 24 - not supported by our stack */
3244	&& uBuf.Wave.u.Fmt.Data.cBitsPerSample != 32)
3245	RTErrInfoSetF(pErrInfo, rc, "Unsupported cBitsPerSample value: %u", uBuf.Wave.u.Fmt.Data.cBitsPerSample);
3246	else if ( uBuf.Wave.u.Fmt.Data.cChannels < 1
3247	\|\| uBuf.Wave.u.Fmt.Data.cChannels >= 16)
3248	RTErrInfoSetF(pErrInfo, rc, "Unsupported cChannels value: %u (expected 1..15)", uBuf.Wave.u.Fmt.Data.cChannels);
3249	else if ( uBuf.Wave.u.Fmt.Data.uHz < 4096
3250	\|\| uBuf.Wave.u.Fmt.Data.uHz > 768000)
3251	RTErrInfoSetF(pErrInfo, rc, "Unsupported uHz value: %u (expected 4096..768000)", uBuf.Wave.u.Fmt.Data.uHz);
3252	else if (uBuf.Wave.u.Fmt.Data.cbFrame != uBuf.Wave.u.Fmt.Data.cChannels * uBuf.Wave.u.Fmt.Data.cBitsPerSample / 8)
3253	RTErrInfoSetF(pErrInfo, rc, "Invalid cbFrame value: %u (expected %u)", uBuf.Wave.u.Fmt.Data.cbFrame,
3254	uBuf.Wave.u.Fmt.Data.cChannels * uBuf.Wave.u.Fmt.Data.cBitsPerSample / 8);
3255	else if (uBuf.Wave.u.Fmt.Data.cbRate != uBuf.Wave.u.Fmt.Data.cbFrame * uBuf.Wave.u.Fmt.Data.uHz)
3256	RTErrInfoSetF(pErrInfo, rc, "Invalid cbRate value: %u (expected %u)", uBuf.Wave.u.Fmt.Data.cbRate,
3257	uBuf.Wave.u.Fmt.Data.cbFrame * uBuf.Wave.u.Fmt.Data.uHz);
3258	else if ( uBuf.Wave.u.Fmt.Data.uFormatTag == RTRIFFWAVEFMT_TAG_EXTENSIBLE
3259	&& uBuf.Wave.u.FmtExt.Data.cbExtra < RTRIFFWAVEFMTEXT_EXTRA_SIZE)
3260	RTErrInfoSetF(pErrInfo, rc, "Invalid cbExtra value: %#x (expected at least %#x)",
3261	uBuf.Wave.u.FmtExt.Data.cbExtra, RTRIFFWAVEFMTEXT_EXTRA_SIZE);
3262	else if ( uBuf.Wave.u.Fmt.Data.uFormatTag == RTRIFFWAVEFMT_TAG_EXTENSIBLE
3263	&& audioTestWaveCountBits(uBuf.Wave.u.FmtExt.Data.fChannelMask) != uBuf.Wave.u.Fmt.Data.cChannels)
3264	RTErrInfoSetF(pErrInfo, rc, "fChannelMask does not match cChannels: %#x (%u bits set) vs %u channels",
3265	uBuf.Wave.u.FmtExt.Data.fChannelMask,
3266	audioTestWaveCountBits(uBuf.Wave.u.FmtExt.Data.fChannelMask), uBuf.Wave.u.Fmt.Data.cChannels);
3267	else if ( uBuf.Wave.u.Fmt.Data.uFormatTag == RTRIFFWAVEFMT_TAG_EXTENSIBLE
3268	&& RTUuidCompareStr(&uBuf.Wave.u.FmtExt.Data.SubFormat, RTRIFFWAVEFMTEXT_SUBTYPE_PCM) != 0)
3269	RTErrInfoSetF(pErrInfo, rc, "SubFormat is not PCM: %RTuuid (expected %s)",
3270	&uBuf.Wave.u.FmtExt.Data.SubFormat, RTRIFFWAVEFMTEXT_SUBTYPE_PCM);
3271	else
3272	{
3273	/*
3274	* Copy out the data we need from the file format structure.
3275	*/
3276	PDMAudioPropsInit(&pWaveFile->Props, uBuf.Wave.u.Fmt.Data.cBitsPerSample / 8, true /fSigned/,
3277	uBuf.Wave.u.Fmt.Data.cChannels, uBuf.Wave.u.Fmt.Data.uHz);
3278	pWaveFile->offSamples = sizeof(RTRIFFHDR) + sizeof(RTRIFFCHUNK) + uBuf.Wave.u.Fmt.Chunk.cbChunk;
3279
3280	/*
3281	* Pick up channel assignments if present.
3282	*/
3283	if (uBuf.Wave.u.Fmt.Data.uFormatTag == RTRIFFWAVEFMT_TAG_EXTENSIBLE)
3284	{
3285	static unsigned const s_cStdIds = (unsigned)PDMAUDIOCHANNELID_END_STANDARD
3286	- (unsigned)PDMAUDIOCHANNELID_FIRST_STANDARD;
3287	unsigned iCh = 0;
3288	for (unsigned idCh = 0; idCh < 32 && iCh < uBuf.Wave.u.Fmt.Data.cChannels; idCh++)
3289	if (uBuf.Wave.u.FmtExt.Data.fChannelMask & RT_BIT_32(idCh))
3290	{
3291	pWaveFile->Props.aidChannels[iCh] = idCh < s_cStdIds
3292	? idCh + (unsigned)PDMAUDIOCHANNELID_FIRST_STANDARD
3293	: (unsigned)PDMAUDIOCHANNELID_UNKNOWN;
3294	iCh++;
3295	}
3296	}
3297
3298	/*
3299	* Find the 'data' chunk with the audio samples.
3300	*
3301	* There can be INFO lists both preceeding this and succeeding
3302	* it, containing IART and other things we can ignored. Thus
3303	* we read a list header here rather than just a chunk header,
3304	* since it doesn't matter if we read 4 bytes extra as
3305	* AudioTestWaveFileRead uses RTFileReadAt anyway.
3306	*/
3307	rc = RTFileReadAt(pWaveFile->hFile, pWaveFile->offSamples, &uBuf, sizeof(uBuf.List), NULL);
3308	for (uint32_t i = 0;
3309	i < 128
3310	&& RT_SUCCESS(rc)
3311	&& uBuf.Chunk.uMagic != RTRIFFWAVEDATACHUNK_MAGIC
3312	&& (uint64_t)uBuf.Chunk.cbChunk + sizeof(RTRIFFCHUNK) * 2 <= cbFile - pWaveFile->offSamples;
3313	i++)
3314	{
3315	if ( uBuf.List.uMagic == RTRIFFLIST_MAGIC
3316	&& uBuf.List.uListType == RTRIFFLIST_TYPE_INFO)
3317	{ /skip/ }
3318	else if (uBuf.Chunk.uMagic == RTRIFFPADCHUNK_MAGIC)
3319	{ /skip/ }
3320	else
3321	break;
3322	pWaveFile->offSamples += sizeof(RTRIFFCHUNK) + uBuf.Chunk.cbChunk;
3323	rc = RTFileReadAt(pWaveFile->hFile, pWaveFile->offSamples, &uBuf, sizeof(uBuf.List), NULL);
3324	}
3325	if (RT_SUCCESS(rc))
3326	{
3327	pWaveFile->offSamples += sizeof(uBuf.Data.Chunk);
3328	pWaveFile->cbSamples = (uint32_t)cbFile - pWaveFile->offSamples;
3329
3330	rc = VERR_VFS_BOGUS_FORMAT;
3331	if ( uBuf.Data.Chunk.uMagic == RTRIFFWAVEDATACHUNK_MAGIC
3332	&& uBuf.Data.Chunk.cbChunk <= pWaveFile->cbSamples
3333	&& PDMAudioPropsIsSizeAligned(&pWaveFile->Props, uBuf.Data.Chunk.cbChunk))
3334	{
3335	pWaveFile->cbSamples = uBuf.Data.Chunk.cbChunk;
3336
3337	/*
3338	* We're good!
3339	*/
3340	pWaveFile->offCur = 0;
3341	pWaveFile->fReadMode = true;
3342	pWaveFile->u32Magic = AUDIOTESTWAVEFILE_MAGIC;
3343	return VINF_SUCCESS;
3344	}
3345
3346	RTErrInfoSetF(pErrInfo, rc, "Bad data header: uMagic=%#x (expected %#x), cbChunk=%#x (max %#RX64, align %u)",
3347	uBuf.Data.Chunk.uMagic, RTRIFFWAVEDATACHUNK_MAGIC,
3348	uBuf.Data.Chunk.cbChunk, pWaveFile->cbSamples, PDMAudioPropsFrameSize(&pWaveFile->Props));
3349	}
3350	else
3351	RTErrInfoSet(pErrInfo, rc, "Failed to read data header");
3352	}
3353	}
3354	else
3355	RTErrInfoSetF(pErrInfo, rc, "Bad file header: uMagic=%#x (vs. %#x), uFileType=%#x (vs %#x), uFmtMagic=%#x (vs %#x) cbFmtChunk=%#x (min %#x)",
3356	uBuf.Wave.Hdr.uMagic, RTRIFFHDR_MAGIC, uBuf.Wave.Hdr.uFileType, RTRIFF_FILE_TYPE_WAVE,
3357	uBuf.Wave.u.Fmt.Chunk.uMagic, RTRIFFWAVEFMT_MAGIC,
3358	uBuf.Wave.u.Fmt.Chunk.cbChunk, sizeof(uBuf.Wave.u.Fmt.Data));
3359	}
3360	else
3361	rc = RTErrInfoSet(pErrInfo, rc, "Failed to read file header");
3362	}
3363	else
3364	rc = RTErrInfoSet(pErrInfo, rc, "Failed to query file size");
3365
3366	RTFileClose(pWaveFile->hFile);
3367	pWaveFile->hFile = NIL_RTFILE;
3368	return rc;
3369	}
3370
3371
3372	/**
3373	* Creates a new wave file.
3374	*
3375	* @returns VBox status code.
3376	* @param pszFile The filename.
3377	* @param pProps The audio format properties.
3378	* @param pWaveFile The wave file structure to fill in on success.
3379	* @param pErrInfo Where to return addition error details on failure.
3380	*/
3381	int AudioTestWaveFileCreate(const char *pszFile, PCPDMAUDIOPCMPROPS pProps, PAUDIOTESTWAVEFILE pWaveFile, PRTERRINFO pErrInfo)
3382	{
3383	/*
3384	* Construct the file header first (we'll do some input validation
3385	* here, so better do it before creating the file).
3386	*/
3387	struct
3388	{
3389	RTRIFFHDR Hdr;
3390	RTRIFFWAVEFMTEXTCHUNK FmtExt;
3391	RTRIFFCHUNK Data;
3392	} FileHdr;
3393
3394	FileHdr.Hdr.uMagic = RTRIFFHDR_MAGIC;
3395	FileHdr.Hdr.cbFile = 0; /* need to update this later */
3396	FileHdr.Hdr.uFileType = RTRIFF_FILE_TYPE_WAVE;
3397	FileHdr.FmtExt.Chunk.uMagic = RTRIFFWAVEFMT_MAGIC;
3398	FileHdr.FmtExt.Chunk.cbChunk = sizeof(RTRIFFWAVEFMTEXTCHUNK) - sizeof(RTRIFFCHUNK);
3399	FileHdr.FmtExt.Data.Core.uFormatTag = RTRIFFWAVEFMT_TAG_EXTENSIBLE;
3400	FileHdr.FmtExt.Data.Core.cChannels = PDMAudioPropsChannels(pProps);
3401	FileHdr.FmtExt.Data.Core.uHz = PDMAudioPropsHz(pProps);
3402	FileHdr.FmtExt.Data.Core.cbRate = PDMAudioPropsFramesToBytes(pProps, PDMAudioPropsHz(pProps));
3403	FileHdr.FmtExt.Data.Core.cbFrame = PDMAudioPropsFrameSize(pProps);
3404	FileHdr.FmtExt.Data.Core.cBitsPerSample = PDMAudioPropsSampleBits(pProps);
3405	FileHdr.FmtExt.Data.cbExtra = sizeof(FileHdr.FmtExt.Data) - sizeof(FileHdr.FmtExt.Data.Core);
3406	FileHdr.FmtExt.Data.cValidBitsPerSample = PDMAudioPropsSampleBits(pProps);
3407	FileHdr.FmtExt.Data.fChannelMask = 0;
3408	for (uintptr_t idxCh = 0; idxCh < FileHdr.FmtExt.Data.Core.cChannels; idxCh++)
3409	{
3410	PDMAUDIOCHANNELID const idCh = (PDMAUDIOCHANNELID)pProps->aidChannels[idxCh];
3411	if ( idCh >= PDMAUDIOCHANNELID_FIRST_STANDARD
3412	&& idCh < PDMAUDIOCHANNELID_END_STANDARD)
3413	{
3414	if (!(FileHdr.FmtExt.Data.fChannelMask & RT_BIT_32(idCh - PDMAUDIOCHANNELID_FIRST_STANDARD)))
3415	FileHdr.FmtExt.Data.fChannelMask \|= RT_BIT_32(idCh - PDMAUDIOCHANNELID_FIRST_STANDARD);
3416	else
3417	return RTErrInfoSetF(pErrInfo, VERR_INVALID_PARAMETER, "Channel #%u repeats channel ID %d", idxCh, idCh);
3418	}
3419	else
3420	return RTErrInfoSetF(pErrInfo, VERR_INVALID_PARAMETER, "Invalid channel ID %d for channel #%u", idCh, idxCh);
3421	}
3422
3423	RTUUID UuidTmp;
3424	int rc = RTUuidFromStr(&UuidTmp, RTRIFFWAVEFMTEXT_SUBTYPE_PCM);
3425	AssertRCReturn(rc, rc);
3426	FileHdr.FmtExt.Data.SubFormat = UuidTmp; /* (64-bit field maybe unaligned) */
3427
3428	FileHdr.Data.uMagic = RTRIFFWAVEDATACHUNK_MAGIC;
3429	FileHdr.Data.cbChunk = 0; /* need to update this later */
3430
3431	/*
3432	* Create the file and write the header.
3433	*/
3434	pWaveFile->hFile = NIL_RTFILE;
3435	rc = RTFileOpen(&pWaveFile->hFile, pszFile, RTFILE_O_CREATE \| RTFILE_O_WRITE \| RTFILE_O_DENY_WRITE);
3436	if (RT_FAILURE(rc))
3437	return RTErrInfoSet(pErrInfo, rc, "RTFileOpen failed");
3438
3439	rc = RTFileWrite(pWaveFile->hFile, &FileHdr, sizeof(FileHdr), NULL);
3440	if (RT_SUCCESS(rc))
3441	{
3442	/*
3443	* Initialize the wave file structure.
3444	*/
3445	pWaveFile->fReadMode = false;
3446	pWaveFile->offCur = 0;
3447	pWaveFile->offSamples = 0;
3448	pWaveFile->cbSamples = 0;
3449	pWaveFile->Props = *pProps;
3450	pWaveFile->offSamples = RTFileTell(pWaveFile->hFile);
3451	if (pWaveFile->offSamples != UINT32_MAX)
3452	{
3453	pWaveFile->u32Magic = AUDIOTESTWAVEFILE_MAGIC;
3454	return VINF_SUCCESS;
3455	}
3456	rc = RTErrInfoSet(pErrInfo, VERR_SEEK, "RTFileTell failed");
3457	}
3458	else
3459	RTErrInfoSet(pErrInfo, rc, "RTFileWrite failed writing header");
3460
3461	RTFileClose(pWaveFile->hFile);
3462	pWaveFile->hFile = NIL_RTFILE;
3463	pWaveFile->u32Magic = AUDIOTESTWAVEFILE_MAGIC_DEAD;
3464
3465	RTFileDelete(pszFile);
3466	return rc;
3467	}
3468
3469
3470	/**
3471	* Closes a wave file.
3472	*/
3473	int AudioTestWaveFileClose(PAUDIOTESTWAVEFILE pWaveFile)
3474	{
3475	AssertReturn(pWaveFile->u32Magic == AUDIOTESTWAVEFILE_MAGIC, VERR_INVALID_MAGIC);
3476	int rcRet = VINF_SUCCESS;
3477	int rc;
3478
3479	/*
3480	* Update the size fields if writing.
3481	*/
3482	if (!pWaveFile->fReadMode)
3483	{
3484	uint64_t cbFile = RTFileTell(pWaveFile->hFile);
3485	if (cbFile != UINT64_MAX)
3486	{
3487	uint32_t cbFile32 = cbFile - sizeof(RTRIFFCHUNK);
3488	rc = RTFileWriteAt(pWaveFile->hFile, RT_OFFSETOF(RTRIFFHDR, cbFile), &cbFile32, sizeof(cbFile32), NULL);
3489	AssertRCStmt(rc, rcRet = rc);
3490
3491	uint32_t cbSamples = cbFile - pWaveFile->offSamples;
3492	rc = RTFileWriteAt(pWaveFile->hFile, pWaveFile->offSamples - sizeof(uint32_t), &cbSamples, sizeof(cbSamples), NULL);
3493	AssertRCStmt(rc, rcRet = rc);
3494	}
3495	else
3496	rcRet = VERR_SEEK;
3497	}
3498
3499	/*
3500	* Close it.
3501	*/
3502	rc = RTFileClose(pWaveFile->hFile);
3503	AssertRCStmt(rc, rcRet = rc);
3504
3505	pWaveFile->hFile = NIL_RTFILE;
3506	pWaveFile->u32Magic = AUDIOTESTWAVEFILE_MAGIC_DEAD;
3507	return rcRet;
3508	}
3509
3510	/**
3511	* Reads samples from a wave file.
3512	*
3513	* @returns VBox status code. See RTVfsFileRead for EOF status handling.
3514	* @param pWaveFile The file to read from.
3515	* @param pvBuf Where to put the samples.
3516	* @param cbBuf How much to read at most.
3517	* @param pcbRead Where to return the actual number of bytes read,
3518	* optional.
3519	*/
3520	int AudioTestWaveFileRead(PAUDIOTESTWAVEFILE pWaveFile, void pvBuf, size_t cbBuf, size_t pcbRead)
3521	{
3522	AssertReturn(pWaveFile->u32Magic == AUDIOTESTWAVEFILE_MAGIC, VERR_INVALID_MAGIC);
3523	AssertReturn(pWaveFile->fReadMode, VERR_ACCESS_DENIED);
3524
3525	bool fEofAdjusted;
3526	if (pWaveFile->offCur + cbBuf <= pWaveFile->cbSamples)
3527	fEofAdjusted = false;
3528	else if (pcbRead)
3529	{
3530	fEofAdjusted = true;
3531	cbBuf = pWaveFile->cbSamples - pWaveFile->offCur;
3532	}
3533	else
3534	return VERR_EOF;
3535
3536	int rc = RTFileReadAt(pWaveFile->hFile, pWaveFile->offSamples + pWaveFile->offCur, pvBuf, cbBuf, pcbRead);
3537	if (RT_SUCCESS(rc))
3538	{
3539	if (pcbRead)
3540	{
3541	pWaveFile->offCur += (uint32_t)*pcbRead;
3542	if (fEofAdjusted \|\| cbBuf > *pcbRead)
3543	rc = VINF_EOF;
3544	else if (!cbBuf && pWaveFile->offCur == pWaveFile->cbSamples)
3545	rc = VINF_EOF;
3546	}
3547	else
3548	pWaveFile->offCur += (uint32_t)cbBuf;
3549	}
3550	return rc;
3551	}
3552
3553
3554	/**
3555	* Writes samples to a wave file.
3556	*
3557	* @returns VBox status code.
3558	* @param pWaveFile The file to write to.
3559	* @param pvBuf The samples to write.
3560	* @param cbBuf How many bytes of samples to write.
3561	*/
3562	int AudioTestWaveFileWrite(PAUDIOTESTWAVEFILE pWaveFile, const void *pvBuf, size_t cbBuf)
3563	{
3564	AssertReturn(pWaveFile->u32Magic == AUDIOTESTWAVEFILE_MAGIC, VERR_INVALID_MAGIC);
3565	AssertReturn(!pWaveFile->fReadMode, VERR_ACCESS_DENIED);
3566
3567	pWaveFile->cbSamples += (uint32_t)cbBuf;
3568	return RTFileWrite(pWaveFile->hFile, pvBuf, cbBuf, NULL);
3569	}
3570

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

source: vbox/trunk/src/VBox/Devices/Audio/AudioTest.cpp@ 93956

Download in other formats: