Index: /trunk/include/VBox/vmm/pdmaudioifs.h =================================================================== --- /trunk/include/VBox/vmm/pdmaudioifs.h (revision 75961) +++ /trunk/include/VBox/vmm/pdmaudioifs.h (revision 75962) @@ -471,4 +471,5 @@ /** Circular buffer for the channel data. */ PRTCIRCBUF pCircBuf; + /** Amount of audio data (in bytes) acquired for reading. */ size_t cbAcq; /** Channel data flags. */ @@ -477,23 +478,65 @@ /** - * Structure for a single channel of an audio stream. - * An audio stream consists of one or multiple channels, + * Enumeration for standard speaker channel IDs. + * This can cover up to 11.0 surround sound. + * + * Note: Any of those channels can be marked / used as the LFE channel (played through the subwoofer). + */ +typedef enum PDMAUDIOSTREAMCHANNELID +{ + /** Unknown / not set channel ID. */ + PDMAUDIOSTREAMCHANNELID_UNKNOWN = 0, + /** Front left channel. */ + PDMAUDIOSTREAMCHANNELID_FRONT_LEFT, + /** Front right channel. */ + PDMAUDIOSTREAMCHANNELID_FRONT_RIGHT, + /** Front center channel. */ + PDMAUDIOSTREAMCHANNELID_FRONT_CENTER, + /** Low frequency effects (subwoofer) channel. */ + PDMAUDIOSTREAMCHANNELID_LFE, + /** Rear left channel. */ + PDMAUDIOSTREAMCHANNELID_REAR_LEFT, + /** Rear right channel. */ + PDMAUDIOSTREAMCHANNELID_REAR_RIGHT, + /** Front left of center channel. */ + PDMAUDIOSTREAMCHANNELID_FRONT_LEFT_OF_CENTER, + /** Front right of center channel. */ + PDMAUDIOSTREAMCHANNELID_FRONT_RIGHT_OF_CENTER, + /** Rear center channel. */ + PDMAUDIOSTREAMCHANNELID_REAR_CENTER, + /** Side left channel. */ + PDMAUDIOSTREAMCHANNELID_SIDE_LEFT, + /** Side right channel. */ + PDMAUDIOSTREAMCHANNELID_SIDE_RIGHT, + /** Left height channel. */ + PDMAUDIOSTREAMCHANNELID_LEFT_HEIGHT, + /** Right height channel. */ + PDMAUDIOSTREAMCHANNELID_RIGHT_HEIGHT, + /** Hack to blow the type up to 32-bit. */ + PDMAUDIOSTREAMCHANNELID_32BIT_HACK = 0x7fffffff +} PDMAUDIOSTREAMCHANNELID; + +/** + * Structure for mapping a single (mono) channel or dual (stereo) channels of an audio stream (aka stream profile). + * + * An audio stream consists of one or multiple channels (e.g. 1 for mono, 2 for stereo), * depending on the configuration. */ -typedef struct PDMAUDIOSTREAMCHANNEL -{ - /** Channel ID. */ - uint8_t uChannel; +typedef struct PDMAUDIOSTREAMMAP +{ + /** Array of channel IDs being handled. + * Note: The first (zero-based) index specifies the leftmost channel. */ + PDMAUDIOSTREAMCHANNELID aID[2]; /** Step size (in bytes) to the channel's next frame. */ - size_t cbStep; + size_t cbSize; /** Frame size (in bytes) of this channel. */ - size_t cbFrame; + size_t cbFrame; /** Offset (in bytes) to first frame in the data block. */ - size_t cbFirst; - /** Currente offset (in bytes) in the data stream. */ - size_t cbOff; + size_t cbFirst; + /** Offset (in bytes) to the next frame in the data block. */ + size_t cbOff; /** Associated data buffer. */ - PDMAUDIOSTREAMCHANNELDATA Data; -} PDMAUDIOSTREAMCHANNEL, *PPDMAUDIOSTREAMCHANNEL; + PDMAUDIOSTREAMCHANNELDATA Data; +} PDMAUDIOSTREAMMAP, *PPDMAUDIOSTREAMMAP; /** Index: /trunk/src/VBox/Devices/Audio/DevHDA.cpp =================================================================== --- /trunk/src/VBox/Devices/Audio/DevHDA.cpp (revision 75961) +++ /trunk/src/VBox/Devices/Audio/DevHDA.cpp (revision 75962) @@ -57,7 +57,4 @@ #include "HDACodec.h" #include "HDAStream.h" -# if defined(VBOX_WITH_HDA_AUDIO_INTERLEAVING_STREAMS_SUPPORT) || defined(VBOX_WITH_AUDIO_HDA_51_SURROUND) -# include "HDAStreamChannel.h" -# endif #include "HDAStreamMap.h" #include "HDAStreamPeriod.h" @@ -108,9 +105,4 @@ #else # error "Please specify your HDA device vendor/device IDs" -#endif - -/* Make sure that interleaving streams support is enabled if the 5.1 surround code is being used. */ -#if defined (VBOX_WITH_AUDIO_HDA_51_SURROUND) && !defined(VBOX_WITH_HDA_AUDIO_INTERLEAVING_STREAMS_SUPPORT) -# define VBOX_WITH_HDA_AUDIO_INTERLEAVING_STREAMS_SUPPORT #endif @@ -1312,4 +1304,12 @@ uSD, fRun, fInRun, fReset, fInReset, u32Value)); +# ifdef DEBUG + if (hdaGetDirFromSD(uSD) == PDMAUDIODIR_OUT) + { + const uint8_t uStripeCtl = ((u32Value >> HDA_SDCTL_STRIPE_SHIFT) & HDA_SDCTL_STRIPE_MASK) + 1; + LogFunc(("[SD%RU8] Using %RU8 SDOs (stripe control)\n", uSD, uStripeCtl)); + } +# endif + /* * Extract the stream tag the guest wants to use for this specific @@ -1810,11 +1810,4 @@ } } -# else /* !VBOX_WITH_AUDIO_HDA_51_SURROUND */ - /* Only support mono or stereo channels. */ - if ( pCfg->Props.cChannels != 1 /* Mono */ - && pCfg->Props.cChannels != 2 /* Stereo */) - { - rc = VERR_NOT_SUPPORTED; - } # endif /* !VBOX_WITH_AUDIO_HDA_51_SURROUND */ @@ -1839,5 +1832,4 @@ pCfg->enmLayout = PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED; - pCfg->Props.cChannels = 2; pCfg->Props.cShift = PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(pCfg->Props.cBytes, pCfg->Props.cChannels); @@ -1855,5 +1847,5 @@ pCfg->Props.cChannels = (fUseCenter && fUseLFE) ? 2 : 1; - pCfg->Props.cShift = PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(pCfg->Props.cBits, pCfg->Props.cChannels); + pCfg->Props.cShift = PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(pCfg->Props.cBytes, pCfg->Props.cChannels); rc = hdaCodecAddStream(pThis->pCodec, PDMAUDIOMIXERCTL_CENTER_LFE, pCfg); @@ -1869,5 +1861,5 @@ pCfg->Props.cChannels = 2; - pCfg->Props.cShift = PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(pCfg->Props.cBits, pCfg->Props.cChannels); + pCfg->Props.cShift = PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(pCfg->Props.cBytes, pCfg->Props.cChannels); rc = hdaCodecAddStream(pThis->pCodec, PDMAUDIOMIXERCTL_REAR, pCfg); @@ -2485,5 +2477,5 @@ AssertPtrReturn(pCfg, VERR_INVALID_POINTER); - LogFunc(("Sink=%s, Stream=%s\n", pMixSink->pszName, pCfg->szName)); + LogFunc(("szSink=%s, szStream=%s, cChannels=%RU8\n", pMixSink->pszName, pCfg->szName, pCfg->Props.cChannels)); PPDMAUDIOSTREAMCFG pStreamCfg = DrvAudioHlpStreamCfgDup(pCfg); Index: /trunk/src/VBox/Devices/Audio/DevHDACommon.cpp =================================================================== --- /trunk/src/VBox/Devices/Audio/DevHDACommon.cpp (revision 75961) +++ /trunk/src/VBox/Devices/Audio/DevHDACommon.cpp (revision 75962) @@ -340,5 +340,5 @@ # endif if (pStream->Dbg.Runtime.fEnabled) - DrvAudioHlpFileWrite(pStream->Dbg.Runtime.pFileDMA, (uint8_t *)pvBuf + cbReadTotal, cbChunk, 0 /* fFlags */); + DrvAudioHlpFileWrite(pStream->Dbg.Runtime.pFileDMARaw, (uint8_t *)pvBuf + cbReadTotal, cbChunk, 0 /* fFlags */); STAM_COUNTER_ADD(&pThis->StatBytesRead, cbChunk); @@ -406,5 +406,5 @@ if (pStream->Dbg.Runtime.fEnabled) - DrvAudioHlpFileWrite(pStream->Dbg.Runtime.pFileDMA, (uint8_t *)pvBuf + cbWrittenTotal, cbChunk, 0 /* fFlags */); + DrvAudioHlpFileWrite(pStream->Dbg.Runtime.pFileDMARaw, (uint8_t *)pvBuf + cbWrittenTotal, cbChunk, 0 /* fFlags */); rc = PDMDevHlpPCIPhysWrite(pThis->CTX_SUFF(pDevIns), Index: /trunk/src/VBox/Devices/Audio/DevHDACommon.h =================================================================== --- /trunk/src/VBox/Devices/Audio/DevHDACommon.h (revision 75961) +++ /trunk/src/VBox/Devices/Audio/DevHDACommon.h (revision 75962) @@ -91,6 +91,10 @@ * * Lowering this value can ask for trouble, as backends then can run - * into data underruns. */ -#define HDA_TIMER_HZ_DEFAULT 100 + * into data underruns. + * + * Note: For handling surround setups (e.g. 5.1 speaker setups) we need + * a higher Hz rate, as the device emulation otherwise will come into + * timing trouble, making the output (DMA reads) crackling. */ +#define HDA_TIMER_HZ_DEFAULT 200 /** Default position adjustment (in audio samples). @@ -113,5 +117,5 @@ /** HDA's (fixed) audio frame size in bytes. * We only support 16-bit stereo frames at the moment. */ -#define HDA_FRAME_SIZE 4 +#define HDA_FRAME_SIZE_DEFAULT 4 /** Offset of the SD0 register map. */ Index: /trunk/src/VBox/Devices/Audio/HDAStream.cpp =================================================================== --- /trunk/src/VBox/Devices/Audio/HDAStream.cpp (revision 75961) +++ /trunk/src/VBox/Devices/Audio/HDAStream.cpp (revision 75962) @@ -94,7 +94,7 @@ if (hdaGetDirFromSD(pStream->u8SD) == PDMAUDIODIR_IN) - RTStrPrintf(szFile, sizeof(szFile), "hdaDMAWriteSD%RU8", pStream->u8SD); + RTStrPrintf(szFile, sizeof(szFile), "hdaDMARawWriteSD%RU8", pStream->u8SD); else - RTStrPrintf(szFile, sizeof(szFile), "hdaDMAReadSD%RU8", pStream->u8SD); + RTStrPrintf(szFile, sizeof(szFile), "hdaDMARawReadSD%RU8", pStream->u8SD); rc2 = DrvAudioHlpFileNameGet(szPath, sizeof(szPath), pThis->Dbg.szOutPath, szFile, @@ -102,10 +102,23 @@ AssertRC(rc2); - rc2 = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szPath, PDMAUDIOFILE_FLAG_NONE, &pStream->Dbg.Runtime.pFileDMA); + rc2 = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szPath, PDMAUDIOFILE_FLAG_NONE, &pStream->Dbg.Runtime.pFileDMARaw); + AssertRC(rc2); + + if (hdaGetDirFromSD(pStream->u8SD) == PDMAUDIODIR_IN) + RTStrPrintf(szFile, sizeof(szFile), "hdaDMAWriteMappedSD%RU8", pStream->u8SD); + else + RTStrPrintf(szFile, sizeof(szFile), "hdaDMAReadMappedSD%RU8", pStream->u8SD); + + rc2 = DrvAudioHlpFileNameGet(szPath, sizeof(szPath), pThis->Dbg.szOutPath, szFile, + 0 /* uInst */, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAG_NONE); + AssertRC(rc2); + + rc2 = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szPath, PDMAUDIOFILE_FLAG_NONE, &pStream->Dbg.Runtime.pFileDMAMapped); AssertRC(rc2); /* Delete stale debugging files from a former run. */ DrvAudioHlpFileDelete(pStream->Dbg.Runtime.pFileStream); - DrvAudioHlpFileDelete(pStream->Dbg.Runtime.pFileDMA); + DrvAudioHlpFileDelete(pStream->Dbg.Runtime.pFileDMARaw); + DrvAudioHlpFileDelete(pStream->Dbg.Runtime.pFileDMAMapped); } @@ -160,6 +173,9 @@ pStream->Dbg.Runtime.pFileStream = NULL; - DrvAudioHlpFileDestroy(pStream->Dbg.Runtime.pFileDMA); - pStream->Dbg.Runtime.pFileDMA = NULL; + DrvAudioHlpFileDestroy(pStream->Dbg.Runtime.pFileDMARaw); + pStream->Dbg.Runtime.pFileDMARaw = NULL; + + DrvAudioHlpFileDestroy(pStream->Dbg.Runtime.pFileDMAMapped); + pStream->Dbg.Runtime.pFileDMAMapped = NULL; } @@ -245,10 +261,4 @@ return VINF_SUCCESS; } - - /* Set the stream's frame size. */ - pStream->State.cbFrameSize = pCfg->Props.cChannels * pCfg->Props.cBytes; - LogFunc(("[SD%RU8] cChannels=%RU8, cBytes=%RU8 -> cbFrameSize=%RU32\n", - pStream->u8SD, pCfg->Props.cChannels, pCfg->Props.cBytes, pStream->State.cbFrameSize)); - Assert(pStream->State.cbFrameSize); /* Frame size must not be 0. */ /* @@ -263,4 +273,14 @@ AssertRCReturn(rc, rc); +#ifndef VBOX_WITH_AUDIO_HDA_51_SURROUND + /* + * When not running with surround support enabled, override the channel count + * with stereo (2) channels so that we at least can properly work with those. + * + * Note: This also involves dealing with surround setups the guest might has set up for us. + */ + pCfg->Props.cChannels = 2; +#endif + LogFunc(("[SD%RU8] DMA @ 0x%x (%RU32 bytes), LVI=%RU16, FIFOS=%RU16, Hz=%RU32, rc=%Rrc\n", pStream->u8SD, pStream->u64BDLBase, pStream->u32CBL, pStream->u16LVI, pStream->u16FIFOS, @@ -268,6 +288,6 @@ /* Make sure that mandatory parameters are set up correctly. */ - AssertStmt(pStream->u32CBL % pStream->State.cbFrameSize == 0, rc = VERR_INVALID_PARAMETER); - AssertStmt(pStream->u16LVI >= 1, rc = VERR_INVALID_PARAMETER); + AssertStmt(pStream->u32CBL % pStream->State.Mapping.cbFrameSize == 0, rc = VERR_INVALID_PARAMETER); + AssertStmt(pStream->u16LVI >= 1, rc = VERR_INVALID_PARAMETER); if (RT_SUCCESS(rc)) @@ -275,6 +295,6 @@ /* Make sure that the chosen Hz rate dividable by the stream's rate. */ if (pStream->State.Cfg.Props.uHz % pThis->uTimerHz != 0) - LogRel(("HDA: Device timer (%RU32) does not fit to stream #RU8 timing (%RU32)\n", - pThis->uTimerHz, pStream->State.Cfg.Props.uHz)); + LogRel(("HDA: Device timer (%RU32) does not fit to stream #%RU8 timing (%RU32)\n", + pThis->uTimerHz, pStream->u8SD, pStream->State.Cfg.Props.uHz)); /* Figure out how many transfer fragments we're going to use for this stream. */ @@ -318,10 +338,10 @@ #ifdef VBOX_WITH_INTEL_HDA /* Intel ICH / PCH: 1 frame. */ - if (BDLE.Desc.u32BufSize == 1 * pStream->State.cbFrameSize) + if (BDLE.Desc.u32BufSize == (uint32_t)(1 * pStream->State.Mapping.cbFrameSize)) { cfPosAdjust = 1; } /* Intel Baytrail / Braswell: 32 frames. */ - else if (BDLE.Desc.u32BufSize == 32 * pStream->State.cbFrameSize) + else if (BDLE.Desc.u32BufSize == (uint32_t)(32 * pStream->State.Mapping.cbFrameSize)) { cfPosAdjust = 32; @@ -344,5 +364,5 @@ * position adjustment. */ - if ( (cfPosAdjust * pStream->State.cbFrameSize) == BDLE.Desc.u32BufSize + if ( (cfPosAdjust * pStream->State.Mapping.cbFrameSize) == BDLE.Desc.u32BufSize && cFragments) { @@ -365,11 +385,11 @@ pStream->State.cbTransferSize = pStream->u32CBL / cFragments; Assert(pStream->State.cbTransferSize); - Assert(pStream->State.cbTransferSize % pStream->State.cbFrameSize == 0); + Assert(pStream->State.cbTransferSize % pStream->State.Mapping.cbFrameSize == 0); /* Calculate the bytes we need to transfer to / from the stream's DMA per iteration. * This is bound to the device's Hz rate and thus to the (virtual) timing the device expects. */ - pStream->State.cbTransferChunk = (pStream->State.Cfg.Props.uHz / pThis->uTimerHz) * pStream->State.cbFrameSize; + pStream->State.cbTransferChunk = (pStream->State.Cfg.Props.uHz / pThis->uTimerHz) * pStream->State.Mapping.cbFrameSize; Assert(pStream->State.cbTransferChunk); - Assert(pStream->State.cbTransferChunk % pStream->State.cbFrameSize == 0); + Assert(pStream->State.cbTransferChunk % pStream->State.Mapping.cbFrameSize == 0); /* Make sure that the transfer chunk does not exceed the overall transfer size. */ @@ -379,5 +399,4 @@ pStream->State.cbTransferProcessed = 0; pStream->State.cTransferPendingInterrupts = 0; - pStream->State.cbDMALeft = 0; pStream->State.tsLastUpdateNs = 0; @@ -542,7 +561,14 @@ } - if (!DrvAudioHlpFileIsOpen(pStream->Dbg.Runtime.pFileDMA)) - { - int rc2 = DrvAudioHlpFileOpen(pStream->Dbg.Runtime.pFileDMA, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS, + if (!DrvAudioHlpFileIsOpen(pStream->Dbg.Runtime.pFileDMARaw)) + { + int rc2 = DrvAudioHlpFileOpen(pStream->Dbg.Runtime.pFileDMARaw, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS, + &pStream->State.Cfg.Props); + AssertRC(rc2); + } + + if (!DrvAudioHlpFileIsOpen(pStream->Dbg.Runtime.pFileDMAMapped)) + { + int rc2 = DrvAudioHlpFileOpen(pStream->Dbg.Runtime.pFileDMAMapped, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS, &pStream->State.Cfg.Props); AssertRC(rc2); @@ -916,5 +942,5 @@ * make sure that we process them first as a whole. */ if (pStream->State.cPosAdjustFramesLeft) - cbChunk = RT_MIN(cbChunk, uint32_t(pStream->State.cPosAdjustFramesLeft * pStream->State.cbFrameSize)); + cbChunk = RT_MIN(cbChunk, uint32_t(pStream->State.cPosAdjustFramesLeft * pStream->State.Mapping.cbFrameSize)); Log3Func(("[SD%RU8] cbChunk=%RU32, cPosAdjustFramesLeft=%RU16\n", @@ -977,8 +1003,6 @@ if (RT_SUCCESS(rc)) { - const uint32_t cbDMAFree = (uint32_t)RTCircBufFree(pCircBuf); - Assert(cbDMAFree >= cbDMA); /* This must always hold. */ - -#ifndef VBOX_WITH_HDA_AUDIO_INTERLEAVING_STREAMS_SUPPORT + const uint32_t cbFree = (uint32_t)RTCircBufFree(pCircBuf); + /* * Most guests don't use different stream frame sizes than @@ -988,8 +1012,8 @@ * Only macOS guests need the frame extraction branch below at the moment AFAIK. */ - if (pStream->State.cbFrameSize == HDA_FRAME_SIZE) + if (pStream->State.Mapping.cbFrameSize == HDA_FRAME_SIZE_DEFAULT) { uint32_t cbDMARead = 0; - uint32_t cbDMALeft = RT_MIN(cbDMA, cbDMAFree); + uint32_t cbDMALeft = RT_MIN(cbDMA, cbFree); while (cbDMALeft) @@ -1021,33 +1045,86 @@ * and just discard the other channel's data. * + * I know, the following code is horribly slow, but seems to work for now. + ** @todo Optimize channel data extraction! Use some SSE(3) / intrinsics? */ - /** @todo Optimize this stuff -- copying only one frame a time is expensive. */ - uint32_t cbDMARead = pStream->State.cbDMALeft ? pStream->State.cbFrameSize - pStream->State.cbDMALeft : 0; - uint32_t cbDMALeft = RT_MIN(cbDMA, cbDMAFree); - - while (cbDMALeft >= pStream->State.cbFrameSize) + for (unsigned m = 0; m < pStream->State.Mapping.cMappings; m++) { - void *pvBuf; size_t cbBuf; - RTCircBufAcquireWriteBlock(pCircBuf, HDA_FRAME_SIZE, &pvBuf, &cbBuf); - - AssertBreak(cbDMARead <= sizeof(abChunk)); - - if (cbBuf) - memcpy(pvBuf, abChunk + cbDMARead, cbBuf); - - RTCircBufReleaseWriteBlock(pCircBuf, cbBuf); - - Assert(cbDMALeft >= pStream->State.cbFrameSize); - cbDMALeft -= pStream->State.cbFrameSize; - cbDMARead += pStream->State.cbFrameSize; + const uint32_t cbFrame = pStream->State.Mapping.cbFrameSize; + + Assert(cbFree >= cbDMA); + + PPDMAUDIOSTREAMMAP pMap = &pStream->State.Mapping.paMappings[m]; + AssertPtr(pMap); + + Log3Func(("Mapping #%u: Start (cbDMA=%RU32, cbFrame=%RU32, cbOff=%RU32)\n", + m, cbDMA, cbFrame, pMap->cbOff)); + + uint8_t *pbSrcBuf = abChunk; + size_t cbSrcOff = pMap->cbOff; + Assert(cbChunk >= cbSrcOff); + + for (unsigned i = 0; i < cbDMA / cbFrame; i++) + { + void *pvDstBuf; size_t cbDstBuf; + RTCircBufAcquireWriteBlock(pCircBuf, pMap->cbSize, &pvDstBuf, &cbDstBuf); + + Assert(cbDstBuf >= pMap->cbSize); + + if (cbDstBuf) + { + Log3Func(("Mapping #%u: Frame #%02u: cbSize=%zu, cbFirst=%zu, cbOff=%zu, cbDstBuf=%zu, cbSrcOff=%zu\n", + m, i, pMap->cbSize, pMap->cbFirst, pMap->cbOff, cbDstBuf, cbSrcOff)); + + memcpy(pvDstBuf, pbSrcBuf + cbSrcOff, cbDstBuf); + +#if 0 /* Too slow, even for release builds, so disabled it. */ + if (pStream->Dbg.Runtime.fEnabled) + DrvAudioHlpFileWrite(pStream->Dbg.Runtime.pFileDMAMapped, pvDstBuf, cbDstBuf, + 0 /* fFlags */); +#endif + Assert(cbSrcOff <= cbDMA); + if (cbSrcOff + cbFrame + pMap->cbFirst <= cbDMA) + cbSrcOff += cbFrame + pMap->cbFirst; + + Log3Func(("Mapping #%u: Frame #%02u: -> cbSrcOff=%zu\n", m, i, cbSrcOff)); + } + + RTCircBufReleaseWriteBlock(pCircBuf, cbDstBuf); + } + + Log3Func(("Mapping #%u: End cbSize=%zu, cbDMA=%RU32, cbSrcOff=%zu\n", + m, pMap->cbSize, cbDMA, cbSrcOff)); + + Assert(cbSrcOff <= cbDMA); + + const uint32_t cbSrcLeft = cbDMA - (uint32_t)cbSrcOff; + if (cbSrcLeft) + { + Log3Func(("Mapping #%u: cbSrcLeft=%RU32\n", m, cbSrcLeft)); + + if (cbSrcLeft >= pMap->cbSize) + { + void *pvDstBuf; size_t cbDstBuf; + RTCircBufAcquireWriteBlock(pCircBuf, pMap->cbSize, &pvDstBuf, &cbDstBuf); + + Assert(cbDstBuf >= pMap->cbSize); + + if (cbDstBuf) + { + memcpy(pvDstBuf, pbSrcBuf + cbSrcOff, cbDstBuf); + } + + RTCircBufReleaseWriteBlock(pCircBuf, cbDstBuf); + } + + Assert(pMap->cbFrame >= cbSrcLeft); + pMap->cbOff = pMap->cbFrame - cbSrcLeft; + } + else + pMap->cbOff = 0; + + Log3Func(("Mapping #%u finish (cbSrcOff=%zu, cbOff=%zu)\n", m, cbSrcOff, pMap->cbOff)); } - - pStream->State.cbDMALeft = cbDMALeft; - Assert(pStream->State.cbDMALeft < pStream->State.cbFrameSize); } -#else - /** @todo This needs making use of HDAStreamMap + HDAStreamChannel. */ -# error "Implement reading interleaving streams support here." -#endif } else @@ -1127,5 +1204,6 @@ /* Do the position adjustment accounting. */ - pStream->State.cPosAdjustFramesLeft -= RT_MIN(pStream->State.cPosAdjustFramesLeft, cbDMA / pStream->State.cbFrameSize); + pStream->State.cPosAdjustFramesLeft -= + RT_MIN(pStream->State.cPosAdjustFramesLeft, cbDMA / pStream->State.Mapping.cbFrameSize); if (RT_FAILURE(rc)) @@ -1144,5 +1222,5 @@ if (pStream->State.cPosAdjustFramesLeft == 0) { - hdaR3StreamPeriodInc(pPeriod, RT_MIN(cbProcessed / pStream->State.cbFrameSize, + hdaR3StreamPeriodInc(pPeriod, RT_MIN(cbProcessed / pStream->State.Mapping.cbFrameSize, hdaR3StreamPeriodGetRemainingFrames(pPeriod))); @@ -1176,5 +1254,5 @@ + hdaR3StreamPeriodFramesToWalClk(pPeriod, pStream->State.cbTransferProcessed - / pStream->State.cbFrameSize), + / pStream->State.Mapping.cbFrameSize), false /* fForce */); RT_NOREF(fWalClkSet); Index: /trunk/src/VBox/Devices/Audio/HDAStream.h =================================================================== --- /trunk/src/VBox/Devices/Audio/HDAStream.h (revision 75961) +++ /trunk/src/VBox/Devices/Audio/HDAStream.h (revision 75962) @@ -61,8 +61,10 @@ * whereas for output streams this dumps data being read from the device FIFO. */ R3PTRTYPE(PPDMAUDIOFILE) pFileStream; - /** File for dumping DMA reads / writes. + /** File for dumping raw DMA reads / writes. * For input streams, this dumps data being written to the device DMA, * whereas for output streams this dumps data being read from the device DMA. */ - R3PTRTYPE(PPDMAUDIOFILE) pFileDMA; + R3PTRTYPE(PPDMAUDIOFILE) pFileDMARaw; + /** File for dumping mapped (that is, extracted) DMA reads / writes. */ + R3PTRTYPE(PPDMAUDIOFILE) pFileDMAMapped; } HDASTREAMDBGINFORT, *PHDASTREAMDBGINFORT; @@ -124,5 +126,5 @@ #endif /** This stream's data mapping. */ - HDASTREAMMAPPING Mapping; + HDASTREAMMAP Mapping; /** Current BDLE (Buffer Descriptor List Entry). */ HDABDLE BDLE; @@ -148,6 +150,5 @@ * BDLE interrupt-on-completion (IOC) bits set. */ uint8_t cTransferPendingInterrupts; - /** The stream's current audio frame size (in bytes). */ - uint32_t cbFrameSize; + uint8_t Padding2[4]; /** How many audio data frames are left to be processed * for the position adjustment handling. @@ -155,5 +156,5 @@ * 0 if position adjustment handling is done or inactive. */ uint16_t cPosAdjustFramesLeft; - uint8_t Padding2[2]; + uint8_t Padding3[2]; /** (Virtual) clock ticks per byte. */ uint64_t cTicksPerByte; @@ -165,16 +166,9 @@ * Should match SDFMT. */ PDMAUDIOSTREAMCFG Cfg; - uint32_t Padding3; + uint32_t Padding4; #ifdef HDA_USE_DMA_ACCESS_HANDLER /** List of DMA handlers. */ RTLISTANCHORR3 lstDMAHandlers; #endif - /** How much DMA data from a previous transfer is left to be processed (in bytes). - * This can happen if the stream's frame size is bigger (e.g. 16 bytes) than - * the current DMA FIFO can hold (e.g. 10 bytes). Mostly needed for more complex - * stuff like interleaved surround streams. */ - uint16_t cbDMALeft; - /** Unused, padding. */ - uint8_t abPadding4[2+4]; /** Timestamp (in ns) of last stream update. */ uint64_t tsLastUpdateNs; Index: /trunk/src/VBox/Devices/Audio/HDAStreamChannel.cpp =================================================================== --- /trunk/src/VBox/Devices/Audio/HDAStreamChannel.cpp (revision 75961) +++ /trunk/src/VBox/Devices/Audio/HDAStreamChannel.cpp (revision 75962) @@ -66,79 +66,4 @@ /** - * Extracts HDA audio stream data and stores it into the given stream channel data block. - * - * @returns IPRT status code. - * @param pChan Channel data to extract audio stream data into. - * @param pvBuf Buffer of audio data to extract. - * @param cbBuf Size (in bytes) of audio data to extract. - */ -int hdaR3StreamChannelExtract(PPDMAUDIOSTREAMCHANNEL pChan, const void *pvBuf, size_t cbBuf) -{ - AssertPtrReturn(pChan, VERR_INVALID_POINTER); - AssertPtrReturn(pvBuf, VERR_INVALID_POINTER); - AssertReturn(cbBuf, VERR_INVALID_PARAMETER); - - AssertRelease(pChan->cbOff <= cbBuf); - - const uint8_t *pu8Buf = (const uint8_t *)pvBuf; - - size_t cbSrc = cbBuf - pChan->cbOff; - const uint8_t *pvSrc = &pu8Buf[pChan->cbOff]; - - size_t cbDst; - uint8_t *pvDst; - RTCircBufAcquireWriteBlock(pChan->Data.pCircBuf, cbBuf, (void **)&pvDst, &cbDst); - - cbSrc = RT_MIN(cbSrc, cbDst); - - while (cbSrc) - { - AssertBreak(cbDst >= cbSrc); - - /* Enough data for at least one next frame? */ - if (cbSrc < pChan->cbFrame) - break; - - memcpy(pvDst, pvSrc, pChan->cbFrame); - - /* Advance to next channel frame in stream. */ - pvSrc += pChan->cbStep; - Assert(cbSrc >= pChan->cbStep); - cbSrc -= pChan->cbStep; - - /* Advance destination by one frame. */ - pvDst += pChan->cbFrame; - Assert(cbDst >= pChan->cbFrame); - cbDst -= pChan->cbFrame; - - /* Adjust offset. */ - pChan->cbOff += pChan->cbFrame; - } - - RTCircBufReleaseWriteBlock(pChan->Data.pCircBuf, cbDst); - - return VINF_SUCCESS; -} - -/** - * Advances the current read / write pointer by a certain amount. - * - * @returns IPRT status code. - * @param pChan Channel data to advance read / write pointer for. - * @param cbAdv Amount (in bytes) to advance read / write pointer. - * - * @remark Currently not used / implemented. - */ -int hdaR3StreamChannelAdvance(PPDMAUDIOSTREAMCHANNEL pChan, size_t cbAdv) -{ - AssertPtrReturn(pChan, VERR_INVALID_POINTER); - - if (!cbAdv) - return VINF_SUCCESS; - - return VINF_SUCCESS; -} - -/** * Acquires (reads) audio channel data. * Must be released when done with hdaR3StreamChannelReleaseData(). Index: /trunk/src/VBox/Devices/Audio/HDAStreamChannel.h =================================================================== --- /trunk/src/VBox/Devices/Audio/HDAStreamChannel.h (revision 75961) +++ /trunk/src/VBox/Devices/Audio/HDAStreamChannel.h (revision 75962) @@ -21,6 +21,4 @@ int hdaR3StreamChannelDataInit(PPDMAUDIOSTREAMCHANNELDATA pChanData, uint32_t fFlags); void hdaR3StreamChannelDataDestroy(PPDMAUDIOSTREAMCHANNELDATA pChanData); -int hdaR3StreamChannelExtract(PPDMAUDIOSTREAMCHANNEL pChan, const void *pvBuf, size_t cbBuf); -int hdaR3StreamChannelAdvance(PPDMAUDIOSTREAMCHANNEL pChan, size_t cbAdv); int hdaR3StreamChannelAcquireData(PPDMAUDIOSTREAMCHANNELDATA pChanData, void *ppvData, size_t *pcbData); int hdaR3StreamChannelReleaseData(PPDMAUDIOSTREAMCHANNELDATA pChanData); Index: /trunk/src/VBox/Devices/Audio/HDAStreamMap.cpp =================================================================== --- /trunk/src/VBox/Devices/Audio/HDAStreamMap.cpp (revision 75961) +++ /trunk/src/VBox/Devices/Audio/HDAStreamMap.cpp (revision 75962) @@ -5,5 +5,5 @@ /* - * Copyright (C) 2017 Oracle Corporation + * Copyright (C) 2017-2018 Oracle Corporation * * This file is part of VirtualBox Open Source Edition (OSE), as @@ -35,14 +35,16 @@ #ifdef IN_RING3 +static int hdaR3StreamMapSetup(PHDASTREAMMAP pMap, PPDMAUDIOPCMPROPS pProps); + /** * Initializes a stream mapping structure according to the given PCM properties. * * @return IPRT status code. - * @param pMapping Pointer to mapping to initialize. + * @param pMap Pointer to mapping to initialize. * @param pProps Pointer to PCM properties to use for initialization. */ -int hdaR3StreamMapInit(PHDASTREAMMAPPING pMapping, PPDMAUDIOPCMPROPS pProps) +int hdaR3StreamMapInit(PHDASTREAMMAP pMap, PPDMAUDIOPCMPROPS pProps) { - AssertPtrReturn(pMapping, VERR_INVALID_POINTER); + AssertPtrReturn(pMap, VERR_INVALID_POINTER); AssertPtrReturn(pProps, VERR_INVALID_POINTER); @@ -50,49 +52,29 @@ return VERR_INVALID_PARAMETER; - hdaR3StreamMapReset(pMapping); + hdaR3StreamMapReset(pMap); - pMapping->paChannels = (PPDMAUDIOSTREAMCHANNEL)RTMemAlloc(sizeof(PDMAUDIOSTREAMCHANNEL) * pProps->cChannels); - if (!pMapping->paChannels) - return VERR_NO_MEMORY; + int rc = hdaR3StreamMapSetup(pMap, pProps); + if (RT_FAILURE(rc)) + return rc; - int rc = VINF_SUCCESS; - - Assert(RT_IS_POWER_OF_TWO(pProps->cBytes * 8)); - - /** @todo We assume all channels in a stream have the same format. */ - PPDMAUDIOSTREAMCHANNEL pChan = pMapping->paChannels; - for (uint8_t i = 0; i < pProps->cChannels; i++) - { - pChan->uChannel = i; - pChan->cbStep = pProps->cBytes; - pChan->cbFrame = pChan->cbStep * pProps->cChannels; - pChan->cbFirst = i * pChan->cbStep; - pChan->cbOff = pChan->cbFirst; - - int rc2 = hdaR3StreamChannelDataInit(&pChan->Data, PDMAUDIOSTREAMCHANNELDATA_FLAG_NONE); - if (RT_SUCCESS(rc)) - rc = rc2; - - if (RT_FAILURE(rc)) - break; - - pChan++; - } - +#ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND if ( RT_SUCCESS(rc) /* Create circular buffer if not created yet. */ - && !pMapping->pCircBuf) + && !pMap->pCircBuf) { - rc = RTCircBufCreate(&pMapping->pCircBuf, _4K); /** @todo Make size configurable? */ + rc = RTCircBufCreate(&pMap->pCircBuf, _4K); /** @todo Make size configurable? */ } +#endif if (RT_SUCCESS(rc)) { - pMapping->cChannels = pProps->cChannels; -#ifdef VBOX_WITH_HDA_AUDIO_INTERLEAVING_STREAMS_SUPPORT - pMapping->enmLayout = PDMAUDIOSTREAMLAYOUT_INTERLEAVED; -#else - pMapping->enmLayout = PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED; -#endif + pMap->cbFrameSize = pProps->cChannels * pProps->cBytes; + + LogFunc(("cChannels=%RU8, cBytes=%RU8 -> cbFrameSize=%RU32\n", + pProps->cChannels, pProps->cBytes, pMap->cbFrameSize)); + + Assert(pMap->cbFrameSize); /* Frame size must not be 0. */ + + pMap->enmLayout = PDMAUDIOSTREAMLAYOUT_INTERLEAVED; } @@ -104,15 +86,17 @@ * Destroys a given stream mapping. * - * @param pMapping Pointer to mapping to destroy. + * @param pMap Pointer to mapping to destroy. */ -void hdaR3StreamMapDestroy(PHDASTREAMMAPPING pMapping) +void hdaR3StreamMapDestroy(PHDASTREAMMAP pMap) { - hdaR3StreamMapReset(pMapping); + hdaR3StreamMapReset(pMap); - if (pMapping->pCircBuf) +#ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND + if (pMap->pCircBuf) { - RTCircBufDestroy(pMapping->pCircBuf); - pMapping->pCircBuf = NULL; + RTCircBufDestroy(pMap->pCircBuf); + pMap->pCircBuf = NULL; } +#endif } @@ -121,25 +105,70 @@ * Resets a given stream mapping. * - * @param pMapping Pointer to mapping to reset. + * @param pMap Pointer to mapping to reset. */ -void hdaR3StreamMapReset(PHDASTREAMMAPPING pMapping) +void hdaR3StreamMapReset(PHDASTREAMMAP pMap) { - AssertPtrReturnVoid(pMapping); + AssertPtrReturnVoid(pMap); - pMapping->enmLayout = PDMAUDIOSTREAMLAYOUT_UNKNOWN; + pMap->enmLayout = PDMAUDIOSTREAMLAYOUT_UNKNOWN; - if (pMapping->cChannels) + if (pMap->paMappings) { - for (uint8_t i = 0; i < pMapping->cChannels; i++) - hdaR3StreamChannelDataDestroy(&pMapping->paChannels[i].Data); + for (uint8_t i = 0; i < pMap->cMappings; i++) + hdaR3StreamChannelDataDestroy(&pMap->paMappings[i].Data); - AssertPtr(pMapping->paChannels); - RTMemFree(pMapping->paChannels); - pMapping->paChannels = NULL; + RTMemFree(pMap->paMappings); + pMap->paMappings = NULL; - pMapping->cChannels = 0; + pMap->cMappings = 0; } } + +/** + * Sets up a stream mapping according to the given properties / configuration. + * + * @return VBox status code, or VERR_NOT_SUPPORTED if the channel setup is not supported (yet). + * @param pMap Pointer to mapping to set up. + * @param pProps PCM audio properties to use for lookup. + */ +static int hdaR3StreamMapSetup(PHDASTREAMMAP pMap, PPDMAUDIOPCMPROPS pProps) +{ + int rc; + + /** @todo We ASSUME that all channels in a stream ... + * - have the same format + * - are in a consecutive order with no gaps in between + * - have a simple (raw) data layout + * - work in a non-striped fashion, e.g. interleaved (only on one SDn, not spread over multiple SDns) */ + if ( pProps->cChannels == 1 /* Mono */ + || pProps->cChannels == 2 /* Stereo */ + || pProps->cChannels == 4 /* Quadrophonic */ + || pProps->cChannels == 6) /* Surround (5.1) */ + { + /* For now we don't have anything other as mono / stereo channels being covered by the backends. + * So just set up one channel covering those and skipping the rest (like configured rear or center/LFE outputs). */ + pMap->cMappings = 1; + pMap->paMappings = (PPDMAUDIOSTREAMMAP)RTMemAlloc(sizeof(PDMAUDIOSTREAMMAP) * pMap->cMappings); + if (!pMap->paMappings) + return VERR_NO_MEMORY; + + PPDMAUDIOSTREAMMAP pMapLR = &pMap->paMappings[0]; + + pMapLR->aID[0] = PDMAUDIOSTREAMCHANNELID_FRONT_LEFT; + pMapLR->aID[1] = PDMAUDIOSTREAMCHANNELID_FRONT_RIGHT; + pMapLR->cbFrame = pProps->cBytes * pProps->cChannels; + pMapLR->cbSize = pProps->cBytes * 2 /* Front left + Front right channels */; + pMapLR->cbFirst = 0; + pMapLR->cbOff = pMapLR->cbFirst; + + rc = hdaR3StreamChannelDataInit(&pMapLR->Data, PDMAUDIOSTREAMCHANNELDATA_FLAG_NONE); + AssertRC(rc); + } + else + rc = VERR_NOT_SUPPORTED; /** @todo r=andy Support more setups. */ + + return rc; +} #endif /* IN_RING3 */ Index: /trunk/src/VBox/Devices/Audio/HDAStreamMap.h =================================================================== --- /trunk/src/VBox/Devices/Audio/HDAStreamMap.h (revision 75961) +++ /trunk/src/VBox/Devices/Audio/HDAStreamMap.h (revision 75962) @@ -1,9 +1,9 @@ /* $Id$ */ /** @file - * HDAStreamMap.h - Stream mapping functions for HD Audio. + * HDAStreamMap.h - Stream map functions for HD Audio. */ /* - * Copyright (C) 2017 Oracle Corporation + * Copyright (C) 2017-2018 Oracle Corporation * * This file is part of VirtualBox Open Source Edition (OSE), as @@ -22,17 +22,26 @@ * Structure for keeping an audio stream data mapping. */ -typedef struct HDASTREAMMAPPING +typedef struct HDASTREAMMAP { /** The stream's layout. */ - PDMAUDIOSTREAMLAYOUT enmLayout; - /** Number of audio channels in this stream. */ - uint8_t cChannels; - /** Array of audio channels. */ - R3PTRTYPE(PPDMAUDIOSTREAMCHANNEL) paChannels; + PDMAUDIOSTREAMLAYOUT enmLayout; + uint8_t cbFrameSize; + /** Number of mappings in paMappings. */ + uint8_t cMappings; + uint8_t aPadding[2]; + /** Array of stream mappings. + * Note: The mappings *must* be layed out in an increasing order, e.g. + * how the data appears in the given data block. */ + R3PTRTYPE(PPDMAUDIOSTREAMMAP) paMappings; +#if HC_ARCH_BITS == 32 + RTR3PTR Padding1; +#endif +#ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND /** Circular buffer holding for holding audio data for this mapping. */ - R3PTRTYPE(PRTCIRCBUF) pCircBuf; -} HDASTREAMMAPPING; -AssertCompileSizeAlignment(HDASTREAMMAPPING, 8); -typedef HDASTREAMMAPPING *PHDASTREAMMAPPING; + R3PTRTYPE(PRTCIRCBUF) pCircBuf; +#endif +} HDASTREAMMAP; +AssertCompileSizeAlignment(HDASTREAMMAP, 8); +typedef HDASTREAMMAP *PHDASTREAMMAP; /** @name Stream mapping functions. @@ -40,7 +49,7 @@ */ #ifdef IN_RING3 -int hdaR3StreamMapInit(PHDASTREAMMAPPING pMapping, PPDMAUDIOPCMPROPS pProps); -void hdaR3StreamMapDestroy(PHDASTREAMMAPPING pMapping); -void hdaR3StreamMapReset(PHDASTREAMMAPPING pMapping); +int hdaR3StreamMapInit(PHDASTREAMMAP pMapping, PPDMAUDIOPCMPROPS pProps); +void hdaR3StreamMapDestroy(PHDASTREAMMAP pMapping); +void hdaR3StreamMapReset(PHDASTREAMMAP pMapping); #endif /* IN_RING3 */ /** @} */ Index: /trunk/src/VBox/Devices/testcase/tstDeviceStructSizeRC.cpp =================================================================== --- /trunk/src/VBox/Devices/testcase/tstDeviceStructSizeRC.cpp (revision 75961) +++ /trunk/src/VBox/Devices/testcase/tstDeviceStructSizeRC.cpp (revision 75962) @@ -1976,4 +1976,6 @@ GEN_CHECK_OFF(HDABDLE, State); + GEN_CHECK_SIZE(HDASTREAMMAP); + GEN_CHECK_SIZE(HDASTREAMSTATE); GEN_CHECK_OFF(HDASTREAMSTATE, uCurBDLE);