diff options
Diffstat (limited to 'src/VBox/Devices/Audio/testcase/tstAudioMixBuffer.cpp')
| -rw-r--r-- | src/VBox/Devices/Audio/testcase/tstAudioMixBuffer.cpp | 916 |
1 files changed, 916 insertions, 0 deletions
diff --git a/src/VBox/Devices/Audio/testcase/tstAudioMixBuffer.cpp b/src/VBox/Devices/Audio/testcase/tstAudioMixBuffer.cpp new file mode 100644 index 00000000..45d263b1 --- /dev/null +++ b/src/VBox/Devices/Audio/testcase/tstAudioMixBuffer.cpp @@ -0,0 +1,916 @@ +/* $Id: tstAudioMixBuffer.cpp $ */ +/** @file + * Audio testcase - Mixing buffer. + */ + +/* + * Copyright (C) 2014-2022 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * SPDX-License-Identifier: GPL-3.0-only + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <iprt/errcore.h> +#include <iprt/initterm.h> +#include <iprt/mem.h> +#include <iprt/rand.h> +#include <iprt/stream.h> +#include <iprt/string.h> +#include <iprt/test.h> + +#include <VBox/vmm/pdm.h> +#include <VBox/vmm/pdmaudioinline.h> + +#include "../AudioMixBuffer.h" +#include "../AudioHlp.h" + +#define _USE_MATH_DEFINES +#include <math.h> /* sin, M_PI */ + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +#ifdef RT_LITTLE_ENDIAN +bool const g_fLittleEndian = true; +#else +bool const g_fLittleEndian = false; +#endif + + +static void tstBasics(RTTEST hTest) +{ + RTTestSub(hTest, "Basics"); + + const PDMAUDIOPCMPROPS Cfg441StereoS16 = PDMAUDIOPCMPROPS_INITIALIZER( + /* a_cb: */ 2, + /* a_fSigned: */ true, + /* a_cChannels: */ 2, + /* a_uHz: */ 44100, + /* a_fSwapEndian: */ false + ); + const PDMAUDIOPCMPROPS Cfg441StereoU16 = PDMAUDIOPCMPROPS_INITIALIZER( + /* a_cb: */ 2, + /* a_fSigned: */ false, + /* a_cChannels: */ 2, + /* a_uHz: */ 44100, + /* a_fSwapEndian: */ false + ); + const PDMAUDIOPCMPROPS Cfg441StereoU32 = PDMAUDIOPCMPROPS_INITIALIZER( + /* a_cb: */ 4, + /* a_fSigned: */ false, + /* a_cChannels: */ 2, + /* a_uHz: */ 44100, + /* a_fSwapEndian: */ false + ); + + RTTESTI_CHECK(PDMAudioPropsGetBitrate(&Cfg441StereoS16) == 44100*4*8); + RTTESTI_CHECK(PDMAudioPropsGetBitrate(&Cfg441StereoU16) == 44100*4*8); + RTTESTI_CHECK(PDMAudioPropsGetBitrate(&Cfg441StereoU32) == 44100*8*8); + + RTTESTI_CHECK(AudioHlpPcmPropsAreValidAndSupported(&Cfg441StereoS16)); + RTTESTI_CHECK(AudioHlpPcmPropsAreValidAndSupported(&Cfg441StereoU16)); + RTTESTI_CHECK(AudioHlpPcmPropsAreValidAndSupported(&Cfg441StereoU32)); + + + RTTESTI_CHECK_MSG(PDMAUDIOPCMPROPS_F2B(&Cfg441StereoS16, 1) == 4, + ("got %x, expected 4\n", PDMAUDIOPCMPROPS_F2B(&Cfg441StereoS16, 1))); + RTTESTI_CHECK_MSG(PDMAUDIOPCMPROPS_F2B(&Cfg441StereoU16, 1) == 4, + ("got %x, expected 4\n", PDMAUDIOPCMPROPS_F2B(&Cfg441StereoU16, 1))); + RTTESTI_CHECK_MSG(PDMAUDIOPCMPROPS_F2B(&Cfg441StereoU32, 1) == 8, + ("got %x, expected 4\n", PDMAUDIOPCMPROPS_F2B(&Cfg441StereoU32, 1))); + + RTTESTI_CHECK_MSG(PDMAudioPropsBytesPerFrame(&Cfg441StereoS16) == 4, + ("got %x, expected 4\n", PDMAudioPropsBytesPerFrame(&Cfg441StereoS16))); + RTTESTI_CHECK_MSG(PDMAudioPropsBytesPerFrame(&Cfg441StereoU16) == 4, + ("got %x, expected 4\n", PDMAudioPropsBytesPerFrame(&Cfg441StereoU16))); + RTTESTI_CHECK_MSG(PDMAudioPropsBytesPerFrame(&Cfg441StereoU32) == 8, + ("got %x, expected 4\n", PDMAudioPropsBytesPerFrame(&Cfg441StereoU32))); + + uint32_t u32; + for (uint32_t i = 0; i < 256; i += 8) + { + RTTESTI_CHECK(PDMAudioPropsIsSizeAligned(&Cfg441StereoU32, i) == true); + for (uint32_t j = 1; j < 8; j++) + RTTESTI_CHECK(PDMAudioPropsIsSizeAligned(&Cfg441StereoU32, i + j) == false); + for (uint32_t j = 0; j < 8; j++) + RTTESTI_CHECK(PDMAudioPropsFloorBytesToFrame(&Cfg441StereoU32, i + j) == i); + } + for (uint32_t i = 0; i < 4096; i += 4) + { + RTTESTI_CHECK(PDMAudioPropsIsSizeAligned(&Cfg441StereoS16, i) == true); + for (uint32_t j = 1; j < 4; j++) + RTTESTI_CHECK(PDMAudioPropsIsSizeAligned(&Cfg441StereoS16, i + j) == false); + for (uint32_t j = 0; j < 4; j++) + RTTESTI_CHECK(PDMAudioPropsFloorBytesToFrame(&Cfg441StereoS16, i + j) == i); + } + + RTTESTI_CHECK_MSG((u32 = PDMAudioPropsFramesToBytes(&Cfg441StereoS16, 44100)) == 44100 * 2 * 2, + ("cb=%RU32\n", u32)); + RTTESTI_CHECK_MSG((u32 = PDMAudioPropsFramesToBytes(&Cfg441StereoS16, 2)) == 2 * 2 * 2, + ("cb=%RU32\n", u32)); + RTTESTI_CHECK_MSG((u32 = PDMAudioPropsFramesToBytes(&Cfg441StereoS16, 1)) == 4, + ("cb=%RU32\n", u32)); + RTTESTI_CHECK_MSG((u32 = PDMAudioPropsFramesToBytes(&Cfg441StereoU16, 1)) == 4, + ("cb=%RU32\n", u32)); + RTTESTI_CHECK_MSG((u32 = PDMAudioPropsFramesToBytes(&Cfg441StereoU32, 1)) == 8, + ("cb=%RU32\n", u32)); + + RTTESTI_CHECK_MSG((u32 = PDMAudioPropsBytesToFrames(&Cfg441StereoS16, 4)) == 1, ("cb=%RU32\n", u32)); + RTTESTI_CHECK_MSG((u32 = PDMAudioPropsBytesToFrames(&Cfg441StereoU16, 4)) == 1, ("cb=%RU32\n", u32)); + RTTESTI_CHECK_MSG((u32 = PDMAudioPropsBytesToFrames(&Cfg441StereoU32, 8)) == 1, ("cb=%RU32\n", u32)); + + uint64_t u64; + RTTESTI_CHECK_MSG((u64 = PDMAudioPropsBytesToNano(&Cfg441StereoS16, 44100 * 2 * 2)) == RT_NS_1SEC, + ("ns=%RU64\n", u64)); + RTTESTI_CHECK_MSG((u64 = PDMAudioPropsBytesToMicro(&Cfg441StereoS16, 44100 * 2 * 2)) == RT_US_1SEC, + ("us=%RU64\n", u64)); + RTTESTI_CHECK_MSG((u64 = PDMAudioPropsBytesToMilli(&Cfg441StereoS16, 44100 * 2 * 2)) == RT_MS_1SEC, + ("ms=%RU64\n", u64)); + + RTTESTI_CHECK_MSG((u64 = PDMAudioPropsFramesToNano(&Cfg441StereoS16, 44100)) == RT_NS_1SEC, ("ns=%RU64\n", u64)); + RTTESTI_CHECK_MSG((u64 = PDMAudioPropsFramesToNano(&Cfg441StereoS16, 1)) == 22675, ("ns=%RU64\n", u64)); + RTTESTI_CHECK_MSG((u64 = PDMAudioPropsFramesToNano(&Cfg441StereoS16, 31)) == 702947, ("ns=%RU64\n", u64)); + RTTESTI_CHECK_MSG((u64 = PDMAudioPropsFramesToNano(&Cfg441StereoS16, 255)) == 5782312, ("ns=%RU64\n", u64)); + //RTTESTI_CHECK_MSG((u64 = DrvAudioHlpFramesToMicro(&Cfg441StereoS16, 44100)) == RT_US_1SEC, + // ("us=%RU64\n", u64)); + RTTESTI_CHECK_MSG((u64 = PDMAudioPropsFramesToMilli(&Cfg441StereoS16, 44100)) == RT_MS_1SEC, ("ms=%RU64\n", u64)); + RTTESTI_CHECK_MSG((u64 = PDMAudioPropsFramesToMilli(&Cfg441StereoS16, 255)) == 5, ("ms=%RU64\n", u64)); + + RTTESTI_CHECK_MSG((u32 = PDMAudioPropsNanoToFrames(&Cfg441StereoS16, RT_NS_1SEC)) == 44100, ("cb=%RU32\n", u32)); + RTTESTI_CHECK_MSG((u32 = PDMAudioPropsNanoToFrames(&Cfg441StereoS16, 215876)) == 10, ("cb=%RU32\n", u32)); + RTTESTI_CHECK_MSG((u32 = PDMAudioPropsMilliToFrames(&Cfg441StereoS16, RT_MS_1SEC)) == 44100, ("cb=%RU32\n", u32)); + RTTESTI_CHECK_MSG((u32 = PDMAudioPropsMilliToFrames(&Cfg441StereoU32, 6)) == 265, ("cb=%RU32\n", u32)); + + RTTESTI_CHECK_MSG((u32 = PDMAudioPropsNanoToBytes(&Cfg441StereoS16, RT_NS_1SEC)) == 44100*2*2, ("cb=%RU32\n", u32)); + RTTESTI_CHECK_MSG((u32 = PDMAudioPropsNanoToBytes(&Cfg441StereoS16, 702947)) == 31*2*2, ("cb=%RU32\n", u32)); + RTTESTI_CHECK_MSG((u32 = PDMAudioPropsMilliToBytes(&Cfg441StereoS16, RT_MS_1SEC)) == 44100*2*2, ("cb=%RU32\n", u32)); + RTTESTI_CHECK_MSG((u32 = PDMAudioPropsMilliToBytes(&Cfg441StereoS16, 5)) == 884, ("cb=%RU32\n", u32)); + + /* DrvAudioHlpClearBuf: */ + uint8_t *pbPage; + int rc = RTTestGuardedAlloc(hTest, HOST_PAGE_SIZE, 0, false /*fHead*/, (void **)&pbPage); + RTTESTI_CHECK_RC_OK_RETV(rc); + + memset(pbPage, 0x42, HOST_PAGE_SIZE); + PDMAudioPropsClearBuffer(&Cfg441StereoS16, pbPage, HOST_PAGE_SIZE, HOST_PAGE_SIZE / 4); + RTTESTI_CHECK(ASMMemIsZero(pbPage, HOST_PAGE_SIZE)); + + memset(pbPage, 0x42, HOST_PAGE_SIZE); + PDMAudioPropsClearBuffer(&Cfg441StereoU16, pbPage, HOST_PAGE_SIZE, HOST_PAGE_SIZE / 4); + for (uint32_t off = 0; off < HOST_PAGE_SIZE; off += 2) + RTTESTI_CHECK_MSG(pbPage[off] == 0 && pbPage[off + 1] == 0x80, ("off=%#x: %#x %x\n", off, pbPage[off], pbPage[off + 1])); + + memset(pbPage, 0x42, HOST_PAGE_SIZE); + PDMAudioPropsClearBuffer(&Cfg441StereoU32, pbPage, HOST_PAGE_SIZE, HOST_PAGE_SIZE / 8); + for (uint32_t off = 0; off < HOST_PAGE_SIZE; off += 4) + RTTESTI_CHECK(pbPage[off] == 0 && pbPage[off + 1] == 0 && pbPage[off + 2] == 0 && pbPage[off + 3] == 0x80); + + + RTTestDisableAssertions(hTest); + memset(pbPage, 0x42, HOST_PAGE_SIZE); + PDMAudioPropsClearBuffer(&Cfg441StereoS16, pbPage, HOST_PAGE_SIZE, HOST_PAGE_SIZE); /* should adjust down the frame count. */ + RTTESTI_CHECK(ASMMemIsZero(pbPage, HOST_PAGE_SIZE)); + + memset(pbPage, 0x42, HOST_PAGE_SIZE); + PDMAudioPropsClearBuffer(&Cfg441StereoU16, pbPage, HOST_PAGE_SIZE, HOST_PAGE_SIZE); /* should adjust down the frame count. */ + for (uint32_t off = 0; off < HOST_PAGE_SIZE; off += 2) + RTTESTI_CHECK_MSG(pbPage[off] == 0 && pbPage[off + 1] == 0x80, ("off=%#x: %#x %x\n", off, pbPage[off], pbPage[off + 1])); + + memset(pbPage, 0x42, HOST_PAGE_SIZE); + PDMAudioPropsClearBuffer(&Cfg441StereoU32, pbPage, HOST_PAGE_SIZE, HOST_PAGE_SIZE); /* should adjust down the frame count. */ + for (uint32_t off = 0; off < HOST_PAGE_SIZE; off += 4) + RTTESTI_CHECK(pbPage[off] == 0 && pbPage[off + 1] == 0 && pbPage[off + 2] == 0 && pbPage[off + 3] == 0x80); + RTTestRestoreAssertions(hTest); + + RTTestGuardedFree(hTest, pbPage); +} + + +static void tstSimple(RTTEST hTest) +{ + RTTestSub(hTest, "Simple"); + + /* 44100Hz, 2 Channels, S16 */ + PDMAUDIOPCMPROPS config = PDMAUDIOPCMPROPS_INITIALIZER( + 2, /* Bytes */ + true, /* Signed */ + 2, /* Channels */ + 44100, /* Hz */ + false /* Swap Endian */ + ); + + RTTESTI_CHECK(AudioHlpPcmPropsAreValidAndSupported(&config)); + + uint32_t cBufSize = _1K; + + /* + * General stuff. + */ + AUDIOMIXBUF mb; + RTTESTI_CHECK_RC_OK_RETV(AudioMixBufInit(&mb, "Single", &config, cBufSize)); + RTTESTI_CHECK(AudioMixBufSize(&mb) == cBufSize); + RTTESTI_CHECK(AUDIOMIXBUF_B2F(&mb, AudioMixBufSizeBytes(&mb)) == cBufSize); + RTTESTI_CHECK(AUDIOMIXBUF_F2B(&mb, AudioMixBufSize(&mb)) == AudioMixBufSizeBytes(&mb)); + RTTESTI_CHECK(AudioMixBufFree(&mb) == cBufSize); + RTTESTI_CHECK(AUDIOMIXBUF_F2B(&mb, AudioMixBufFree(&mb)) == AudioMixBufFreeBytes(&mb)); + + AUDIOMIXBUFWRITESTATE WriteState; + RTTESTI_CHECK_RC(AudioMixBufInitWriteState(&mb, &WriteState, &config), VINF_SUCCESS); + + AUDIOMIXBUFPEEKSTATE PeekState; + RTTESTI_CHECK_RC(AudioMixBufInitPeekState(&mb, &PeekState, &config), VINF_SUCCESS); + + /* + * A few writes (used to be the weird absolute writes). + */ + uint32_t cFramesRead = 0, cFramesWritten = 0, cFramesWrittenAbs = 0; + int16_t aFrames16[2] = { 0xAA, 0xBB }; + int32_t aFrames32[2] = { 0xCC, 0xDD }; + + RTTESTI_CHECK(AudioMixBufUsed(&mb) == 0); + + AudioMixBufWrite(&mb, &WriteState, &aFrames16, sizeof(aFrames16), 0 /*offDstFrame*/, cBufSize / 4, &cFramesWritten); + RTTESTI_CHECK(cFramesWritten == 1 /* Frames */); + RTTESTI_CHECK(AudioMixBufUsed(&mb) == 0); + AudioMixBufCommit(&mb, cFramesWritten); + RTTESTI_CHECK(AudioMixBufUsed(&mb) == 1); + RTTESTI_CHECK(AudioMixBufReadPos(&mb) == 0); + RTTESTI_CHECK(AudioMixBufWritePos(&mb) == 1); + + AudioMixBufWrite(&mb, &WriteState, &aFrames32, sizeof(aFrames32), 0 /*offDstFrame*/, cBufSize / 4, &cFramesWritten); + RTTESTI_CHECK(cFramesWritten == 2 /* Frames */); + AudioMixBufCommit(&mb, cFramesWritten); + RTTESTI_CHECK(AudioMixBufUsed(&mb) == 3); + RTTESTI_CHECK(AudioMixBufReadPos(&mb) == 0); + RTTESTI_CHECK(AudioMixBufWritePos(&mb) == 3); + + /* Pretend we read the frames.*/ + AudioMixBufAdvance(&mb, 3); + RTTESTI_CHECK(AudioMixBufUsed(&mb) == 0); + RTTESTI_CHECK(AudioMixBufReadPos(&mb) == 3); + RTTESTI_CHECK(AudioMixBufWritePos(&mb) == 3); + + /* Fill up the buffer completely and check wraps. */ + + uint32_t cbSamples = PDMAudioPropsFramesToBytes(&config, cBufSize); + uint16_t *paSamples = (uint16_t *)RTMemAlloc(cbSamples); + RTTESTI_CHECK_RETV(paSamples); + AudioMixBufWrite(&mb, &WriteState, paSamples, cbSamples, 0 /*offDstFrame*/, cBufSize, &cFramesWritten); + RTTESTI_CHECK(cFramesWritten == cBufSize); + AudioMixBufCommit(&mb, cFramesWritten); + RTTESTI_CHECK(AudioMixBufUsed(&mb) == cBufSize); + RTTESTI_CHECK(AudioMixBufReadPos(&mb) == 3); + RTTESTI_CHECK(AudioMixBufWritePos(&mb) == 3); + RTMemFree(paSamples); + cbSamples = 0; + + /* + * Writes and reads (used to be circular). + */ + AudioMixBufDrop(&mb); + + cFramesWrittenAbs = AudioMixBufUsed(&mb); + + uint32_t cToWrite = AudioMixBufSize(&mb) - cFramesWrittenAbs - 1; /* -1 as padding plus -2 frames for above. */ + for (uint32_t i = 0; i < cToWrite; i++) + { + AudioMixBufWrite(&mb, &WriteState, &aFrames16[0], sizeof(aFrames16), 0 /*offDstFrame*/, 1, &cFramesWritten); + RTTESTI_CHECK(cFramesWritten == 1); + AudioMixBufCommit(&mb, cFramesWritten); + } + RTTESTI_CHECK(!AudioMixBufIsEmpty(&mb)); + RTTESTI_CHECK(AudioMixBufFree(&mb) == 1); + RTTESTI_CHECK(AudioMixBufFreeBytes(&mb) == AUDIOMIXBUF_F2B(&mb, 1U)); + RTTESTI_CHECK(AudioMixBufUsed(&mb) == cToWrite + cFramesWrittenAbs /* + last absolute write */); + + AudioMixBufWrite(&mb, &WriteState, &aFrames16[0], sizeof(aFrames16), 0 /*offDstFrame*/, 1, &cFramesWritten); + RTTESTI_CHECK(cFramesWritten == 1); + AudioMixBufCommit(&mb, cFramesWritten); + RTTESTI_CHECK(AudioMixBufFree(&mb) == 0); + RTTESTI_CHECK(AudioMixBufFreeBytes(&mb) == AUDIOMIXBUF_F2B(&mb, 0U)); + RTTESTI_CHECK(AudioMixBufUsed(&mb) == cBufSize); + + /* Reads. */ + RTTESTI_CHECK(AudioMixBufReadPos(&mb) == 0); + uint32_t cbRead; + uint16_t aFrames16Buf[RT_ELEMENTS(aFrames16)]; + uint32_t cToRead = AudioMixBufSize(&mb) - cFramesWrittenAbs - 1; + for (uint32_t i = 0; i < cToRead; i++) + { + AudioMixBufPeek(&mb, 0 /*offSrcFrame*/, 1, &cFramesRead, &PeekState, aFrames16Buf, sizeof(aFrames16Buf), &cbRead); + RTTESTI_CHECK(cFramesRead == 1); + RTTESTI_CHECK(cbRead == sizeof(aFrames16Buf)); + AudioMixBufAdvance(&mb, cFramesRead); + RTTESTI_CHECK(AudioMixBufReadPos(&mb) == i + 1); + } + RTTESTI_CHECK(!AudioMixBufIsEmpty(&mb)); + RTTESTI_CHECK(AudioMixBufFree(&mb) == AudioMixBufSize(&mb) - cFramesWrittenAbs - 1); + RTTESTI_CHECK(AudioMixBufFreeBytes(&mb) == AUDIOMIXBUF_F2B(&mb, cBufSize - cFramesWrittenAbs - 1)); + RTTESTI_CHECK(AudioMixBufUsed(&mb) == cBufSize - cToRead); + + AudioMixBufPeek(&mb, 0 /*offSrcFrame*/, 1, &cFramesRead, &PeekState, aFrames16Buf, sizeof(aFrames16Buf), &cbRead); + RTTESTI_CHECK(cFramesRead == 1); + RTTESTI_CHECK(cbRead == sizeof(aFrames16Buf)); + AudioMixBufAdvance(&mb, cFramesRead); + RTTESTI_CHECK(AudioMixBufFree(&mb) == cBufSize - cFramesWrittenAbs); + RTTESTI_CHECK(AudioMixBufFreeBytes(&mb) == AUDIOMIXBUF_F2B(&mb, cBufSize - cFramesWrittenAbs)); + RTTESTI_CHECK(AudioMixBufUsed(&mb) == cFramesWrittenAbs); + RTTESTI_CHECK(AudioMixBufReadPos(&mb) == 0); + + AudioMixBufTerm(&mb); +} + +/** @name Eight test samples represented in all basic formats. + * @{ */ +static uint8_t const g_au8TestSamples[8] = { 0x1, 0x11, 0x32, 0x7f, 0x80, 0x81, 0xbe, 0xff }; +static int8_t const g_ai8TestSamples[8] = { -127, -111, -78, -1, 0, 1, 62, 127 }; +static uint16_t const g_au16TestSamples[8] = { 0x100, 0x1100, 0x3200, 0x7f00, 0x8000, 0x8100, 0xbe00, 0xff00 }; +static int16_t const g_ai16TestSamples[8] = { -32512, -28416, -19968, -256, 0, 256, 15872, 32512 }; +static uint32_t const g_au32TestSamples[8] = { 0x1000000, 0x11000000, 0x32000000, 0x7f000000, 0x80000000, 0x81000000, 0xbe000000, 0xff000000 }; +static int32_t const g_ai32TestSamples[8] = { -2130706432, -1862270976, -1308622848, -16777216, 0, 16777216, 1040187392, 2130706432 }; +static int64_t const g_ai64TestSamples[8] = { -2130706432, -1862270976, -1308622848, -16777216, 0, 16777216, 1040187392, 2130706432 }; +static struct { void const *apv[2]; uint32_t cb; } g_aTestSamples[] = +{ + /* 0/0: */ { { NULL, NULL }, 0 }, + /* 1/8: */ { { g_au8TestSamples, g_ai8TestSamples }, sizeof( g_au8TestSamples) }, + /* 2/16: */ { { g_au16TestSamples, g_ai16TestSamples }, sizeof(g_au16TestSamples) }, + /* 3/24: */ { { NULL, NULL }, 0 }, + /* 4/32: */ { { g_au32TestSamples, g_ai32TestSamples }, sizeof(g_au32TestSamples) }, + /* 5: */ { { NULL, NULL }, 0 }, + /* 6: */ { { NULL, NULL }, 0 }, + /* 7: */ { { NULL, NULL }, 0 }, + /* 8:64 */ { { NULL, g_ai64TestSamples }, sizeof(g_ai64TestSamples) }, /* raw */ +}; +/** @} */ + +/** Fills a buffer with samples from an g_aTestSamples entry. */ +static uint32_t tstFillBuf(PCPDMAUDIOPCMPROPS pCfg, void const *pvTestSamples, uint32_t iTestSample, + uint8_t *pbBuf, uint32_t cFrames) +{ + uint8_t const cTestSamples = RT_ELEMENTS(g_au8TestSamples); + + cFrames *= PDMAudioPropsChannels(pCfg); + switch (PDMAudioPropsSampleSize(pCfg)) + { + case 1: + { + uint8_t const * const pau8TestSamples = (uint8_t const *)pvTestSamples; + uint8_t *pu8Dst = (uint8_t *)pbBuf; + while (cFrames-- > 0) + { + *pu8Dst++ = pau8TestSamples[iTestSample]; + iTestSample = (iTestSample + 1) % cTestSamples; + } + break; + } + + case 2: + { + uint16_t const * const pau16TestSamples = (uint16_t const *)pvTestSamples; + uint16_t *pu16Dst = (uint16_t *)pbBuf; + while (cFrames-- > 0) + { + *pu16Dst++ = pau16TestSamples[iTestSample]; + iTestSample = (iTestSample + 1) % cTestSamples; + } + break; + } + + case 4: + { + uint32_t const * const pau32TestSamples = (uint32_t const *)pvTestSamples; + uint32_t *pu32Dst = (uint32_t *)pbBuf; + while (cFrames-- > 0) + { + *pu32Dst++ = pau32TestSamples[iTestSample]; + iTestSample = (iTestSample + 1) % cTestSamples; + } + break; + } + + case 8: + { + uint64_t const * const pau64TestSamples = (uint64_t const *)pvTestSamples; + uint64_t *pu64Dst = (uint64_t *)pbBuf; + while (cFrames-- > 0) + { + *pu64Dst++ = pau64TestSamples[iTestSample]; + iTestSample = (iTestSample + 1) % cTestSamples; + } + break; + } + + default: + AssertFailedBreak(); + } + return iTestSample; +} + + +static void tstConversion(RTTEST hTest, uint8_t cSrcBits, bool fSrcSigned, uint8_t cSrcChs, + uint8_t cDstBits, bool fDstSigned, uint8_t cDstChs) +{ + RTTestSubF(hTest, "Conv %uch %c%u to %uch %c%u", cSrcChs, fSrcSigned ? 'S' : 'U', cSrcBits, + cDstChs, fDstSigned ? 'S' : 'U', cDstBits); + + PDMAUDIOPCMPROPS CfgSrc, CfgDst; + PDMAudioPropsInitEx(&CfgSrc, cSrcBits / 8, fSrcSigned, cSrcChs, 44100, g_fLittleEndian, cSrcBits == 64 /*fRaw*/); + PDMAudioPropsInitEx(&CfgDst, cDstBits / 8, fDstSigned, cDstChs, 44100, g_fLittleEndian, cDstBits == 64 /*fRaw*/); + + void const * const pvSrcTestSamples = g_aTestSamples[cSrcBits / 8].apv[fSrcSigned]; + void const * const pvDstTestSamples = g_aTestSamples[cDstBits / 8].apv[fDstSigned]; + uint32_t const cMixBufFrames = RTRandU32Ex(128, 16384); + uint32_t const cIterations = RTRandU32Ex(256, 1536); + uint32_t const cbSrcBuf = PDMAudioPropsFramesToBytes(&CfgSrc, cMixBufFrames + 64); + uint8_t * const pbSrcBuf = (uint8_t *)RTMemAllocZ(cbSrcBuf); + uint32_t const cbDstBuf = PDMAudioPropsFramesToBytes(&CfgDst, cMixBufFrames + 64); + uint8_t * const pbDstBuf = (uint8_t *)RTMemAllocZ(cbDstBuf); + uint8_t * const pbDstExpect = (uint8_t *)RTMemAllocZ(cbDstBuf); + RTTESTI_CHECK_RETV(pbSrcBuf); + RTTESTI_CHECK_RETV(pbDstBuf); + RTTESTI_CHECK_RETV(pbDstExpect); + + AUDIOMIXBUF MixBuf; + RTTESTI_CHECK_RC_RETV(AudioMixBufInit(&MixBuf, "FormatOutputConversion", &CfgSrc, cMixBufFrames), VINF_SUCCESS); + AUDIOMIXBUFWRITESTATE WriteState; + RTTESTI_CHECK_RC_RETV(AudioMixBufInitWriteState(&MixBuf, &WriteState, &CfgSrc), VINF_SUCCESS); + AUDIOMIXBUFWRITESTATE WriteStateIgnZero = WriteState; RT_NOREF(WriteStateIgnZero); + AUDIOMIXBUFPEEKSTATE PeekState; + RTTESTI_CHECK_RC_RETV(AudioMixBufInitPeekState(&MixBuf, &PeekState, &CfgDst), VINF_SUCCESS); + + uint32_t iSrcTestSample = 0; + uint32_t iDstTestSample = 0; + //RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "cIterations=%u\n", cIterations); + for (uint32_t iIteration = 0; iIteration < cIterations; iIteration++) + { + /* Write some frames to the buffer. */ + uint32_t const cSrcFramesToWrite = iIteration < 16 ? iIteration + 1 + : AudioMixBufFree(&MixBuf) ? RTRandU32Ex(1, AudioMixBufFree(&MixBuf)) : 0; + if (cSrcFramesToWrite > 0) + { + uint32_t const cbSrcToWrite = PDMAudioPropsFramesToBytes(&CfgSrc, cSrcFramesToWrite); + uint32_t cFrames = RTRandU32(); + switch (RTRandU32Ex(0, 3)) + { + default: + iSrcTestSample = tstFillBuf(&CfgSrc, pvSrcTestSamples, iSrcTestSample, pbSrcBuf, cSrcFramesToWrite); + AudioMixBufWrite(&MixBuf, &WriteState, pbSrcBuf, cbSrcToWrite, 0 /*offDstFrame*/, cSrcFramesToWrite, &cFrames); + RTTESTI_CHECK(cFrames == cSrcFramesToWrite); + break; + + case 1: /* zero & blend */ + AudioMixBufSilence(&MixBuf, &WriteStateIgnZero, 0 /*offFrame*/, cSrcFramesToWrite); + iSrcTestSample = tstFillBuf(&CfgSrc, pvSrcTestSamples, iSrcTestSample, pbSrcBuf, cSrcFramesToWrite); + AudioMixBufBlend(&MixBuf, &WriteState, pbSrcBuf, cbSrcToWrite, 0 /*offDstFrame*/, cSrcFramesToWrite, &cFrames); + RTTESTI_CHECK(cFrames == cSrcFramesToWrite); + break; + + case 2: /* blend same equal data twice */ + { + AUDIOMIXBUFWRITESTATE WriteStateSame = WriteState; + iSrcTestSample = tstFillBuf(&CfgSrc, pvSrcTestSamples, iSrcTestSample, pbSrcBuf, cSrcFramesToWrite); + AudioMixBufWrite(&MixBuf, &WriteState, pbSrcBuf, cbSrcToWrite, 0 /*offDstFrame*/, cSrcFramesToWrite, &cFrames); + RTTESTI_CHECK(cFrames == cSrcFramesToWrite); + AudioMixBufBlend(&MixBuf, &WriteStateSame, pbSrcBuf, cbSrcToWrite, 0 /*offDstFrame*/, cSrcFramesToWrite, &cFrames); + RTTESTI_CHECK(cFrames == cSrcFramesToWrite); + break; + } + case 3: /* write & blend with zero */ + { + AUDIOMIXBUFWRITESTATE WriteStateSame = WriteState; + iSrcTestSample = tstFillBuf(&CfgSrc, pvSrcTestSamples, iSrcTestSample, pbSrcBuf, cSrcFramesToWrite); + AudioMixBufWrite(&MixBuf, &WriteState, pbSrcBuf, cbSrcToWrite, 0 /*offDstFrame*/, cSrcFramesToWrite, &cFrames); + RTTESTI_CHECK(cFrames == cSrcFramesToWrite); + PDMAudioPropsClearBuffer(&CfgSrc, pbSrcBuf, cbSrcToWrite, cSrcFramesToWrite); + AudioMixBufBlend(&MixBuf, &WriteStateSame, pbSrcBuf, cbSrcToWrite, 0 /*offDstFrame*/, cSrcFramesToWrite, &cFrames); + RTTESTI_CHECK(cFrames == cSrcFramesToWrite); + break; + } + } + AudioMixBufCommit(&MixBuf, cSrcFramesToWrite); + } + + /* Read some frames back. */ + uint32_t const cUsed = AudioMixBufUsed(&MixBuf); + uint32_t const cDstFramesToRead = iIteration < 16 ? iIteration + 1 : iIteration + 5 >= cIterations ? cUsed + : cUsed ? RTRandU32Ex(1, cUsed) : 0; + if (cDstFramesToRead > 0) + { + uint32_t const cbDstToRead = PDMAudioPropsFramesToBytes(&CfgDst, cDstFramesToRead); + uint32_t cbRead = RTRandU32(); + uint32_t cFrames = RTRandU32(); + RTRandBytes(pbDstBuf, cbDstToRead); + AudioMixBufPeek(&MixBuf, 0 /*offSrcFrame*/, (iIteration & 3) != 2 ? cDstFramesToRead : cUsed, &cFrames, + &PeekState, pbDstBuf, (iIteration & 3) != 3 ? cbDstToRead : cbDstBuf, &cbRead); + RTTESTI_CHECK(cFrames == cDstFramesToRead); + RTTESTI_CHECK(cbRead == cbDstToRead); + AudioMixBufAdvance(&MixBuf, cFrames); + + /* Verify if we can. */ + if (PDMAudioPropsChannels(&CfgSrc) == PDMAudioPropsChannels(&CfgDst)) + { + iDstTestSample = tstFillBuf(&CfgDst, pvDstTestSamples, iDstTestSample, pbDstExpect, cFrames); + if (memcmp(pbDstExpect, pbDstBuf, cbRead) == 0) + { /* likely */ } + else + { + RTTestFailed(hTest, + "mismatch: %.*Rhxs\n" + "expected: %.*Rhxs\n" + "iIteration=%u cDstFramesToRead=%u cbRead=%#x\n", + RT_MIN(cbRead, 48), pbDstBuf, + RT_MIN(cbRead, 48), pbDstExpect, + iIteration, cDstFramesToRead, cbRead); + break; + } + } + } + } + + AudioMixBufTerm(&MixBuf); + RTMemFree(pbSrcBuf); + RTMemFree(pbDstBuf); + RTMemFree(pbDstExpect); +} + + +#if 0 /** @todo rewrite to non-parent/child setup */ +static void tstDownsampling(RTTEST hTest, uint32_t uFromHz, uint32_t uToHz) +{ + RTTestSubF(hTest, "Downsampling %u to %u Hz (S16)", uFromHz, uToHz); + + struct { int16_t l, r; } + aSrcFrames[4096], + aDstFrames[4096]; + + /* Parent (destination) buffer is xxxHz 2ch S16 */ + uint32_t const cFramesParent = RTRandU32Ex(16, RT_ELEMENTS(aDstFrames)); + PDMAUDIOPCMPROPS const CfgDst = PDMAUDIOPCMPROPS_INITIALIZER(2 /*cbSample*/, true /*fSigned*/, 2 /*ch*/, uToHz, false /*fSwap*/); + RTTESTI_CHECK(AudioHlpPcmPropsAreValid(&CfgDst)); + AUDIOMIXBUF Parent; + RTTESTI_CHECK_RC_OK_RETV(AudioMixBufInit(&Parent, "ParentDownsampling", &CfgDst, cFramesParent)); + + /* Child (source) buffer is yyykHz 2ch S16 */ + PDMAUDIOPCMPROPS const CfgSrc = PDMAUDIOPCMPROPS_INITIALIZER(2 /*cbSample*/, true /*fSigned*/, 2 /*ch*/, uFromHz, false /*fSwap*/); + RTTESTI_CHECK(AudioHlpPcmPropsAreValid(&CfgSrc)); + uint32_t const cFramesChild = RTRandU32Ex(32, RT_ELEMENTS(aSrcFrames)); + AUDIOMIXBUF Child; + RTTESTI_CHECK_RC_OK_RETV(AudioMixBufInit(&Child, "ChildDownsampling", &CfgSrc, cFramesChild)); + RTTESTI_CHECK_RC_OK_RETV(AudioMixBufLinkTo(&Child, &Parent)); + + /* + * Test parameters. + */ + uint32_t const cMaxSrcFrames = RT_MIN(cFramesParent * uFromHz / uToHz - 1, cFramesChild); + uint32_t const cIterations = RTRandU32Ex(4, 128); + RTTestErrContext(hTest, "cFramesParent=%RU32 cFramesChild=%RU32 cMaxSrcFrames=%RU32 cIterations=%RU32", + cFramesParent, cFramesChild, cMaxSrcFrames, cIterations); + RTTestPrintf(hTest, RTTESTLVL_DEBUG, "cFramesParent=%RU32 cFramesChild=%RU32 cMaxSrcFrames=%RU32 cIterations=%RU32\n", + cFramesParent, cFramesChild, cMaxSrcFrames, cIterations); + + /* + * We generate a simple "A" sine wave as input. + */ + uint32_t iSrcFrame = 0; + uint32_t iDstFrame = 0; + double rdFixed = 2.0 * M_PI * 440.0 /* A */ / PDMAudioPropsHz(&CfgSrc); /* Fixed sin() input. */ + for (uint32_t i = 0; i < cIterations; i++) + { + RTTestPrintf(hTest, RTTESTLVL_DEBUG, "i=%RU32\n", i); + + /* + * Generate source frames and write them. + */ + uint32_t const cSrcFrames = i < cIterations / 2 + ? RTRandU32Ex(2, cMaxSrcFrames) & ~(uint32_t)1 + : RTRandU32Ex(1, cMaxSrcFrames - 1) | 1; + for (uint32_t j = 0; j < cSrcFrames; j++, iSrcFrame++) + aSrcFrames[j].r = aSrcFrames[j].l = 32760 /*Amplitude*/ * sin(rdFixed * iSrcFrame); + + uint32_t cSrcFramesWritten = UINT32_MAX / 2; + RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufWriteAt(&Child, 0, &aSrcFrames, cSrcFrames * sizeof(aSrcFrames[0]), + &cSrcFramesWritten)); + RTTESTI_CHECK_MSG_BREAK(cSrcFrames == cSrcFramesWritten, + ("cSrcFrames=%RU32 vs cSrcFramesWritten=%RU32\n", cSrcFrames, cSrcFramesWritten)); + + /* + * Mix them. + */ + uint32_t cSrcFramesMixed = UINT32_MAX / 2; + RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufMixToParent(&Child, cSrcFramesWritten, &cSrcFramesMixed)); + RTTESTI_CHECK_MSG(AudioMixBufUsed(&Child) == 0, ("%RU32\n", AudioMixBufUsed(&Child))); + RTTESTI_CHECK_MSG_BREAK(cSrcFramesWritten == cSrcFramesMixed, + ("cSrcFramesWritten=%RU32 cSrcFramesMixed=%RU32\n", cSrcFramesWritten, cSrcFramesMixed)); + RTTESTI_CHECK_MSG_BREAK(AudioMixBufUsed(&Child) == 0, ("%RU32\n", AudioMixBufUsed(&Child))); + + /* + * Read out the parent buffer. + */ + uint32_t cDstFrames = AudioMixBufUsed(&Parent); + while (cDstFrames > 0) + { + uint32_t cFramesRead = UINT32_MAX / 2; + RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufAcquireReadBlock(&Parent, aDstFrames, sizeof(aDstFrames), &cFramesRead)); + RTTESTI_CHECK_MSG(cFramesRead > 0 && cFramesRead <= cDstFrames, + ("cFramesRead=%RU32 cDstFrames=%RU32\n", cFramesRead, cDstFrames)); + + AudioMixBufReleaseReadBlock(&Parent, cFramesRead); + AudioMixBufFinish(&Parent, cFramesRead); + + iDstFrame += cFramesRead; + cDstFrames -= cFramesRead; + RTTESTI_CHECK(AudioMixBufUsed(&Parent) == cDstFrames); + } + } + + RTTESTI_CHECK(AudioMixBufUsed(&Parent) == 0); + RTTESTI_CHECK(AudioMixBufLive(&Child) == 0); + uint32_t const cDstMinExpect = (uint64_t)iSrcFrame * uToHz / uFromHz; + uint32_t const cDstMaxExpect = ((uint64_t)iSrcFrame * uToHz + uFromHz - 1) / uFromHz; + RTTESTI_CHECK_MSG(iDstFrame == cDstMinExpect || iDstFrame == cDstMaxExpect, + ("iSrcFrame=%#x -> %#x,%#x; iDstFrame=%#x\n", iSrcFrame, cDstMinExpect, cDstMaxExpect, iDstFrame)); + + AudioMixBufDestroy(&Parent); + AudioMixBufDestroy(&Child); +} +#endif + + +static void tstNewPeek(RTTEST hTest, uint32_t uFromHz, uint32_t uToHz) +{ + RTTestSubF(hTest, "New peek %u to %u Hz (S16)", uFromHz, uToHz); + + struct { int16_t l, r; } + aSrcFrames[4096], + aDstFrames[4096]; + + /* Mix buffer is uFromHz 2ch S16 */ + uint32_t const cFrames = RTRandU32Ex(16, RT_ELEMENTS(aSrcFrames)); + PDMAUDIOPCMPROPS const CfgSrc = PDMAUDIOPCMPROPS_INITIALIZER(2 /*cbSample*/, true /*fSigned*/, 2 /*ch*/, uFromHz, false /*fSwap*/); + RTTESTI_CHECK(AudioHlpPcmPropsAreValidAndSupported(&CfgSrc)); + AUDIOMIXBUF MixBuf; + RTTESTI_CHECK_RC_OK_RETV(AudioMixBufInit(&MixBuf, "NewPeekMixBuf", &CfgSrc, cFrames)); + + /* Write state (source). */ + AUDIOMIXBUFWRITESTATE WriteState; + RTTESTI_CHECK_RC_OK_RETV(AudioMixBufInitWriteState(&MixBuf, &WriteState, &CfgSrc)); + + /* Peek state (destination) is uToHz 2ch S16 */ + PDMAUDIOPCMPROPS const CfgDst = PDMAUDIOPCMPROPS_INITIALIZER(2 /*cbSample*/, true /*fSigned*/, 2 /*ch*/, uToHz, false /*fSwap*/); + RTTESTI_CHECK(AudioHlpPcmPropsAreValidAndSupported(&CfgDst)); + AUDIOMIXBUFPEEKSTATE PeekState; + RTTESTI_CHECK_RC_OK_RETV(AudioMixBufInitPeekState(&MixBuf, &PeekState, &CfgDst)); + + /* + * Test parameters. + */ + uint32_t const cMaxSrcFrames = RT_MIN(cFrames * uFromHz / uToHz - 1, cFrames); + uint32_t const cIterations = RTRandU32Ex(64, 1024); + RTTestErrContext(hTest, "cFrames=%RU32 cMaxSrcFrames=%RU32 cIterations=%RU32", cFrames, cMaxSrcFrames, cIterations); + RTTestPrintf(hTest, RTTESTLVL_DEBUG, "cFrames=%RU32 cMaxSrcFrames=%RU32 cIterations=%RU32\n", + cFrames, cMaxSrcFrames, cIterations); + + /* + * We generate a simple "A" sine wave as input. + */ + uint32_t iSrcFrame = 0; + uint32_t iDstFrame = 0; + double rdFixed = 2.0 * M_PI * 440.0 /* A */ / PDMAudioPropsHz(&CfgSrc); /* Fixed sin() input. */ + for (uint32_t i = 0; i < cIterations; i++) + { + RTTestPrintf(hTest, RTTESTLVL_DEBUG, "i=%RU32\n", i); + + /* + * Generate source frames and write them. + */ + uint32_t const cSrcFrames = i < cIterations / 2 + ? RTRandU32Ex(2, cMaxSrcFrames) & ~(uint32_t)1 + : RTRandU32Ex(1, cMaxSrcFrames - 1) | 1; + for (uint32_t j = 0; j < cSrcFrames; j++, iSrcFrame++) + aSrcFrames[j].r = aSrcFrames[j].l = 32760 /*Amplitude*/ * sin(rdFixed * iSrcFrame); + + uint32_t cSrcFramesWritten = UINT32_MAX / 2; + AudioMixBufWrite(&MixBuf, &WriteState, &aSrcFrames[0], cSrcFrames * sizeof(aSrcFrames[0]), + 0 /*offDstFrame*/, cSrcFrames, &cSrcFramesWritten); + RTTESTI_CHECK_MSG_BREAK(cSrcFrames == cSrcFramesWritten, + ("cSrcFrames=%RU32 vs cSrcFramesWritten=%RU32 cLiveFrames=%RU32\n", + cSrcFrames, cSrcFramesWritten, AudioMixBufUsed(&MixBuf))); + AudioMixBufCommit(&MixBuf, cSrcFrames); + + /* + * Read out all the frames using the peek function. + */ + uint32_t offSrcFrame = 0; + while (offSrcFrame < cSrcFramesWritten) + { + uint32_t cSrcFramesToRead = cSrcFramesWritten - offSrcFrame; + uint32_t cTmp = (uint64_t)cSrcFramesToRead * uToHz / uFromHz; + if (cTmp + 32 >= RT_ELEMENTS(aDstFrames)) + cSrcFramesToRead = ((uint64_t)RT_ELEMENTS(aDstFrames) - 32) * uFromHz / uToHz; /* kludge */ + + uint32_t cSrcFramesPeeked = UINT32_MAX / 4; + uint32_t cbDstPeeked = UINT32_MAX / 2; + RTRandBytes(aDstFrames, sizeof(aDstFrames)); + AudioMixBufPeek(&MixBuf, offSrcFrame, cSrcFramesToRead, &cSrcFramesPeeked, + &PeekState, aDstFrames, sizeof(aDstFrames), &cbDstPeeked); + uint32_t cDstFramesPeeked = PDMAudioPropsBytesToFrames(&CfgDst, cbDstPeeked); + RTTESTI_CHECK(cbDstPeeked > 0 || cSrcFramesPeeked > 0); + + if (uFromHz == uToHz) + { + for (uint32_t iDst = 0; iDst < cDstFramesPeeked; iDst++) + if (memcmp(&aDstFrames[iDst], &aSrcFrames[offSrcFrame + iDst], sizeof(aSrcFrames[0])) != 0) + RTTestFailed(hTest, "Frame #%u differs: %#x / %#x, expected %#x / %#x\n", iDstFrame + iDst, + aDstFrames[iDst].l, aDstFrames[iDst].r, + aSrcFrames[iDst + offSrcFrame].l, aSrcFrames[iDst + offSrcFrame].r); + } + + offSrcFrame += cSrcFramesPeeked; + iDstFrame += cDstFramesPeeked; + } + + /* + * Then advance. + */ + AudioMixBufAdvance(&MixBuf, cSrcFrames); + RTTESTI_CHECK(AudioMixBufUsed(&MixBuf) == 0); + } + + /** @todo this is a bit lax... */ + uint32_t const cDstMinExpect = ((uint64_t)iSrcFrame * uToHz - uFromHz - 1) / uFromHz; + uint32_t const cDstMaxExpect = ((uint64_t)iSrcFrame * uToHz + uFromHz - 1) / uFromHz; + RTTESTI_CHECK_MSG(iDstFrame >= cDstMinExpect && iDstFrame <= cDstMaxExpect, + ("iSrcFrame=%#x -> %#x..%#x; iDstFrame=%#x (delta %d)\n", + iSrcFrame, cDstMinExpect, cDstMaxExpect, iDstFrame, (cDstMinExpect + cDstMaxExpect) / 2 - iDstFrame)); + + AudioMixBufTerm(&MixBuf); +} + +/* Test volume control. */ +static void tstVolume(RTTEST hTest) +{ + RTTestSub(hTest, "Volume control (44.1kHz S16 2ch)"); + uint32_t const cBufSize = 256; + + /* + * Configure a mixbuf where we read and write 44.1kHz S16 2ch. + */ + PDMAUDIOPCMPROPS const Cfg = PDMAUDIOPCMPROPS_INITIALIZER( + 2, /* Bytes */ + true, /* Signed */ + 2, /* Channels */ + 44100, /* Hz */ + false /* Swap Endian */ + ); + AUDIOMIXBUF MixBuf; + RTTESTI_CHECK_RC_RETV(AudioMixBufInit(&MixBuf, "Volume", &Cfg, cBufSize), VINF_SUCCESS); + + AUDIOMIXBUFWRITESTATE WriteState; + RTTESTI_CHECK_RC_RETV(AudioMixBufInitWriteState(&MixBuf, &WriteState, &Cfg), VINF_SUCCESS); + + AUDIOMIXBUFPEEKSTATE PeekState; + RTTESTI_CHECK_RC_RETV(AudioMixBufInitPeekState(&MixBuf, &PeekState, &Cfg), VINF_SUCCESS); + + /* + * A few 16-bit signed test samples. + */ + static int16_t const s_aFrames16S[16] = + { + INT16_MIN, INT16_MIN + 1, -128, -64, -4, -1, 0, 1, + 2, 255, 256, INT16_MAX / 2, INT16_MAX - 2, INT16_MAX - 1, INT16_MAX, 0, + }; + + /* + * 1) Full volume/0dB attenuation (255). + */ + PDMAUDIOVOLUME Vol = PDMAUDIOVOLUME_INITIALIZER_MAX; + AudioMixBufSetVolume(&MixBuf, &Vol); + + /* Write all the test frames to the mixer buffer: */ + uint32_t cFramesWritten; + AudioMixBufWrite(&MixBuf, &WriteState, &s_aFrames16S[0], sizeof(s_aFrames16S), 0 /*offDstFrame*/, cBufSize, &cFramesWritten); + RTTESTI_CHECK(cFramesWritten == RT_ELEMENTS(s_aFrames16S) / 2); + AudioMixBufCommit(&MixBuf, cFramesWritten); + + /* Read them back. We should get them back just like we wrote them. */ + uint16_t au16Buf[cBufSize * 2]; + uint32_t cFramesPeeked; + uint32_t cbPeeked; + AudioMixBufPeek(&MixBuf, 0 /*offSrcFrame*/, cFramesWritten, &cFramesPeeked, &PeekState, au16Buf, sizeof(au16Buf), &cbPeeked); + RTTESTI_CHECK(cFramesPeeked == cFramesWritten); + RTTESTI_CHECK(cbPeeked == PDMAudioPropsFramesToBytes(&Cfg, cFramesPeeked)); + AudioMixBufAdvance(&MixBuf, cFramesPeeked); + + /* Check that at 0dB the frames came out unharmed. */ + if (memcmp(au16Buf, s_aFrames16S, sizeof(s_aFrames16S)) != 0) + RTTestFailed(hTest, + "0dB test failed\n" + "mismatch: %.*Rhxs\n" + "expected: %.*Rhxs\n", + sizeof(s_aFrames16S), au16Buf, sizeof(s_aFrames16S), s_aFrames16S); + + /* + * 2) Half volume/-6dB attenuation (16 steps down). + */ + PDMAudioVolumeInitFromStereo(&Vol, false, 255 - 16, 255 - 16); + AudioMixBufSetVolume(&MixBuf, &Vol); + + /* Write all the test frames to the mixer buffer: */ + AudioMixBufWrite(&MixBuf, &WriteState, &s_aFrames16S[0], sizeof(s_aFrames16S), 0 /*offDstFrame*/, cBufSize, &cFramesWritten); + RTTESTI_CHECK(cFramesWritten == RT_ELEMENTS(s_aFrames16S) / 2); + AudioMixBufCommit(&MixBuf, cFramesWritten); + + /* Read them back. We should get them back just like we wrote them. */ + AudioMixBufPeek(&MixBuf, 0 /*offSrcFrame*/, cFramesWritten, &cFramesPeeked, &PeekState, au16Buf, sizeof(au16Buf), &cbPeeked); + RTTESTI_CHECK(cFramesPeeked == cFramesWritten); + RTTESTI_CHECK(cbPeeked == PDMAudioPropsFramesToBytes(&Cfg, cFramesPeeked)); + AudioMixBufAdvance(&MixBuf, cFramesPeeked); + + /* Check that at -6dB the sample values are halved. */ + int16_t ai16Expect[sizeof(s_aFrames16S) / 2]; + memcpy(ai16Expect, s_aFrames16S, sizeof(ai16Expect)); + for (uintptr_t i = 0; i < RT_ELEMENTS(ai16Expect); i++) + ai16Expect[i] >>= 1; /* /= 2 - not the same for signed numbers; */ + if (memcmp(au16Buf, ai16Expect, sizeof(ai16Expect)) != 0) + RTTestFailed(hTest, + "-6dB test failed\n" + "mismatch: %.*Rhxs\n" + "expected: %.*Rhxs\n" + "wrote: %.*Rhxs\n", + sizeof(ai16Expect), au16Buf, sizeof(ai16Expect), ai16Expect, sizeof(s_aFrames16S), s_aFrames16S); + + AudioMixBufTerm(&MixBuf); +} + + +int main(int argc, char **argv) +{ + RTR3InitExe(argc, &argv, 0); + + /* + * Initialize IPRT and create the test. + */ + RTTEST hTest; + int rc = RTTestInitAndCreate("tstAudioMixBuffer", &hTest); + if (rc) + return rc; + RTTestBanner(hTest); + + tstBasics(hTest); + tstSimple(hTest); + + /* Run tstConversion for all combinations we have test data. */ + for (unsigned iSrc = 0; iSrc < RT_ELEMENTS(g_aTestSamples); iSrc++) + { + for (unsigned iSrcSigned = 0; iSrcSigned < RT_ELEMENTS(g_aTestSamples[0].apv); iSrcSigned++) + if (g_aTestSamples[iSrc].apv[iSrcSigned]) + for (unsigned cSrcChs = 1; cSrcChs <= 2; cSrcChs++) + for (unsigned iDst = 0; iDst < RT_ELEMENTS(g_aTestSamples); iDst++) + for (unsigned iDstSigned = 0; iDstSigned < RT_ELEMENTS(g_aTestSamples[0].apv); iDstSigned++) + if (g_aTestSamples[iDst].apv[iDstSigned]) + for (unsigned cDstChs = 1; cDstChs <= 2; cDstChs++) + tstConversion(hTest, iSrc * 8, iSrcSigned == 1, cSrcChs, + /*->*/ iDst * 8, iDstSigned == 1, cDstChs); + } + +#if 0 /** @todo rewrite to non-parent/child setup */ + tstDownsampling(hTest, 44100, 22050); + tstDownsampling(hTest, 48000, 44100); + tstDownsampling(hTest, 48000, 22050); + tstDownsampling(hTest, 48000, 11000); +#endif + tstNewPeek(hTest, 48000, 48000); + tstNewPeek(hTest, 48000, 11000); + tstNewPeek(hTest, 48000, 44100); + tstNewPeek(hTest, 44100, 22050); + tstNewPeek(hTest, 44100, 11000); + //tstNewPeek(hTest, 11000, 48000); + //tstNewPeek(hTest, 22050, 44100); + + tstVolume(hTest); + + /* + * Summary + */ + return RTTestSummaryAndDestroy(hTest); +} |