VirtualBox

Changeset 69948 in vbox for trunk/src/VBox/Devices


Ignore:
Timestamp:
Dec 6, 2017 9:59:08 AM (7 years ago)
Author:
vboxsync
Message:

Audio/HDA: Renaming (pStrm -> pStream).

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r69939 r69948  
    33843384/* Saved state callbacks. */
    33853385
    3386 static int hdaSaveStream(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, PHDASTREAM pStrm)
     3386static int hdaSaveStream(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, PHDASTREAM pStream)
    33873387{
    33883388    RT_NOREF(pDevIns);
    … …  
    33913391#endif
    33923392
    3393     Log2Func(("[SD%RU8]\n", pStrm->u8SD));
     3393    Log2Func(("[SD%RU8]\n", pStream->u8SD));
    33943394
    33953395    /* Save stream ID. */
    3396     int rc = SSMR3PutU8(pSSM, pStrm->u8SD);
     3396    int rc = SSMR3PutU8(pSSM, pStream->u8SD);
    33973397    AssertRCReturn(rc, rc);
    3398     Assert(pStrm->u8SD < HDA_MAX_STREAMS);
    3399 
    3400     rc = SSMR3PutStructEx(pSSM, &pStrm->State, sizeof(HDASTREAMSTATE), 0 /*fFlags*/, g_aSSMStreamStateFields7, NULL);
     3398    Assert(pStream->u8SD < HDA_MAX_STREAMS);
     3399
     3400    rc = SSMR3PutStructEx(pSSM, &pStream->State, sizeof(HDASTREAMSTATE), 0 /*fFlags*/, g_aSSMStreamStateFields7, NULL);
    34013401    AssertRCReturn(rc, rc);
    34023402
    34033403#ifdef VBOX_STRICT /* Sanity checks. */
    3404     uint64_t u64BaseDMA = RT_MAKE_U64(HDA_STREAM_REG(pThis, BDPL, pStrm->u8SD),
    3405                                       HDA_STREAM_REG(pThis, BDPU, pStrm->u8SD));
    3406     uint16_t u16LVI     = HDA_STREAM_REG(pThis, LVI, pStrm->u8SD);
    3407     uint32_t u32CBL     = HDA_STREAM_REG(pThis, CBL, pStrm->u8SD);
    3408 
    3409     Assert(u64BaseDMA == pStrm->u64BDLBase);
    3410     Assert(u16LVI     == pStrm->u16LVI);
    3411     Assert(u32CBL     == pStrm->u32CBL);
    3412 #endif
    3413 
    3414     rc = SSMR3PutStructEx(pSSM, &pStrm->State.BDLE.Desc, sizeof(HDABDLEDESC),
     3404    uint64_t u64BaseDMA = RT_MAKE_U64(HDA_STREAM_REG(pThis, BDPL, pStream->u8SD),
     3405                                      HDA_STREAM_REG(pThis, BDPU, pStream->u8SD));
     3406    uint16_t u16LVI     = HDA_STREAM_REG(pThis, LVI, pStream->u8SD);
     3407    uint32_t u32CBL     = HDA_STREAM_REG(pThis, CBL, pStream->u8SD);
     3408
     3409    Assert(u64BaseDMA == pStream->u64BDLBase);
     3410    Assert(u16LVI     == pStream->u16LVI);
     3411    Assert(u32CBL     == pStream->u32CBL);
     3412#endif
     3413
     3414    rc = SSMR3PutStructEx(pSSM, &pStream->State.BDLE.Desc, sizeof(HDABDLEDESC),
    34153415                          0 /*fFlags*/, g_aSSMBDLEDescFields7, NULL);
    34163416    AssertRCReturn(rc, rc);
    34173417
    3418     rc = SSMR3PutStructEx(pSSM, &pStrm->State.BDLE.State, sizeof(HDABDLESTATE),
     3418    rc = SSMR3PutStructEx(pSSM, &pStream->State.BDLE.State, sizeof(HDABDLESTATE),
    34193419                          0 /*fFlags*/, g_aSSMBDLEStateFields7, NULL);
    34203420    AssertRCReturn(rc, rc);
    34213421
    3422     rc = SSMR3PutStructEx(pSSM, &pStrm->State.Period, sizeof(HDASTREAMPERIOD),
     3422    rc = SSMR3PutStructEx(pSSM, &pStream->State.Period, sizeof(HDASTREAMPERIOD),
    34233423                          0 /* fFlags */, g_aSSMStreamPeriodFields7, NULL);
    34243424    AssertRCReturn(rc, rc);
    34253425
    34263426#ifdef VBOX_STRICT /* Sanity checks. */
    3427     PHDABDLE pBDLE = &pStrm->State.BDLE;
     3427    PHDABDLE pBDLE = &pStream->State.BDLE;
    34283428    if (u64BaseDMA)
    34293429    {
    3430         Assert(pStrm->State.uCurBDLE <= u16LVI + 1);
     3430        Assert(pStream->State.uCurBDLE <= u16LVI + 1);
    34313431
    34323432        HDABDLE curBDLE;
    3433         rc = hdaBDLEFetch(pThis, &curBDLE, u64BaseDMA, pStrm->State.uCurBDLE);
     3433        rc = hdaBDLEFetch(pThis, &curBDLE, u64BaseDMA, pStream->State.uCurBDLE);
    34343434        AssertRC(rc);
    34353435
    … …  
    34483448    uint32_t cbCircBufUsed = 0;
    34493449
    3450     if (pStrm->State.pCircBuf)
    3451     {
    3452         cbCircBufSize = (uint32_t)RTCircBufSize(pStrm->State.pCircBuf);
    3453         cbCircBufUsed = (uint32_t)RTCircBufUsed(pStrm->State.pCircBuf);
     3450    if (pStream->State.pCircBuf)
     3451    {
     3452        cbCircBufSize = (uint32_t)RTCircBufSize(pStream->State.pCircBuf);
     3453        cbCircBufUsed = (uint32_t)RTCircBufUsed(pStream->State.pCircBuf);
    34543454    }
    34553455
    … …  
    34693469         * So get the current read offset and serialize the buffer data manually based on that.
    34703470         */
    3471         size_t cbCircBufOffRead = RTCircBufOffsetRead(pStrm->State.pCircBuf);
     3471        size_t cbCircBufOffRead = RTCircBufOffsetRead(pStream->State.pCircBuf);
    34723472
    34733473        void  *pvBuf;
    34743474        size_t cbBuf;
    3475         RTCircBufAcquireReadBlock(pStrm->State.pCircBuf, cbCircBufUsed, &pvBuf, &cbBuf);
     3475        RTCircBufAcquireReadBlock(pStream->State.pCircBuf, cbCircBufUsed, &pvBuf, &cbBuf);
    34763476
    34773477        if (cbBuf)
    … …  
    34993499        }
    35003500
    3501         RTCircBufReleaseReadBlock(pStrm->State.pCircBuf, 0 /* Don't advance read pointer -- see comment above */);
     3501        RTCircBufReleaseReadBlock(pStream->State.pCircBuf, 0 /* Don't advance read pointer -- see comment above */);
    35023502    }
    35033503
    35043504    Log2Func(("[SD%RU8] LPIB=%RU32, CBL=%RU32, LVI=%RU32\n",
    3505               pStrm->u8SD,
    3506               HDA_STREAM_REG(pThis, LPIB, pStrm->u8SD), HDA_STREAM_REG(pThis, CBL, pStrm->u8SD), HDA_STREAM_REG(pThis, LVI, pStrm->u8SD)));
     3505              pStream->u8SD,
     3506              HDA_STREAM_REG(pThis, LPIB, pStream->u8SD), HDA_STREAM_REG(pThis, CBL, pStream->u8SD), HDA_STREAM_REG(pThis, LVI, pStream->u8SD)));
    35073507
    35083508#ifdef LOG_ENABLED
    3509     hdaBDLEDumpAll(pThis, pStrm->u64BDLBase, pStrm->u16LVI + 1);
     3509    hdaBDLEDumpAll(pThis, pStream->u64BDLBase, pStream->u16LVI + 1);
    35103510#endif
    35113511
    … …  
    37863786                    break;
    37873787
    3788                 PHDASTREAM pStrm = hdaGetStreamFromSD(pThis, uStreamID);
     3788                PHDASTREAM pStream = hdaGetStreamFromSD(pThis, uStreamID);
    37893789                HDASTREAM  StreamDummy;
    37903790
    3791                 if (!pStrm)
     3791                if (!pStream)
    37923792                {
    3793                     pStrm = &StreamDummy;
     3793                    pStream = &StreamDummy;
    37943794                    LogRel2(("HDA: Warning: Stream ID=%RU32 not supported, skipping to load ...\n", uStreamID));
    37953795                }
    37963796
    3797                 rc = hdaStreamInit(pStrm, uStreamID);
     3797                rc = hdaStreamInit(pStream, uStreamID);
    37983798                if (RT_FAILURE(rc))
    37993799                {
    … …  
    38153815                    rc = SSMR3GetU16(pSSM, &cBDLE);                 /* cBDLE */
    38163816                    AssertRC(rc);
    3817                     rc = SSMR3GetU16(pSSM, &pStrm->State.uCurBDLE); /* uCurBDLE */
     3817                    rc = SSMR3GetU16(pSSM, &pStream->State.uCurBDLE); /* uCurBDLE */
    38183818                    AssertRC(rc);
    38193819                    rc = SSMR3Skip(pSSM, sizeof(uint32_t));         /* End marker */
    … …  
    38293829
    38303830                        /* Does the current BDLE index match the current BDLE to process? */
    3831                         if (u32BDLEIndex == pStrm->State.uCurBDLE)
     3831                        if (u32BDLEIndex == pStream->State.uCurBDLE)
    38323832                        {
    3833                             rc = SSMR3GetU32(pSSM, &pStrm->State.BDLE.State.cbBelowFIFOW); /* cbBelowFIFOW */
     3833                            rc = SSMR3GetU32(pSSM, &pStream->State.BDLE.State.cbBelowFIFOW); /* cbBelowFIFOW */
    38343834                            AssertRC(rc);
    38353835                            rc = SSMR3Skip(pSSM, sizeof(uint8_t) * 256);                   /* FIFO, deprecated */
    38363836                            AssertRC(rc);
    3837                             rc = SSMR3GetU32(pSSM, &pStrm->State.BDLE.State.u32BufOff);    /* u32BufOff */
     3837                            rc = SSMR3GetU32(pSSM, &pStream->State.BDLE.State.u32BufOff);    /* u32BufOff */
    38383838                            AssertRC(rc);
    38393839                            rc = SSMR3Skip(pSSM, sizeof(uint32_t));                        /* End marker */
    … …  
    38523852                else
    38533853                {
    3854                     rc = SSMR3GetStructEx(pSSM, &pStrm->State, sizeof(HDASTREAMSTATE),
     3854                    rc = SSMR3GetStructEx(pSSM, &pStream->State, sizeof(HDASTREAMSTATE),
    38553855                                          0 /* fFlags */, g_aSSMStreamStateFields6, NULL);
    38563856                    if (RT_FAILURE(rc))
    … …  
    38623862                    AssertRC(rc);
    38633863                    Assert(uMarker == UINT32_C(0x19200102) /* SSMR3STRUCT_BEGIN */);
    3864                     rc = SSMR3GetU64(pSSM, &pStrm->State.BDLE.Desc.u64BufAdr);
     3864                    rc = SSMR3GetU64(pSSM, &pStream->State.BDLE.Desc.u64BufAdr);
    38653865                    AssertRC(rc);
    3866                     rc = SSMR3GetU32(pSSM, &pStrm->State.BDLE.Desc.u32BufSize);
     3866                    rc = SSMR3GetU32(pSSM, &pStream->State.BDLE.Desc.u32BufSize);
    38673867                    AssertRC(rc);
    38683868                    bool fFlags = false;
    38693869                    rc = SSMR3GetBool(pSSM, &fFlags);      /* Saved states < v7 only stored the IOC as boolean flag. */
    38703870                    AssertRC(rc);
    3871                     pStrm->State.BDLE.Desc.fFlags = fFlags ? HDA_BDLE_FLAG_IOC : 0;
     3871                    pStream->State.BDLE.Desc.fFlags = fFlags ? HDA_BDLE_FLAG_IOC : 0;
    38723872                    rc = SSMR3GetU32(pSSM, &uMarker);      /* End marker. */
    38733873                    AssertRC(rc);
    38743874                    Assert(uMarker == UINT32_C(0x19920406) /* SSMR3STRUCT_END */);
    38753875
    3876                     rc = SSMR3GetStructEx(pSSM, &pStrm->State.BDLE.State, sizeof(HDABDLESTATE),
     3876                    rc = SSMR3GetStructEx(pSSM, &pStream->State.BDLE.State, sizeof(HDABDLESTATE),
    38773877                                          0 /* fFlags */, g_aSSMBDLEStateFields6, NULL);
    38783878                    if (RT_FAILURE(rc))
    … …  
    38833883                              HDA_STREAM_REG(pThis, LPIB, uStreamID), HDA_STREAM_REG(pThis, CBL, uStreamID), HDA_STREAM_REG(pThis, LVI, uStreamID)));
    38843884#ifdef LOG_ENABLED
    3885                     hdaBDLEDumpAll(pThis, pStrm->u64BDLBase, pStrm->u16LVI + 1);
     3885                    hdaBDLEDumpAll(pThis, pStream->u64BDLBase, pStream->u16LVI + 1);
    38863886#endif
    38873887                }
    … …  
    39823982        AssertRC(rc);
    39833983
    3984         PHDASTREAM pStrm = hdaGetStreamFromSD(pThis, uStreamID);
     3984        PHDASTREAM pStream = hdaGetStreamFromSD(pThis, uStreamID);
    39853985        HDASTREAM  StreamDummy;
    39863986
    3987         if (!pStrm)
    3988         {
    3989             pStrm = &StreamDummy;
     3987        if (!pStream)
     3988        {
     3989            pStream = &StreamDummy;
    39903990            LogRel2(("HDA: Warning: Loading of stream #%RU8 not supported, skipping to load ...\n", uStreamID));
    39913991        }
    39923992
    3993         rc = hdaStreamInit(pStrm, uStreamID);
     3993        rc = hdaStreamInit(pStream, uStreamID);
    39943994        if (RT_FAILURE(rc))
    39953995        {
    … …  
    39983998        }
    39993999
    4000         rc = SSMR3GetStructEx(pSSM, &pStrm->State, sizeof(HDASTREAMSTATE),
     4000        rc = SSMR3GetStructEx(pSSM, &pStream->State, sizeof(HDASTREAMSTATE),
    40014001                              0 /* fFlags */, g_aSSMStreamStateFields7,
    40024002                              NULL);
    … …  
    40064006         * Load BDLEs (Buffer Descriptor List Entries) and DMA counters.
    40074007         */
    4008         rc = SSMR3GetStructEx(pSSM, &pStrm->State.BDLE.Desc, sizeof(HDABDLEDESC),
     4008        rc = SSMR3GetStructEx(pSSM, &pStream->State.BDLE.Desc, sizeof(HDABDLEDESC),
    40094009                              0 /* fFlags */, g_aSSMBDLEDescFields7, NULL);
    40104010        AssertRC(rc);
    40114011
    4012         rc = SSMR3GetStructEx(pSSM, &pStrm->State.BDLE.State, sizeof(HDABDLESTATE),
     4012        rc = SSMR3GetStructEx(pSSM, &pStream->State.BDLE.State, sizeof(HDABDLESTATE),
    40134013                              0 /* fFlags */, g_aSSMBDLEStateFields7, NULL);
    40144014        AssertRC(rc);
    40154015
    4016         Log2Func(("[SD%RU8] %R[bdle]\n", pStrm->u8SD, &pStrm->State.BDLE));
     4016        Log2Func(("[SD%RU8] %R[bdle]\n", pStream->u8SD, &pStream->State.BDLE));
    40174017
    40184018        /*
    … …  
    40204020         * Don't annoy other team mates (forgot this for state v7).
    40214021         */
    4022         hdaStreamPeriodInit(&pStrm->State.Period,
    4023                             pStrm->u8SD, pStrm->u16LVI, pStrm->u32CBL, &pStrm->State.Cfg);
     4022        hdaStreamPeriodInit(&pStream->State.Period,
     4023                            pStream->u8SD, pStream->u16LVI, pStream->u32CBL, &pStream->State.Cfg);
    40244024
    40254025        if (   SSMR3HandleRevision(pSSM) >= 116273
    40264026            || SSMR3HandleVersion(pSSM)  >= VBOX_FULL_VERSION_MAKE(5, 2, 0))
    40274027        {
    4028             rc = SSMR3GetStructEx(pSSM, &pStrm->State.Period, sizeof(HDASTREAMPERIOD),
     4028            rc = SSMR3GetStructEx(pSSM, &pStream->State.Period, sizeof(HDASTREAMPERIOD),
    40294029                                  0 /* fFlags */, g_aSSMStreamPeriodFields7, NULL);
    40304030            AssertRC(rc);
    … …  
    40514051                             ("HDA: Saved state contains invalid DMA buffer usage (%RU32/%RU32) for stream #%RU8",
    40524052                              cbCircBufUsed, cbCircBufSize, uStreamID));
    4053             AssertPtr(pStrm->State.pCircBuf);
     4053            AssertPtr(pStream->State.pCircBuf);
    40544054
    40554055            /* Do we need to cre-create the circular buffer do fit the data size? */
    4056             if (cbCircBufSize != (uint32_t)RTCircBufSize(pStrm->State.pCircBuf))
     4056            if (cbCircBufSize != (uint32_t)RTCircBufSize(pStream->State.pCircBuf))
    40574057            {
    4058                 RTCircBufDestroy(pStrm->State.pCircBuf);
    4059                 pStrm->State.pCircBuf = NULL;
    4060 
    4061                 rc = RTCircBufCreate(&pStrm->State.pCircBuf, cbCircBufSize);
     4058                RTCircBufDestroy(pStream->State.pCircBuf);
     4059                pStream->State.pCircBuf = NULL;
     4060
     4061                rc = RTCircBufCreate(&pStream->State.pCircBuf, cbCircBufSize);
    40624062                AssertRC(rc);
    40634063            }
    … …  
    40694069                size_t cbBuf;
    40704070
    4071                 RTCircBufAcquireWriteBlock(pStrm->State.pCircBuf, cbCircBufUsed, &pvBuf, &cbBuf);
     4071                RTCircBufAcquireWriteBlock(pStream->State.pCircBuf, cbCircBufUsed, &pvBuf, &cbBuf);
    40724072
    40734073                if (cbBuf)
    … …  
    40774077                }
    40784078
    4079                 RTCircBufReleaseWriteBlock(pStrm->State.pCircBuf, cbBuf);
     4079                RTCircBufReleaseWriteBlock(pStream->State.pCircBuf, cbBuf);
    40804080
    40814081                Assert(cbBuf == cbCircBufUsed);
    … …  
    40874087                  HDA_STREAM_REG(pThis, LPIB, uStreamID), HDA_STREAM_REG(pThis, CBL, uStreamID), HDA_STREAM_REG(pThis, LVI, uStreamID)));
    40884088#ifdef LOG_ENABLED
    4089         hdaBDLEDumpAll(pThis, pStrm->u64BDLBase, pStrm->u16LVI + 1);
     4089        hdaBDLEDumpAll(pThis, pStream->u64BDLBase, pStream->u16LVI + 1);
    40904090#endif
    40914091        /** @todo (Re-)initialize active periods? */
    … …  
    42264226           && iIdx < HDA_MAX_STREAMS);
    42274227
    4228     const PHDASTREAM pStrm = &pThis->aStreams[iIdx];
     4228    const PHDASTREAM pStream = &pThis->aStreams[iIdx];
    42294229
    42304230    pHlp->pfnPrintf(pHlp, "Stream #%d:\n", iIdx);
    … …  
    42334233    pHlp->pfnPrintf(pHlp, "\tSD%dFIFOS: %R[sdfifos]\n", iIdx, HDA_STREAM_REG(pThis, FIFOS, iIdx));
    42344234    pHlp->pfnPrintf(pHlp, "\tSD%dFIFOW: %R[sdfifow]\n", iIdx, HDA_STREAM_REG(pThis, FIFOW, iIdx));
    4235     pHlp->pfnPrintf(pHlp, "\tBDLE     : %R[bdle]\n",    &pStrm->State.BDLE);
     4235    pHlp->pfnPrintf(pHlp, "\tBDLE     : %R[bdle]\n",    &pStream->State.BDLE);
    42364236}
    42374237
    … …  
    42424242           && iIdx < HDA_MAX_STREAMS);
    42434243
    4244     const PHDASTREAM pStrm = &pThis->aStreams[iIdx];
    4245     const PHDABDLE   pBDLE = &pStrm->State.BDLE;
     4244    const PHDASTREAM pStream = &pThis->aStreams[iIdx];
     4245    const PHDABDLE   pBDLE   = &pStream->State.BDLE;
    42464246
    42474247    pHlp->pfnPrintf(pHlp, "Stream #%d BDLE:\n",      iIdx);
Note: See TracChangeset for help on using the changeset viewer.

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