VirtualBox

Changeset 67833 in vbox


Ignore:
Timestamp:
Jul 6, 2017 2:54:00 PM (8 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
116767
Message:

Audio/DevHDA.cpp: Get rid of the PHDASTATE parameter for all hdaStreamXXX functions to make the stream stuff more self-contained. No other code changes.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r67806 r67833  
    673673    uint16_t                 u16LVI;
    674674    uint16_t                 Padding1[2];
     675    /** Pointer to the HDA state this stream is attached to. */
     676    R3PTRTYPE(PHDASTATE)     pHDAState;
    675677    /** Pointer to HDA sink this stream is attached to. */
    676678    R3PTRTYPE(PHDAMIXERSINK) pMixSink;
    … …  
    10051007 */
    10061008#ifdef IN_RING3
    1007 static void          hdaStreamDestroy(PHDASTATE pThis, PHDASTREAM pStream);
    1008 static int           hdaStreamEnable(PHDASTATE pThis, PHDASTREAM pStream, bool fEnable);
     1009static void          hdaStreamDestroy(PHDASTREAM pStream);
     1010static int           hdaStreamEnable(PHDASTREAM pStream, bool fEnable);
    10091011static uint32_t      hdaStreamGetUsed(PHDASTREAM pStream);
    10101012static uint32_t      hdaStreamGetFree(PHDASTREAM pStream);
    1011 static int           hdaStreamTransfer(PHDASTATE pThis, PHDASTREAM pStream, uint32_t cbToProcessMax);
    1012 DECLINLINE(uint32_t) hdaStreamUpdateLPIB(PHDASTATE pThis, PHDASTREAM pStream, uint32_t u32LPIB);
     1013static int           hdaStreamTransfer(PHDASTREAM pStream, uint32_t cbToProcessMax);
     1014DECLINLINE(uint32_t) hdaStreamUpdateLPIB(PHDASTREAM pStream, uint32_t u32LPIB);
    10131015static void          hdaStreamLock(PHDASTREAM pStream);
    10141016static void          hdaStreamUnlock(PHDASTREAM pStream);
    1015 static int           hdaStreamRead(PHDASTATE pThis, PHDASTREAM pStream, uint32_t cbToRead, uint32_t *pcbRead);
    1016 static int           hdaStreamWrite(PHDASTATE pThis, PHDASTREAM pStream, uint32_t cbToWrite, uint32_t *pcbWritten);
    1017 static void          hdaStreamUpdate(PHDASTATE pThis, PHDASTREAM pStream, bool fAsync);
     1017static int           hdaStreamRead(PHDASTREAM pStream, uint32_t cbToRead, uint32_t *pcbRead);
     1018static int           hdaStreamWrite(PHDASTREAM pStream, uint32_t cbToWrite, uint32_t *pcbWritten);
     1019static void          hdaStreamUpdate(PHDASTREAM pStream, bool fAsync);
    10181020# ifdef HDA_USE_DMA_ACCESS_HANDLER
    1019 static bool          hdaStreamRegisterDMAHandlers(PHDASTATE pThis, PHDASTREAM pStream);
    1020 static void          hdaStreamUnregisterDMAHandlers(PHDASTATE pThis, PHDASTREAM pStream);
     1021static bool          hdaStreamRegisterDMAHandlers(PHDASTREAM pStream);
     1022static void          hdaStreamUnregisterDMAHandlers(PHDASTREAM pStream);
    10211023# endif
    10221024#endif /* IN_RING3 */
    … …  
    10291031# ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
    10301032static DECLCALLBACK(int) hdaStreamAsyncIOThread(RTTHREAD hThreadSelf, void *pvUser);
    1031 static int               hdaStreamAsyncIOCreate(PHDASTATE pThis, PHDASTREAM pStream);
    1032 static int               hdaStreamAsyncIODestroy(PHDASTATE pThis, PHDASTREAM pStream);
    1033 static int               hdaStreamAsyncIONotify(PHDASTATE pThis, PHDASTREAM pStream);
     1033static int               hdaStreamAsyncIOCreate(PHDASTREAM pStream);
     1034static int               hdaStreamAsyncIODestroy(PHDASTREAM pStream);
     1035static int               hdaStreamAsyncIONotify(PHDASTREAM pStream);
    10341036static void              hdaStreamAsyncIOLock(PHDASTREAM pStream);
    10351037static void              hdaStreamAsyncIOUnlock(PHDASTREAM pStream);
    … …  
    13241326 *
    13251327 * @returns Set LPIB value.
    1326  * @param   pThis               HDA state.
    13271328 * @param   pStream             HDA stream to update read / write position for.
    13281329 * @param   u32LPIB             New LPIB (position) value to set.
    13291330 */
    1330 DECLINLINE(uint32_t) hdaStreamUpdateLPIB(PHDASTATE pThis, PHDASTREAM pStream, uint32_t u32LPIB)
    1331 {
    1332     AssertPtrReturn(pThis,   0);
     1331DECLINLINE(uint32_t) hdaStreamUpdateLPIB(PHDASTREAM pStream, uint32_t u32LPIB)
     1332{
    13331333    AssertPtrReturn(pStream, 0);
    13341334
    13351335    AssertMsg(u32LPIB <= pStream->u32CBL,
    13361336              ("[SD%RU8] New LPIB (%RU32) exceeds CBL (%RU32)\n", pStream->u8SD, u32LPIB, pStream->u32CBL));
     1337
     1338    const PHDASTATE pThis = pStream->pHDAState;
    13371339
    13381340    u32LPIB = RT_MIN(u32LPIB, pStream->u32CBL);
    … …  
    18471849}
    18481850
    1849 static int hdaStreamCreate(PHDASTATE pThis, PHDASTREAM pStream)
     1851static int hdaStreamCreate(PHDASTREAM pStream, PHDASTATE pThis)
    18501852{
    18511853    RT_NOREF(pThis);
    … …  
    18541856    pStream->u8SD           = UINT8_MAX;
    18551857    pStream->pMixSink       = NULL;
     1858    pStream->pHDAState      = pThis;
    18561859
    18571860    pStream->State.fInReset = false;
    … …  
    18761879}
    18771880
    1878 static void hdaStreamDestroy(PHDASTATE pThis, PHDASTREAM pStream)
     1881static void hdaStreamDestroy(PHDASTREAM pStream)
    18791882{
    18801883    AssertPtrReturnVoid(pStream);
    … …  
    18871890
    18881891#ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
    1889     rc2 = hdaStreamAsyncIODestroy(pThis, pStream);
     1892    rc2 = hdaStreamAsyncIODestroy(pStream);
    18901893    AssertRC(rc2);
    18911894#else
    … …  
    19121915}
    19131916
    1914 static int hdaStreamInit(PHDASTATE pThis, PHDASTREAM pStream, uint8_t uSD)
    1915 {
    1916     AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
     1917static int hdaStreamInit(PHDASTREAM pStream, uint8_t uSD)
     1918{
    19171919    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
     1920
     1921    PHDASTATE pThis = pStream->pHDAState;
     1922    AssertPtr(pThis);
    19181923
    19191924    pStream->u8SD       = uSD;
    … …  
    19251930
    19261931    /* Make sure to also update the stream's DMA counter (based on its current LPIB value). */
    1927     hdaStreamUpdateLPIB(pThis, pStream, HDA_STREAM_REG(pThis, LPIB, pStream->u8SD));
     1932    hdaStreamUpdateLPIB(pStream, HDA_STREAM_REG(pThis, LPIB, pStream->u8SD));
    19281933
    19291934    PPDMAUDIOSTREAMCFG pCfg = &pStream->State.strmCfg;
    … …  
    20372042
    20382043    /* (Re-)initialize the stream with current values. */
    2039     int rc2 = hdaStreamInit(pThis, pStream, uSD);
     2044    int rc2 = hdaStreamInit(pStream, uSD);
    20402045    AssertRC(rc2);
    20412046
    … …  
    20672072 *
    20682073 * @returns IPRT status code.
    2069  * @param   pThis               HDA state.
    20702074 * @param   pStream             HDA stream to enable or disable.
    20712075 * @param   fEnable             Whether to enable or disble the stream.
    20722076 */
    2073 static int hdaStreamEnable(PHDASTATE pThis, PHDASTREAM pStream, bool fEnable)
    2074 {
    2075     AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
     2077static int hdaStreamEnable(PHDASTREAM pStream, bool fEnable)
     2078{
    20762079    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
    20772080
    … …  
    25502553#endif
    25512554            /* (Re-)initialize the stream with current values. */
    2552             int rc2 = hdaStreamInit(pThis, pStream, pStream->u8SD);
     2555            int rc2 = hdaStreamInit(pStream, pStream->u8SD);
    25532556            AssertRC(rc2);
    25542557
    25552558            /* Enable/disable the stream. */
    2556             hdaStreamEnable(pThis, pStream, fRun /* fEnable */);
     2559            hdaStreamEnable(pStream, fRun /* fEnable */);
    25572560
    25582561            if (fRun)
    … …  
    31473150    AssertRC(rc);
    31483151
    3149     rc = hdaStreamInit(pThis, pStream, pStream->u8SD);
     3152    rc = hdaStreamInit(pStream, pStream->u8SD);
    31503153    if (RT_SUCCESS(rc))
    31513154    {
    … …  
    31543157# ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
    31553158        if (RT_SUCCESS(rc))
    3156             rc = hdaStreamAsyncIOCreate(pThis, pStream);
     3159            rc = hdaStreamAsyncIOCreate(pStream);
    31573160# endif
    31583161    }
    … …  
    33483351 *
    33493352 * @returns true if registration was successful, false if not.
    3350  * @param   pThis               HDA state.
    33513353 * @param   pStream             HDA stream to register BDLE access handlers for.
    33523354 */
    3353 static bool hdaStreamRegisterDMAHandlers(PHDASTATE pThis, PHDASTREAM pStream)
     3355static bool hdaStreamRegisterDMAHandlers(PHDASTREAM pStream)
    33543356{
    33553357    /* At least LVI and the BDL base must be set. */
    … …  
    33603362    }
    33613363
    3362     hdaStreamUnregisterDMAHandlers(pThis, pStream);
     3364    hdaStreamUnregisterDMAHandlers(pStream);
    33633365
    33643366    LogFunc(("Registering ...\n"));
    … …  
    34443446        RTStrPrintf(szDesc, sizeof(szDesc), "HDA[SD%RU8 - RANGE%02zu]", pStream->u8SD, i);
    34453447
    3446         int rc2 = PGMR3HandlerPhysicalTypeRegister(PDMDevHlpGetVM(pThis->pDevInsR3), PGMPHYSHANDLERKIND_WRITE,
     3448        int rc2 = PGMR3HandlerPhysicalTypeRegister(PDMDevHlpGetVM(pStream->pHDAState->pDevInsR3), PGMPHYSHANDLERKIND_WRITE,
    34473449                                                   hdaDMAAccessHandler,
    34483450                                                   NULL, NULL, NULL,
    … …  
    34693471                 pHandler->BDLEAddr, pHandler->BDLEAddr + pHandler->BDLESize, pHandler->BDLESize));
    34703472
    3471         rc2 = PGMHandlerPhysicalRegister(PDMDevHlpGetVM(pThis->pDevInsR3),
     3473        rc2 = PGMHandlerPhysicalRegister(PDMDevHlpGetVM(pStream->pHDAState->pDevInsR3),
    34723474                                         pHandler->GCPhysFirst, pHandler->GCPhysLast,
    34733475                                         pHandler->hAccessHandlerType, pHandler, NIL_RTR0PTR, NIL_RTRCPTR,
    … …  
    34863488 * Unregisters access handlers of a stream's BDLEs.
    34873489 *
    3488  * @param   pThis               HDA state.
    34893490 * @param   pStream             HDA stream to unregister BDLE access handlers for.
    34903491 */
    3491 static void hdaStreamUnregisterDMAHandlers(PHDASTATE pThis, PHDASTREAM pStream)
     3492static void hdaStreamUnregisterDMAHandlers(PHDASTREAM pStream)
    34923493{
    34933494    LogFunc(("\n"));
    … …  
    35023503                 pHandler->GCPhysFirst, pHandler->GCPhysLast, pHandler->GCPhysLast - pHandler->GCPhysFirst));
    35033504
    3504         int rc2 = PGMHandlerPhysicalDeregister(PDMDevHlpGetVM(pThis->pDevInsR3),
     3505        int rc2 = PGMHandlerPhysicalDeregister(PDMDevHlpGetVM(pStream->pHDAState->pDevInsR3),
    35053506                                               pHandler->GCPhysFirst);
    35063507        AssertRC(rc2);
    … …  
    36283629
    36293630
    3630 DECLINLINE(void) hdaStreamTransferInc(PHDASTATE pThis, PHDASTREAM pStream, uint32_t cbInc)
    3631 {
    3632     AssertPtrReturnVoid(pThis);
     3631DECLINLINE(void) hdaStreamTransferInc(PHDASTREAM pStream, uint32_t cbInc)
     3632{
    36333633    AssertPtrReturnVoid(pStream);
    36343634
    … …  
    36363636        return;
    36373637
     3638    const PHDASTATE pThis  = pStream->pHDAState;
     3639
    36383640    const uint32_t u32LPIB = HDA_STREAM_REG(pThis, LPIB, pStream->u8SD);
    36393641
    … …  
    36413643              pStream->u8SD, u32LPIB, cbInc, u32LPIB + cbInc, pStream->u32CBL));
    36423644
    3643     hdaStreamUpdateLPIB(pThis, pStream, u32LPIB + cbInc);
     3645    hdaStreamUpdateLPIB(pStream, u32LPIB + cbInc);
    36443646}
    36453647
    … …  
    47144716#endif
    47154717
    4716     hdaStreamUpdate(pThis, pStreamFront,  true /* fInTimer */);
     4718    hdaStreamUpdate(pStreamFront,  true /* fInTimer */);
    47174719#ifdef VBOX_WITH_AUDIO_HDA_MIC_IN
    4718     hdaStreamUpdate(pThis, pStreamMicIn,  true /* fInTimer */);
    4719 #endif
    4720     hdaStreamUpdate(pThis, pStreamLineIn, true /* fInTimer */);
     4720    hdaStreamUpdate(pStreamMicIn,  true /* fInTimer */);
     4721#endif
     4722    hdaStreamUpdate(pStreamLineIn, true /* fInTimer */);
    47214723}
    47224724
    … …  
    47624764 *
    47634765 * @returns IPRT status code.
    4764  * @param   pThis               HDA state.
    47654766 * @param   pStream             HDA stream to write to.
    47664767 * @param   cbToWrite           Number of bytes to write.
    47674768 * @param   pcbWritten          Number of bytes written. Optional.
    47684769 */
    4769 static int hdaStreamWrite(PHDASTATE pThis, PHDASTREAM pStream, uint32_t cbToWrite, uint32_t *pcbWritten)
    4770 {
    4771     RT_NOREF(pThis);
     4770static int hdaStreamWrite(PHDASTREAM pStream, uint32_t cbToWrite, uint32_t *pcbWritten)
     4771{
    47724772    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
    47734773    AssertReturn(cbToWrite,  VERR_INVALID_PARAMETER);
    … …  
    48404840 *
    48414841 * @returns IPRT status code.
    4842  * @param   pThis               HDA state.
    48434842 * @param   pStream             HDA stream to read audio data from.
    48444843 * @param   cbToRead            Number of bytes to read.
    48454844 * @param   pcbRead             Number of bytes read. Optional.
    48464845 */
    4847 static int hdaStreamRead(PHDASTATE pThis, PHDASTREAM pStream, uint32_t cbToRead, uint32_t *pcbRead)
    4848 {
    4849     RT_NOREF(pThis);
     4846static int hdaStreamRead(PHDASTREAM pStream, uint32_t cbToRead, uint32_t *pcbRead)
     4847{
    48504848    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
    48514849    AssertReturn(cbToRead,   VERR_INVALID_PARAMETER);
    … …  
    49264924    AssertPtr(pCtx);
    49274925
    4928     PHDASTATE pThis = pCtx->pThis;
    4929     AssertPtr(pThis);
    4930 
    49314926    PHDASTREAM pStream = pCtx->pStream;
    49324927    AssertPtr(pStream);
    … …  
    49584953            }
    49594954
    4960             hdaStreamUpdate(pThis, pStream, false /* fInTimer */);
     4955            hdaStreamUpdate(pStream, false /* fInTimer */);
    49614956
    49624957            int rc3 = RTCritSectLeave(&pAIO->CritSect);
    … …  
    49784973 *
    49794974 * @returns IPRT status code.
    4980  * @param   pThis               HDA state.
    49814975 * @param   pStream             HDA audio stream to create the async I/O thread for.
    49824976 */
    4983 static int hdaStreamAsyncIOCreate(PHDASTATE pThis, PHDASTREAM pStream)
     4977static int hdaStreamAsyncIOCreate(PHDASTREAM pStream)
    49844978{
    49854979    PHDASTREAMSTATEAIO pAIO = &pStream->State.AIO;
    … …  
    49974991            if (RT_SUCCESS(rc))
    49984992            {
    4999                 HDASTREAMTHREADCTX Ctx = { pThis, pStream };
     4993                HDASTREAMTHREADCTX Ctx = { pStream->pHDAState, pStream };
    50004994
    50014995                char szThreadName[64];
    … …  
    50205014 *
    50215015 * @returns IPRT status code.
    5022  * @param   pThis               HDA state.
    50235016 * @param   pStream             HDA audio stream to destroy the async I/O thread for.
    50245017 */
    5025 static int hdaStreamAsyncIODestroy(PHDASTATE pThis, PHDASTREAM pStream)
     5018static int hdaStreamAsyncIODestroy(PHDASTREAM pStream)
    50265019{
    50275020    PHDASTREAMSTATEAIO pAIO = &pStream->State.AIO;
    … …  
    50325025    ASMAtomicWriteBool(&pAIO->fShutdown, true);
    50335026
    5034     int rc = hdaStreamAsyncIONotify(pThis, pStream);
     5027    int rc = hdaStreamAsyncIONotify(pStream);
    50355028    AssertRC(rc);
    50365029
    … …  
    50605053 *
    50615054 * @returns IPRT status code.
    5062  * @param   pThis               HDA state.
    50635055 * @param   pStream             HDA stream to notify async I/O thread for.
    50645056 */
    5065 static int hdaStreamAsyncIONotify(PHDASTATE pThis, PHDASTREAM pStream)
    5066 {
    5067     RT_NOREF(pThis);
     5057static int hdaStreamAsyncIONotify(PHDASTREAM pStream)
     5058{
    50685059    return RTSemEventSignal(pStream->State.AIO.Event);
    50695060}
    … …  
    51165107#endif /* VBOX_WITH_AUDIO_HDA_ASYNC_IO */
    51175108
    5118 static uint32_t hdaStreamTransferGetElapsed(PHDASTATE pThis, PHDASTREAM pStream)
    5119 {
    5120     const uint64_t cTicksNow     = TMTimerGet(pThis->pTimer);
    5121     const uint64_t cTicksPerSec  = TMTimerGetFreq(pThis->pTimer);
     5109static uint32_t hdaStreamTransferGetElapsed(PHDASTREAM pStream)
     5110{
     5111    AssertPtr(pStream->pHDAState->pTimer);
     5112    const uint64_t cTicksNow     = TMTimerGet(pStream->pHDAState->pTimer);
     5113    const uint64_t cTicksPerSec  = TMTimerGetFreq(pStream->pHDAState->pTimer);
    51225114
    51235115    const uint64_t cTicksElapsed = cTicksNow - pStream->State.uTimerTS;
    … …  
    51265118#endif
    51275119
    5128     AssertPtr(pThis->pCodec);
     5120    AssertPtr(pStream->pHDAState->pCodec);
    51295121
    51305122    PPDMAUDIOSTREAMCFG pCfg = &pStream->State.strmCfg;
    … …  
    51495141 *
    51505142 * @returns IPRT status code.
    5151  * @param   pThis               HDA state.
    51525143 * @param   pStream             HDA stream to update.
    51535144 * @param   cbToProcessMax      Maximum of data (in bytes) to process.
    51545145 */
    5155 static int hdaStreamTransfer(PHDASTATE pThis, PHDASTREAM pStream, uint32_t cbToProcessMax)
    5156 {
    5157     AssertPtrReturn(pThis,          VERR_INVALID_POINTER);
     5146static int hdaStreamTransfer(PHDASTREAM pStream, uint32_t cbToProcessMax)
     5147{
    51585148    AssertPtrReturn(pStream,        VERR_INVALID_POINTER);
    51595149    AssertReturn(cbToProcessMax,    VERR_INVALID_PARAMETER);
    51605150
    51615151    hdaStreamLock(pStream);
     5152
     5153    PHDASTATE pThis = pStream->pHDAState;
     5154    AssertPtr(pThis);
    51625155
    51635156    PHDASTREAMPERIOD pPeriod = &pStream->State.Period;
    … …  
    52065199    Assert(cbPeriodRemaining); /* Paranoia. */
    52075200
    5208     const uint32_t cbElapsed         = hdaStreamTransferGetElapsed(pThis, pStream);
     5201    const uint32_t cbElapsed         = hdaStreamTransferGetElapsed(pStream);
    52095202    Assert(cbElapsed);         /* Paranoia. */
    52105203
    … …  
    52585251            Assert(pBDLE->State.u32BufOff <= pBDLE->Desc.u32BufSize);
    52595252
    5260             hdaStreamTransferInc(pThis, pStream, cbDMA);
     5253            hdaStreamTransferInc(pStream, cbDMA);
    52615254
    52625255            uint32_t framesDMA = cbDMA / HDA_FRAME_SIZE;
    … …  
    52905283
    52915284                pStream->State.uCurBDLE = 0;
    5292                 hdaStreamUpdateLPIB(pThis, pStream, 0 /* LPIB */);
     5285                hdaStreamUpdateLPIB(pStream, 0 /* LPIB */);
    52935286            }
    52945287            else
    … …  
    53675360 * This routine is called by both, the synchronous and the asynchronous, implementations.
    53685361 *
    5369  * @param   pThis               HDA state.
    53705362 * @param   pStream             HDA stream to update.
    53715363 * @param   fInTimer            Whether to this function was called from the timer
    53725364 *                              context or an asynchronous I/O stream thread (if supported).
    53735365 */
    5374 static void hdaStreamUpdate(PHDASTATE pThis, PHDASTREAM pStream, bool fInTimer)
     5366static void hdaStreamUpdate(PHDASTREAM pStream, bool fInTimer)
    53755367{
    53765368    PAUDMIXSINK pSink = NULL;
    … …  
    53975389
    53985390            /* Do the DMA transfer. */
    5399             rc2 = hdaStreamTransfer(pThis, pStream, cbFree);
     5391            rc2 = hdaStreamTransfer(pStream, cbFree);
    54005392            AssertRC(rc2);
    54015393        }
    … …  
    54085400            && cbUsed)
    54095401        {
    5410             rc2 = hdaStreamAsyncIONotify(pThis, pStream);
     5402            rc2 = hdaStreamAsyncIONotify(pStream);
    54115403            AssertRC(rc2);
    54125404        }
    … …  
    54245416            {
    54255417                /* Read (guest output) data and write it to the stream's sink. */
    5426                 rc2 = hdaStreamRead(pThis, pStream, cbUsed, NULL /* pcbRead */);
     5418                rc2 = hdaStreamRead(pStream, cbUsed, NULL /* pcbRead */);
    54275419                AssertRC(rc2);
    54285420            }
    … …  
    54425434        if (fInTimer)
    54435435        {
    5444             rc2 = hdaStreamAsyncIONotify(pThis, pStream);
     5436            rc2 = hdaStreamAsyncIONotify(pStream);
    54455437            AssertRC(rc2);
    54465438        }
    … …  
    54675459            {
    54685460                /* Write (guest input) data to the stream which was read from stream's sink before. */
    5469                 rc2 = hdaStreamWrite(pThis, pStream, cbFree, NULL /* pcbWritten */);
     5461                rc2 = hdaStreamWrite(pStream, cbFree, NULL /* pcbWritten */);
    54705462                AssertRC(rc2);
    54715463            }
    … …  
    54835475                /* When running synchronously, do the DMA data transfers here.
    54845476                 * Otherwise this will be done in the stream's async I/O thread. */
    5485                 rc2 = hdaStreamTransfer(pThis, pStream, cbToTransfer);
     5477                rc2 = hdaStreamTransfer(pStream, cbToTransfer);
    54865478                AssertRC(rc2);
    54875479            }
    … …  
    60065998#ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
    60075999                /* Make sure to also create the async I/O thread before actually enabling the stream. */
    6008                 rc2 = hdaStreamAsyncIOCreate(pThis, pStream);
     6000                rc2 = hdaStreamAsyncIOCreate(pStream);
    60096001                AssertRC(rc2);
    60106002
    … …  
    60136005#endif
    60146006                /* (Re-)initialize the stream with current values. */
    6015                 rc2 = hdaStreamInit(pThis, pStream, pStream->u8SD);
     6007                rc2 = hdaStreamInit(pStream, pStream->u8SD);
    60166008                AssertRC(rc2);
    60176009
    … …  
    60206012
    60216013                /* (Re-)enable the stream. */
    6022                 rc2 = hdaStreamEnable(pThis, pStream, true /* fEnable */);
     6014                rc2 = hdaStreamEnable(pStream, true /* fEnable */);
    60236015                AssertRC(rc2);
    60246016
    … …  
    61726164            /* Output */
    61736165            PHDASTREAM pStream = &pThis->aStreams[4];
    6174             rc = hdaStreamInit(pThis, pStream, 4 /* Stream descriptor, hardcoded */);
     6166            rc = hdaStreamInit(pStream, 4 /* Stream descriptor, hardcoded */);
    61756167            if (RT_FAILURE(rc))
    61766168                break;
    … …  
    61806172            /* Microphone-In */
    61816173            pStream = &pThis->aStreams[2];
    6182             rc = hdaStreamInit(pThis, pStream, 2 /* Stream descriptor, hardcoded */);
     6174            rc = hdaStreamInit(pStream, 2 /* Stream descriptor, hardcoded */);
    61836175            if (RT_FAILURE(rc))
    61846176                break;
    … …  
    61886180            /* Line-In */
    61896181            pStream = &pThis->aStreams[0];
    6190             rc = hdaStreamInit(pThis, pStream, 0 /* Stream descriptor, hardcoded */);
     6182            rc = hdaStreamInit(pStream, 0 /* Stream descriptor, hardcoded */);
    61916183            if (RT_FAILURE(rc))
    61926184                break;
    … …  
    62256217                }
    62266218
    6227                 rc = hdaStreamInit(pThis, pStrm, uStreamID);
     6219                rc = hdaStreamInit(pStrm, uStreamID);
    62286220                if (RT_FAILURE(rc))
    62296221                {
    … …  
    64196411        }
    64206412
    6421         rc = hdaStreamInit(pThis, pStrm, uStreamID);
     6413        rc = hdaStreamInit(pStrm, uStreamID);
    64226414        if (RT_FAILURE(rc))
    64236415        {
    … …  
    68666858
    68676859    for (uint8_t i = 0; i < HDA_MAX_STREAMS; i++)
    6868         hdaStreamDestroy(pThis, &pThis->aStreams[i]);
     6860        hdaStreamDestroy(&pThis->aStreams[i]);
    68696861
    68706862    return VINF_SUCCESS;
    … …  
    73127304        for (uint8_t i = 0; i < HDA_MAX_STREAMS; ++i)
    73137305        {
    7314             rc = hdaStreamCreate(pThis, &pThis->aStreams[i]);
     7306            rc = hdaStreamCreate(&pThis->aStreams[i], pThis);
    73157307            AssertRC(rc);
    73167308        }
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