static DECLCALLBACK(int) drvHostALSAAudioInitIn(PPDMIHOSTAUDIO pInterface, PPDMAUDIOHSTSTRMIN pHstStrmIn, PPDMAUDIOSTREAMCFG pCfg, PDMAUDIORECSOURCE enmRecSource, uint32_t *pcSamples) { NOREF(pInterface); AssertPtrReturn(pHstStrmIn, VERR_INVALID_POINTER); AssertPtrReturn(pCfg, VERR_INVALID_POINTER); int rc; PALSAAUDIOSTREAMIN pThisStrmIn = (PALSAAUDIOSTREAMIN)pHstStrmIn; snd_pcm_t *phPCM = NULL; do { ALSAAUDIOSTREAMCFG req; req.fmt = drvHostALSAAudioFmtToALSA(pCfg->enmFormat); req.freq = pCfg->uHz; req.nchannels = pCfg->cChannels; req.period_size = s_ALSAConf.period_size_in; req.buffer_size = s_ALSAConf.buffer_size_in; ALSAAUDIOSTREAMCFG obt; rc = drvHostALSAAudioOpen(true /* fIn */, &req, &obt, &phPCM); if (RT_FAILURE(rc)) break; PDMAUDIOFMT enmFormat; PDMAUDIOENDIANNESS enmEnd; rc = drvHostALSAAudioALSAToFmt(obt.fmt, &enmFormat, &enmEnd); if (RT_FAILURE(rc)) break; PDMAUDIOSTREAMCFG streamCfg; streamCfg.uHz = obt.freq; streamCfg.cChannels = obt.nchannels; streamCfg.enmFormat = enmFormat; streamCfg.enmEndianness = enmEnd; rc = drvAudioStreamCfgToProps(&streamCfg, &pHstStrmIn->Props); if (RT_FAILURE(rc)) break; AssertBreakStmt(obt.samples, rc = VERR_INVALID_PARAMETER); size_t cbBuf = obt.samples * (1 << pHstStrmIn->Props.cShift); AssertBreakStmt(cbBuf, rc = VERR_INVALID_PARAMETER); pThisStrmIn->pvBuf = RTMemAlloc(cbBuf); if (!pThisStrmIn->pvBuf) { LogRel(("ALSA: Not enough memory for input ADC buffer (%RU32 samples, each %d bytes)\n", obt.samples, 1 << pHstStrmIn->Props.cShift)); rc = VERR_NO_MEMORY; break; } pThisStrmIn->cbBuf = cbBuf; pThisStrmIn->phPCM = phPCM; if (pcSamples) *pcSamples = obt.samples; } while (0); if (RT_FAILURE(rc)) drvHostALSAAudioClose(&phPCM); LogFlowFuncLeaveRC(rc); return rc; }
static int tstParentChild(RTTEST hTest) { RTTestSubF(hTest, "2 Children -> Parent"); uint32_t cBufSize = _1K; PDMAUDIOSTREAMCFG cfg_p = { 44100, /* Hz */ 2 /* Channels */, AUD_FMT_S16 /* Format */, PDMAUDIOENDIANESS_LITTLE /* Endianess */ }; PDMPCMPROPS props; int rc = drvAudioStreamCfgToProps(&cfg_p, &props); AssertRC(rc); PDMAUDIOMIXBUF parent; RTTESTI_CHECK_RC_OK(audioMixBufInit(&parent, "Parent", &props, cBufSize)); PDMAUDIOSTREAMCFG cfg_c1 = /* Upmixing to parent */ { 22100, /* Hz */ 2 /* Channels */, AUD_FMT_S16 /* Format */, PDMAUDIOENDIANESS_LITTLE /* Endianess */ }; rc = drvAudioStreamCfgToProps(&cfg_c1, &props); AssertRC(rc); PDMAUDIOMIXBUF child1; RTTESTI_CHECK_RC_OK(audioMixBufInit(&child1, "Child1", &props, cBufSize)); RTTESTI_CHECK_RC_OK(audioMixBufLinkTo(&child1, &parent)); PDMAUDIOSTREAMCFG cfg_c2 = /* Downmixing to parent */ { 48000, /* Hz */ 2 /* Channels */, AUD_FMT_S16 /* Format */, PDMAUDIOENDIANESS_LITTLE /* Endianess */ }; rc = drvAudioStreamCfgToProps(&cfg_c2, &props); AssertRC(rc); PDMAUDIOMIXBUF child2; RTTESTI_CHECK_RC_OK(audioMixBufInit(&child2, "Child2", &props, cBufSize)); RTTESTI_CHECK_RC_OK(audioMixBufLinkTo(&child2, &parent)); /* * Writing + mixing from child/children -> parent, sequential. */ size_t cbBuf = _1K; char pvBuf[_1K]; int16_t samples[32] = { 0xAA, 0xBB }; uint32_t free, read , written, proc, mixed, temp; uint32_t cChild1Free = cBufSize; uint32_t cChild1Mixed = 0; uint32_t cSamplesParent1 = 16; uint32_t cSamplesChild1 = 16; uint32_t cChild2Free = cBufSize; uint32_t cChild2Mixed = 0; uint32_t cSamplesParent2 = 16; uint32_t cSamplesChild2 = 16; uint32_t t = RTRandU32() % 64; for (uint32_t i = 0; i < t; i++) { RTTestPrintf(hTest, RTTESTLVL_DEBUG, "i=%RU32\n", i); RTTESTI_CHECK_RC_OK_BREAK(audioMixBufWriteAt(&child1, 0, &samples, sizeof(samples), &written)); RTTESTI_CHECK_MSG_BREAK(written == cSamplesChild1, ("Child1: Expected %RU32 written samples, got %RU32\n", cSamplesChild1, written)); RTTESTI_CHECK_RC_OK_BREAK(audioMixBufMixToParent(&child1, written, &mixed)); temp = audioMixBufProcessed(&parent) - audioMixBufMixed(&child2); RTTESTI_CHECK_MSG_BREAK(audioMixBufMixed(&child1) == temp, ("Child1: Expected %RU32 mixed samples, got %RU32\n", audioMixBufMixed(&child1), temp)); RTTESTI_CHECK_RC_OK_BREAK(audioMixBufWriteAt(&child2, 0, &samples, sizeof(samples), &written)); RTTESTI_CHECK_MSG_BREAK(written == cSamplesChild2, ("Child2: Expected %RU32 written samples, got %RU32\n", cSamplesChild2, written)); RTTESTI_CHECK_RC_OK_BREAK(audioMixBufMixToParent(&child2, written, &mixed)); temp = audioMixBufProcessed(&parent) - audioMixBufMixed(&child1); RTTESTI_CHECK_MSG_BREAK(audioMixBufMixed(&child2) == temp, ("Child2: Expected %RU32 mixed samples, got %RU32\n", audioMixBufMixed(&child2), temp)); } RTTESTI_CHECK(audioMixBufProcessed(&parent) == audioMixBufMixed(&child1) + audioMixBufMixed(&child2)); for (;;) { RTTESTI_CHECK_RC_OK_BREAK(audioMixBufReadCirc(&parent, pvBuf, cbBuf, &read)); if (!read) break; audioMixBufFinish(&parent, read); } RTTESTI_CHECK(audioMixBufProcessed(&parent) == 0); RTTESTI_CHECK(audioMixBufMixed(&child1) == 0); RTTESTI_CHECK(audioMixBufMixed(&child2) == 0); return RTTestSubErrorCount(hTest) ? VERR_GENERAL_FAILURE : VINF_SUCCESS; }
static int tstSingle(RTTEST hTest) { RTTestSubF(hTest, "Single buffer"); PDMAUDIOSTREAMCFG config = { 44100, /* Hz */ 2 /* Channels */, AUD_FMT_S16 /* Format */, PDMAUDIOENDIANESS_LITTLE /* Endianess */ }; PDMPCMPROPS props; int rc = drvAudioStreamCfgToProps(&config, &props); AssertRC(rc); uint32_t cBufSize = _1K; /* * General stuff. */ PDMAUDIOMIXBUF mb; RTTESTI_CHECK_RC_OK(audioMixBufInit(&mb, "Single", &props, cBufSize)); RTTESTI_CHECK(audioMixBufSize(&mb) == cBufSize); RTTESTI_CHECK(AUDIOMIXBUF_B2S(&mb, audioMixBufSizeBytes(&mb)) == cBufSize); RTTESTI_CHECK(AUDIOMIXBUF_S2B(&mb, audioMixBufSize(&mb)) == audioMixBufSizeBytes(&mb)); RTTESTI_CHECK(audioMixBufFree(&mb) == cBufSize); RTTESTI_CHECK(AUDIOMIXBUF_S2B(&mb, audioMixBufFree(&mb)) == audioMixBufFreeBytes(&mb)); /* * Absolute writes. */ uint32_t read = 0, written = 0, written_abs = 0; int8_t samples8 [2] = { 0x12, 0x34 }; int16_t samples16[2] = { 0xAA, 0xBB }; int32_t samples32[2] = { 0xCC, 0xDD }; int64_t samples64[2] = { 0xEE, 0xFF }; RTTESTI_CHECK_RC_OK(audioMixBufWriteAt(&mb, 0, &samples8, sizeof(samples8), &written)); RTTESTI_CHECK(written == 0 /* Samples */); RTTESTI_CHECK_RC_OK(audioMixBufWriteAt(&mb, 0, &samples16, sizeof(samples16), &written)); RTTESTI_CHECK(written == 1 /* Samples */); RTTESTI_CHECK_RC_OK(audioMixBufWriteAt(&mb, 2, &samples32, sizeof(samples32), &written)); RTTESTI_CHECK(written == 2 /* Samples */); written_abs = 0; /* Beyond buffer. */ RTTESTI_CHECK_RC(audioMixBufWriteAt(&mb, audioMixBufSize(&mb) + 1, &samples16, sizeof(samples16), &written), VERR_BUFFER_OVERFLOW); /* * Circular writes. */ size_t cToWrite = audioMixBufSize(&mb) - written_abs - 1; /* -1 as padding plus -2 samples for above. */ for (size_t i = 0; i < cToWrite; i++) { RTTESTI_CHECK_RC_OK(audioMixBufWriteCirc(&mb, &samples16, sizeof(samples16), &written)); RTTESTI_CHECK(written == 1); } RTTESTI_CHECK(!audioMixBufIsEmpty(&mb)); RTTESTI_CHECK(audioMixBufFree(&mb) == 1); RTTESTI_CHECK(audioMixBufFreeBytes(&mb) == AUDIOMIXBUF_S2B(&mb, 1U)); RTTESTI_CHECK(audioMixBufProcessed(&mb) == cToWrite + written_abs /* + last absolute write */); RTTESTI_CHECK_RC_OK(audioMixBufWriteCirc(&mb, &samples16, sizeof(samples16), &written)); RTTESTI_CHECK(written == 1); RTTESTI_CHECK(audioMixBufFree(&mb) == 0); RTTESTI_CHECK(audioMixBufFreeBytes(&mb) == AUDIOMIXBUF_S2B(&mb, 0)); RTTESTI_CHECK(audioMixBufProcessed(&mb) == cBufSize); /* Circular reads. */ size_t cToRead = audioMixBufSize(&mb) - written_abs - 1; for (size_t i = 0; i < cToWrite; i++) { RTTESTI_CHECK_RC_OK(audioMixBufReadCirc(&mb, &samples16, sizeof(samples16), &read)); RTTESTI_CHECK(read == 1); audioMixBufFinish(&mb, read); } RTTESTI_CHECK(!audioMixBufIsEmpty(&mb)); RTTESTI_CHECK(audioMixBufFree(&mb) == audioMixBufSize(&mb) - written_abs - 1); RTTESTI_CHECK(audioMixBufFreeBytes(&mb) == AUDIOMIXBUF_S2B(&mb, cBufSize - written_abs - 1)); RTTESTI_CHECK(audioMixBufProcessed(&mb) == cBufSize - cToRead + written_abs); RTTESTI_CHECK_RC_OK(audioMixBufReadCirc(&mb, &samples16, sizeof(samples16), &read)); RTTESTI_CHECK(read == 1); audioMixBufFinish(&mb, read); RTTESTI_CHECK(audioMixBufFree(&mb) == cBufSize - written_abs); RTTESTI_CHECK(audioMixBufFreeBytes(&mb) == AUDIOMIXBUF_S2B(&mb, cBufSize - written_abs)); RTTESTI_CHECK(audioMixBufProcessed(&mb) == written_abs); return RTTestSubErrorCount(hTest) ? VERR_GENERAL_FAILURE : VINF_SUCCESS; }
static DECLCALLBACK(int) drvHostPulseAudioInitOut(PPDMIHOSTAUDIO pInterface, PPDMAUDIOHSTSTRMOUT pHstStrmOut, PPDMAUDIOSTREAMCFG pCfg, uint32_t *pcSamples) { AssertPtrReturn(pInterface, VERR_INVALID_POINTER); AssertPtrReturn(pHstStrmOut, VERR_INVALID_POINTER); AssertPtrReturn(pCfg, VERR_INVALID_POINTER); /* pcSamples is optional. */ PDRVHOSTPULSEAUDIO pDrv = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface); PPULSEAUDIOSTREAM pThisStrmOut = (PPULSEAUDIOSTREAM)pHstStrmOut; LogFlowFuncEnter(); pThisStrmOut->pDrainOp = NULL; pThisStrmOut->SampleSpec.format = drvHostPulseAudioFmtToPulse(pCfg->enmFormat); pThisStrmOut->SampleSpec.rate = pCfg->uHz; pThisStrmOut->SampleSpec.channels = pCfg->cChannels; /* Note that setting maxlength to -1 does not work on PulseAudio servers * older than 0.9.10. So use the suggested value of 3/2 of tlength */ pThisStrmOut->BufAttr.tlength = (pa_bytes_per_second(&pThisStrmOut->SampleSpec) * s_pulseCfg.buffer_msecs_out) / 1000; pThisStrmOut->BufAttr.maxlength = (pThisStrmOut->BufAttr.tlength * 3) / 2; pThisStrmOut->BufAttr.prebuf = -1; /* Same as tlength */ pThisStrmOut->BufAttr.minreq = -1; /* Pulse should set something sensible for minreq on it's own */ /* Note that the struct BufAttr is updated to the obtained values after this call! */ char achName[64]; RTStrPrintf(achName, sizeof(achName), "%.32s (out)", pDrv->pszStreamName); int rc = drvHostPulseAudioOpen(false /* fIn */, achName, &pThisStrmOut->SampleSpec, &pThisStrmOut->BufAttr, &pThisStrmOut->pStream); if (RT_FAILURE(rc)) return rc; PDMAUDIOSTREAMCFG streamCfg; rc = drvHostPulseAudioPulseToFmt(pThisStrmOut->SampleSpec.format, &streamCfg.enmFormat, &streamCfg.enmEndianness); if (RT_FAILURE(rc)) { LogRel(("PulseAudio: Cannot find audio output format %ld\n", pThisStrmOut->SampleSpec.format)); return rc; } streamCfg.uHz = pThisStrmOut->SampleSpec.rate; streamCfg.cChannels = pThisStrmOut->SampleSpec.channels; rc = drvAudioStreamCfgToProps(&streamCfg, &pHstStrmOut->Props); if (RT_SUCCESS(rc)) { uint32_t cbBuf = RT_MIN(pThisStrmOut->BufAttr.tlength * 2, pThisStrmOut->BufAttr.maxlength); /** @todo Make this configurable! */ if (cbBuf) { pThisStrmOut->pvPCMBuf = RTMemAllocZ(cbBuf); if (pThisStrmOut->pvPCMBuf) { pThisStrmOut->cbPCMBuf = cbBuf; uint32_t cSamples = cbBuf >> pHstStrmOut->Props.cShift; if (pcSamples) *pcSamples = cSamples; /* Save pointer to driver instance. */ pThisStrmOut->pDrv = pDrv; LogFunc(("cbBuf=%RU32, cSamples=%RU32\n", cbBuf, cSamples)); } else rc = VERR_NO_MEMORY; }