VirtualBox

Changeset 88031 in vbox


Ignore:
Timestamp:
Mar 9, 2021 12:13:46 AM (4 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
143160
Message:

Audio: Preparing for moving the enumeration helpers to PDM. Simplify allocation. bugref:9890

Location:
trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/vmm/pdmaudioifs.h

    r88026 r88031  
    354354typedef struct PDMAUDIODEVICE
    355355{
    356     /** List node. */
     356    /** List entry (like PDMAUDIODEVICEENUM::LstDevices). */
    357357    RTLISTNODE          Node;
    358     /** Additional data which might be relevant for the current context.
    359      * @todo r=bird: I would do this C++ style, having the host specific bits
    360      *       appended after this structure and downcast. */
     358    /** Additional data which might be relevant for the current context (follows
     359     * immediately after the end of this structure). */
    361360    void               *pvData;
    362361    /** Size of the additional data. */
    … …  
    374373    /** Maximum number of output audio channels the device supports. */
    375374    uint8_t             cMaxOutputChannels;
     375    uint8_t             bAlignment[1];
    376376    /** Device type union, based on enmType. */
    377377    union
    … …  
    380380        struct
    381381        {
    382             /** Vendor ID.
    383              * @todo r=bird: Why signed?? VUSB uses uint16_t for idVendor and idProduct!  */
    384             int16_t     VID;
     382            /** Vendor ID. */
     383            uint16_t    idVendor;
    385384            /** Product ID. */
    386             int16_t     PID;
     385            uint16_t    idProduct;
    387386        } USB;
     387        uint64_t        uPadding[2];
    388388    } Type;
    389389    /** Friendly name of the device, if any. */
    390390    char                szName[64];
    391391} PDMAUDIODEVICE;
     392AssertCompileSizeAlignment(PDMAUDIODEVICE, 32);
    392393/** Pointer to audio device info (enum result). */
    393394typedef PDMAUDIODEVICE *PPDMAUDIODEVICE;
     395/** Pointer to a const audio device info (enum result). */
     396typedef PDMAUDIODEVICE const *PCPDMAUDIODEVICE;
    394397
    395398/**
    396399 * An audio device enumeration result.
     400 *
    397401 * @sa PDMIHOSTAUDIO::pfnGetDevices
    398402 */
    399403typedef struct PDMAUDIODEVICEENUM
    400404{
     405    /** List of audio devices (PDMAUDIODEVICE). */
     406    RTLISTANCHOR    LstDevices;
    401407    /** Number of audio devices in the list. */
    402     uint16_t        cDevices;
    403     /** List of audio devices. */
    404     RTLISTANCHOR    lstDevices;
     408    uint32_t        cDevices;
    405409} PDMAUDIODEVICEENUM;
    406410/** Pointer to an audio device enumeration result. */
    407411typedef PDMAUDIODEVICEENUM *PPDMAUDIODEVICEENUM;
     412/** Pointer to a const audio device enumeration result. */
     413typedef PDMAUDIODEVICEENUM const *PCPDMAUDIODEVICEENUM;
    408414
    409415/**

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

    r88029 r88031  
    21722172
    21732173            PPDMAUDIODEVICE pDev;
    2174             RTListForEach(&DevEnum.lstDevices, pDev, PDMAUDIODEVICE, Node)
     2174            RTListForEach(&DevEnum.LstDevices, pDev, PDMAUDIODEVICE, Node)
    21752175            {
    21762176                if (fLog)

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

    r88028 r88031  
    209209/** @name Audio device methods.
    210210 * @{ */
     211PPDMAUDIODEVICE PDMAudioDeviceAlloc(size_t cb);
     212void            PDMAudioDeviceFree(PPDMAUDIODEVICE pDev);
     213PPDMAUDIODEVICE PDMAudioDeviceDup(const PPDMAUDIODEVICE pDev, bool fCopyUserData);
     214
    211215PPDMAUDIODEVICE DrvAudioHlpDeviceAlloc(size_t cbData);
    212 void DrvAudioHlpDeviceFree(PPDMAUDIODEVICE pDev);
    213 PPDMAUDIODEVICE DrvAudioHlpDeviceDup(const PPDMAUDIODEVICE pDev, bool fCopyUserData);
    214216/** @}  */
    215217

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

    r88028 r88031  
    8484
    8585
     86#if 0 /* unused, no header prototypes */
    8687
    8788/**
    … …  
    140141}
    141142
     143#endif /* unused */
     144
    142145/**
    143146 * Allocates an audio device.
    144147 *
    145  * @returns Newly allocated audio device, or NULL if failed.
     148 * @returns Newly allocated audio device, or NULL on failure.
     149 * @param   cb      The total device structure size.   This must be at least the
     150 *                  size of PDMAUDIODEVICE.  The idea is that the caller extends
     151 *                  the PDMAUDIODEVICE structure and appends additional data
     152 *                  after it in its private structure.
     153 */
     154PPDMAUDIODEVICE PDMAudioDeviceAlloc(size_t cb)
     155{
     156    AssertReturn(cb >= sizeof(PDMAUDIODEVICE), NULL);
     157    AssertReturn(cb < _4M, NULL);
     158
     159    PPDMAUDIODEVICE pDev = (PPDMAUDIODEVICE)RTMemAllocZ(RT_ALIGN_Z(cb, 64));
     160    if (pDev)
     161    {
     162        pDev->pvData = pDev + 1;
     163        pDev->cbData = cb - sizeof(PDMAUDIODEVICE);
     164        RTListInit(&pDev->Node);
     165
     166        //pDev->cMaxInputChannels  = 0;
     167        //pDev->cMaxOutputChannels = 0;
     168    }
     169    return pDev;
     170}
     171
     172/**
     173 * Allocates an audio device.
     174 *
     175 * @returns Newly allocated audio device, or NULL on failure.
    146176 * @param   cbData              How much additional data (in bytes) should be allocated to provide
    147177 *                              a (backend) specific area to store additional data.
    … …  
    150180PPDMAUDIODEVICE DrvAudioHlpDeviceAlloc(size_t cbData)
    151181{
    152     PPDMAUDIODEVICE pDev = (PPDMAUDIODEVICE)RTMemAllocZ(sizeof(PDMAUDIODEVICE));
    153     if (!pDev)
    154         return NULL;
    155 
    156     if (cbData)
    157     {
    158         pDev->pvData = RTMemAllocZ(cbData);
    159         if (!pDev->pvData)
    160         {
    161             RTMemFree(pDev);
    162             return NULL;
    163         }
    164     }
    165 
    166     pDev->cbData = cbData;
    167 
    168     pDev->cMaxInputChannels  = 0;
    169     pDev->cMaxOutputChannels = 0;
    170 
    171     return pDev;
    172 }
    173 
    174 /**
    175  * Frees an audio device.
    176  *
    177  * @param pDev                  Device to free.
    178  */
    179 void DrvAudioHlpDeviceFree(PPDMAUDIODEVICE pDev)
    180 {
    181     if (!pDev)
    182         return;
    183 
    184     Assert(pDev->cRefCount == 0);
    185 
    186     if (pDev->pvData)
    187     {
    188         Assert(pDev->cbData);
    189 
    190         RTMemFree(pDev->pvData);
     182    AssertReturn(cbData < _4M, NULL);
     183    return PDMAudioDeviceAlloc(cbData + sizeof(PDMAUDIODEVICE));
     184}
     185
     186/**
     187 * Frees an audio device allocated by PDMAudioDeviceAlloc.
     188 *
     189 * @param   pDev    The device to free.  NULL is ignored.
     190 */
     191void PDMAudioDeviceFree(PPDMAUDIODEVICE pDev)
     192{
     193    if (pDev)
     194    {
     195        Assert(pDev->cRefCount == 0);
     196
    191197        pDev->pvData = NULL;
    192     }
    193 
    194     RTMemFree(pDev);
    195     pDev = NULL;
     198        pDev->cbData = 0;
     199
     200        RTMemFree(pDev);
     201    }
    196202}
    197203
    … …  
    200206 *
    201207 * @returns Duplicated audio device entry on success, or NULL on failure.
    202  * @param   pDev                Audio device entry to duplicate.
    203  * @param   fCopyUserData       Whether to also copy the user data portion or not.
    204  */
    205 PPDMAUDIODEVICE DrvAudioHlpDeviceDup(const PPDMAUDIODEVICE pDev, bool fCopyUserData)
     208 * @param   pDev            The audio device enum entry to duplicate.
     209 * @param   fCopyUserData   Whether to also copy the user data portion or not.
     210 */
     211PPDMAUDIODEVICE PDMAudioDeviceDup(PPDMAUDIODEVICE pDev, bool fCopyUserData)
    206212{
    207213    AssertPtrReturn(pDev, NULL);
    208214
    209     PPDMAUDIODEVICE pDevDup = DrvAudioHlpDeviceAlloc(fCopyUserData ? pDev->cbData : 0);
     215    PPDMAUDIODEVICE pDevDup = PDMAudioDeviceAlloc(sizeof(*pDev) + (fCopyUserData ? pDev->cbData : 0));
    210216    if (pDevDup)
    211217    {
    212218        memcpy(pDevDup, pDev, sizeof(PDMAUDIODEVICE));
     219        RTListInit(&pDevDup->Node);
    213220
    214221        if (   fCopyUserData
    215             && pDevDup->cbData)
    216         {
    217             memcpy(pDevDup->pvData, pDev->pvData, pDevDup->cbData);
    218         }
    219         else
    220         {
    221             pDevDup->cbData = 0;
    222             pDevDup->pvData = NULL;
     222            && pDev->cbData)
     223        {
     224            /** @todo r=bird: This ASSUMES that no special data is stored here, like
     225             *        pointers or similar that cannot just be memcpy'ied. */
     226            memcpy(pDevDup + 1, pDev + 1, pDev->cbData);
    223227        }
    224228    }
    … …  
    237241    AssertPtrReturn(pDevEnm, VERR_INVALID_POINTER);
    238242
    239     RTListInit(&pDevEnm->lstDevices);
     243    RTListInit(&pDevEnm->LstDevices);
    240244    pDevEnm->cDevices = 0;
    241245
    … …  
    254258
    255259    PPDMAUDIODEVICE pDev, pDevNext;
    256     RTListForEachSafe(&pDevEnm->lstDevices, pDev, pDevNext, PDMAUDIODEVICE, Node)
     260    RTListForEachSafe(&pDevEnm->LstDevices, pDev, pDevNext, PDMAUDIODEVICE, Node)
    257261    {
    258262        RTListNodeRemove(&pDev->Node);
    259263
    260         DrvAudioHlpDeviceFree(pDev);
     264        PDMAudioDeviceFree(pDev);
    261265
    262266        pDevEnm->cDevices--;
    … …  
    264268
    265269    /* Sanity. */
    266     Assert(RTListIsEmpty(&pDevEnm->lstDevices));
     270    Assert(RTListIsEmpty(&pDevEnm->LstDevices));
    267271    Assert(pDevEnm->cDevices == 0);
    268272}
    … …  
    280284    AssertPtrReturn(pDev,    VERR_INVALID_POINTER);
    281285
    282     RTListAppend(&pDevEnm->lstDevices, &pDev->Node);
     286    RTListAppend(&pDevEnm->LstDevices, &pDev->Node);
    283287    pDevEnm->cDevices++;
    284288
    … …  
    305309
    306310    PPDMAUDIODEVICE pDev;
    307     RTListForEach(&pDevEnm->lstDevices, pDev, PDMAUDIODEVICE, Node)
    308     {
    309         PPDMAUDIODEVICE pDevDup = DrvAudioHlpDeviceDup(pDev, true /* fCopyUserData */);
     311    RTListForEach(&pDevEnm->LstDevices, pDev, PDMAUDIODEVICE, Node)
     312    {
     313        PPDMAUDIODEVICE pDevDup = PDMAudioDeviceDup(pDev, true /* fCopyUserData */);
    310314        if (!pDevDup)
    311315        {
    … …  
    317321        if (RT_FAILURE(rc2))
    318322        {
    319             DrvAudioHlpDeviceFree(pDevDup);
     323            PDMAudioDeviceFree(pDevDup);
    320324            break;
    321325        }
    … …  
    349353
    350354    PPDMAUDIODEVICE pSrcDev;
    351     RTListForEach(&pSrcDevEnm->lstDevices, pSrcDev, PDMAUDIODEVICE, Node)
     355    RTListForEach(&pSrcDevEnm->LstDevices, pSrcDev, PDMAUDIODEVICE, Node)
    352356    {
    353357        if (   enmUsage != PDMAUDIODIR_DUPLEX
    … …  
    357361        }
    358362
    359         PPDMAUDIODEVICE pDstDev = DrvAudioHlpDeviceDup(pSrcDev, fCopyUserData);
     363        PPDMAUDIODEVICE pDstDev = PDMAudioDeviceDup(pSrcDev, fCopyUserData);
    360364        if (!pDstDev)
    361365        {
    … …  
    400404
    401405    PPDMAUDIODEVICE pDev;
    402     RTListForEach(&pDevEnm->lstDevices, pDev, PDMAUDIODEVICE, Node)
     406    RTListForEach(&pDevEnm->LstDevices, pDev, PDMAUDIODEVICE, Node)
    403407    {
    404408        if (enmUsage != PDMAUDIODIR_DUPLEX)
    … …  
    432436
    433437    PPDMAUDIODEVICE pDev;
    434     RTListForEach(&pDevEnm->lstDevices, pDev, PDMAUDIODEVICE, Node)
     438    RTListForEach(&pDevEnm->LstDevices, pDev, PDMAUDIODEVICE, Node)
    435439    {
    436440        if (enmUsage == pDev->enmUsage)
    … …  
    455459
    456460    PPDMAUDIODEVICE pDev;
    457     RTListForEach(&pDevEnm->lstDevices, pDev, PDMAUDIODEVICE, Node)
     461    RTListForEach(&pDevEnm->LstDevices, pDev, PDMAUDIODEVICE, Node)
    458462    {
    459463        char *pszFlags = DrvAudioHlpAudDevFlagsToStrA(pDev->fFlags);

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

    r88028 r88031  
    534534        {
    535535            if (pDev) /* Some (skipped) device to clean up first? */
    536                 DrvAudioHlpDeviceFree(pDev);
     536                PDMAudioDeviceFree(pDev);
    537537
    538538            pDev = DrvAudioHlpDeviceAlloc(sizeof(COREAUDIODEVICEDATA));
    … …  
    669669        if (RT_FAILURE(rc))
    670670        {
    671             DrvAudioHlpDeviceFree(pDev);
     671            PDMAudioDeviceFree(pDev);
    672672            pDev = NULL;
    673673        }
    … …  
    703703{
    704704    PPDMAUDIODEVICE pDevSrc;
    705     RTListForEach(&pEnmSrc->lstDevices, pDevSrc, PDMAUDIODEVICE, Node)
     705    RTListForEach(&pEnmSrc->LstDevices, pDevSrc, PDMAUDIODEVICE, Node)
    706706    {
    707707        PCOREAUDIODEVICEDATA pDevSrcData = (PCOREAUDIODEVICEDATA)pDevSrc->pvData;
    … …  
    746746            {
    747747                PPDMAUDIODEVICE pDevSrcIn;
    748                 RTListForEach(&devEnmIn.lstDevices, pDevSrcIn, PDMAUDIODEVICE, Node)
     748                RTListForEach(&devEnmIn.LstDevices, pDevSrcIn, PDMAUDIODEVICE, Node)
    749749                {
    750750                    PCOREAUDIODEVICEDATA pDevSrcInData = (PCOREAUDIODEVICEDATA)pDevSrcIn->pvData;
    … …  
    779779                     */
    780780                    PPDMAUDIODEVICE pDevSrcOut;
    781                     RTListForEach(&devEnmOut.lstDevices, pDevSrcOut, PDMAUDIODEVICE, Node)
     781                    RTListForEach(&devEnmOut.LstDevices, pDevSrcOut, PDMAUDIODEVICE, Node)
    782782                    {
    783783                        PCOREAUDIODEVICEDATA pDevSrcOutData = (PCOREAUDIODEVICEDATA)pDevSrcOut->pvData;
    … …  
    801801                    else
    802802                    {
    803                         DrvAudioHlpDeviceFree(pDevDst);
     803                        PDMAudioDeviceFree(pDevDst);
    804804                        pDevDst = NULL;
    805805                    }
    … …  
    813813                     */
    814814                    PPDMAUDIODEVICE pDevSrcOut;
    815                     RTListForEach(&devEnmOut.lstDevices, pDevSrcOut, PDMAUDIODEVICE, Node)
     815                    RTListForEach(&devEnmOut.LstDevices, pDevSrcOut, PDMAUDIODEVICE, Node)
    816816                    {
    817817                        PCOREAUDIODEVICEDATA pDevSrcOutData = (PCOREAUDIODEVICEDATA)pDevSrcOut->pvData;
    … …  
    847847                        if (RT_FAILURE(rc))
    848848                        {
    849                             DrvAudioHlpDeviceFree(pDevDst);
     849                            PDMAudioDeviceFree(pDevDst);
    850850                            break;
    851851                        }

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

    r88028 r88031  
    181181
    182182/**
    183  * Structure for keeping a DirectSound-specific device entry.
    184  * This is then bound to the PDMAUDIODEVICE's pvData area.
     183 * DirectSound-specific device entry.
    185184 */
    186185typedef struct DSOUNDDEV
    187186{
    188     GUID Guid;
    189 } DSOUNDDEV, *PDSOUNDDEV;
     187    PDMAUDIODEVICE  Core;
     188    /** The GUID if handy. */
     189    GUID            Guid;
     190} DSOUNDDEV;
     191/** Pointer to a DirectSound device entry. */
     192typedef DSOUNDDEV *PDSOUNDDEV;
    190193
    191194/**
    … …  
    11281131 */
    11291132
     1133#if 0 /* unused */
    11301134static LPCGUID dsoundCaptureSelectDevice(PDRVHOSTDSOUND pThis, PPDMAUDIOSTREAMCFG pCfg)
    11311135{
    … …  
    11381142    if (!pGUID)
    11391143    {
    1140         PPDMAUDIODEVICE pDev = NULL;
    1141 
     1144        PDSOUNDDEV pDev = NULL;
    11421145        switch (pCfg->u.enmSrc)
    11431146        {
    … …  
    11511154                 */
    11521155            case PDMAUDIORECSRC_MIC:
    1153             {
    1154                 pDev = DrvAudioHlpDeviceEnumGetDefaultDevice(&pThis->DeviceEnum, PDMAUDIODIR_IN);
     1156                pDev = (PDSOUNDDEV)DrvAudioHlpDeviceEnumGetDefaultDevice(&pThis->DeviceEnum, PDMAUDIODIR_IN);
    11551157                break;
    1156             }
    11571158
    11581159            default:
    … …  
    11651166        {
    11661167            DSLOG(("DSound: Guest source '%s' is using host recording device '%s'\n",
    1167                    PDMAudioRecSrcGetName(pCfg->u.enmSrc), pDev->szName));
    1168 
    1169             PDSOUNDDEV pDSoundDev = (PDSOUNDDEV)pDev->pvData;
    1170             AssertPtr(pDSoundDev);
    1171 
    1172             pGUID = &pDSoundDev->Guid;
    1173         }
    1174     }
    1175 
    1176     if (RT_FAILURE(rc))
    1177     {
    1178         LogRel(("DSound: Selecting recording device failed with %Rrc\n", rc));
    1179         return NULL;
    1180     }
    1181 
     1168                   PDMAudioRecSrcGetName(pCfg->u.enmSrc), pDev->Core.szName));
     1169            pGUID = &pDev->Guid;
     1170        }
     1171        if (RT_FAILURE(rc))
     1172        {
     1173            LogRel(("DSound: Selecting recording device failed with %Rrc\n", rc));
     1174            return NULL;
     1175        }
     1176    }
     1177
     1178    /* This always has to be in the release log. */
    11821179    char *pszGUID = dsoundGUIDToUtf8StrA(pGUID);
    1183 
    1184     /* This always has to be in the release log. */
    11851180    LogRel(("DSound: Guest source '%s' is using host recording device with GUID '%s'\n",
    11861181            PDMAudioRecSrcGetName(pCfg->u.enmSrc), pszGUID ? pszGUID: "{?}"));
    1187 
    1188     if (pszGUID)
    1189     {
    1190         RTStrFree(pszGUID);
    1191         pszGUID = NULL;
    1192     }
     1182    RTStrFree(pszGUID);
    11931183
    11941184    return pGUID;
    11951185}
     1186#endif
    11961187
    11971188/**
    … …  
    15781569 * @param   pwszModule          Pointer to module name of enumerated device.
    15791570 * @param   lpContext           Pointer to PDSOUNDENUMCBCTX context for storing the enumerated information.
     1571 *
     1572 * @note    Carbon copy of dsoundDevicesEnumCbPlayback with OUT direction.
    15801573 */
    15811574static BOOL CALLBACK dsoundDevicesEnumCbPlayback(LPGUID pGUID, LPCWSTR pwszDescription, LPCWSTR pwszModule, PVOID lpContext)
    15821575{
    1583     RT_NOREF(pwszModule);
    1584 
    15851576    PDSOUNDENUMCBCTX pEnumCtx = (PDSOUNDENUMCBCTX)lpContext;
    15861577    AssertPtrReturn(pEnumCtx , FALSE);
    … …  
    15891580    AssertPtrReturn(pDevEnm, FALSE);
    15901581
    1591     /* pGUID can be NULL for default device(s). */
     1582    AssertPtrNullReturn(pGUID, FALSE); /* pGUID can be NULL for default device(s). */
    15921583    AssertPtrReturn(pwszDescription, FALSE);
    1593     /* Do not care about pwszModule. */
     1584    RT_NOREF(pwszModule); /* Do not care about pwszModule. */
    15941585
    15951586    int rc;
    1596 
    1597     PPDMAUDIODEVICE pDev = DrvAudioHlpDeviceAlloc(sizeof(DSOUNDDEV));
     1587    PDSOUNDDEV pDev = (PDSOUNDDEV)PDMAudioDeviceAlloc(sizeof(DSOUNDDEV));
    15981588    if (pDev)
    15991589    {
    1600         pDev->enmUsage = PDMAUDIODIR_OUT;
    1601         pDev->enmType  = PDMAUDIODEVICETYPE_BUILTIN;
     1590        pDev->Core.enmUsage = PDMAUDIODIR_OUT;
     1591        pDev->Core.enmType  = PDMAUDIODEVICETYPE_BUILTIN;
    16021592
    16031593        if (pGUID == NULL)
    1604             pDev->fFlags = PDMAUDIODEV_FLAGS_DEFAULT;
     1594            pDev->Core.fFlags = PDMAUDIODEV_FLAGS_DEFAULT;
    16051595
    16061596        char *pszName;
    … …  
    16081598        if (RT_SUCCESS(rc))
    16091599        {
    1610             RTStrCopy(pDev->szName, sizeof(pDev->szName), pszName);
     1600            RTStrCopy(pDev->Core.szName, sizeof(pDev->Core.szName), pszName);
    16111601            RTStrFree(pszName);
    16121602
    1613             PDSOUNDDEV pDSoundDev = (PDSOUNDDEV)pDev->pvData;
    1614 
    16151603            if (pGUID) /* pGUID == NULL means default device. */
    1616                 memcpy(&pDSoundDev->Guid, pGUID, sizeof(GUID));
    1617 
    1618             rc = DrvAudioHlpDeviceEnumAdd(pDevEnm, pDev);
    1619 
    1620             /* Note: Querying the actual device information will be done at some
    1621              *       later point in time outside this enumeration callback to prevent
    1622              *       DSound hangs. */
    1623         }
     1604                memcpy(&pDev->Guid, pGUID, sizeof(pDev->Guid));
     1605
     1606            rc = DrvAudioHlpDeviceEnumAdd(pDevEnm, &pDev->Core);
     1607            if (RT_SUCCESS(rc))
     1608            {
     1609                /* Note: Querying the actual device information will be done at some
     1610                 *       later point in time outside this enumeration callback to prevent
     1611                 *       DSound hangs. */
     1612                return TRUE;
     1613            }
     1614        }
     1615        PDMAudioDeviceFree(&pDev->Core);
    16241616    }
    16251617    else
    16261618        rc = VERR_NO_MEMORY;
    16271619
    1628     if (RT_FAILURE(rc))
    1629     {
    1630         LogRel(("DSound: Error enumeration playback device '%ls', rc=%Rrc\n", pwszDescription, rc));
    1631         return FALSE; /* Abort enumeration. */
    1632     }
    1633 
    1634     return TRUE;
     1620    LogRel(("DSound: Error enumeration playback device '%ls': rc=%Rrc\n", pwszDescription, rc));
     1621    return FALSE; /* Abort enumeration. */
    16351622}
    16361623
    … …  
    16431630 * @param   pwszModule          Pointer to module name of enumerated device.
    16441631 * @param   lpContext           Pointer to PDSOUNDENUMCBCTX context for storing the enumerated information.
     1632 *
     1633 * @note    Carbon copy of dsoundDevicesEnumCbPlayback with IN direction.
    16451634 */
    16461635static BOOL CALLBACK dsoundDevicesEnumCbCapture(LPGUID pGUID, LPCWSTR pwszDescription, LPCWSTR pwszModule, PVOID lpContext)
    16471636{
    1648     RT_NOREF(pwszModule);
    1649 
    16501637    PDSOUNDENUMCBCTX pEnumCtx = (PDSOUNDENUMCBCTX )lpContext;
    16511638    AssertPtrReturn(pEnumCtx , FALSE);
    … …  
    16541641    AssertPtrReturn(pDevEnm, FALSE);
    16551642
    1656     /* pGUID can be NULL for default device(s). */
     1643    AssertPtrNullReturn(pGUID, FALSE); /* pGUID can be NULL for default device(s). */
    16571644    AssertPtrReturn(pwszDescription, FALSE);
    1658     /* Do not care about pwszModule. */
     1645    RT_NOREF(pwszModule); /* Do not care about pwszModule. */
    16591646
    16601647    int rc;
    1661 
    1662     PPDMAUDIODEVICE pDev = DrvAudioHlpDeviceAlloc(sizeof(DSOUNDDEV));
     1648    PDSOUNDDEV pDev = (PDSOUNDDEV)PDMAudioDeviceAlloc(sizeof(DSOUNDDEV));
    16631649    if (pDev)
    16641650    {
    1665         pDev->enmUsage = PDMAUDIODIR_IN;
    1666         pDev->enmType  = PDMAUDIODEVICETYPE_BUILTIN;
     1651        pDev->Core.enmUsage = PDMAUDIODIR_IN;
     1652        pDev->Core.enmType  = PDMAUDIODEVICETYPE_BUILTIN;
    16671653
    16681654        char *pszName;
    … …  
    16701656        if (RT_SUCCESS(rc))
    16711657        {
    1672             RTStrCopy(pDev->szName, sizeof(pDev->szName), pszName);
     1658            RTStrCopy(pDev->Core.szName, sizeof(pDev->Core.szName), pszName);
    16731659            RTStrFree(pszName);
    16741660
    1675             PDSOUNDDEV pDSoundDev = (PDSOUNDDEV)pDev->pvData;
    1676 
    16771661            if (pGUID) /* pGUID == NULL means default capture device. */
    1678                 memcpy(&pDSoundDev->Guid, pGUID, sizeof(GUID));
    1679 
    1680             rc = DrvAudioHlpDeviceEnumAdd(pDevEnm, pDev);
    1681 
    1682             /* Note: Querying the actual device information will be done at some
    1683              *       later point in time outside this enumeration callback to prevent
    1684              *       DSound hangs. */
    1685         }
     1662                memcpy(&pDev->Guid, pGUID, sizeof(pDev->Guid));
     1663
     1664            rc = DrvAudioHlpDeviceEnumAdd(pDevEnm, &pDev->Core);
     1665            if (RT_SUCCESS(rc))
     1666            {
     1667                /* Note: Querying the actual device information will be done at some
     1668                 *       later point in time outside this enumeration callback to prevent
     1669                 *       DSound hangs. */
     1670                return TRUE;
     1671            }
     1672        }
     1673        PDMAudioDeviceFree(&pDev->Core);
    16861674    }
    16871675    else
    16881676        rc = VERR_NO_MEMORY;
    16891677
    1690     if (RT_FAILURE(rc))
    1691     {
    1692         LogRel(("DSound: Error enumeration capture device '%ls', rc=%Rrc\n", pwszDescription, rc));
    1693         return FALSE; /* Abort enumeration. */
    1694     }
    1695 
    1696     return TRUE;
     1678    LogRel(("DSound: Error enumeration capture device '%ls', rc=%Rrc\n", pwszDescription, rc));
     1679    return FALSE; /* Abort enumeration. */
    16971680}
    16981681
    … …  
    17041687 * @param   pDev                Audio device to query information for.
    17051688 */
    1706 static int dsoundDeviceQueryInfo(PDRVHOSTDSOUND pThis, PPDMAUDIODEVICE pDev)
     1689static int dsoundDeviceQueryInfo(PDRVHOSTDSOUND pThis, PDSOUNDDEV pDev)
    17071690{
    17081691    AssertPtrReturn(pThis, VERR_INVALID_POINTER);
    17091692    AssertPtrReturn(pDev,  VERR_INVALID_POINTER);
    1710 
    1711     PDSOUNDDEV pDSoundDev = (PDSOUNDDEV)pDev->pvData;
    1712     AssertPtr(pDSoundDev);
    1713 
    17141693    int rc;
    17151694
    1716     if (pDev->enmUsage == PDMAUDIODIR_OUT)
     1695    if (pDev->Core.enmUsage == PDMAUDIODIR_OUT)
    17171696    {
    17181697        LPDIRECTSOUND8 pDS;
    1719         HRESULT hr = directSoundPlayInterfaceCreate(&pDSoundDev->Guid, &pDS);
     1698        HRESULT hr = directSoundPlayInterfaceCreate(&pDev->Guid, &pDS);
    17201699        if (SUCCEEDED(hr))
    17211700        {
    … …  
    17261705            if (SUCCEEDED(hr))
    17271706            {
    1728                 pDev->cMaxOutputChannels = DSCaps.dwFlags & DSCAPS_PRIMARYSTEREO ? 2 : 1;
     1707                pDev->Core.cMaxOutputChannels = DSCaps.dwFlags & DSCAPS_PRIMARYSTEREO ? 2 : 1;
    17291708
    17301709                DWORD dwSpeakerCfg;
    … …  
    17481727
    17491728                    if (uSpeakerCount) /* Do we need to update the channel count? */
    1750                         pDev->cMaxOutputChannels = uSpeakerCount;
     1729                        pDev->Core.cMaxOutputChannels = uSpeakerCount;
    17511730
    17521731                    rc = VINF_SUCCESS;
    … …  
    17691748            rc = VERR_GENERAL_FAILURE;
    17701749    }
    1771     else if (pDev->enmUsage == PDMAUDIODIR_IN)
     1750    else if (pDev->Core.enmUsage == PDMAUDIODIR_IN)
    17721751    {
    17731752        LPDIRECTSOUNDCAPTURE8 pDSC;
    1774         HRESULT hr = directSoundCaptureInterfaceCreate(&pDSoundDev->Guid, &pDSC);
     1753        HRESULT hr = directSoundCaptureInterfaceCreate(&pDev->Guid, &pDSC);
    17751754        if (SUCCEEDED(hr))
    17761755        {
    … …  
    17811760            if (SUCCEEDED(hr))
    17821761            {
    1783                 pDev->cMaxInputChannels = DSCCaps.dwChannels;
     1762                pDev->Core.cMaxInputChannels = DSCCaps.dwChannels;
    17841763                rc = VINF_SUCCESS;
    17851764            }
    … …  
    18581837         * Query Information from all enumerated devices.
    18591838         */
    1860         PPDMAUDIODEVICE pDev;
    1861         RTListForEach(&pDevEnm->lstDevices, pDev, PDMAUDIODEVICE, Node)
    1862             /* ignore rc */ dsoundDeviceQueryInfo(pThis, pDev);
     1839        PDSOUNDDEV pDev;
     1840        RTListForEach(&pDevEnm->LstDevices, pDev, DSOUNDDEV, Core.Node)
     1841        {
     1842            dsoundDeviceQueryInfo(pThis, pDev); /* ignore rc */
     1843        }
    18631844
    18641845        RTLdrClose(hDSound);
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