/* $Id: tstAudioMixBuffer.cpp 88022 2021-03-08 17:50:57Z vboxsync $ */ /** @file * Audio testcase - Mixing buffer. */ /* * Copyright (C) 2014-2020 Oracle Corporation * * This file is part of VirtualBox Open Source Edition (OSE), as * available from http://www.virtualbox.org. This file is free software; * you can redistribute it and/or modify it under the terms of the GNU * General Public License (GPL) as published by the Free Software * Foundation, in version 2 as it comes in the "COPYING" file of the * VirtualBox OSE distribution. VirtualBox OSE is distributed in the * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. */ /********************************************************************************************************************************* * Header Files * *********************************************************************************************************************************/ #include #include #include #include #include #include #include #include "../AudioMixBuffer.h" #include "../DrvAudio.h" static void tstBasics(RTTEST hTest) { RTTestSub(hTest, "Basics"); static const PDMAUDIOPCMPROPS s_Cfg441StereoS16 = PDMAUDIOPCMPROPS_INITIALIZOR( /* a_cb: */ 2, /* a_fSigned: */ true, /* a_cChannels: */ 2, /* a_uHz: */ 44100, /* a_cShift: */ PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(2 /* cb */, 2 /* cChannels */), /* a_fSwapEndian: */ false ); static const PDMAUDIOPCMPROPS s_Cfg441StereoU16 = PDMAUDIOPCMPROPS_INITIALIZOR( /* a_cb: */ 2, /* a_fSigned: */ false, /* a_cChannels: */ 2, /* a_uHz: */ 44100, /* a_cShift: */ PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(2 /* cb */, 2 /* cChannels */), /* a_fSwapEndian: */ false ); static const PDMAUDIOPCMPROPS s_Cfg441StereoU32 = PDMAUDIOPCMPROPS_INITIALIZOR( /* a_cb: */ 4, /* a_fSigned: */ false, /* a_cChannels: */ 2, /* a_uHz: */ 44100, /* a_cShift: */ PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(4 /* cb */, 2 /* cChannels */), /* a_fSwapEndian: */ false ); RTTESTI_CHECK(PDMAudioPropsGetBitrate(&s_Cfg441StereoS16) == 44100*4*8); RTTESTI_CHECK(PDMAudioPropsGetBitrate(&s_Cfg441StereoU16) == 44100*4*8); RTTESTI_CHECK(PDMAudioPropsGetBitrate(&s_Cfg441StereoU32) == 44100*8*8); RTTESTI_CHECK(DrvAudioHlpPcmPropsAreValid(&s_Cfg441StereoS16)); RTTESTI_CHECK(DrvAudioHlpPcmPropsAreValid(&s_Cfg441StereoU16) == false); /* go figure */ RTTESTI_CHECK(DrvAudioHlpPcmPropsAreValid(&s_Cfg441StereoU32) == false); /* go figure */ RTTESTI_CHECK_MSG(PDMAUDIOPCMPROPS_F2B(&s_Cfg441StereoS16, 1) == 4, ("got %x, expected 4\n", PDMAUDIOPCMPROPS_F2B(&s_Cfg441StereoS16, 1))); RTTESTI_CHECK_MSG(PDMAUDIOPCMPROPS_F2B(&s_Cfg441StereoU16, 1) == 4, ("got %x, expected 4\n", PDMAUDIOPCMPROPS_F2B(&s_Cfg441StereoU16, 1))); RTTESTI_CHECK_MSG(PDMAUDIOPCMPROPS_F2B(&s_Cfg441StereoU32, 1) == 8, ("got %x, expected 4\n", PDMAUDIOPCMPROPS_F2B(&s_Cfg441StereoU32, 1))); RTTESTI_CHECK_MSG(PDMAudioPropsBytesPerFrame(&s_Cfg441StereoS16) == 4, ("got %x, expected 4\n", PDMAudioPropsBytesPerFrame(&s_Cfg441StereoS16))); RTTESTI_CHECK_MSG(PDMAudioPropsBytesPerFrame(&s_Cfg441StereoU16) == 4, ("got %x, expected 4\n", PDMAudioPropsBytesPerFrame(&s_Cfg441StereoU16))); RTTESTI_CHECK_MSG(PDMAudioPropsBytesPerFrame(&s_Cfg441StereoU32) == 8, ("got %x, expected 4\n", PDMAudioPropsBytesPerFrame(&s_Cfg441StereoU32))); uint32_t u32; for (uint32_t i = 0; i < 256; i += 8) { RTTESTI_CHECK(PDMAudioPropsIsSizeAligned(&s_Cfg441StereoU32, i) == true); for (uint32_t j = 1; j < 8; j++) RTTESTI_CHECK(PDMAudioPropsIsSizeAligned(&s_Cfg441StereoU32, i + j) == false); for (uint32_t j = 0; j < 8; j++) RTTESTI_CHECK(PDMAudioPropsFloorBytesToFrame(&s_Cfg441StereoU32, i + j) == i); } for (uint32_t i = 0; i < 4096; i += 4) { RTTESTI_CHECK(PDMAudioPropsIsSizeAligned(&s_Cfg441StereoS16, i) == true); for (uint32_t j = 1; j < 4; j++) RTTESTI_CHECK(PDMAudioPropsIsSizeAligned(&s_Cfg441StereoS16, i + j) == false); for (uint32_t j = 0; j < 4; j++) RTTESTI_CHECK(PDMAudioPropsFloorBytesToFrame(&s_Cfg441StereoS16, i + j) == i); } RTTESTI_CHECK_MSG((u32 = PDMAudioPropsFramesToBytes(&s_Cfg441StereoS16, 44100)) == 44100 * 2 * 2, ("cb=%RU32\n", u32)); RTTESTI_CHECK_MSG((u32 = PDMAudioPropsFramesToBytes(&s_Cfg441StereoS16, 2)) == 2 * 2 * 2, ("cb=%RU32\n", u32)); RTTESTI_CHECK_MSG((u32 = PDMAudioPropsFramesToBytes(&s_Cfg441StereoS16, 1)) == 4, ("cb=%RU32\n", u32)); RTTESTI_CHECK_MSG((u32 = PDMAudioPropsFramesToBytes(&s_Cfg441StereoU16, 1)) == 4, ("cb=%RU32\n", u32)); RTTESTI_CHECK_MSG((u32 = PDMAudioPropsFramesToBytes(&s_Cfg441StereoU32, 1)) == 8, ("cb=%RU32\n", u32)); RTTESTI_CHECK_MSG((u32 = PDMAudioPropsBytesToFrames(&s_Cfg441StereoS16, 4)) == 1, ("cb=%RU32\n", u32)); RTTESTI_CHECK_MSG((u32 = PDMAudioPropsBytesToFrames(&s_Cfg441StereoU16, 4)) == 1, ("cb=%RU32\n", u32)); RTTESTI_CHECK_MSG((u32 = PDMAudioPropsBytesToFrames(&s_Cfg441StereoU32, 8)) == 1, ("cb=%RU32\n", u32)); uint64_t u64; RTTESTI_CHECK_MSG((u64 = PDMAudioPropsBytesToNano(&s_Cfg441StereoS16, 44100 * 2 * 2)) == RT_NS_1SEC, ("ns=%RU64\n", u64)); RTTESTI_CHECK_MSG((u64 = PDMAudioPropsBytesToMicro(&s_Cfg441StereoS16, 44100 * 2 * 2)) == RT_US_1SEC, ("us=%RU64\n", u64)); RTTESTI_CHECK_MSG((u64 = PDMAudioPropsBytesToMilli(&s_Cfg441StereoS16, 44100 * 2 * 2)) == RT_MS_1SEC, ("ms=%RU64\n", u64)); RTTESTI_CHECK_MSG((u64 = PDMAudioPropsFramesToNano(&s_Cfg441StereoS16, 44100)) == RT_NS_1SEC, ("ns=%RU64\n", u64)); RTTESTI_CHECK_MSG((u64 = PDMAudioPropsFramesToNano(&s_Cfg441StereoS16, 1)) == 22675, ("ns=%RU64\n", u64)); RTTESTI_CHECK_MSG((u64 = PDMAudioPropsFramesToNano(&s_Cfg441StereoS16, 31)) == 702947, ("ns=%RU64\n", u64)); RTTESTI_CHECK_MSG((u64 = PDMAudioPropsFramesToNano(&s_Cfg441StereoS16, 255)) == 5782312, ("ns=%RU64\n", u64)); //RTTESTI_CHECK_MSG((u64 = DrvAudioHlpFramesToMicro(&s_Cfg441StereoS16, 44100)) == RT_US_1SEC, // ("us=%RU64\n", u64)); RTTESTI_CHECK_MSG((u64 = PDMAudioPropsFramesToMilli(&s_Cfg441StereoS16, 44100)) == RT_MS_1SEC, ("ms=%RU64\n", u64)); RTTESTI_CHECK_MSG((u64 = PDMAudioPropsFramesToMilli(&s_Cfg441StereoS16, 255)) == 5, ("ms=%RU64\n", u64)); RTTESTI_CHECK_MSG((u32 = PDMAudioPropsNanoToFrames(&s_Cfg441StereoS16, RT_NS_1SEC)) == 44100, ("cb=%RU32\n", u32)); RTTESTI_CHECK_MSG((u32 = PDMAudioPropsNanoToFrames(&s_Cfg441StereoS16, 215876)) == 10, ("cb=%RU32\n", u32)); RTTESTI_CHECK_MSG((u32 = PDMAudioPropsMilliToFrames(&s_Cfg441StereoS16, RT_MS_1SEC)) == 44100, ("cb=%RU32\n", u32)); RTTESTI_CHECK_MSG((u32 = PDMAudioPropsMilliToFrames(&s_Cfg441StereoU32, 6)) == 265, ("cb=%RU32\n", u32)); RTTESTI_CHECK_MSG((u32 = PDMAudioPropsNanoToBytes(&s_Cfg441StereoS16, RT_NS_1SEC)) == 44100*2*2, ("cb=%RU32\n", u32)); RTTESTI_CHECK_MSG((u32 = PDMAudioPropsNanoToBytes(&s_Cfg441StereoS16, 702947)) == 31*2*2, ("cb=%RU32\n", u32)); RTTESTI_CHECK_MSG((u32 = PDMAudioPropsMilliToBytes(&s_Cfg441StereoS16, RT_MS_1SEC)) == 44100*2*2, ("cb=%RU32\n", u32)); RTTESTI_CHECK_MSG((u32 = PDMAudioPropsMilliToBytes(&s_Cfg441StereoS16, 5)) == 884, ("cb=%RU32\n", u32)); /* DrvAudioHlpClearBuf: */ uint8_t *pbPage; int rc = RTTestGuardedAlloc(hTest, PAGE_SIZE, 0, false /*fHead*/, (void **)&pbPage); RTTESTI_CHECK_RC_OK_RETV(rc); memset(pbPage, 0x42, PAGE_SIZE); PDMAudioPropsClearBuffer(&s_Cfg441StereoS16, pbPage, PAGE_SIZE, PAGE_SIZE / 4); RTTESTI_CHECK(ASMMemIsZero(pbPage, PAGE_SIZE)); memset(pbPage, 0x42, PAGE_SIZE); PDMAudioPropsClearBuffer(&s_Cfg441StereoU16, pbPage, PAGE_SIZE, PAGE_SIZE / 4); for (uint32_t off = 0; off < PAGE_SIZE; off += 2) RTTESTI_CHECK_MSG(pbPage[off] == 0x80 && pbPage[off + 1] == 0, ("off=%#x: %#x %x\n", off, pbPage[off], pbPage[off + 1])); memset(pbPage, 0x42, PAGE_SIZE); PDMAudioPropsClearBuffer(&s_Cfg441StereoU32, pbPage, PAGE_SIZE, PAGE_SIZE / 8); for (uint32_t off = 0; off < PAGE_SIZE; off += 4) RTTESTI_CHECK(pbPage[off] == 0x80 && pbPage[off + 1] == 0 && pbPage[off + 2] == 0 && pbPage[off + 3] == 0); RTTestDisableAssertions(hTest); memset(pbPage, 0x42, PAGE_SIZE); PDMAudioPropsClearBuffer(&s_Cfg441StereoS16, pbPage, PAGE_SIZE, PAGE_SIZE); /* should adjust down the frame count. */ RTTESTI_CHECK(ASMMemIsZero(pbPage, PAGE_SIZE)); memset(pbPage, 0x42, PAGE_SIZE); PDMAudioPropsClearBuffer(&s_Cfg441StereoU16, pbPage, PAGE_SIZE, PAGE_SIZE); /* should adjust down the frame count. */ for (uint32_t off = 0; off < PAGE_SIZE; off += 2) RTTESTI_CHECK_MSG(pbPage[off] == 0x80 && pbPage[off + 1] == 0, ("off=%#x: %#x %x\n", off, pbPage[off], pbPage[off + 1])); memset(pbPage, 0x42, PAGE_SIZE); PDMAudioPropsClearBuffer(&s_Cfg441StereoU32, pbPage, PAGE_SIZE, PAGE_SIZE); /* should adjust down the frame count. */ for (uint32_t off = 0; off < PAGE_SIZE; off += 4) RTTESTI_CHECK(pbPage[off] == 0x80 && pbPage[off + 1] == 0 && pbPage[off + 2] == 0 && pbPage[off + 3] == 0); RTTestRestoreAssertions(hTest); RTTestGuardedFree(hTest, pbPage); } static int tstSingle(RTTEST hTest) { RTTestSub(hTest, "Single buffer"); /* 44100Hz, 2 Channels, S16 */ PDMAUDIOPCMPROPS config = PDMAUDIOPCMPROPS_INITIALIZOR( 2, /* Bytes */ true, /* Signed */ 2, /* Channels */ 44100, /* Hz */ PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(2 /* Bytes */, 2 /* Channels */), /* Shift */ false /* Swap Endian */ ); RTTESTI_CHECK(DrvAudioHlpPcmPropsAreValid(&config)); uint32_t cBufSize = _1K; /* * General stuff. */ PDMAUDIOMIXBUF mb; RTTESTI_CHECK_RC_OK(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)); /* * Absolute writes. */ uint32_t cFramesRead = 0, cFramesWritten = 0, cFramesWrittenAbs = 0; int8_t aFrames8 [2] = { 0x12, 0x34 }; int16_t aFrames16[2] = { 0xAA, 0xBB }; int32_t aFrames32[2] = { 0xCC, 0xDD }; RTTESTI_CHECK_RC_OK(AudioMixBufWriteAt(&mb, 0 /* Offset */, &aFrames8, sizeof(aFrames8), &cFramesWritten)); RTTESTI_CHECK(cFramesWritten == 0 /* Frames */); RTTESTI_CHECK(AudioMixBufUsed(&mb) == 0); RTTESTI_CHECK_RC_OK(AudioMixBufWriteAt(&mb, 0 /* Offset */, &aFrames16, sizeof(aFrames16), &cFramesWritten)); RTTESTI_CHECK(cFramesWritten == 1 /* Frames */); RTTESTI_CHECK(AudioMixBufUsed(&mb) == 1); RTTESTI_CHECK_RC_OK(AudioMixBufWriteAt(&mb, 2 /* Offset */, &aFrames32, sizeof(aFrames32), &cFramesWritten)); RTTESTI_CHECK(cFramesWritten == 2 /* Frames */); RTTESTI_CHECK(AudioMixBufUsed(&mb) == 2); /* Beyond buffer. */ RTTESTI_CHECK_RC(AudioMixBufWriteAt(&mb, AudioMixBufSize(&mb) + 1, &aFrames16, sizeof(aFrames16), &cFramesWritten), VERR_BUFFER_OVERFLOW); /* Offset wrap-around: When writing as much (or more) frames the mixing buffer can hold. */ uint32_t cbSamples = cBufSize * sizeof(int16_t) * 2 /* Channels */; RTTESTI_CHECK(cbSamples); uint16_t *paSamples = (uint16_t *)RTMemAlloc(cbSamples); RTTESTI_CHECK(paSamples); RTTESTI_CHECK_RC_OK(AudioMixBufWriteAt(&mb, 0 /* Offset */, paSamples, cbSamples, &cFramesWritten)); RTTESTI_CHECK(cFramesWritten == cBufSize /* Frames */); RTTESTI_CHECK(AudioMixBufUsed(&mb) == cBufSize); RTTESTI_CHECK(AudioMixBufReadPos(&mb) == 0); RTTESTI_CHECK(AudioMixBufWritePos(&mb) == 0); RTMemFree(paSamples); cbSamples = 0; /* * Circular writes. */ AudioMixBufReset(&mb); RTTESTI_CHECK_RC_OK(AudioMixBufWriteAt(&mb, 2 /* Offset */, &aFrames32, sizeof(aFrames32), &cFramesWritten)); RTTESTI_CHECK(cFramesWritten == 2 /* Frames */); RTTESTI_CHECK(AudioMixBufUsed(&mb) == 2); 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++) { RTTESTI_CHECK_RC_OK(AudioMixBufWriteCirc(&mb, &aFrames16, sizeof(aFrames16), &cFramesWritten)); RTTESTI_CHECK(cFramesWritten == 1); } 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 */); RTTESTI_CHECK_RC_OK(AudioMixBufWriteCirc(&mb, &aFrames16, sizeof(aFrames16), &cFramesWritten)); RTTESTI_CHECK(cFramesWritten == 1); RTTESTI_CHECK(AudioMixBufFree(&mb) == 0); RTTESTI_CHECK(AudioMixBufFreeBytes(&mb) == AUDIOMIXBUF_F2B(&mb, 0U)); RTTESTI_CHECK(AudioMixBufUsed(&mb) == cBufSize); /* Circular reads. */ uint32_t cToRead = AudioMixBufSize(&mb) - cFramesWrittenAbs - 1; for (uint32_t i = 0; i < cToRead; i++) { RTTESTI_CHECK_RC_OK(AudioMixBufAcquireReadBlock(&mb, &aFrames16, sizeof(aFrames16), &cFramesRead)); RTTESTI_CHECK(cFramesRead == 1); AudioMixBufReleaseReadBlock(&mb, cFramesRead); AudioMixBufFinish(&mb, cFramesRead); } 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); RTTESTI_CHECK_RC_OK(AudioMixBufAcquireReadBlock(&mb, &aFrames16, sizeof(aFrames16), &cFramesRead)); RTTESTI_CHECK(cFramesRead == 1); AudioMixBufReleaseReadBlock(&mb, cFramesRead); AudioMixBufFinish(&mb, cFramesRead); RTTESTI_CHECK(AudioMixBufFree(&mb) == cBufSize - cFramesWrittenAbs); RTTESTI_CHECK(AudioMixBufFreeBytes(&mb) == AUDIOMIXBUF_F2B(&mb, cBufSize - cFramesWrittenAbs)); RTTESTI_CHECK(AudioMixBufUsed(&mb) == cFramesWrittenAbs); AudioMixBufDestroy(&mb); return RTTestSubErrorCount(hTest) ? VERR_GENERAL_FAILURE : VINF_SUCCESS; } static int tstParentChild(RTTEST hTest) { uint32_t cParentBufSize = RTRandU32Ex(_1K /* Min */, _16K /* Max */); /* Enough room for random sizes */ /* 44100Hz, 2 Channels, S16 */ PDMAUDIOPCMPROPS cfg_p = PDMAUDIOPCMPROPS_INITIALIZOR( 2, /* Bytes */ true, /* Signed */ 2, /* Channels */ 44100, /* Hz */ PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(2 /* Bytes */, 2 /* Channels */), /* Shift */ false /* Swap Endian */ ); RTTESTI_CHECK(DrvAudioHlpPcmPropsAreValid(&cfg_p)); PDMAUDIOMIXBUF parent; RTTESTI_CHECK_RC_OK(AudioMixBufInit(&parent, "Parent", &cfg_p, cParentBufSize)); /* 22050Hz, 2 Channels, S16 */ PDMAUDIOPCMPROPS cfg_c1 = PDMAUDIOPCMPROPS_INITIALIZOR(/* Upmixing to parent */ 2, /* Bytes */ true, /* Signed */ 2, /* Channels */ 22050, /* Hz */ PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(2 /* Bytes */, 2 /* Channels */), /* Shift */ false /* Swap Endian */ ); RTTESTI_CHECK(DrvAudioHlpPcmPropsAreValid(&cfg_c1)); uint32_t cFrames = 16; uint32_t cChildBufSize = RTRandU32Ex(cFrames /* Min */, 64 /* Max */); PDMAUDIOMIXBUF child1; RTTESTI_CHECK_RC_OK(AudioMixBufInit(&child1, "Child1", &cfg_c1, cChildBufSize)); RTTESTI_CHECK_RC_OK(AudioMixBufLinkTo(&child1, &parent)); /* 48000Hz, 2 Channels, S16 */ PDMAUDIOPCMPROPS cfg_c2 = PDMAUDIOPCMPROPS_INITIALIZOR(/* Downmixing to parent */ 2, /* Bytes */ true, /* Signed */ 2, /* Channels */ 48000, /* Hz */ PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(2 /* Bytes */, 2 /* Channels */), /* Shift */ false /* Swap Endian */ ); RTTESTI_CHECK(DrvAudioHlpPcmPropsAreValid(&cfg_c2)); PDMAUDIOMIXBUF child2; RTTESTI_CHECK_RC_OK(AudioMixBufInit(&child2, "Child2", &cfg_c2, cChildBufSize)); RTTESTI_CHECK_RC_OK(AudioMixBufLinkTo(&child2, &parent)); /* * Writing + mixing from child/children -> parent, sequential. */ uint32_t cbBuf = _1K; char pvBuf[_1K]; int16_t aFrames16[32] = { 0xAA, 0xBB }; uint32_t cFramesRead, cFramesWritten, cFramesMixed; uint32_t cFramesChild1 = cFrames; uint32_t cFramesChild2 = cFrames; uint32_t t = RTRandU32() % 32; RTTestPrintf(hTest, RTTESTLVL_DEBUG, "cParentBufSize=%RU32, cChildBufSize=%RU32, %RU32 frames -> %RU32 iterations total\n", cParentBufSize, cChildBufSize, cFrames, t); /* * Using AudioMixBufWriteAt for writing to children. */ RTTestSub(hTest, "2 Children -> Parent (AudioMixBufWriteAt)"); uint32_t cChildrenSamplesMixedTotal = 0; for (uint32_t i = 0; i < t; i++) { RTTestPrintf(hTest, RTTESTLVL_DEBUG, "i=%RU32\n", i); uint32_t cChild1Writes = RTRandU32() % 8; for (uint32_t c1 = 0; c1 < cChild1Writes; c1++) { /* Child 1. */ RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufWriteAt(&child1, 0, &aFrames16, sizeof(aFrames16), &cFramesWritten)); RTTESTI_CHECK_MSG_BREAK(cFramesWritten == cFramesChild1, ("Child1: Expected %RU32 written frames, got %RU32\n", cFramesChild1, cFramesWritten)); RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufMixToParent(&child1, cFramesWritten, &cFramesMixed)); cChildrenSamplesMixedTotal += cFramesMixed; RTTESTI_CHECK_MSG_BREAK(cFramesWritten == cFramesMixed, ("Child1: Expected %RU32 mixed frames, got %RU32\n", cFramesWritten, cFramesMixed)); RTTESTI_CHECK_MSG_BREAK(AudioMixBufUsed(&child1) == 0, ("Child1: Expected %RU32 used frames, got %RU32\n", 0, AudioMixBufUsed(&child1))); } uint32_t cChild2Writes = RTRandU32() % 8; for (uint32_t c2 = 0; c2 < cChild2Writes; c2++) { /* Child 2. */ RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufWriteAt(&child2, 0, &aFrames16, sizeof(aFrames16), &cFramesWritten)); RTTESTI_CHECK_MSG_BREAK(cFramesWritten == cFramesChild2, ("Child2: Expected %RU32 written frames, got %RU32\n", cFramesChild2, cFramesWritten)); RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufMixToParent(&child2, cFramesWritten, &cFramesMixed)); cChildrenSamplesMixedTotal += cFramesMixed; RTTESTI_CHECK_MSG_BREAK(cFramesWritten == cFramesMixed, ("Child2: Expected %RU32 mixed frames, got %RU32\n", cFramesWritten, cFramesMixed)); RTTESTI_CHECK_MSG_BREAK(AudioMixBufUsed(&child2) == 0, ("Child2: Expected %RU32 used frames, got %RU32\n", 0, AudioMixBufUsed(&child2))); } /* * Read out all frames from the parent buffer and also mark the just-read frames as finished * so that both connected children buffers can keep track of their stuff. */ uint32_t cParentSamples = AudioMixBufUsed(&parent); while (cParentSamples) { RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufAcquireReadBlock(&parent, pvBuf, cbBuf, &cFramesRead)); if (!cFramesRead) break; AudioMixBufReleaseReadBlock(&parent, cFramesRead); AudioMixBufFinish(&parent, cFramesRead); RTTESTI_CHECK(cParentSamples >= cFramesRead); cParentSamples -= cFramesRead; } RTTESTI_CHECK(cParentSamples == 0); } RTTESTI_CHECK(AudioMixBufUsed(&parent) == 0); RTTESTI_CHECK(AudioMixBufLive(&child1) == 0); RTTESTI_CHECK(AudioMixBufLive(&child2) == 0); AudioMixBufDestroy(&parent); AudioMixBufDestroy(&child1); AudioMixBufDestroy(&child2); return RTTestSubErrorCount(hTest) ? VERR_GENERAL_FAILURE : VINF_SUCCESS; } /* Test 8-bit sample conversion (8-bit -> internal -> 8-bit). */ static int tstConversion8(RTTEST hTest) { unsigned i; uint32_t cBufSize = 256; RTTestSub(hTest, "Sample conversion (U8)"); /* 44100Hz, 1 Channel, U8 */ PDMAUDIOPCMPROPS cfg_p = PDMAUDIOPCMPROPS_INITIALIZOR( 1, /* Bytes */ false, /* Signed */ 1, /* Channels */ 44100, /* Hz */ PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(1 /* Bytes */, 1 /* Channels */), /* Shift */ false /* Swap Endian */ ); RTTESTI_CHECK(DrvAudioHlpPcmPropsAreValid(&cfg_p)); PDMAUDIOMIXBUF parent; RTTESTI_CHECK_RC_OK(AudioMixBufInit(&parent, "Parent", &cfg_p, cBufSize)); /* Child uses half the sample rate; that ensures the mixing engine can't * take shortcuts and performs conversion. Because conversion to double * the sample rate effectively inserts one additional sample between every * two source frames, N source frames will be converted to N * 2 - 1 * frames. However, the last source sample will be saved for later * interpolation and not immediately output. */ /* 22050Hz, 1 Channel, U8 */ PDMAUDIOPCMPROPS cfg_c = PDMAUDIOPCMPROPS_INITIALIZOR( /* Upmixing to parent */ 1, /* Bytes */ false, /* Signed */ 1, /* Channels */ 22050, /* Hz */ PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(1 /* Bytes */, 1 /* Channels */), /* Shift */ false /* Swap Endian */ ); RTTESTI_CHECK(DrvAudioHlpPcmPropsAreValid(&cfg_c)); PDMAUDIOMIXBUF child; RTTESTI_CHECK_RC_OK(AudioMixBufInit(&child, "Child", &cfg_c, cBufSize)); RTTESTI_CHECK_RC_OK(AudioMixBufLinkTo(&child, &parent)); /* 8-bit unsigned frames. Often used with SB16 device. */ uint8_t aFrames8U[16] = { 0xAA, 0xBB, 0, 1, 43, 125, 126, 127, 128, 129, 130, 131, 132, UINT8_MAX - 1, UINT8_MAX, 0 }; /* * Writing + mixing from child -> parent, sequential. */ uint32_t cbBuf = 256; char achBuf[256]; uint32_t cFramesRead, cFramesWritten, cFramesMixed; uint32_t cFramesChild = 16; uint32_t cFramesParent = cFramesChild * 2 - 2; uint32_t cFramesTotalRead = 0; /**** 8-bit unsigned samples ****/ RTTestPrintf(hTest, RTTESTLVL_DEBUG, "Conversion test %uHz %uch 8-bit\n", cfg_c.uHz, cfg_c.cChannels); RTTESTI_CHECK_RC_OK(AudioMixBufWriteCirc(&child, &aFrames8U, sizeof(aFrames8U), &cFramesWritten)); RTTESTI_CHECK_MSG(cFramesWritten == cFramesChild, ("Child: Expected %RU32 written frames, got %RU32\n", cFramesChild, cFramesWritten)); RTTESTI_CHECK_RC_OK(AudioMixBufMixToParent(&child, cFramesWritten, &cFramesMixed)); uint32_t cFrames = AudioMixBufUsed(&parent); RTTESTI_CHECK_MSG(AudioMixBufLive(&child) == cFrames, ("Child: Expected %RU32 mixed frames, got %RU32\n", AudioMixBufLive(&child), cFrames)); RTTESTI_CHECK(AudioMixBufUsed(&parent) == AudioMixBufLive(&child)); for (;;) { RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufAcquireReadBlock(&parent, achBuf, cbBuf, &cFramesRead)); if (!cFramesRead) break; cFramesTotalRead += cFramesRead; AudioMixBufReleaseReadBlock(&parent, cFramesRead); AudioMixBufFinish(&parent, cFramesRead); } RTTESTI_CHECK_MSG(cFramesTotalRead == cFramesParent, ("Parent: Expected %RU32 mixed frames, got %RU32\n", cFramesParent, cFramesTotalRead)); /* Check that the frames came out unharmed. Every other sample is interpolated and we ignore it. */ /* NB: This also checks that the default volume setting is 0dB attenuation. */ uint8_t *pSrc8 = &aFrames8U[0]; uint8_t *pDst8 = (uint8_t *)achBuf; for (i = 0; i < cFramesChild - 1; ++i) { RTTESTI_CHECK_MSG(*pSrc8 == *pDst8, ("index %u: Dst=%d, Src=%d\n", i, *pDst8, *pSrc8)); pSrc8 += 1; pDst8 += 2; } RTTESTI_CHECK(AudioMixBufUsed(&parent) == 0); RTTESTI_CHECK(AudioMixBufLive(&child) == 0); AudioMixBufDestroy(&parent); AudioMixBufDestroy(&child); return RTTestSubErrorCount(hTest) ? VERR_GENERAL_FAILURE : VINF_SUCCESS; } /* Test 16-bit sample conversion (16-bit -> internal -> 16-bit). */ static int tstConversion16(RTTEST hTest) { unsigned i; uint32_t cBufSize = 256; RTTestSub(hTest, "Sample conversion (S16)"); /* 44100Hz, 1 Channel, S16 */ PDMAUDIOPCMPROPS cfg_p = PDMAUDIOPCMPROPS_INITIALIZOR( 2, /* Bytes */ true, /* Signed */ 1, /* Channels */ 44100, /* Hz */ PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(2 /* Bytes */, 1 /* Channels */), /* Shift */ false /* Swap Endian */ ); RTTESTI_CHECK(DrvAudioHlpPcmPropsAreValid(&cfg_p)); PDMAUDIOMIXBUF parent; RTTESTI_CHECK_RC_OK(AudioMixBufInit(&parent, "Parent", &cfg_p, cBufSize)); /* 22050Hz, 1 Channel, S16 */ PDMAUDIOPCMPROPS cfg_c = PDMAUDIOPCMPROPS_INITIALIZOR( /* Upmixing to parent */ 2, /* Bytes */ true, /* Signed */ 1, /* Channels */ 22050, /* Hz */ PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(2 /* Bytes */, 1 /* Channels */), /* Shift */ false /* Swap Endian */ ); RTTESTI_CHECK(DrvAudioHlpPcmPropsAreValid(&cfg_c)); PDMAUDIOMIXBUF child; RTTESTI_CHECK_RC_OK(AudioMixBufInit(&child, "Child", &cfg_c, cBufSize)); RTTESTI_CHECK_RC_OK(AudioMixBufLinkTo(&child, &parent)); /* 16-bit signed. More or less exclusively used as output, and usually as input, too. */ int16_t aFrames16S[16] = { 0xAA, 0xBB, INT16_MIN, INT16_MIN + 1, INT16_MIN / 2, -3, -2, -1, 0, 1, 2, 3, INT16_MAX / 2, INT16_MAX - 1, INT16_MAX, 0 }; /* * Writing + mixing from child -> parent, sequential. */ uint32_t cbBuf = 256; char achBuf[256]; uint32_t cFramesRead, cFramesWritten, cFramesMixed; uint32_t cFramesChild = 16; uint32_t cFramesParent = cFramesChild * 2 - 2; uint32_t cFramesTotalRead = 0; /**** 16-bit signed samples ****/ RTTestPrintf(hTest, RTTESTLVL_DEBUG, "Conversion test %uHz %uch 16-bit\n", cfg_c.uHz, cfg_c.cChannels); RTTESTI_CHECK_RC_OK(AudioMixBufWriteCirc(&child, &aFrames16S, sizeof(aFrames16S), &cFramesWritten)); RTTESTI_CHECK_MSG(cFramesWritten == cFramesChild, ("Child: Expected %RU32 written frames, got %RU32\n", cFramesChild, cFramesWritten)); RTTESTI_CHECK_RC_OK(AudioMixBufMixToParent(&child, cFramesWritten, &cFramesMixed)); uint32_t cFrames = AudioMixBufUsed(&parent); RTTESTI_CHECK_MSG(AudioMixBufLive(&child) == cFrames, ("Child: Expected %RU32 mixed frames, got %RU32\n", AudioMixBufLive(&child), cFrames)); RTTESTI_CHECK(AudioMixBufUsed(&parent) == AudioMixBufLive(&child)); for (;;) { RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufAcquireReadBlock(&parent, achBuf, cbBuf, &cFramesRead)); if (!cFramesRead) break; cFramesTotalRead += cFramesRead; AudioMixBufReleaseReadBlock(&parent, cFramesRead); AudioMixBufFinish(&parent, cFramesRead); } RTTESTI_CHECK_MSG(cFramesTotalRead == cFramesParent, ("Parent: Expected %RU32 mixed frames, got %RU32\n", cFramesParent, cFramesTotalRead)); /* Check that the frames came out unharmed. Every other sample is interpolated and we ignore it. */ /* NB: This also checks that the default volume setting is 0dB attenuation. */ int16_t *pSrc16 = &aFrames16S[0]; int16_t *pDst16 = (int16_t *)achBuf; for (i = 0; i < cFramesChild - 1; ++i) { RTTESTI_CHECK_MSG(*pSrc16 == *pDst16, ("index %u: Dst=%d, Src=%d\n", i, *pDst16, *pSrc16)); pSrc16 += 1; pDst16 += 2; } RTTESTI_CHECK(AudioMixBufUsed(&parent) == 0); RTTESTI_CHECK(AudioMixBufLive(&child) == 0); AudioMixBufDestroy(&parent); AudioMixBufDestroy(&child); return RTTestSubErrorCount(hTest) ? VERR_GENERAL_FAILURE : VINF_SUCCESS; } /* Test volume control. */ static int tstVolume(RTTEST hTest) { unsigned i; uint32_t cBufSize = 256; RTTestSub(hTest, "Volume control"); /* Same for parent/child. */ /* 44100Hz, 2 Channels, S16 */ PDMAUDIOPCMPROPS cfg = PDMAUDIOPCMPROPS_INITIALIZOR( 2, /* Bytes */ true, /* Signed */ 2, /* Channels */ 44100, /* Hz */ PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(2 /* Bytes */, 2 /* Channels */), /* Shift */ false /* Swap Endian */ ); RTTESTI_CHECK(DrvAudioHlpPcmPropsAreValid(&cfg)); PDMAUDIOVOLUME vol = { false, 0, 0 }; /* Not muted. */ PDMAUDIOMIXBUF parent; RTTESTI_CHECK_RC_OK(AudioMixBufInit(&parent, "Parent", &cfg, cBufSize)); PDMAUDIOMIXBUF child; RTTESTI_CHECK_RC_OK(AudioMixBufInit(&child, "Child", &cfg, cBufSize)); RTTESTI_CHECK_RC_OK(AudioMixBufLinkTo(&child, &parent)); /* A few 16-bit signed samples. */ int16_t 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 }; /* * Writing + mixing from child -> parent. */ uint32_t cbBuf = 256; char achBuf[256]; uint32_t cFramesRead, cFramesWritten, cFramesMixed; uint32_t cFramesChild = 8; uint32_t cFramesParent = cFramesChild; uint32_t cFramesTotalRead; int16_t *pSrc16; int16_t *pDst16; /**** Volume control test ****/ RTTestPrintf(hTest, RTTESTLVL_DEBUG, "Volume control test %uHz %uch \n", cfg.uHz, cfg.cChannels); /* 1) Full volume/0dB attenuation (255). */ vol.uLeft = vol.uRight = 255; AudioMixBufSetVolume(&child, &vol); RTTESTI_CHECK_RC_OK(AudioMixBufWriteCirc(&child, &aFrames16S, sizeof(aFrames16S), &cFramesWritten)); RTTESTI_CHECK_MSG(cFramesWritten == cFramesChild, ("Child: Expected %RU32 written frames, got %RU32\n", cFramesChild, cFramesWritten)); RTTESTI_CHECK_RC_OK(AudioMixBufMixToParent(&child, cFramesWritten, &cFramesMixed)); cFramesTotalRead = 0; for (;;) { RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufAcquireReadBlock(&parent, achBuf, cbBuf, &cFramesRead)); if (!cFramesRead) break; cFramesTotalRead += cFramesRead; AudioMixBufReleaseReadBlock(&parent, cFramesRead); AudioMixBufFinish(&parent, cFramesRead); } RTTESTI_CHECK_MSG(cFramesTotalRead == cFramesParent, ("Parent: Expected %RU32 mixed frames, got %RU32\n", cFramesParent, cFramesTotalRead)); /* Check that at 0dB the frames came out unharmed. */ pSrc16 = &aFrames16S[0]; pDst16 = (int16_t *)achBuf; for (i = 0; i < cFramesParent * 2 /* stereo */; ++i) { RTTESTI_CHECK_MSG(*pSrc16 == *pDst16, ("index %u: Dst=%d, Src=%d\n", i, *pDst16, *pSrc16)); ++pSrc16; ++pDst16; } AudioMixBufReset(&child); /* 2) Half volume/-6dB attenuation (16 steps down). */ vol.uLeft = vol.uRight = 255 - 16; AudioMixBufSetVolume(&child, &vol); RTTESTI_CHECK_RC_OK(AudioMixBufWriteCirc(&child, &aFrames16S, sizeof(aFrames16S), &cFramesWritten)); RTTESTI_CHECK_MSG(cFramesWritten == cFramesChild, ("Child: Expected %RU32 written frames, got %RU32\n", cFramesChild, cFramesWritten)); RTTESTI_CHECK_RC_OK(AudioMixBufMixToParent(&child, cFramesWritten, &cFramesMixed)); cFramesTotalRead = 0; for (;;) { RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufAcquireReadBlock(&parent, achBuf, cbBuf, &cFramesRead)); if (!cFramesRead) break; cFramesTotalRead += cFramesRead; AudioMixBufReleaseReadBlock(&parent, cFramesRead); AudioMixBufFinish(&parent, cFramesRead); } RTTESTI_CHECK_MSG(cFramesTotalRead == cFramesParent, ("Parent: Expected %RU32 mixed frames, got %RU32\n", cFramesParent, cFramesTotalRead)); /* Check that at -6dB the sample values are halved. */ pSrc16 = &aFrames16S[0]; pDst16 = (int16_t *)achBuf; for (i = 0; i < cFramesParent * 2 /* stereo */; ++i) { /* Watch out! For negative values, x >> 1 is not the same as x / 2. */ RTTESTI_CHECK_MSG(*pSrc16 >> 1 == *pDst16, ("index %u: Dst=%d, Src=%d\n", i, *pDst16, *pSrc16)); ++pSrc16; ++pDst16; } AudioMixBufDestroy(&parent); AudioMixBufDestroy(&child); return RTTestSubErrorCount(hTest) ? VERR_GENERAL_FAILURE : VINF_SUCCESS; } 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); tstSingle(hTest); tstParentChild(hTest); tstConversion8(hTest); tstConversion16(hTest); tstVolume(hTest); /* * Summary */ return RTTestSummaryAndDestroy(hTest); }