tstAudioMixBuffer.cpp

Last change on this file was 108633, checked in by vboxsync, 7 weeks ago
Devices/Audio/testcase/tstAudioMixBuffer.cpp: Make it work for hosts where we don't know the host page size when building, bugref:10391 [build fix]
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 43.0 KB

Line
1	/* $Id: tstAudioMixBuffer.cpp 108633 2025-03-20 11:23:40Z vboxsync $ */
2	/** @file
3	* Audio testcase - Mixing buffer.
4	*/
5
6	/*
7	* Copyright (C) 2014-2024 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#include <iprt/errcore.h>
33	#include <iprt/initterm.h>
34	#include <iprt/mem.h>
35	#include <iprt/rand.h>
36	#include <iprt/stream.h>
37	#include <iprt/string.h>
38	#include <iprt/test.h>
39	#include <iprt/system.h>
40
41	#include <VBox/vmm/pdm.h>
42	#include <VBox/vmm/pdmaudioinline.h>
43
44	#include "../AudioMixBuffer.h"
45	#include "../AudioHlp.h"
46
47	#define _USE_MATH_DEFINES
48	#include <math.h> /* sin, M_PI */
49
50
51	/*********************************************************************************************************************************
52	* Global Variables *
53	*********************************************************************************************************************************/
54	#ifdef RT_LITTLE_ENDIAN
55	bool const g_fLittleEndian = true;
56	#else
57	bool const g_fLittleEndian = false;
58	#endif
59
60
61	static void tstBasics(RTTEST hTest)
62	{
63	RTTestSub(hTest, "Basics");
64
65	const PDMAUDIOPCMPROPS Cfg441StereoS16 = PDMAUDIOPCMPROPS_INITIALIZER(
66	/* a_cb: */ 2,
67	/* a_fSigned: */ true,
68	/* a_cChannels: */ 2,
69	/* a_uHz: */ 44100,
70	/* a_fSwapEndian: */ false
71	);
72	const PDMAUDIOPCMPROPS Cfg441StereoU16 = PDMAUDIOPCMPROPS_INITIALIZER(
73	/* a_cb: */ 2,
74	/* a_fSigned: */ false,
75	/* a_cChannels: */ 2,
76	/* a_uHz: */ 44100,
77	/* a_fSwapEndian: */ false
78	);
79	const PDMAUDIOPCMPROPS Cfg441StereoU32 = PDMAUDIOPCMPROPS_INITIALIZER(
80	/* a_cb: */ 4,
81	/* a_fSigned: */ false,
82	/* a_cChannels: */ 2,
83	/* a_uHz: */ 44100,
84	/* a_fSwapEndian: */ false
85	);
86
87	RTTESTI_CHECK(PDMAudioPropsGetBitrate(&Cfg441StereoS16) == 4410048);
88	RTTESTI_CHECK(PDMAudioPropsGetBitrate(&Cfg441StereoU16) == 4410048);
89	RTTESTI_CHECK(PDMAudioPropsGetBitrate(&Cfg441StereoU32) == 4410088);
90
91	RTTESTI_CHECK(AudioHlpPcmPropsAreValidAndSupported(&Cfg441StereoS16));
92	RTTESTI_CHECK(AudioHlpPcmPropsAreValidAndSupported(&Cfg441StereoU16));
93	RTTESTI_CHECK(AudioHlpPcmPropsAreValidAndSupported(&Cfg441StereoU32));
94
95
96	RTTESTI_CHECK_MSG(PDMAUDIOPCMPROPS_F2B(&Cfg441StereoS16, 1) == 4,
97	("got %x, expected 4\n", PDMAUDIOPCMPROPS_F2B(&Cfg441StereoS16, 1)));
98	RTTESTI_CHECK_MSG(PDMAUDIOPCMPROPS_F2B(&Cfg441StereoU16, 1) == 4,
99	("got %x, expected 4\n", PDMAUDIOPCMPROPS_F2B(&Cfg441StereoU16, 1)));
100	RTTESTI_CHECK_MSG(PDMAUDIOPCMPROPS_F2B(&Cfg441StereoU32, 1) == 8,
101	("got %x, expected 4\n", PDMAUDIOPCMPROPS_F2B(&Cfg441StereoU32, 1)));
102
103	RTTESTI_CHECK_MSG(PDMAudioPropsBytesPerFrame(&Cfg441StereoS16) == 4,
104	("got %x, expected 4\n", PDMAudioPropsBytesPerFrame(&Cfg441StereoS16)));
105	RTTESTI_CHECK_MSG(PDMAudioPropsBytesPerFrame(&Cfg441StereoU16) == 4,
106	("got %x, expected 4\n", PDMAudioPropsBytesPerFrame(&Cfg441StereoU16)));
107	RTTESTI_CHECK_MSG(PDMAudioPropsBytesPerFrame(&Cfg441StereoU32) == 8,
108	("got %x, expected 4\n", PDMAudioPropsBytesPerFrame(&Cfg441StereoU32)));
109
110	uint32_t u32;
111	for (uint32_t i = 0; i < 256; i += 8)
112	{
113	RTTESTI_CHECK(PDMAudioPropsIsSizeAligned(&Cfg441StereoU32, i) == true);
114	for (uint32_t j = 1; j < 8; j++)
115	RTTESTI_CHECK(PDMAudioPropsIsSizeAligned(&Cfg441StereoU32, i + j) == false);
116	for (uint32_t j = 0; j < 8; j++)
117	RTTESTI_CHECK(PDMAudioPropsFloorBytesToFrame(&Cfg441StereoU32, i + j) == i);
118	}
119	for (uint32_t i = 0; i < 4096; i += 4)
120	{
121	RTTESTI_CHECK(PDMAudioPropsIsSizeAligned(&Cfg441StereoS16, i) == true);
122	for (uint32_t j = 1; j < 4; j++)
123	RTTESTI_CHECK(PDMAudioPropsIsSizeAligned(&Cfg441StereoS16, i + j) == false);
124	for (uint32_t j = 0; j < 4; j++)
125	RTTESTI_CHECK(PDMAudioPropsFloorBytesToFrame(&Cfg441StereoS16, i + j) == i);
126	}
127
128	RTTESTI_CHECK_MSG((u32 = PDMAudioPropsFramesToBytes(&Cfg441StereoS16, 44100)) == 44100 * 2 * 2,
129	("cb=%RU32\n", u32));
130	RTTESTI_CHECK_MSG((u32 = PDMAudioPropsFramesToBytes(&Cfg441StereoS16, 2)) == 2 * 2 * 2,
131	("cb=%RU32\n", u32));
132	RTTESTI_CHECK_MSG((u32 = PDMAudioPropsFramesToBytes(&Cfg441StereoS16, 1)) == 4,
133	("cb=%RU32\n", u32));
134	RTTESTI_CHECK_MSG((u32 = PDMAudioPropsFramesToBytes(&Cfg441StereoU16, 1)) == 4,
135	("cb=%RU32\n", u32));
136	RTTESTI_CHECK_MSG((u32 = PDMAudioPropsFramesToBytes(&Cfg441StereoU32, 1)) == 8,
137	("cb=%RU32\n", u32));
138
139	RTTESTI_CHECK_MSG((u32 = PDMAudioPropsBytesToFrames(&Cfg441StereoS16, 4)) == 1, ("cb=%RU32\n", u32));
140	RTTESTI_CHECK_MSG((u32 = PDMAudioPropsBytesToFrames(&Cfg441StereoU16, 4)) == 1, ("cb=%RU32\n", u32));
141	RTTESTI_CHECK_MSG((u32 = PDMAudioPropsBytesToFrames(&Cfg441StereoU32, 8)) == 1, ("cb=%RU32\n", u32));
142
143	uint64_t u64;
144	RTTESTI_CHECK_MSG((u64 = PDMAudioPropsBytesToNano(&Cfg441StereoS16, 44100 * 2 * 2)) == RT_NS_1SEC,
145	("ns=%RU64\n", u64));
146	RTTESTI_CHECK_MSG((u64 = PDMAudioPropsBytesToMicro(&Cfg441StereoS16, 44100 * 2 * 2)) == RT_US_1SEC,
147	("us=%RU64\n", u64));
148	RTTESTI_CHECK_MSG((u64 = PDMAudioPropsBytesToMilli(&Cfg441StereoS16, 44100 * 2 * 2)) == RT_MS_1SEC,
149	("ms=%RU64\n", u64));
150
151	RTTESTI_CHECK_MSG((u64 = PDMAudioPropsFramesToNano(&Cfg441StereoS16, 44100)) == RT_NS_1SEC, ("ns=%RU64\n", u64));
152	RTTESTI_CHECK_MSG((u64 = PDMAudioPropsFramesToNano(&Cfg441StereoS16, 1)) == 22675, ("ns=%RU64\n", u64));
153	RTTESTI_CHECK_MSG((u64 = PDMAudioPropsFramesToNano(&Cfg441StereoS16, 31)) == 702947, ("ns=%RU64\n", u64));
154	RTTESTI_CHECK_MSG((u64 = PDMAudioPropsFramesToNano(&Cfg441StereoS16, 255)) == 5782312, ("ns=%RU64\n", u64));
155	//RTTESTI_CHECK_MSG((u64 = DrvAudioHlpFramesToMicro(&Cfg441StereoS16, 44100)) == RT_US_1SEC,
156	// ("us=%RU64\n", u64));
157	RTTESTI_CHECK_MSG((u64 = PDMAudioPropsFramesToMilli(&Cfg441StereoS16, 44100)) == RT_MS_1SEC, ("ms=%RU64\n", u64));
158	RTTESTI_CHECK_MSG((u64 = PDMAudioPropsFramesToMilli(&Cfg441StereoS16, 255)) == 5, ("ms=%RU64\n", u64));
159
160	RTTESTI_CHECK_MSG((u32 = PDMAudioPropsNanoToFrames(&Cfg441StereoS16, RT_NS_1SEC)) == 44100, ("cb=%RU32\n", u32));
161	RTTESTI_CHECK_MSG((u32 = PDMAudioPropsNanoToFrames(&Cfg441StereoS16, 215876)) == 10, ("cb=%RU32\n", u32));
162	RTTESTI_CHECK_MSG((u32 = PDMAudioPropsMilliToFrames(&Cfg441StereoS16, RT_MS_1SEC)) == 44100, ("cb=%RU32\n", u32));
163	RTTESTI_CHECK_MSG((u32 = PDMAudioPropsMilliToFrames(&Cfg441StereoU32, 6)) == 265, ("cb=%RU32\n", u32));
164
165	RTTESTI_CHECK_MSG((u32 = PDMAudioPropsNanoToBytes(&Cfg441StereoS16, RT_NS_1SEC)) == 4410022, ("cb=%RU32\n", u32));
166	RTTESTI_CHECK_MSG((u32 = PDMAudioPropsNanoToBytes(&Cfg441StereoS16, 702947)) == 3122, ("cb=%RU32\n", u32));
167	RTTESTI_CHECK_MSG((u32 = PDMAudioPropsMilliToBytes(&Cfg441StereoS16, RT_MS_1SEC)) == 4410022, ("cb=%RU32\n", u32));
168	RTTESTI_CHECK_MSG((u32 = PDMAudioPropsMilliToBytes(&Cfg441StereoS16, 5)) == 884, ("cb=%RU32\n", u32));
169
170	/* DrvAudioHlpClearBuf: */
171	uint32_t const cbPageSize = RTSystemGetPageSize();
172	uint8_t *pbPage;
173	int rc = RTTestGuardedAlloc(hTest, cbPageSize, 0, false /fHead/, (void **)&pbPage);
174	RTTESTI_CHECK_RC_OK_RETV(rc);
175
176	memset(pbPage, 0x42, cbPageSize);
177	PDMAudioPropsClearBuffer(&Cfg441StereoS16, pbPage, cbPageSize, cbPageSize / 4);
178	RTTESTI_CHECK(ASMMemIsZero(pbPage, cbPageSize));
179
180	memset(pbPage, 0x42, cbPageSize);
181	PDMAudioPropsClearBuffer(&Cfg441StereoU16, pbPage, cbPageSize, cbPageSize / 4);
182	for (uint32_t off = 0; off < cbPageSize; off += 2)
183	RTTESTI_CHECK_MSG(pbPage[off] == 0 && pbPage[off + 1] == 0x80, ("off=%#x: %#x %x\n", off, pbPage[off], pbPage[off + 1]));
184
185	memset(pbPage, 0x42, cbPageSize);
186	PDMAudioPropsClearBuffer(&Cfg441StereoU32, pbPage, cbPageSize, cbPageSize / 8);
187	for (uint32_t off = 0; off < cbPageSize; off += 4)
188	RTTESTI_CHECK(pbPage[off] == 0 && pbPage[off + 1] == 0 && pbPage[off + 2] == 0 && pbPage[off + 3] == 0x80);
189
190
191	RTTestDisableAssertions(hTest);
192	memset(pbPage, 0x42, cbPageSize);
193	PDMAudioPropsClearBuffer(&Cfg441StereoS16, pbPage, cbPageSize, cbPageSize); /* should adjust down the frame count. */
194	RTTESTI_CHECK(ASMMemIsZero(pbPage, cbPageSize));
195
196	memset(pbPage, 0x42, cbPageSize);
197	PDMAudioPropsClearBuffer(&Cfg441StereoU16, pbPage, cbPageSize, cbPageSize); /* should adjust down the frame count. */
198	for (uint32_t off = 0; off < cbPageSize; off += 2)
199	RTTESTI_CHECK_MSG(pbPage[off] == 0 && pbPage[off + 1] == 0x80, ("off=%#x: %#x %x\n", off, pbPage[off], pbPage[off + 1]));
200
201	memset(pbPage, 0x42, cbPageSize);
202	PDMAudioPropsClearBuffer(&Cfg441StereoU32, pbPage, cbPageSize, cbPageSize); /* should adjust down the frame count. */
203	for (uint32_t off = 0; off < cbPageSize; off += 4)
204	RTTESTI_CHECK(pbPage[off] == 0 && pbPage[off + 1] == 0 && pbPage[off + 2] == 0 && pbPage[off + 3] == 0x80);
205	RTTestRestoreAssertions(hTest);
206
207	RTTestGuardedFree(hTest, pbPage);
208	}
209
210
211	static void tstSimple(RTTEST hTest)
212	{
213	RTTestSub(hTest, "Simple");
214
215	/* 44100Hz, 2 Channels, S16 */
216	PDMAUDIOPCMPROPS config = PDMAUDIOPCMPROPS_INITIALIZER(
217	2, /* Bytes */
218	true, /* Signed */
219	2, /* Channels */
220	44100, /* Hz */
221	false /* Swap Endian */
222	);
223
224	RTTESTI_CHECK(AudioHlpPcmPropsAreValidAndSupported(&config));
225
226	uint32_t cBufSize = _1K;
227
228	/*
229	* General stuff.
230	*/
231	AUDIOMIXBUF mb;
232	RTTESTI_CHECK_RC_OK_RETV(AudioMixBufInit(&mb, "Single", &config, cBufSize));
233	RTTESTI_CHECK(AudioMixBufSize(&mb) == cBufSize);
234	RTTESTI_CHECK(AUDIOMIXBUF_B2F(&mb, AudioMixBufSizeBytes(&mb)) == cBufSize);
235	RTTESTI_CHECK(AUDIOMIXBUF_F2B(&mb, AudioMixBufSize(&mb)) == AudioMixBufSizeBytes(&mb));
236	RTTESTI_CHECK(AudioMixBufFree(&mb) == cBufSize);
237	RTTESTI_CHECK(AUDIOMIXBUF_F2B(&mb, AudioMixBufFree(&mb)) == AudioMixBufFreeBytes(&mb));
238
239	AUDIOMIXBUFWRITESTATE WriteState;
240	RTTESTI_CHECK_RC(AudioMixBufInitWriteState(&mb, &WriteState, &config), VINF_SUCCESS);
241
242	AUDIOMIXBUFPEEKSTATE PeekState;
243	RTTESTI_CHECK_RC(AudioMixBufInitPeekState(&mb, &PeekState, &config), VINF_SUCCESS);
244
245	/*
246	* A few writes (used to be the weird absolute writes).
247	*/
248	uint32_t cFramesRead = 0, cFramesWritten = 0, cFramesWrittenAbs = 0;
249	int16_t aFrames16[2] = { 0xAA, 0xBB };
250	int32_t aFrames32[2] = { 0xCC, 0xDD };
251
252	RTTESTI_CHECK(AudioMixBufUsed(&mb) == 0);
253
254	AudioMixBufWrite(&mb, &WriteState, &aFrames16, sizeof(aFrames16), 0 /offDstFrame/, cBufSize / 4, &cFramesWritten);
255	RTTESTI_CHECK(cFramesWritten == 1 /* Frames */);
256	RTTESTI_CHECK(AudioMixBufUsed(&mb) == 0);
257	AudioMixBufCommit(&mb, cFramesWritten);
258	RTTESTI_CHECK(AudioMixBufUsed(&mb) == 1);
259	RTTESTI_CHECK(AudioMixBufReadPos(&mb) == 0);
260	RTTESTI_CHECK(AudioMixBufWritePos(&mb) == 1);
261
262	AudioMixBufWrite(&mb, &WriteState, &aFrames32, sizeof(aFrames32), 0 /offDstFrame/, cBufSize / 4, &cFramesWritten);
263	RTTESTI_CHECK(cFramesWritten == 2 /* Frames */);
264	AudioMixBufCommit(&mb, cFramesWritten);
265	RTTESTI_CHECK(AudioMixBufUsed(&mb) == 3);
266	RTTESTI_CHECK(AudioMixBufReadPos(&mb) == 0);
267	RTTESTI_CHECK(AudioMixBufWritePos(&mb) == 3);
268
269	/* Pretend we read the frames.*/
270	AudioMixBufAdvance(&mb, 3);
271	RTTESTI_CHECK(AudioMixBufUsed(&mb) == 0);
272	RTTESTI_CHECK(AudioMixBufReadPos(&mb) == 3);
273	RTTESTI_CHECK(AudioMixBufWritePos(&mb) == 3);
274
275	/* Fill up the buffer completely and check wraps. */
276
277	uint32_t cbSamples = PDMAudioPropsFramesToBytes(&config, cBufSize);
278	uint16_t paSamples = (uint16_t )RTMemAlloc(cbSamples);
279	RTTESTI_CHECK_RETV(paSamples);
280	AudioMixBufWrite(&mb, &WriteState, paSamples, cbSamples, 0 /offDstFrame/, cBufSize, &cFramesWritten);
281	RTTESTI_CHECK(cFramesWritten == cBufSize);
282	AudioMixBufCommit(&mb, cFramesWritten);
283	RTTESTI_CHECK(AudioMixBufUsed(&mb) == cBufSize);
284	RTTESTI_CHECK(AudioMixBufReadPos(&mb) == 3);
285	RTTESTI_CHECK(AudioMixBufWritePos(&mb) == 3);
286	RTMemFree(paSamples);
287	cbSamples = 0;
288
289	/*
290	* Writes and reads (used to be circular).
291	*/
292	AudioMixBufDrop(&mb);
293
294	cFramesWrittenAbs = AudioMixBufUsed(&mb);
295
296	uint32_t cToWrite = AudioMixBufSize(&mb) - cFramesWrittenAbs - 1; /* -1 as padding plus -2 frames for above. */
297	for (uint32_t i = 0; i < cToWrite; i++)
298	{
299	AudioMixBufWrite(&mb, &WriteState, &aFrames16[0], sizeof(aFrames16), 0 /offDstFrame/, 1, &cFramesWritten);
300	RTTESTI_CHECK(cFramesWritten == 1);
301	AudioMixBufCommit(&mb, cFramesWritten);
302	}
303	RTTESTI_CHECK(!AudioMixBufIsEmpty(&mb));
304	RTTESTI_CHECK(AudioMixBufFree(&mb) == 1);
305	RTTESTI_CHECK(AudioMixBufFreeBytes(&mb) == AUDIOMIXBUF_F2B(&mb, 1U));
306	RTTESTI_CHECK(AudioMixBufUsed(&mb) == cToWrite + cFramesWrittenAbs /* + last absolute write */);
307
308	AudioMixBufWrite(&mb, &WriteState, &aFrames16[0], sizeof(aFrames16), 0 /offDstFrame/, 1, &cFramesWritten);
309	RTTESTI_CHECK(cFramesWritten == 1);
310	AudioMixBufCommit(&mb, cFramesWritten);
311	RTTESTI_CHECK(AudioMixBufFree(&mb) == 0);
312	RTTESTI_CHECK(AudioMixBufFreeBytes(&mb) == AUDIOMIXBUF_F2B(&mb, 0U));
313	RTTESTI_CHECK(AudioMixBufUsed(&mb) == cBufSize);
314
315	/* Reads. */
316	RTTESTI_CHECK(AudioMixBufReadPos(&mb) == 0);
317	uint32_t cbRead;
318	uint16_t aFrames16Buf[RT_ELEMENTS(aFrames16)];
319	uint32_t cToRead = AudioMixBufSize(&mb) - cFramesWrittenAbs - 1;
320	for (uint32_t i = 0; i < cToRead; i++)
321	{
322	AudioMixBufPeek(&mb, 0 /offSrcFrame/, 1, &cFramesRead, &PeekState, aFrames16Buf, sizeof(aFrames16Buf), &cbRead);
323	RTTESTI_CHECK(cFramesRead == 1);
324	RTTESTI_CHECK(cbRead == sizeof(aFrames16Buf));
325	AudioMixBufAdvance(&mb, cFramesRead);
326	RTTESTI_CHECK(AudioMixBufReadPos(&mb) == i + 1);
327	}
328	RTTESTI_CHECK(!AudioMixBufIsEmpty(&mb));
329	RTTESTI_CHECK(AudioMixBufFree(&mb) == AudioMixBufSize(&mb) - cFramesWrittenAbs - 1);
330	RTTESTI_CHECK(AudioMixBufFreeBytes(&mb) == AUDIOMIXBUF_F2B(&mb, cBufSize - cFramesWrittenAbs - 1));
331	RTTESTI_CHECK(AudioMixBufUsed(&mb) == cBufSize - cToRead);
332
333	AudioMixBufPeek(&mb, 0 /offSrcFrame/, 1, &cFramesRead, &PeekState, aFrames16Buf, sizeof(aFrames16Buf), &cbRead);
334	RTTESTI_CHECK(cFramesRead == 1);
335	RTTESTI_CHECK(cbRead == sizeof(aFrames16Buf));
336	AudioMixBufAdvance(&mb, cFramesRead);
337	RTTESTI_CHECK(AudioMixBufFree(&mb) == cBufSize - cFramesWrittenAbs);
338	RTTESTI_CHECK(AudioMixBufFreeBytes(&mb) == AUDIOMIXBUF_F2B(&mb, cBufSize - cFramesWrittenAbs));
339	RTTESTI_CHECK(AudioMixBufUsed(&mb) == cFramesWrittenAbs);
340	RTTESTI_CHECK(AudioMixBufReadPos(&mb) == 0);
341
342	AudioMixBufTerm(&mb);
343	}
344
345	/** @name Eight test samples represented in all basic formats.
346	* @{ */
347	static uint8_t const g_au8TestSamples[8] = { 0x1, 0x11, 0x32, 0x7f, 0x80, 0x81, 0xbe, 0xff };
348	static int8_t const g_ai8TestSamples[8] = { -127, -111, -78, -1, 0, 1, 62, 127 };
349	static uint16_t const g_au16TestSamples[8] = { 0x100, 0x1100, 0x3200, 0x7f00, 0x8000, 0x8100, 0xbe00, 0xff00 };
350	static int16_t const g_ai16TestSamples[8] = { -32512, -28416, -19968, -256, 0, 256, 15872, 32512 };
351	static uint32_t const g_au32TestSamples[8] = { 0x1000000, 0x11000000, 0x32000000, 0x7f000000, 0x80000000, 0x81000000, 0xbe000000, 0xff000000 };
352	static int32_t const g_ai32TestSamples[8] = { -2130706432, -1862270976, -1308622848, -16777216, 0, 16777216, 1040187392, 2130706432 };
353	static int64_t const g_ai64TestSamples[8] = { -2130706432, -1862270976, -1308622848, -16777216, 0, 16777216, 1040187392, 2130706432 };
354	static struct { void const *apv[2]; uint32_t cb; } g_aTestSamples[] =
355	{
356	/* 0/0: */ { { NULL, NULL }, 0 },
357	/* 1/8: */ { { g_au8TestSamples, g_ai8TestSamples }, sizeof( g_au8TestSamples) },
358	/* 2/16: */ { { g_au16TestSamples, g_ai16TestSamples }, sizeof(g_au16TestSamples) },
359	/* 3/24: */ { { NULL, NULL }, 0 },
360	/* 4/32: */ { { g_au32TestSamples, g_ai32TestSamples }, sizeof(g_au32TestSamples) },
361	/* 5: */ { { NULL, NULL }, 0 },
362	/* 6: */ { { NULL, NULL }, 0 },
363	/* 7: */ { { NULL, NULL }, 0 },
364	/* 8:64 / { { NULL, g_ai64TestSamples }, sizeof(g_ai64TestSamples) }, / raw */
365	};
366	/** @} */
367
368	/** Fills a buffer with samples from an g_aTestSamples entry. */
369	static uint32_t tstFillBuf(PCPDMAUDIOPCMPROPS pCfg, void const *pvTestSamples, uint32_t iTestSample,
370	uint8_t *pbBuf, uint32_t cFrames)
371	{
372	uint8_t const cTestSamples = RT_ELEMENTS(g_au8TestSamples);
373
374	cFrames *= PDMAudioPropsChannels(pCfg);
375	switch (PDMAudioPropsSampleSize(pCfg))
376	{
377	case 1:
378	{
379	uint8_t const * const pau8TestSamples = (uint8_t const *)pvTestSamples;
380	uint8_t pu8Dst = (uint8_t )pbBuf;
381	while (cFrames-- > 0)
382	{
383	*pu8Dst++ = pau8TestSamples[iTestSample];
384	iTestSample = (iTestSample + 1) % cTestSamples;
385	}
386	break;
387	}
388
389	case 2:
390	{
391	uint16_t const * const pau16TestSamples = (uint16_t const *)pvTestSamples;
392	uint16_t pu16Dst = (uint16_t )pbBuf;
393	while (cFrames-- > 0)
394	{
395	*pu16Dst++ = pau16TestSamples[iTestSample];
396	iTestSample = (iTestSample + 1) % cTestSamples;
397	}
398	break;
399	}
400
401	case 4:
402	{
403	uint32_t const * const pau32TestSamples = (uint32_t const *)pvTestSamples;
404	uint32_t pu32Dst = (uint32_t )pbBuf;
405	while (cFrames-- > 0)
406	{
407	*pu32Dst++ = pau32TestSamples[iTestSample];
408	iTestSample = (iTestSample + 1) % cTestSamples;
409	}
410	break;
411	}
412
413	case 8:
414	{
415	uint64_t const * const pau64TestSamples = (uint64_t const *)pvTestSamples;
416	uint64_t pu64Dst = (uint64_t )pbBuf;
417	while (cFrames-- > 0)
418	{
419	*pu64Dst++ = pau64TestSamples[iTestSample];
420	iTestSample = (iTestSample + 1) % cTestSamples;
421	}
422	break;
423	}
424
425	default:
426	AssertFailedBreak();
427	}
428	return iTestSample;
429	}
430
431
432	static void tstConversion(RTTEST hTest, uint8_t cSrcBits, bool fSrcSigned, uint8_t cSrcChs,
433	uint8_t cDstBits, bool fDstSigned, uint8_t cDstChs)
434	{
435	RTTestSubF(hTest, "Conv %uch %c%u to %uch %c%u", cSrcChs, fSrcSigned ? 'S' : 'U', cSrcBits,
436	cDstChs, fDstSigned ? 'S' : 'U', cDstBits);
437
438	PDMAUDIOPCMPROPS CfgSrc, CfgDst;
439	PDMAudioPropsInitEx(&CfgSrc, cSrcBits / 8, fSrcSigned, cSrcChs, 44100, g_fLittleEndian, cSrcBits == 64 /fRaw/);
440	PDMAudioPropsInitEx(&CfgDst, cDstBits / 8, fDstSigned, cDstChs, 44100, g_fLittleEndian, cDstBits == 64 /fRaw/);
441
442	void const * const pvSrcTestSamples = g_aTestSamples[cSrcBits / 8].apv[fSrcSigned];
443	void const * const pvDstTestSamples = g_aTestSamples[cDstBits / 8].apv[fDstSigned];
444	uint32_t const cMixBufFrames = RTRandU32Ex(128, 16384);
445	uint32_t const cIterations = RTRandU32Ex(256, 1536);
446	uint32_t const cbSrcBuf = PDMAudioPropsFramesToBytes(&CfgSrc, cMixBufFrames + 64);
447	uint8_t * const pbSrcBuf = (uint8_t *)RTMemAllocZ(cbSrcBuf);
448	uint32_t const cbDstBuf = PDMAudioPropsFramesToBytes(&CfgDst, cMixBufFrames + 64);
449	uint8_t * const pbDstBuf = (uint8_t *)RTMemAllocZ(cbDstBuf);
450	uint8_t * const pbDstExpect = (uint8_t *)RTMemAllocZ(cbDstBuf);
451	RTTESTI_CHECK_RETV(pbSrcBuf);
452	RTTESTI_CHECK_RETV(pbDstBuf);
453	RTTESTI_CHECK_RETV(pbDstExpect);
454
455	AUDIOMIXBUF MixBuf;
456	RTTESTI_CHECK_RC_RETV(AudioMixBufInit(&MixBuf, "FormatOutputConversion", &CfgSrc, cMixBufFrames), VINF_SUCCESS);
457	AUDIOMIXBUFWRITESTATE WriteState;
458	RTTESTI_CHECK_RC_RETV(AudioMixBufInitWriteState(&MixBuf, &WriteState, &CfgSrc), VINF_SUCCESS);
459	AUDIOMIXBUFWRITESTATE WriteStateIgnZero = WriteState; RT_NOREF(WriteStateIgnZero);
460	AUDIOMIXBUFPEEKSTATE PeekState;
461	RTTESTI_CHECK_RC_RETV(AudioMixBufInitPeekState(&MixBuf, &PeekState, &CfgDst), VINF_SUCCESS);
462
463	uint32_t iSrcTestSample = 0;
464	uint32_t iDstTestSample = 0;
465	//RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "cIterations=%u\n", cIterations);
466	for (uint32_t iIteration = 0; iIteration < cIterations; iIteration++)
467	{
468	/* Write some frames to the buffer. */
469	uint32_t const cSrcFramesToWrite = iIteration < 16 ? iIteration + 1
470	: AudioMixBufFree(&MixBuf) ? RTRandU32Ex(1, AudioMixBufFree(&MixBuf)) : 0;
471	if (cSrcFramesToWrite > 0)
472	{
473	uint32_t const cbSrcToWrite = PDMAudioPropsFramesToBytes(&CfgSrc, cSrcFramesToWrite);
474	uint32_t cFrames = RTRandU32();
475	switch (RTRandU32Ex(0, 3))
476	{
477	default:
478	iSrcTestSample = tstFillBuf(&CfgSrc, pvSrcTestSamples, iSrcTestSample, pbSrcBuf, cSrcFramesToWrite);
479	AudioMixBufWrite(&MixBuf, &WriteState, pbSrcBuf, cbSrcToWrite, 0 /offDstFrame/, cSrcFramesToWrite, &cFrames);
480	RTTESTI_CHECK(cFrames == cSrcFramesToWrite);
481	break;
482
483	case 1: /* zero & blend */
484	AudioMixBufSilence(&MixBuf, &WriteStateIgnZero, 0 /offFrame/, cSrcFramesToWrite);
485	iSrcTestSample = tstFillBuf(&CfgSrc, pvSrcTestSamples, iSrcTestSample, pbSrcBuf, cSrcFramesToWrite);
486	AudioMixBufBlend(&MixBuf, &WriteState, pbSrcBuf, cbSrcToWrite, 0 /offDstFrame/, cSrcFramesToWrite, &cFrames);
487	RTTESTI_CHECK(cFrames == cSrcFramesToWrite);
488	break;
489
490	case 2: /* blend same equal data twice */
491	{
492	AUDIOMIXBUFWRITESTATE WriteStateSame = WriteState;
493	iSrcTestSample = tstFillBuf(&CfgSrc, pvSrcTestSamples, iSrcTestSample, pbSrcBuf, cSrcFramesToWrite);
494	AudioMixBufWrite(&MixBuf, &WriteState, pbSrcBuf, cbSrcToWrite, 0 /offDstFrame/, cSrcFramesToWrite, &cFrames);
495	RTTESTI_CHECK(cFrames == cSrcFramesToWrite);
496	AudioMixBufBlend(&MixBuf, &WriteStateSame, pbSrcBuf, cbSrcToWrite, 0 /offDstFrame/, cSrcFramesToWrite, &cFrames);
497	RTTESTI_CHECK(cFrames == cSrcFramesToWrite);
498	break;
499	}
500	case 3: /* write & blend with zero */
501	{
502	AUDIOMIXBUFWRITESTATE WriteStateSame = WriteState;
503	iSrcTestSample = tstFillBuf(&CfgSrc, pvSrcTestSamples, iSrcTestSample, pbSrcBuf, cSrcFramesToWrite);
504	AudioMixBufWrite(&MixBuf, &WriteState, pbSrcBuf, cbSrcToWrite, 0 /offDstFrame/, cSrcFramesToWrite, &cFrames);
505	RTTESTI_CHECK(cFrames == cSrcFramesToWrite);
506	PDMAudioPropsClearBuffer(&CfgSrc, pbSrcBuf, cbSrcToWrite, cSrcFramesToWrite);
507	AudioMixBufBlend(&MixBuf, &WriteStateSame, pbSrcBuf, cbSrcToWrite, 0 /offDstFrame/, cSrcFramesToWrite, &cFrames);
508	RTTESTI_CHECK(cFrames == cSrcFramesToWrite);
509	break;
510	}
511	}
512	AudioMixBufCommit(&MixBuf, cSrcFramesToWrite);
513	}
514
515	/* Read some frames back. */
516	uint32_t const cUsed = AudioMixBufUsed(&MixBuf);
517	uint32_t const cDstFramesToRead = iIteration < 16 ? iIteration + 1 : iIteration + 5 >= cIterations ? cUsed
518	: cUsed ? RTRandU32Ex(1, cUsed) : 0;
519	if (cDstFramesToRead > 0)
520	{
521	uint32_t const cbDstToRead = PDMAudioPropsFramesToBytes(&CfgDst, cDstFramesToRead);
522	uint32_t cbRead = RTRandU32();
523	uint32_t cFrames = RTRandU32();
524	RTRandBytes(pbDstBuf, cbDstToRead);
525	AudioMixBufPeek(&MixBuf, 0 /offSrcFrame/, (iIteration & 3) != 2 ? cDstFramesToRead : cUsed, &cFrames,
526	&PeekState, pbDstBuf, (iIteration & 3) != 3 ? cbDstToRead : cbDstBuf, &cbRead);
527	RTTESTI_CHECK(cFrames == cDstFramesToRead);
528	RTTESTI_CHECK(cbRead == cbDstToRead);
529	AudioMixBufAdvance(&MixBuf, cFrames);
530
531	/* Verify if we can. */
532	if (PDMAudioPropsChannels(&CfgSrc) == PDMAudioPropsChannels(&CfgDst))
533	{
534	iDstTestSample = tstFillBuf(&CfgDst, pvDstTestSamples, iDstTestSample, pbDstExpect, cFrames);
535	if (memcmp(pbDstExpect, pbDstBuf, cbRead) == 0)
536	{ /* likely */ }
537	else
538	{
539	RTTestFailed(hTest,
540	"mismatch: %.*Rhxs\n"
541	"expected: %.*Rhxs\n"
542	"iIteration=%u cDstFramesToRead=%u cbRead=%#x\n",
543	RT_MIN(cbRead, 48), pbDstBuf,
544	RT_MIN(cbRead, 48), pbDstExpect,
545	iIteration, cDstFramesToRead, cbRead);
546	break;
547	}
548	}
549	}
550	}
551
552	AudioMixBufTerm(&MixBuf);
553	RTMemFree(pbSrcBuf);
554	RTMemFree(pbDstBuf);
555	RTMemFree(pbDstExpect);
556	}
557
558
559	#if 0 /** @todo rewrite to non-parent/child setup */
560	static void tstDownsampling(RTTEST hTest, uint32_t uFromHz, uint32_t uToHz)
561	{
562	RTTestSubF(hTest, "Downsampling %u to %u Hz (S16)", uFromHz, uToHz);
563
564	struct { int16_t l, r; }
565	aSrcFrames[4096],
566	aDstFrames[4096];
567
568	/* Parent (destination) buffer is xxxHz 2ch S16 */
569	uint32_t const cFramesParent = RTRandU32Ex(16, RT_ELEMENTS(aDstFrames));
570	PDMAUDIOPCMPROPS const CfgDst = PDMAUDIOPCMPROPS_INITIALIZER(2 /cbSample/, true /fSigned/, 2 /ch/, uToHz, false /fSwap/);
571	RTTESTI_CHECK(AudioHlpPcmPropsAreValid(&CfgDst));
572	AUDIOMIXBUF Parent;
573	RTTESTI_CHECK_RC_OK_RETV(AudioMixBufInit(&Parent, "ParentDownsampling", &CfgDst, cFramesParent));
574
575	/* Child (source) buffer is yyykHz 2ch S16 */
576	PDMAUDIOPCMPROPS const CfgSrc = PDMAUDIOPCMPROPS_INITIALIZER(2 /cbSample/, true /fSigned/, 2 /ch/, uFromHz, false /fSwap/);
577	RTTESTI_CHECK(AudioHlpPcmPropsAreValid(&CfgSrc));
578	uint32_t const cFramesChild = RTRandU32Ex(32, RT_ELEMENTS(aSrcFrames));
579	AUDIOMIXBUF Child;
580	RTTESTI_CHECK_RC_OK_RETV(AudioMixBufInit(&Child, "ChildDownsampling", &CfgSrc, cFramesChild));
581	RTTESTI_CHECK_RC_OK_RETV(AudioMixBufLinkTo(&Child, &Parent));
582
583	/*
584	* Test parameters.
585	*/
586	uint32_t const cMaxSrcFrames = RT_MIN(cFramesParent * uFromHz / uToHz - 1, cFramesChild);
587	uint32_t const cIterations = RTRandU32Ex(4, 128);
588	RTTestErrContext(hTest, "cFramesParent=%RU32 cFramesChild=%RU32 cMaxSrcFrames=%RU32 cIterations=%RU32",
589	cFramesParent, cFramesChild, cMaxSrcFrames, cIterations);
590	RTTestPrintf(hTest, RTTESTLVL_DEBUG, "cFramesParent=%RU32 cFramesChild=%RU32 cMaxSrcFrames=%RU32 cIterations=%RU32\n",
591	cFramesParent, cFramesChild, cMaxSrcFrames, cIterations);
592
593	/*
594	* We generate a simple "A" sine wave as input.
595	*/
596	uint32_t iSrcFrame = 0;
597	uint32_t iDstFrame = 0;
598	double rdFixed = 2.0 * M_PI * 440.0 /* A / / PDMAudioPropsHz(&CfgSrc); / Fixed sin() input. */
599	for (uint32_t i = 0; i < cIterations; i++)
600	{
601	RTTestPrintf(hTest, RTTESTLVL_DEBUG, "i=%RU32\n", i);
602
603	/*
604	* Generate source frames and write them.
605	*/
606	uint32_t const cSrcFrames = i < cIterations / 2
607	? RTRandU32Ex(2, cMaxSrcFrames) & ~(uint32_t)1
608	: RTRandU32Ex(1, cMaxSrcFrames - 1) \| 1;
609	for (uint32_t j = 0; j < cSrcFrames; j++, iSrcFrame++)
610	aSrcFrames[j].r = aSrcFrames[j].l = 32760 /Amplitude/ * sin(rdFixed * iSrcFrame);
611
612	uint32_t cSrcFramesWritten = UINT32_MAX / 2;
613	RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufWriteAt(&Child, 0, &aSrcFrames, cSrcFrames * sizeof(aSrcFrames[0]),
614	&cSrcFramesWritten));
615	RTTESTI_CHECK_MSG_BREAK(cSrcFrames == cSrcFramesWritten,
616	("cSrcFrames=%RU32 vs cSrcFramesWritten=%RU32\n", cSrcFrames, cSrcFramesWritten));
617
618	/*
619	* Mix them.
620	*/
621	uint32_t cSrcFramesMixed = UINT32_MAX / 2;
622	RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufMixToParent(&Child, cSrcFramesWritten, &cSrcFramesMixed));
623	RTTESTI_CHECK_MSG(AudioMixBufUsed(&Child) == 0, ("%RU32\n", AudioMixBufUsed(&Child)));
624	RTTESTI_CHECK_MSG_BREAK(cSrcFramesWritten == cSrcFramesMixed,
625	("cSrcFramesWritten=%RU32 cSrcFramesMixed=%RU32\n", cSrcFramesWritten, cSrcFramesMixed));
626	RTTESTI_CHECK_MSG_BREAK(AudioMixBufUsed(&Child) == 0, ("%RU32\n", AudioMixBufUsed(&Child)));
627
628	/*
629	* Read out the parent buffer.
630	*/
631	uint32_t cDstFrames = AudioMixBufUsed(&Parent);
632	while (cDstFrames > 0)
633	{
634	uint32_t cFramesRead = UINT32_MAX / 2;
635	RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufAcquireReadBlock(&Parent, aDstFrames, sizeof(aDstFrames), &cFramesRead));
636	RTTESTI_CHECK_MSG(cFramesRead > 0 && cFramesRead <= cDstFrames,
637	("cFramesRead=%RU32 cDstFrames=%RU32\n", cFramesRead, cDstFrames));
638
639	AudioMixBufReleaseReadBlock(&Parent, cFramesRead);
640	AudioMixBufFinish(&Parent, cFramesRead);
641
642	iDstFrame += cFramesRead;
643	cDstFrames -= cFramesRead;
644	RTTESTI_CHECK(AudioMixBufUsed(&Parent) == cDstFrames);
645	}
646	}
647
648	RTTESTI_CHECK(AudioMixBufUsed(&Parent) == 0);
649	RTTESTI_CHECK(AudioMixBufLive(&Child) == 0);
650	uint32_t const cDstMinExpect = (uint64_t)iSrcFrame * uToHz / uFromHz;
651	uint32_t const cDstMaxExpect = ((uint64_t)iSrcFrame * uToHz + uFromHz - 1) / uFromHz;
652	RTTESTI_CHECK_MSG(iDstFrame == cDstMinExpect \|\| iDstFrame == cDstMaxExpect,
653	("iSrcFrame=%#x -> %#x,%#x; iDstFrame=%#x\n", iSrcFrame, cDstMinExpect, cDstMaxExpect, iDstFrame));
654
655	AudioMixBufDestroy(&Parent);
656	AudioMixBufDestroy(&Child);
657	}
658	#endif
659
660
661	static void tstNewPeek(RTTEST hTest, uint32_t uFromHz, uint32_t uToHz)
662	{
663	RTTestSubF(hTest, "New peek %u to %u Hz (S16)", uFromHz, uToHz);
664
665	struct { int16_t l, r; }
666	aSrcFrames[4096],
667	aDstFrames[4096];
668
669	/* Mix buffer is uFromHz 2ch S16 */
670	uint32_t const cFrames = RTRandU32Ex(16, RT_ELEMENTS(aSrcFrames));
671	PDMAUDIOPCMPROPS const CfgSrc = PDMAUDIOPCMPROPS_INITIALIZER(2 /cbSample/, true /fSigned/, 2 /ch/, uFromHz, false /fSwap/);
672	RTTESTI_CHECK(AudioHlpPcmPropsAreValidAndSupported(&CfgSrc));
673	AUDIOMIXBUF MixBuf;
674	RTTESTI_CHECK_RC_OK_RETV(AudioMixBufInit(&MixBuf, "NewPeekMixBuf", &CfgSrc, cFrames));
675
676	/* Write state (source). */
677	AUDIOMIXBUFWRITESTATE WriteState;
678	RTTESTI_CHECK_RC_OK_RETV(AudioMixBufInitWriteState(&MixBuf, &WriteState, &CfgSrc));
679
680	/* Peek state (destination) is uToHz 2ch S16 */
681	PDMAUDIOPCMPROPS const CfgDst = PDMAUDIOPCMPROPS_INITIALIZER(2 /cbSample/, true /fSigned/, 2 /ch/, uToHz, false /fSwap/);
682	RTTESTI_CHECK(AudioHlpPcmPropsAreValidAndSupported(&CfgDst));
683	AUDIOMIXBUFPEEKSTATE PeekState;
684	RTTESTI_CHECK_RC_OK_RETV(AudioMixBufInitPeekState(&MixBuf, &PeekState, &CfgDst));
685
686	/*
687	* Test parameters.
688	*/
689	uint32_t const cMaxSrcFrames = RT_MIN(cFrames * uFromHz / uToHz - 1, cFrames);
690	uint32_t const cIterations = RTRandU32Ex(64, 1024);
691	RTTestErrContext(hTest, "cFrames=%RU32 cMaxSrcFrames=%RU32 cIterations=%RU32", cFrames, cMaxSrcFrames, cIterations);
692	RTTestPrintf(hTest, RTTESTLVL_DEBUG, "cFrames=%RU32 cMaxSrcFrames=%RU32 cIterations=%RU32\n",
693	cFrames, cMaxSrcFrames, cIterations);
694
695	/*
696	* We generate a simple "A" sine wave as input.
697	*/
698	uint32_t iSrcFrame = 0;
699	uint32_t iDstFrame = 0;
700	double rdFixed = 2.0 * M_PI * 440.0 /* A / / PDMAudioPropsHz(&CfgSrc); / Fixed sin() input. */
701	for (uint32_t i = 0; i < cIterations; i++)
702	{
703	RTTestPrintf(hTest, RTTESTLVL_DEBUG, "i=%RU32\n", i);
704
705	/*
706	* Generate source frames and write them.
707	*/
708	uint32_t const cSrcFrames = i < cIterations / 2
709	? RTRandU32Ex(2, cMaxSrcFrames) & ~(uint32_t)1
710	: RTRandU32Ex(1, cMaxSrcFrames - 1) \| 1;
711	for (uint32_t j = 0; j < cSrcFrames; j++, iSrcFrame++)
712	aSrcFrames[j].r = aSrcFrames[j].l = 32760 /Amplitude/ * sin(rdFixed * iSrcFrame);
713
714	uint32_t cSrcFramesWritten = UINT32_MAX / 2;
715	AudioMixBufWrite(&MixBuf, &WriteState, &aSrcFrames[0], cSrcFrames * sizeof(aSrcFrames[0]),
716	0 /offDstFrame/, cSrcFrames, &cSrcFramesWritten);
717	RTTESTI_CHECK_MSG_BREAK(cSrcFrames == cSrcFramesWritten,
718	("cSrcFrames=%RU32 vs cSrcFramesWritten=%RU32 cLiveFrames=%RU32\n",
719	cSrcFrames, cSrcFramesWritten, AudioMixBufUsed(&MixBuf)));
720	AudioMixBufCommit(&MixBuf, cSrcFrames);
721
722	/*
723	* Read out all the frames using the peek function.
724	*/
725	uint32_t offSrcFrame = 0;
726	while (offSrcFrame < cSrcFramesWritten)
727	{
728	uint32_t cSrcFramesToRead = cSrcFramesWritten - offSrcFrame;
729	uint32_t cTmp = (uint64_t)cSrcFramesToRead * uToHz / uFromHz;
730	if (cTmp + 32 >= RT_ELEMENTS(aDstFrames))
731	cSrcFramesToRead = ((uint64_t)RT_ELEMENTS(aDstFrames) - 32) * uFromHz / uToHz; /* kludge */
732
733	uint32_t cSrcFramesPeeked = UINT32_MAX / 4;
734	uint32_t cbDstPeeked = UINT32_MAX / 2;
735	RTRandBytes(aDstFrames, sizeof(aDstFrames));
736	AudioMixBufPeek(&MixBuf, offSrcFrame, cSrcFramesToRead, &cSrcFramesPeeked,
737	&PeekState, aDstFrames, sizeof(aDstFrames), &cbDstPeeked);
738	uint32_t cDstFramesPeeked = PDMAudioPropsBytesToFrames(&CfgDst, cbDstPeeked);
739	RTTESTI_CHECK(cbDstPeeked > 0 \|\| cSrcFramesPeeked > 0);
740
741	if (uFromHz == uToHz)
742	{
743	for (uint32_t iDst = 0; iDst < cDstFramesPeeked; iDst++)
744	if (memcmp(&aDstFrames[iDst], &aSrcFrames[offSrcFrame + iDst], sizeof(aSrcFrames[0])) != 0)
745	RTTestFailed(hTest, "Frame #%u differs: %#x / %#x, expected %#x / %#x\n", iDstFrame + iDst,
746	aDstFrames[iDst].l, aDstFrames[iDst].r,
747	aSrcFrames[iDst + offSrcFrame].l, aSrcFrames[iDst + offSrcFrame].r);
748	}
749
750	offSrcFrame += cSrcFramesPeeked;
751	iDstFrame += cDstFramesPeeked;
752	}
753
754	/*
755	* Then advance.
756	*/
757	AudioMixBufAdvance(&MixBuf, cSrcFrames);
758	RTTESTI_CHECK(AudioMixBufUsed(&MixBuf) == 0);
759	}
760
761	/** @todo this is a bit lax... */
762	uint32_t const cDstMinExpect = ((uint64_t)iSrcFrame * uToHz - uFromHz - 1) / uFromHz;
763	uint32_t const cDstMaxExpect = ((uint64_t)iSrcFrame * uToHz + uFromHz - 1) / uFromHz;
764	RTTESTI_CHECK_MSG(iDstFrame >= cDstMinExpect && iDstFrame <= cDstMaxExpect,
765	("iSrcFrame=%#x -> %#x..%#x; iDstFrame=%#x (delta %d)\n",
766	iSrcFrame, cDstMinExpect, cDstMaxExpect, iDstFrame, (cDstMinExpect + cDstMaxExpect) / 2 - iDstFrame));
767
768	AudioMixBufTerm(&MixBuf);
769	}
770
771	/* Test volume control. */
772	static void tstVolume(RTTEST hTest)
773	{
774	RTTestSub(hTest, "Volume control (44.1kHz S16 2ch)");
775	uint32_t const cBufSize = 256;
776
777	/*
778	* Configure a mixbuf where we read and write 44.1kHz S16 2ch.
779	*/
780	PDMAUDIOPCMPROPS const Cfg = PDMAUDIOPCMPROPS_INITIALIZER(
781	2, /* Bytes */
782	true, /* Signed */
783	2, /* Channels */
784	44100, /* Hz */
785	false /* Swap Endian */
786	);
787	AUDIOMIXBUF MixBuf;
788	RTTESTI_CHECK_RC_RETV(AudioMixBufInit(&MixBuf, "Volume", &Cfg, cBufSize), VINF_SUCCESS);
789
790	AUDIOMIXBUFWRITESTATE WriteState;
791	RTTESTI_CHECK_RC_RETV(AudioMixBufInitWriteState(&MixBuf, &WriteState, &Cfg), VINF_SUCCESS);
792
793	AUDIOMIXBUFPEEKSTATE PeekState;
794	RTTESTI_CHECK_RC_RETV(AudioMixBufInitPeekState(&MixBuf, &PeekState, &Cfg), VINF_SUCCESS);
795
796	/*
797	* A few 16-bit signed test samples.
798	*/
799	static int16_t const s_aFrames16S[16] =
800	{
801	INT16_MIN, INT16_MIN + 1, -128, -64, -4, -1, 0, 1,
802	2, 255, 256, INT16_MAX / 2, INT16_MAX - 2, INT16_MAX - 1, INT16_MAX, 0,
803	};
804
805	/*
806	* 1) Full volume/0dB attenuation (255).
807	*/
808	PDMAUDIOVOLUME Vol = PDMAUDIOVOLUME_INITIALIZER_MAX;
809	AudioMixBufSetVolume(&MixBuf, &Vol);
810
811	/* Write all the test frames to the mixer buffer: */
812	uint32_t cFramesWritten;
813	AudioMixBufWrite(&MixBuf, &WriteState, &s_aFrames16S[0], sizeof(s_aFrames16S), 0 /offDstFrame/, cBufSize, &cFramesWritten);
814	RTTESTI_CHECK(cFramesWritten == RT_ELEMENTS(s_aFrames16S) / 2);
815	AudioMixBufCommit(&MixBuf, cFramesWritten);
816
817	/* Read them back. We should get them back just like we wrote them. */
818	uint16_t au16Buf[cBufSize * 2];
819	uint32_t cFramesPeeked;
820	uint32_t cbPeeked;
821	AudioMixBufPeek(&MixBuf, 0 /offSrcFrame/, cFramesWritten, &cFramesPeeked, &PeekState, au16Buf, sizeof(au16Buf), &cbPeeked);
822	RTTESTI_CHECK(cFramesPeeked == cFramesWritten);
823	RTTESTI_CHECK(cbPeeked == PDMAudioPropsFramesToBytes(&Cfg, cFramesPeeked));
824	AudioMixBufAdvance(&MixBuf, cFramesPeeked);
825
826	/* Check that at 0dB the frames came out unharmed. */
827	if (memcmp(au16Buf, s_aFrames16S, sizeof(s_aFrames16S)) != 0)
828	RTTestFailed(hTest,
829	"0dB test failed\n"
830	"mismatch: %.*Rhxs\n"
831	"expected: %.*Rhxs\n",
832	sizeof(s_aFrames16S), au16Buf, sizeof(s_aFrames16S), s_aFrames16S);
833
834	/*
835	* 2) Half volume/-6dB attenuation (16 steps down).
836	*/
837	PDMAudioVolumeInitFromStereo(&Vol, false, 255 - 16, 255 - 16);
838	AudioMixBufSetVolume(&MixBuf, &Vol);
839
840	/* Write all the test frames to the mixer buffer: */
841	AudioMixBufWrite(&MixBuf, &WriteState, &s_aFrames16S[0], sizeof(s_aFrames16S), 0 /offDstFrame/, cBufSize, &cFramesWritten);
842	RTTESTI_CHECK(cFramesWritten == RT_ELEMENTS(s_aFrames16S) / 2);
843	AudioMixBufCommit(&MixBuf, cFramesWritten);
844
845	/* Read them back. We should get them back just like we wrote them. */
846	AudioMixBufPeek(&MixBuf, 0 /offSrcFrame/, cFramesWritten, &cFramesPeeked, &PeekState, au16Buf, sizeof(au16Buf), &cbPeeked);
847	RTTESTI_CHECK(cFramesPeeked == cFramesWritten);
848	RTTESTI_CHECK(cbPeeked == PDMAudioPropsFramesToBytes(&Cfg, cFramesPeeked));
849	AudioMixBufAdvance(&MixBuf, cFramesPeeked);
850
851	/* Check that at -6dB the sample values are halved. */
852	int16_t ai16Expect[sizeof(s_aFrames16S) / 2];
853	memcpy(ai16Expect, s_aFrames16S, sizeof(ai16Expect));
854	for (uintptr_t i = 0; i < RT_ELEMENTS(ai16Expect); i++)
855	ai16Expect[i] >>= 1; /* /= 2 - not the same for signed numbers; */
856	if (memcmp(au16Buf, ai16Expect, sizeof(ai16Expect)) != 0)
857	RTTestFailed(hTest,
858	"-6dB test failed\n"
859	"mismatch: %.*Rhxs\n"
860	"expected: %.*Rhxs\n"
861	"wrote: %.*Rhxs\n",
862	sizeof(ai16Expect), au16Buf, sizeof(ai16Expect), ai16Expect, sizeof(s_aFrames16S), s_aFrames16S);
863
864	AudioMixBufTerm(&MixBuf);
865	}
866
867
868	int main(int argc, char **argv)
869	{
870	RTR3InitExe(argc, &argv, 0);
871
872	/*
873	* Initialize IPRT and create the test.
874	*/
875	RTTEST hTest;
876	int rc = RTTestInitAndCreate("tstAudioMixBuffer", &hTest);
877	if (rc)
878	return rc;
879	RTTestBanner(hTest);
880
881	tstBasics(hTest);
882	tstSimple(hTest);
883
884	/* Run tstConversion for all combinations we have test data. */
885	for (unsigned iSrc = 0; iSrc < RT_ELEMENTS(g_aTestSamples); iSrc++)
886	{
887	for (unsigned iSrcSigned = 0; iSrcSigned < RT_ELEMENTS(g_aTestSamples[0].apv); iSrcSigned++)
888	if (g_aTestSamples[iSrc].apv[iSrcSigned])
889	for (unsigned cSrcChs = 1; cSrcChs <= 2; cSrcChs++)
890	for (unsigned iDst = 0; iDst < RT_ELEMENTS(g_aTestSamples); iDst++)
891	for (unsigned iDstSigned = 0; iDstSigned < RT_ELEMENTS(g_aTestSamples[0].apv); iDstSigned++)
892	if (g_aTestSamples[iDst].apv[iDstSigned])
893	for (unsigned cDstChs = 1; cDstChs <= 2; cDstChs++)
894	tstConversion(hTest, iSrc * 8, iSrcSigned == 1, cSrcChs,
895	/->/ iDst * 8, iDstSigned == 1, cDstChs);
896	}
897
898	#if 0 /** @todo rewrite to non-parent/child setup */
899	tstDownsampling(hTest, 44100, 22050);
900	tstDownsampling(hTest, 48000, 44100);
901	tstDownsampling(hTest, 48000, 22050);
902	tstDownsampling(hTest, 48000, 11000);
903	#endif
904	tstNewPeek(hTest, 48000, 48000);
905	tstNewPeek(hTest, 48000, 11000);
906	tstNewPeek(hTest, 48000, 44100);
907	tstNewPeek(hTest, 44100, 22050);
908	tstNewPeek(hTest, 44100, 11000);
909	//tstNewPeek(hTest, 11000, 48000);
910	//tstNewPeek(hTest, 22050, 44100);
911
912	tstVolume(hTest);
913
914	/*
915	* Summary
916	*/
917	return RTTestSummaryAndDestroy(hTest);
918	}

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

source: vbox/trunk/src/VBox/Devices/Audio/testcase/tstAudioMixBuffer.cpp

Download in other formats: