static DECLCALLBACK(int) drvHostALSAAudioCaptureIn(PPDMIHOSTAUDIO pInterface, PPDMAUDIOHSTSTRMIN pHstStrmIn,
uint32_t *pcSamplesCaptured)
{
NOREF(pInterface);
AssertPtrReturn(pHstStrmIn, VERR_INVALID_POINTER);
PALSAAUDIOSTREAMIN pThisStrmIn = (PALSAAUDIOSTREAMIN)pHstStrmIn;
snd_pcm_sframes_t cAvail;
int rc = drvHostALSAAudioGetAvail(pThisStrmIn->phPCM, &cAvail);
if (RT_FAILURE(rc))
{
LogFunc(("Error getting number of captured frames, rc=%Rrc\n", rc));
return rc;
}
if (!cAvail) /* No data yet? */
{
snd_pcm_state_t state = snd_pcm_state(pThisStrmIn->phPCM);
switch (state)
{
case SND_PCM_STATE_PREPARED:
cAvail = AudioMixBufFree(&pHstStrmIn->MixBuf);
break;
case SND_PCM_STATE_SUSPENDED:
{
rc = drvHostALSAAudioResume(pThisStrmIn->phPCM);
if (RT_FAILURE(rc))
break;
LogFlow(("Resuming suspended input stream\n"));
break;
}
default:
LogFlow(("No frames available, state=%d\n", state));
break;
}
if (!cAvail)
{
if (pcSamplesCaptured)
*pcSamplesCaptured = 0;
return VINF_SUCCESS;
}
}
/*
* Check how much we can read from the capture device without overflowing
* the mixer buffer.
*/
Assert(cAvail);
size_t cbMixFree = AudioMixBufFreeBytes(&pHstStrmIn->MixBuf);
size_t cbToRead = RT_MIN((size_t)AUDIOMIXBUF_S2B(&pHstStrmIn->MixBuf, cAvail), cbMixFree);
LogFlowFunc(("cbToRead=%zu, cAvail=%RI32\n", cbToRead, cAvail));
uint32_t cWrittenTotal = 0;
snd_pcm_uframes_t cToRead;
snd_pcm_sframes_t cRead;
while ( cbToRead
&& RT_SUCCESS(rc))
{
cToRead = RT_MIN(AUDIOMIXBUF_B2S(&pHstStrmIn->MixBuf, cbToRead),
AUDIOMIXBUF_B2S(&pHstStrmIn->MixBuf, pThisStrmIn->cbBuf));
AssertBreakStmt(cToRead, rc = VERR_NO_DATA);
cRead = snd_pcm_readi(pThisStrmIn->phPCM, pThisStrmIn->pvBuf, cToRead);
if (cRead <= 0)
{
switch (cRead)
{
case 0:
{
LogFunc(("No input frames available\n"));
rc = VERR_ACCESS_DENIED;
break;
}
case -EAGAIN:
/*
* Don't set error here because EAGAIN means there are no further frames
* available at the moment, try later. As we might have read some frames
* already these need to be processed instead.
*/
cbToRead = 0;
break;
case -EPIPE:
{
rc = drvHostALSAAudioRecover(pThisStrmIn->phPCM);
if (RT_FAILURE(rc))
break;
LogFlowFunc(("Recovered from capturing\n"));
continue;
}
default:
LogFunc(("Failed to read input frames: %s\n", snd_strerror(cRead)));
rc = VERR_GENERAL_FAILURE; /** @todo Fudge! */
break;
}
}
else
{
uint32_t cWritten;
rc = AudioMixBufWriteCirc(&pHstStrmIn->MixBuf,
pThisStrmIn->pvBuf, AUDIOMIXBUF_S2B(&pHstStrmIn->MixBuf, cRead),
&cWritten);
if (RT_FAILURE(rc))
break;
/*
* We should not run into a full mixer buffer or we loose samples and
* run into an endless loop if ALSA keeps producing samples ("null"
* capture device for example).
*/
AssertLogRelMsgBreakStmt(cWritten > 0, ("Mixer buffer shouldn't be full at this point!\n"),
rc = VERR_INTERNAL_ERROR);
uint32_t cbWritten = AUDIOMIXBUF_S2B(&pHstStrmIn->MixBuf, cWritten);
Assert(cbToRead >= cbWritten);
cbToRead -= cbWritten;
cWrittenTotal += cWritten;
}
}
if (RT_SUCCESS(rc))
{
uint32_t cProcessed = 0;
if (cWrittenTotal)
rc = AudioMixBufMixToParent(&pHstStrmIn->MixBuf, cWrittenTotal,
&cProcessed);
if (pcSamplesCaptured)
*pcSamplesCaptured = cWrittenTotal;
LogFlowFunc(("cWrittenTotal=%RU32 (%RU32 processed), rc=%Rrc\n",
cWrittenTotal, cProcessed, rc));
}
LogFlowFuncLeaveRC(rc);
return rc;
}
static DECLCALLBACK(int) drvHostALSAAudioPlayOut(PPDMIHOSTAUDIO pInterface, PPDMAUDIOHSTSTRMOUT pHstStrmOut,
uint32_t *pcSamplesPlayed)
{
NOREF(pInterface);
AssertPtrReturn(pHstStrmOut, VERR_INVALID_POINTER);
PALSAAUDIOSTREAMOUT pThisStrmOut = (PALSAAUDIOSTREAMOUT)pHstStrmOut;
int rc = VINF_SUCCESS;
uint32_t cbReadTotal = 0;
do
{
snd_pcm_sframes_t cAvail;
rc = drvHostALSAAudioGetAvail(pThisStrmOut->phPCM, &cAvail);
if (RT_FAILURE(rc))
{
LogFunc(("Error getting number of playback frames, rc=%Rrc\n", rc));
break;
}
size_t cbToRead = RT_MIN(AUDIOMIXBUF_S2B(&pHstStrmOut->MixBuf,
cAvail),
AUDIOMIXBUF_S2B(&pHstStrmOut->MixBuf,
drvAudioHstOutSamplesLive(pHstStrmOut, NULL /* pcStreamsLive */)));
LogFlowFunc(("cbToRead=%zu, cbAvail=%zu\n",
cbToRead, AUDIOMIXBUF_S2B(&pHstStrmOut->MixBuf, cAvail)));
uint32_t cRead, cbRead;
snd_pcm_sframes_t cWritten;
while (cbToRead)
{
rc = AudioMixBufReadCirc(&pHstStrmOut->MixBuf, pThisStrmOut->pvBuf, cbToRead, &cRead);
if (RT_FAILURE(rc))
break;
cbRead = AUDIOMIXBUF_S2B(&pHstStrmOut->MixBuf, cRead);
AssertBreak(cbRead);
cWritten = snd_pcm_writei(pThisStrmOut->phPCM, pThisStrmOut->pvBuf, cRead);
if (cWritten <= 0)
{
switch (cWritten)
{
case 0:
{
LogFunc(("Failed to write %RI32 frames\n", cRead));
rc = VERR_ACCESS_DENIED;
break;
}
case -EPIPE:
{
rc = drvHostALSAAudioRecover(pThisStrmOut->phPCM);
if (RT_FAILURE(rc))
break;
LogFlowFunc(("Recovered from playback\n"));
continue;
}
case -ESTRPIPE:
{
/* Stream was suspended and waiting for a recovery. */
rc = drvHostALSAAudioResume(pThisStrmOut->phPCM);
if (RT_FAILURE(rc))
{
LogRel(("ALSA: Failed to resume output stream\n"));
break;
}
LogFlowFunc(("Resumed suspended output stream\n"));
continue;
}
default:
LogFlowFunc(("Failed to write %RI32 output frames, rc=%Rrc\n",
cRead, rc));
rc = VERR_GENERAL_FAILURE; /** @todo */
break;
}
}
if (RT_FAILURE(rc))
break;
Assert(cbToRead >= cbRead);
cbToRead -= cbRead;
cbReadTotal += cbRead;
}
}
while (0);
if (RT_SUCCESS(rc))
{
uint32_t cReadTotal = AUDIOMIXBUF_B2S(&pHstStrmOut->MixBuf, cbReadTotal);
if (cReadTotal)
AudioMixBufFinish(&pHstStrmOut->MixBuf, cReadTotal);
if (pcSamplesPlayed)
*pcSamplesPlayed = cReadTotal;
LogFlowFunc(("cReadTotal=%RU32 (%RU32 bytes), rc=%Rrc\n",
cReadTotal, cbReadTotal, rc));
}
LogFlowFuncLeaveRC(rc);
return rc;
}
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;
}
