VirtualBox

Changeset 88944 in vbox


Ignore:
Timestamp:
May 8, 2021 1:29:43 PM (4 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
144279
Message:

AudioMixer,DevHda: Added AudioMixerSinkTransferToCircBuf and AudioMixerSinkTransferFromCircBuf for doing the transfers between the mixer buffer and the internal DMA buffer of the device that usually takes place on the AIO thread. Refactored from hdaR3StreamPullFromMixer and hdaR3StreamPushToMixer. bugref:9890

Location:
trunk/src/VBox/Devices
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Audio/AudioMixer.cpp

    r88941 r88944  
    21052105
    21062106/**
     2107 * Transfer data from the device's DMA buffer and into the sink.
     2108 *
     2109 * The caller is already holding the mixer sink's critical section, either by
     2110 * way of being the AIO thread doing update jobs or by explicit locking calls.
     2111 *
     2112 * @returns The new stream offset.
     2113 * @param   pSink       The mixer sink to transfer samples to.
     2114 * @param   pCircBuf    The internal DMA buffer to move samples from.
     2115 * @param   offStream   The stream current offset (logging, dtrace, return).
     2116 * @param   idStream    Device specific audio stream identifier (logging, dtrace).
     2117 * @param   pDbgFile    Debug file, NULL if disabled.
     2118 */
     2119uint64_t AudioMixerSinkTransferFromCircBuf(PAUDMIXSINK pSink, PRTCIRCBUF pCircBuf, uint64_t offStream,
     2120                                           uint32_t idStream, PAUDIOHLPFILE pDbgFile)
     2121{
     2122    /*
     2123     * Sanity.
     2124     */
     2125    AssertReturn(pSink, offStream);
     2126    AssertReturn(pCircBuf, offStream);
     2127    Assert(RTCritSectIsOwner(&pSink->CritSect));
     2128
     2129    /*
     2130     * Figure how much that we can push down.
     2131     */
     2132    uint32_t const cbSinkWritable     = AudioMixerSinkGetWritable(pSink);
     2133    uint32_t const cbCircBufReadable  = (uint32_t)RTCircBufUsed(pCircBuf);
     2134    uint32_t       cbToTransfer       = RT_MIN(cbCircBufReadable, cbSinkWritable);
     2135    /* Make sure that we always align the number of bytes when reading to the stream's PCM properties. */
     2136    cbToTransfer = PDMAudioPropsFloorBytesToFrame(&pSink->PCMProps, cbToTransfer);
     2137
     2138    Log3Func(("idStream=%#x: cbSinkWritable=%#RX32 cbCircBufReadable=%#RX32 -> cbToTransfer=%#RX32\n",
     2139              idStream, cbSinkWritable, cbCircBufReadable, cbToTransfer));
     2140    RT_NOREF(idStream);
     2141
     2142    /*
     2143     * Do the pushing.
     2144     */
     2145    while (cbToTransfer > 0)
     2146    {
     2147        void /*const*/ *pvSrcBuf;
     2148        size_t          cbSrcBuf;
     2149        RTCircBufAcquireReadBlock(pCircBuf, cbToTransfer, &pvSrcBuf, &cbSrcBuf);
     2150
     2151        uint32_t cbWritten = 0;
     2152        int rc = AudioMixerSinkWrite(pSink, AUDMIXOP_COPY, pvSrcBuf, (uint32_t)cbSrcBuf, &cbWritten);
     2153        AssertRC(rc);
     2154        Assert(cbWritten <= cbSrcBuf);
     2155
     2156        Log2Func(("idStream=%#x: %#RX32/%#zx bytes read @%#RX64\n", cbWritten, cbSrcBuf, offStream));
     2157#ifdef VBOX_WITH_DTRACE
     2158        VBOXDD_AUDIO_MIXER_SINK_AIO_OUT(idStream, cbWritten, offStream);
     2159#endif
     2160        offStream += cbWritten;
     2161
     2162        if (!pDbgFile)
     2163        { /* likely */ }
     2164        else
     2165            AudioHlpFileWrite(pDbgFile, pvSrcBuf, cbSrcBuf, 0 /* fFlags */);
     2166
     2167
     2168        RTCircBufReleaseReadBlock(pCircBuf, cbWritten);
     2169
     2170        /* advance */
     2171        cbToTransfer -= cbWritten;
     2172    }
     2173
     2174    return offStream;
     2175}
     2176
     2177
     2178/**
     2179 * Transfer data to the device's DMA buffer from the sink.
     2180 *
     2181 * The caller is already holding the mixer sink's critical section, either by
     2182 * way of being the AIO thread doing update jobs or by explicit locking calls.
     2183 *
     2184 * @returns The new stream offset.
     2185 * @param   pSink       The mixer sink to transfer samples from.
     2186 * @param   pCircBuf    The internal DMA buffer to move samples to.
     2187 * @param   offStream   The stream current offset (logging, dtrace, return).
     2188 * @param   idStream    Device specific audio stream identifier (logging, dtrace).
     2189 * @param   pDbgFile    Debug file, NULL if disabled.
     2190 */
     2191uint64_t AudioMixerSinkTransferToCircBuf(PAUDMIXSINK pSink, PRTCIRCBUF pCircBuf, uint64_t offStream,
     2192                                         uint32_t idStream, PAUDIOHLPFILE pDbgFile)
     2193{
     2194    /*
     2195     * Sanity.
     2196     */
     2197    AssertReturn(pSink, offStream);
     2198    AssertReturn(pCircBuf, offStream);
     2199    Assert(RTCritSectIsOwner(&pSink->CritSect));
     2200
     2201    /*
     2202     * Figure out how much we can transfer.
     2203     */
     2204    const uint32_t cbSinkReadable    = AudioMixerSinkGetReadable(pSink);
     2205    const uint32_t cbCircBufWritable = (uint32_t)RTCircBufFree(pCircBuf);
     2206    uint32_t       cbToTransfer      = RT_MIN(cbCircBufWritable, cbSinkReadable);
     2207
     2208    /* Make sure that we always align the number of bytes when reading to the stream's PCM properties. */
     2209    cbToTransfer = PDMAudioPropsFloorBytesToFrame(&pSink->PCMProps, cbToTransfer);
     2210
     2211    Log3Func(("idStream=%#x: cbSinkReadable=%#RX32 cbCircBufWritable=%#RX32 -> cbToTransfer=%#RX32 @#RX64\n",
     2212              idStream, cbSinkReadable, cbCircBufWritable, cbToTransfer, offStream));
     2213    RT_NOREF(idStream);
     2214
     2215    /** @todo should we throttle (read less) this if we're far ahead? */
     2216
     2217    /*
     2218     * Copy loop.
     2219     */
     2220    while (cbToTransfer > 0)
     2221    {
     2222/** @todo We should be able to read straight into the circular buffer here
     2223 *        as it should have a frame aligned size. */
     2224
     2225        /* Read a chunk of data. */
     2226        uint8_t  abBuf[4096];
     2227        uint32_t cbRead = 0;
     2228        int rc = AudioMixerSinkRead(pSink, AUDMIXOP_COPY, abBuf, RT_MIN(cbToTransfer, sizeof(abBuf)), &cbRead);
     2229        AssertRCBreak(rc);
     2230        AssertMsg(cbRead > 0, ("Nothing read from sink, even if %#RX32 bytes were (still) announced\n", cbToTransfer));
     2231
     2232        /* Write it to the internal DMA buffer. */
     2233        uint32_t off = 0;
     2234        while (off < cbRead)
     2235        {
     2236            void  *pvDstBuf;
     2237            size_t cbDstBuf;
     2238            RTCircBufAcquireWriteBlock(pCircBuf, cbRead - off, &pvDstBuf, &cbDstBuf);
     2239
     2240            memcpy(pvDstBuf, &abBuf[off], cbDstBuf);
     2241
     2242#ifdef VBOX_WITH_DTRACE
     2243            VBOXDD_AUDIO_MIXER_SINK_AIO_IN(idStream, (uint32_t)cbDstBuf, offStream);
     2244#endif
     2245            offStream += cbDstBuf;
     2246
     2247            RTCircBufReleaseWriteBlock(pCircBuf, cbDstBuf);
     2248
     2249            off += (uint32_t)cbDstBuf;
     2250        }
     2251        Assert(off == cbRead);
     2252
     2253        /* Write to debug file? */
     2254        if (RT_LIKELY(!pDbgFile))
     2255        { /* likely */ }
     2256        else
     2257            AudioHlpFileWrite(pDbgFile, abBuf, cbRead, 0 /* fFlags */);
     2258
     2259        /* Advance. */
     2260        Assert(cbRead <= cbToTransfer);
     2261        cbToTransfer -= cbRead;
     2262    }
     2263
     2264    return offStream;
     2265}
     2266
     2267
     2268/**
    21072269 * Signals the AIO thread to perform updates.
    21082270 *

  • trunk/src/VBox/Devices/Audio/AudioMixer.h

    r88941 r88944  
    276276int AudioMixerSinkUpdate(PAUDMIXSINK pSink);
    277277
    278 int     AudioMixerSinkAddUpdateJob(PAUDMIXSINK pSink, PFNAUDMIXSINKUPDATE pfnUpdate, void *pvUser, uint32_t cMsTypicalInterval);
    279 int     AudioMixerSinkRemoveUpdateJob(PAUDMIXSINK pSink, PFNAUDMIXSINKUPDATE pfnUpdate, void *pvUser);
    280 int     AudioMixerSinkSignalUpdateJob(PAUDMIXSINK pSink);
    281 int     AudioMixerSinkLock(PAUDMIXSINK pSink);
    282 int     AudioMixerSinkTryLock(PAUDMIXSINK pSink);
    283 int     AudioMixerSinkUnlock(PAUDMIXSINK pSink);
     278int         AudioMixerSinkAddUpdateJob(PAUDMIXSINK pSink, PFNAUDMIXSINKUPDATE pfnUpdate, void *pvUser, uint32_t cMsTypicalInterval);
     279int         AudioMixerSinkRemoveUpdateJob(PAUDMIXSINK pSink, PFNAUDMIXSINKUPDATE pfnUpdate, void *pvUser);
     280int         AudioMixerSinkSignalUpdateJob(PAUDMIXSINK pSink);
     281uint64_t    AudioMixerSinkTransferFromCircBuf(PAUDMIXSINK pSink, PRTCIRCBUF pCircBuf, uint64_t offStream,
     282                                              uint32_t idStream, PAUDIOHLPFILE pDbgFile);
     283uint64_t    AudioMixerSinkTransferToCircBuf(PAUDMIXSINK pSink, PRTCIRCBUF pCircBuf, uint64_t offStream,
     284                                            uint32_t idStream, PAUDIOHLPFILE pDbgFile);
     285int         AudioMixerSinkLock(PAUDMIXSINK pSink);
     286int         AudioMixerSinkTryLock(PAUDMIXSINK pSink);
     287int         AudioMixerSinkUnlock(PAUDMIXSINK pSink);
    284288
    285289void AudioMixerStreamDestroy(PAUDMIXSTREAM pStream, PPDMDEVINS pDevIns);

  • trunk/src/VBox/Devices/Audio/DevHdaStream.cpp

    r88943 r88944  
    15501550 * buffer.
    15511551 *
    1552  * @param   pStreamShared   HDA stream to update (shared bits).
    15531552 * @param   pStreamR3       HDA stream to update (ring-3 bits).
    15541553 * @param   pSink           The mixer sink to pull from.
    15551554 */
    1556 static void hdaR3StreamPullFromMixer(PHDASTREAM pStreamShared, PHDASTREAMR3 pStreamR3, PAUDMIXSINK pSink)
    1557 {
    1558     RT_NOREF(pStreamShared);
    1559 
    1560     /* Is the sink ready to be read (host input data) from? If so, by how much? */
    1561     uint32_t cbSinkReadable = AudioMixerSinkGetReadable(pSink);
    1562 
    1563     /* How much (guest input) data is available for writing at the moment for the HDA stream? */
    1564     const uint32_t cbStreamFree = hdaR3StreamGetFree(pStreamR3);
    1565 
    1566     Log3Func(("[SD%RU8] cbSinkReadable=%RU32, cbStreamFree=%RU32\n", pStreamShared->u8SD, cbSinkReadable, cbStreamFree));
    1567 
    1568     /* Do not read more than the HDA stream can hold at the moment.
    1569      * The host sets the overall pace. */
    1570     if (cbSinkReadable > cbStreamFree)
    1571         cbSinkReadable = cbStreamFree;
    1572 
    1573     /** @todo should we throttle (read less) this if we're far ahead? */
    1574 
    1575     /*
    1576      * Copy loop.
    1577      */
    1578     while (cbSinkReadable)
    1579     {
    1580         /* Read a chunk of data. */
    1581         uint8_t  abBuf[4096];
    1582         uint32_t cbRead = 0;
    1583         int rc = AudioMixerSinkRead(pSink, AUDMIXOP_COPY, abBuf, RT_MIN(cbSinkReadable, sizeof(abBuf)), &cbRead);
    1584         AssertRCBreak(rc);
    1585         AssertMsg(cbRead > 0, ("Nothing read from sink, even if %RU32 bytes were (still) announced\n", cbSinkReadable));
    1586 
    1587         /* Write it to the internal DMA buffer. */
    1588         uint32_t off = 0;
    1589         while (off < cbRead)
    1590         {
    1591             void  *pvDstBuf;
    1592             size_t cbDstBuf;
    1593             RTCircBufAcquireWriteBlock(pStreamR3->State.pCircBuf, cbRead - off, &pvDstBuf, &cbDstBuf);
    1594 
    1595             memcpy(pvDstBuf, &abBuf[off], cbDstBuf);
    1596 
    1597 #ifdef VBOX_WITH_DTRACE
    1598             VBOXDD_HDA_STREAM_AIO_IN((uint32_t)pStreamR3->u8SD, (uint32_t)cbDstBuf, pStreamR3->State.offWrite);
     1555static void hdaR3StreamPullFromMixer(PHDASTREAMR3 pStreamR3, PAUDMIXSINK pSink)
     1556{
     1557#ifdef LOG_ENABLED
     1558    uint64_t const offWriteOld = pStreamR3->State.offWrite;
    15991559#endif
    1600             pStreamR3->State.offWrite += cbDstBuf;
    1601 
    1602             RTCircBufReleaseWriteBlock(pStreamR3->State.pCircBuf, cbDstBuf);
    1603 
    1604             off += (uint32_t)cbDstBuf;
    1605         }
    1606         Assert(off == cbRead);
    1607 
    1608         /* Write to debug file? */
    1609         if (RT_LIKELY(!pStreamR3->Dbg.Runtime.fEnabled))
    1610         { /* likely */ }
    1611         else
    1612             AudioHlpFileWrite(pStreamR3->Dbg.Runtime.pFileStream, abBuf, cbRead, 0 /* fFlags */);
    1613 
    1614         /* Advance. */
    1615         Assert(cbRead <= cbSinkReadable);
    1616         cbSinkReadable -= cbRead;
    1617     }
     1560    pStreamR3->State.offWrite = AudioMixerSinkTransferFromCircBuf(pSink,
     1561                                                                  pStreamR3->State.pCircBuf,
     1562                                                                  pStreamR3->State.offWrite,
     1563                                                                  pStreamR3->u8SD,
     1564                                                                  pStreamR3->Dbg.Runtime.fEnabled
     1565                                                                  ? pStreamR3->Dbg.Runtime.pFileStream : NULL);
     1566
     1567    Log3Func(("[SD%RU8] transferred=%#RX64 bytes -> @%#RX64\n", pStreamR3->u8SD,
     1568              pStreamR3->State.offWrite - offWriteOld, pStreamR3->State.offWrite));
    16181569
    16191570    /* Update buffer stats. */
    16201571    pStreamR3->State.StatDmaBufUsed = (uint32_t)RTCircBufUsed(pStreamR3->State.pCircBuf);
    16211572}
     1573
    16221574
    16231575/**
    … …  
    18301782}
    18311783
    1832 /**
    1833  * Output streams: Pushes data from to the mixer.
     1784
     1785/**
     1786 * Output streams: Pushes data to the mixer.
    18341787 *
    18351788 * @param   pStreamShared   HDA stream to update (shared bits).
    … …  
    18401793static void hdaR3StreamPushToMixer(PHDASTREAM pStreamShared, PHDASTREAMR3 pStreamR3, PAUDMIXSINK pSink, uint64_t nsNow)
    18411794{
    1842     /*
    1843      * Figure how much that we can push down.
    1844      */
    1845     uint32_t const cbSinkWritable     = AudioMixerSinkGetWritable(pSink);
    1846     uint32_t const cbStreamReadable   = hdaR3StreamGetUsed(pStreamR3);
    1847     uint32_t       cbToReadFromStream = RT_MIN(cbStreamReadable, cbSinkWritable);
    1848     /* Make sure that we always align the number of bytes when reading to the stream's PCM properties. */
    1849     cbToReadFromStream = PDMAudioPropsFloorBytesToFrame(&pStreamShared->State.Cfg.Props, cbToReadFromStream);
     1795#ifdef LOG_ENABLED
     1796    uint64_t const offReadOld = pStreamR3->State.offRead;
     1797#endif
     1798    pStreamR3->State.offRead = AudioMixerSinkTransferFromCircBuf(pSink,
     1799                                                                 pStreamR3->State.pCircBuf,
     1800                                                                 pStreamR3->State.offRead,
     1801                                                                 pStreamR3->u8SD,
     1802                                                                 pStreamR3->Dbg.Runtime.fEnabled
     1803                                                                 ? pStreamR3->Dbg.Runtime.pFileStream : NULL);
    18501804
    18511805    Assert(nsNow >= pStreamShared->State.tsLastReadNs);
    1852     Log3Func(("[SD%RU8] nsDeltaLastRead=%RI64 cbSinkWritable=%RU32 cbStreamReadable=%RU32 -> cbToReadFromStream=%RU32\n",
    1853               pStreamShared->u8SD, nsNow - pStreamShared->State.tsLastReadNs, cbSinkWritable, cbStreamReadable, cbToReadFromStream));
     1806    Log3Func(("[SD%RU8] nsDeltaLastRead=%RI64 transferred=%#RX64 bytes -> @%#RX64\n", pStreamR3->u8SD,
     1807              nsNow - pStreamShared->State.tsLastReadNs, pStreamR3->State.offRead - offReadOld, pStreamR3->State.offRead));
    18541808    RT_NOREF(pStreamShared, nsNow);
    1855 
    1856     /*
    1857      * Do the pushing.
    1858      */
    1859     Assert(pStreamR3->State.pCircBuf);
    1860     while (cbToReadFromStream > 0)
    1861     {
    1862         void /*const*/ *pvSrcBuf;
    1863         size_t          cbSrcBuf;
    1864         RTCircBufAcquireReadBlock(pStreamR3->State.pCircBuf, cbToReadFromStream, &pvSrcBuf, &cbSrcBuf);
    1865 
    1866         if (!pStreamR3->Dbg.Runtime.fEnabled)
    1867         { /* likely */ }
    1868         else
    1869             AudioHlpFileWrite(pStreamR3->Dbg.Runtime.pFileStream, pvSrcBuf, cbSrcBuf, 0 /* fFlags */);
    1870 
    1871         uint32_t cbWritten = 0;
    1872         int rc = AudioMixerSinkWrite(pSink, AUDMIXOP_COPY, pvSrcBuf, (uint32_t)cbSrcBuf, &cbWritten);
    1873         AssertRC(rc);
    1874         Assert(cbWritten <= cbSrcBuf);
    1875 
    1876         Log2Func(("[SD%RU8] %#RX32/%#zx bytes read @ %#RX64\n", pStreamR3->u8SD, cbWritten, cbSrcBuf, pStreamR3->State.offRead));
    1877 #ifdef VBOX_WITH_DTRACE
    1878         VBOXDD_HDA_STREAM_AIO_OUT(pStreamR3->u8SD, cbWritten, pStreamR3->State.offRead);
    1879 #endif
    1880         pStreamR3->State.offRead += cbWritten;
    1881 
    1882         RTCircBufReleaseReadBlock(pStreamR3->State.pCircBuf, cbWritten);
    1883 
    1884         /* advance */
    1885         cbToReadFromStream -= cbWritten;
    1886     }
    18871809
    18881810    /* Update buffer stats. */
    18891811    pStreamR3->State.StatDmaBufUsed = (uint32_t)RTCircBufUsed(pStreamR3->State.pCircBuf);
    18901812}
     1813
    18911814
    18921815/**
    … …  
    19541877}
    19551878
     1879
    19561880/**
    19571881 * Updates a HDA stream by doing DMA transfers.
    … …  
    20141938        {
    20151939            STAM_REL_COUNTER_INC(&pStreamR3->State.StatDmaFlowProblems);
    2016             Log(("hdaR3StreamUpdate: Warning! Stream #%u has insufficient space free: %u bytes, need %u.  Will try move data out of the buffer...\n",
     1940            Log(("hdaR3StreamUpdateDma: Warning! Stream #%u has insufficient space free: %u bytes, need %u.  Will try move data out of the buffer...\n",
    20171941                 pStreamShared->u8SD, cbStreamFree, cbPeriod));
    20181942            int rc = AudioMixerSinkTryLock(pSink);
    … …  
    20251949            else
    20261950                RTThreadYield();
    2027             Log(("hdaR3StreamUpdate: Gained %u bytes.\n", hdaR3StreamGetFree(pStreamR3) - cbStreamFree));
     1951            Log(("hdaR3StreamUpdateDma: Gained %u bytes.\n", hdaR3StreamGetFree(pStreamR3) - cbStreamFree));
    20281952
    20291953            cbStreamFree = hdaR3StreamGetFree(pStreamR3);
    … …  
    21292053            if (cbStreamUsed < pStreamShared->State.cbInputPreBuffer)
    21302054            {
    2131                 Log3(("hdaR3StreamUpdate: Pre-buffering (got %#x out of %#x bytes)...\n",
     2055                Log3(("hdaR3StreamUpdateDma: Pre-buffering (got %#x out of %#x bytes)...\n",
    21322056                      cbStreamUsed, pStreamShared->State.cbInputPreBuffer));
    21332057                fWriteSilence = true;
    … …  
    21352059            else
    21362060            {
    2137                 Log3(("hdaR3StreamUpdate: Completed pre-buffering (got %#x, needed %#x bytes).\n",
     2061                Log3(("hdaR3StreamUpdateDma: Completed pre-buffering (got %#x, needed %#x bytes).\n",
    21382062                      cbStreamUsed, pStreamShared->State.cbInputPreBuffer));
    21392063                pStreamShared->State.fInputPreBuffered = true;
    … …  
    21542078             *        pulse audio is configured for by default (10 ms vs 150ms). */
    21552079            STAM_REL_COUNTER_INC(&pStreamR3->State.StatDmaFlowProblems);
    2156             Log(("hdaR3StreamUpdate: Warning! Stream #%u has insufficient data available: %u bytes, need %u.  Will try move pull more data into the buffer...\n",
     2080            Log(("hdaR3StreamUpdateDma: Warning! Stream #%u has insufficient data available: %u bytes, need %u.  Will try move pull more data into the buffer...\n",
    21572081                 pStreamShared->u8SD, cbStreamUsed, cbPeriod));
    21582082            int rc = AudioMixerSinkTryLock(pSink);
    … …  
    21602084            {
    21612085                AudioMixerSinkUpdate(pSink);
    2162                 hdaR3StreamPullFromMixer(pStreamShared, pStreamR3, pSink);
     2086                hdaR3StreamPullFromMixer(pStreamR3, pSink);
    21632087                AudioMixerSinkUnlock(pSink);
    21642088            }
    21652089            else
    21662090                RTThreadYield();
    2167             Log(("hdaR3StreamUpdate: Gained %u bytes.\n", hdaR3StreamGetUsed(pStreamR3) - cbStreamUsed));
     2091            Log(("hdaR3StreamUpdateDma: Gained %u bytes.\n", hdaR3StreamGetUsed(pStreamR3) - cbStreamUsed));
    21682092            cbStreamUsed = hdaR3StreamGetUsed(pStreamR3);
    21692093            if (cbStreamUsed < cbPeriod)
    … …  
    21812105                    if (cbStreamUsed < cbPeriod)
    21822106                    {
    2183                         hdaR3StreamPullFromMixer(pStreamShared, pStreamR3, pSink);
     2107                        hdaR3StreamPullFromMixer(pStreamR3, pSink);
    21842108                        cbStreamUsed = hdaR3StreamGetUsed(pStreamR3);
    21852109                        while (cbStreamUsed < cbPeriod)
    … …  
    22762200    {
    22772201        Assert(hdaGetDirFromSD(pStreamShared->u8SD) == PDMAUDIODIR_IN);
    2278         hdaR3StreamPullFromMixer(pStreamShared, pStreamR3, pSink);
     2202        hdaR3StreamPullFromMixer(pStreamR3, pSink);
    22792203    }
    22802204}

  • trunk/src/VBox/Devices/build/VBoxDD.d

    r87989 r88944  
    3131    probe hda__stream__dma__in(uint32_t idxStream, uint32_t cb, uint64_t off);
    3232    probe hda__stream__dma__flowerror(uint32_t idxStream, uint32_t cbFree, uint32_t cbPeriod, int32_t fOverflow);
    33     probe hda__stream__aio__out(uint32_t idxStream, uint32_t cb, uint64_t off);
    34     probe hda__stream__aio__in(uint32_t idxStream, uint32_t cb, uint64_t off);
     33
     34    probe audio__mixer__sink__aio__out(uint32_t idxStream, uint32_t cb, uint64_t off);
     35    probe audio__mixer__sink__aio__in(uint32_t idxStream, uint32_t cb, uint64_t off);
    3536};
    3637
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette