VirtualBox

Changeset 89500 in vbox for trunk


Ignore:
Timestamp:
Jun 4, 2021 10:30:47 AM (3 years ago)
Author:
vboxsync
Message:

Audio: Changed PDMAUDIOHOSTDEV::szName into a pszName so we don't have to truncate anything. Made PDMAudioHostDevAlloc capable of allocating both pszName and pszId as part of the device allocation. bugref:9890

Location:
trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/include/VBox/vmm/pdmaudiohostenuminline.h

    r89232 r89500  
    6262 *                  the PDMAUDIOHOSTDEV structure and appends additional data
    6363 *                  after it in its private structure.
    64  */
    65 DECLINLINE(PPDMAUDIOHOSTDEV) PDMAudioHostDevAlloc(size_t cb)
     64 * @param   cbName  The number of bytes to allocate for the name field
     65 *                  (including the terminator). Pass zero if RTStrAlloc and
     66 *                  friends will be used.
     67 * @param   cbId    The number of bytes to allocate for the ID field. Pass
     68 *                  zero if RTStrAlloc and friends will be used.
     69 */
     70DECLINLINE(PPDMAUDIOHOSTDEV) PDMAudioHostDevAlloc(size_t cb, size_t cbName, size_t cbId)
    6671{
    6772    AssertReturn(cb >= sizeof(PDMAUDIOHOSTDEV), NULL);
    6873    AssertReturn(cb < _4M, NULL);
    69 
    70     PPDMAUDIOHOSTDEV pDev = (PPDMAUDIOHOSTDEV)RTMemAllocZ(RT_ALIGN_Z(cb, 64));
     74    AssertReturn(cbName < _4K, NULL);
     75    AssertReturn(cbId < _16K, NULL);
     76
     77    PPDMAUDIOHOSTDEV pDev = (PPDMAUDIOHOSTDEV)RTMemAllocZ(RT_ALIGN_Z(cb + cbName + cbId, 64));
    7178    if (pDev)
    7279    {
    73         pDev->uMagic = PDMAUDIOHOSTDEV_MAGIC;
    74         pDev->cbSelf = (uint32_t)cb;
     80        pDev->uMagic  = PDMAUDIOHOSTDEV_MAGIC;
     81        pDev->cbSelf  = (uint32_t)cb;
    7582        RTListInit(&pDev->ListEntry);
    76 
    77         //pDev->cMaxInputChannels  = 0;
    78         //pDev->cMaxOutputChannels = 0;
     83        if (cbName)
     84            pDev->pszName = (char *)pDev + cb;
     85        if (cbId)
     86            pDev->pszId   = (char *)pDev + cb + cbName;
    7987    }
    8088    return pDev;
     
    94102        pDev->cbSelf = 0;
    95103
     104        if (pDev->fFlags & PDMAUDIOHOSTDEV_F_NAME_ALLOC)
     105        {
     106            RTStrFree(pDev->pszName);
     107            pDev->pszName = NULL;
     108        }
     109
    96110        if (pDev->fFlags & PDMAUDIOHOSTDEV_F_ID_ALLOC)
    97111        {
     
    120134    AssertReturn(cbToDup >= sizeof(*pDev), NULL);
    121135
    122     PPDMAUDIOHOSTDEV pDevDup = PDMAudioHostDevAlloc(cbToDup);
     136    PPDMAUDIOHOSTDEV pDevDup = PDMAudioHostDevAlloc(cbToDup, 0, 0);
    123137    if (pDevDup)
    124138    {
     
    126140        RTListInit(&pDevDup->ListEntry);
    127141        pDevDup->cbSelf = cbToDup;
     142
     143        if (pDev->pszName)
     144        {
     145            uintptr_t off;
     146            if (   (pDevDup->fFlags & PDMAUDIOHOSTDEV_F_NAME_ALLOC)
     147                || (off = (uintptr_t)pDev->pszName - (uintptr_t)pDev) >= pDevDup->cbSelf)
     148            {
     149                pDevDup->fFlags |= PDMAUDIOHOSTDEV_F_NAME_ALLOC;
     150                pDevDup->pszName = RTStrDup(pDev->pszName);
     151                AssertReturnStmt(pDevDup->pszName, PDMAudioHostDevFree(pDevDup), NULL);
     152            }
     153            else
     154                pDevDup->pszName = (char *)pDevDup + off;
     155        }
     156
    128157        if (pDev->pszId)
    129158        {
    130             pDevDup->fFlags |= PDMAUDIOHOSTDEV_F_ID_ALLOC;
    131             pDevDup->pszId   = RTStrDup(pDev->pszId);
    132             AssertReturnStmt(pDevDup->pszId, RTMemFree(pDevDup), NULL);
     159            uintptr_t off;
     160            if (   (pDevDup->fFlags & PDMAUDIOHOSTDEV_F_ID_ALLOC)
     161                || (off = (uintptr_t)pDev->pszId - (uintptr_t)pDev) >= pDevDup->cbSelf)
     162            {
     163                pDevDup->fFlags |= PDMAUDIOHOSTDEV_F_ID_ALLOC;
     164                pDevDup->pszId   = RTStrDup(pDev->pszId);
     165                AssertReturnStmt(pDevDup->pszId, PDMAudioHostDevFree(pDevDup), NULL);
     166            }
     167            else
     168                pDevDup->pszId = (char *)pDevDup + off;
    133169        }
    134170    }
     
    334370/** The max string length for all PDMAUDIOHOSTDEV_F_XXX.
    335371 * @sa PDMAudioHostDevFlagsToString */
    336 #define PDMAUDIOHOSTDEV_MAX_FLAGS_STRING_LEN sizeof("DEFAULT_OUT DEFAULT_IN HOTPLUG BUGGY IGNORE LOCKED DEAD ID_ALLOC NO_DUP ")
     372#define PDMAUDIOHOSTDEV_MAX_FLAGS_STRING_LEN sizeof("DEFAULT_OUT DEFAULT_IN HOTPLUG BUGGY IGNORE LOCKED DEAD NAME_ALLOC ID_ALLOC NO_DUP ")
    337373
    338374/**
     
    356392        { RT_STR_TUPLE("LOCKED "),      PDMAUDIOHOSTDEV_F_LOCKED  },
    357393        { RT_STR_TUPLE("DEAD "),        PDMAUDIOHOSTDEV_F_DEAD    },
    358         { RT_STR_TUPLE("ID_ALLOC "),    PDMAUDIOHOSTDEV_F_ID_ALLOC  },
     394        { RT_STR_TUPLE("NAME_ALLOC "),  PDMAUDIOHOSTDEV_F_NAME_ALLOC },
     395        { RT_STR_TUPLE("ID_ALLOC "),    PDMAUDIOHOSTDEV_F_ID_ALLOC },
    359396        { RT_STR_TUPLE("NO_DUP "),      PDMAUDIOHOSTDEV_F_NO_DUP  },
    360397    };
     
    398435        {
    399436            char szFlags[PDMAUDIOHOSTDEV_MAX_FLAGS_STRING_LEN];
    400             LogFunc(("Device '%s':\n", pDev->szName));
     437            LogFunc(("Device '%s':\n", pDev->pszName));
     438            LogFunc(("  ID              = %s\n",             pDev->pszId ? pDev->pszId : "<none>"));
    401439            LogFunc(("  Usage           = %s\n",             PDMAudioDirGetName(pDev->enmUsage)));
    402440            LogFunc(("  Flags           = %s\n",             PDMAudioHostDevFlagsToString(szFlags, pDev->fFlags)));
  • trunk/include/VBox/vmm/pdmaudioifs.h

    r89489 r89500  
    291291/** The device is present but not in an alive state (dead). */
    292292#define PDMAUDIOHOSTDEV_F_DEAD              RT_BIT_32(6)
     293/** Set if the PDMAUDIOHOSTDEV::pszName is allocated. */
     294#define PDMAUDIOHOSTDEV_F_NAME_ALLOC        RT_BIT_32(29)
    293295/** Set if the PDMAUDIOHOSTDEV::pszId is allocated. */
    294296#define PDMAUDIOHOSTDEV_F_ID_ALLOC          RT_BIT_32(30)
     
    342344    /** Maximum number of output audio channels the device supports. */
    343345    uint8_t             cMaxOutputChannels;
    344     uint8_t             abAlignment[ARCH_BITS == 32 ? 2 + 12 : 2];
     346    uint8_t             abAlignment[ARCH_BITS == 32 ? 2 + 8 : 2 + 8];
    345347    /** Backend specific device identifier, can be NULL, used to select device.
    346348     * This can either point into some non-public part of this structure or to a
     
    349351     * @sa PDMIHOSTAUDIO::pfnSetDevice */
    350352    char               *pszId;
    351     /** Friendly name of the device, if any. Could be truncated. */
    352     char                szName[64];
     353    /** The friendly device name. */
     354    char               *pszName;
    353355} PDMAUDIOHOSTDEV;
    354356AssertCompileSizeAlignment(PDMAUDIOHOSTDEV, 16);
     
    359361
    360362/** Magic value for PDMAUDIOHOSTDEV.  */
    361 #define PDMAUDIOHOSTDEV_MAGIC       PDM_VERSION_MAKE(0xa0d0, 2, 0)
     363#define PDMAUDIOHOSTDEV_MAGIC       PDM_VERSION_MAKE(0xa0d0, 3, 0)
    362364
    363365
     
    13871389
    13881390/** PDMIHOSTAUDIO interface ID. */
    1389 #define PDMIHOSTAUDIO_IID                           "147dedd7-cac1-469b-b545-335dbe90abf6"
     1391#define PDMIHOSTAUDIO_IID                           "2d57627f-6f47-4669-a2fa-93a5f1cb6e51"
    13901392
    13911393
  • trunk/src/VBox/Devices/Audio/DrvAudio.cpp

    r89489 r89500  
    764764                {
    765765                    char szFlags[PDMAUDIOHOSTDEV_MAX_FLAGS_STRING_LEN];
    766                     LogRel(("Audio: Device '%s'%s%s%s:\n"
     766                    LogRel(("Audio: Device '%s':\n"
     767                            "Audio:   ID              = %s\n"
    767768                            "Audio:   Usage           = %s\n"
    768769                            "Audio:   Flags           = %s\n"
    769770                            "Audio:   Input channels  = %RU8\n"
    770771                            "Audio:   Output channels = %RU8\n",
    771                             pDev->szName, pDev->pszId ? " (ID '" : "", pDev->pszId ? pDev->pszId : "", pDev->pszId ? "')" : "",
     772                            pDev->pszName, pDev->pszId ? pDev->pszId : "",
    772773                            PDMAudioDirGetName(pDev->enmUsage), PDMAudioHostDevFlagsToString(szFlags, pDev->fFlags),
    773774                            pDev->cMaxInputChannels, pDev->cMaxOutputChannels));
  • trunk/src/VBox/Devices/Audio/DrvHostAudioAlsa.cpp

    r89488 r89500  
    244244            char * const pszDesc    = snd_device_name_get_hint(pszHint, "DESC");
    245245
    246             if (pszDev && RTStrICmp(pszDev, "null") != 0)
     246            if (pszDev && RTStrICmpAscii(pszDev, "null") != 0)
    247247            {
    248248                /* Detect and log presence of pulse audio plugin. */
     
    252252                /*
    253253                 * Add an entry to the enumeration result.
     254                 * We engage in some trickery here to deal with device names that
     255                 * are more than 63 characters long.
    254256                 */
    255                 PPDMAUDIOHOSTDEV pDev = PDMAudioHostDevAlloc(sizeof(*pDev));
     257                size_t const     cbId   = pszDev ? strlen(pszDev) + 1 : 1;
     258                size_t const     cbName = pszDesc ? strlen(pszDesc) + 2 + 1 : cbId;
     259                PPDMAUDIOHOSTDEV pDev   = PDMAudioHostDevAlloc(sizeof(*pDev), cbName, cbId);
    256260                if (pDev)
    257261                {
    258                     pDev->fFlags  = PDMAUDIOHOSTDEV_F_NONE;
    259                     pDev->enmType = PDMAUDIODEVICETYPE_UNKNOWN;
    260 
    261                     if (pszInOutId == NULL)
     262                    RTStrCopy(pDev->pszId, cbId, pszDev);
     263                    if (pDev->pszId)
    262264                    {
    263                         pDev->enmUsage           = PDMAUDIODIR_DUPLEX;
    264                         pDev->cMaxInputChannels  = 2;
    265                         pDev->cMaxOutputChannels = 2;
    266                     }
    267                     else if (RTStrICmp(pszInOutId, "Input") == 0)
    268                     {
    269                         pDev->enmUsage           = PDMAUDIODIR_IN;
    270                         pDev->cMaxInputChannels  = 2;
    271                         pDev->cMaxOutputChannels = 0;
     265                        pDev->fFlags  = PDMAUDIOHOSTDEV_F_NONE;
     266                        pDev->enmType = PDMAUDIODEVICETYPE_UNKNOWN;
     267
     268                        if (pszInOutId == NULL)
     269                        {
     270                            pDev->enmUsage           = PDMAUDIODIR_DUPLEX;
     271                            pDev->cMaxInputChannels  = 2;
     272                            pDev->cMaxOutputChannels = 2;
     273                        }
     274                        else if (RTStrICmpAscii(pszInOutId, "Input") == 0)
     275                        {
     276                            pDev->enmUsage           = PDMAUDIODIR_IN;
     277                            pDev->cMaxInputChannels  = 2;
     278                            pDev->cMaxOutputChannels = 0;
     279                        }
     280                        else
     281                        {
     282                            AssertMsg(RTStrICmpAscii(pszInOutId, "Output") == 0, ("%s (%s)\n", pszInOutId, pszHint));
     283                            pDev->enmUsage           = PDMAUDIODIR_OUT;
     284                            pDev->cMaxInputChannels  = 0;
     285                            pDev->cMaxOutputChannels = 2;
     286                        }
     287
     288                        if (pszDesc && *pszDesc)
     289                        {
     290                            char *pszDesc2 = strchr(pszDesc, '\n');
     291                            if (!pszDesc2)
     292                                RTStrCopy(pDev->pszName, cbName, pszDesc);
     293                            else
     294                            {
     295                                *pszDesc2++ = '\0';
     296                                char *psz;
     297                                while ((psz = strchr(pszDesc2, '\n')) != NULL)
     298                                    *psz = ' ';
     299                                RTStrPrintf(pDev->pszName, cbName, "%s (%s)", pszDesc2, pszDesc);
     300                            }
     301                        }
     302                        else
     303                            RTStrCopy(pDev->pszName, cbName, pszDev);
     304
     305                        PDMAudioHostEnumAppend(pDeviceEnum, pDev);
     306
     307                        LogRel2(("ALSA: Device #%u: '%s' enmDir=%s: %s\n", iHint, pszDev,
     308                                 PDMAudioDirGetName(pDev->enmUsage), pszDesc));
    272309                    }
    273310                    else
    274311                    {
    275                         AssertMsg(RTStrICmp(pszInOutId, "Output") == 0, ("%s (%s)\n", pszInOutId, pszHint));
    276                         pDev->enmUsage = PDMAUDIODIR_OUT;
    277                         pDev->cMaxInputChannels  = 0;
    278                         pDev->cMaxOutputChannels = 2;
     312                        PDMAudioHostDevFree(pDev);
     313                        rc = VERR_NO_STR_MEMORY;
    279314                    }
    280 
    281                     int rc2 = RTStrCopy(pDev->szName, sizeof(pDev->szName), pszDev);
    282                     AssertRC(rc2);
    283 
    284                     PDMAudioHostEnumAppend(pDeviceEnum, pDev);
    285 
    286                     LogRel2(("ALSA: Device #%u: '%s' enmDir=%s: %s\n", iHint, pszDev,
    287                              PDMAudioDirGetName(pDev->enmUsage), pszDesc));
    288315                }
    289316                else
  • trunk/src/VBox/Devices/Audio/DrvHostAudioCoreAudio.cpp

    r89487 r89500  
    12601260                                       kAudioObjectPropertyElementMaster, "device name", &hStrName, sizeof(hStrName)))
    12611261        {
    1262             drvHstAudCaCFStringToBuf(hStrName, pDevEntry->Core.szName, sizeof(pDevEntry->Core.szName));
     1262            pDevEntry->Core.pszName = drvHstAudCaCFStringToHeap(hStrName);
     1263            pDevEntry->Core.fFlags |= PDMAUDIOHOSTDEV_F_NAME_ALLOC;
    12631264            CFRelease(hStrName);
    12641265        }
     
    12911292
    12921293        /*
    1293          * Add the device to the enumeration.
     1294         * Try make sure we've got a name...  Only add it to the enumeration if we have one.
    12941295         */
    1295         PDMAudioHostEnumAppend(pDevEnm, &pDevEntry->Core);
     1296        if (!pDevEntry->Core.pszName)
     1297        {
     1298            pDevEntry->Core.pszName = pDevEntry->Core.pszId;
     1299            pDevEntry->Core.fFlags &= ~PDMAUDIOHOSTDEV_F_NAME_ALLOC;
     1300        }
     1301
     1302        if (pDevEntry->Core.pszName)
     1303            PDMAudioHostEnumAppend(pDevEnm, &pDevEntry->Core);
     1304        else
     1305            PDMAudioHostDevFree(&pDevEntry->Core);
    12961306    }
    12971307
  • trunk/src/VBox/Devices/Audio/DrvHostAudioDSound.cpp

    r89487 r89500  
    801801
    802802    int rc;
    803     PDSOUNDDEV pDev = (PDSOUNDDEV)PDMAudioHostDevAlloc(sizeof(DSOUNDDEV));
     803    size_t const cbName = RTUtf16CalcUtf8Len(pwszDescription) + 1;
     804    PDSOUNDDEV pDev = (PDSOUNDDEV)PDMAudioHostDevAlloc(sizeof(DSOUNDDEV), cbName, 0);
    804805    if (pDev)
    805806    {
     
    810811            pDev->Core.fFlags = PDMAUDIOHOSTDEV_F_DEFAULT_OUT;
    811812
    812         char *pszName;
    813         rc = RTUtf16ToUtf8(pwszDescription, &pszName);
     813        rc = RTUtf16ToUtf8Ex(pwszDescription, RTSTR_MAX, &pDev->Core.pszName, cbName, NULL);
    814814        if (RT_SUCCESS(rc))
    815815        {
    816             RTStrCopy(pDev->Core.szName, sizeof(pDev->Core.szName), pszName);
    817             RTStrFree(pszName);
    818 
    819816            if (!pGUID)
    820817                pDev->Core.fFlags |= PDMAUDIOHOSTDEV_F_DEFAULT_OUT;
     
    869866
    870867    int rc;
    871     PDSOUNDDEV pDev = (PDSOUNDDEV)PDMAudioHostDevAlloc(sizeof(DSOUNDDEV));
     868    size_t const cbName = RTUtf16CalcUtf8Len(pwszDescription) + 1;
     869    PDSOUNDDEV pDev = (PDSOUNDDEV)PDMAudioHostDevAlloc(sizeof(DSOUNDDEV), cbName, 0);
    872870    if (pDev)
    873871    {
     
    875873        pDev->Core.enmType  = PDMAUDIODEVICETYPE_BUILTIN;
    876874
    877         char *pszName;
    878         rc = RTUtf16ToUtf8(pwszDescription, &pszName);
     875        rc = RTUtf16ToUtf8Ex(pwszDescription, RTSTR_MAX, &pDev->Core.pszName, cbName, NULL);
    879876        if (RT_SUCCESS(rc))
    880877        {
    881             RTStrCopy(pDev->Core.szName, sizeof(pDev->Core.szName), pszName);
    882             RTStrFree(pszName);
    883 
    884878            if (!pGUID)
    885879                pDev->Core.fFlags |= PDMAUDIOHOSTDEV_F_DEFAULT_IN;
     
    10521046                     * Create a enumeration entry for it.
    10531047                     */
    1054                     PDSOUNDDEV pDev = (PDSOUNDDEV)PDMAudioHostDevAlloc(sizeof(DSOUNDDEV));
     1048                    size_t const cbName = RTUtf16CalcUtf8Len(VarName.pwszVal) + 1;
     1049                    PDSOUNDDEV pDev = (PDSOUNDDEV)PDMAudioHostDevAlloc(sizeof(DSOUNDDEV), cbName, 0);
    10551050                    if (pDev)
    10561051                    {
     
    10731068                            pDev->Core.pszId = &pDev->szGuid[0];
    10741069
    1075                             char *pszName;
    1076                             rc = RTUtf16ToUtf8(VarName.pwszVal, &pszName);
     1070                            rc = RTUtf16ToUtf8Ex(VarName.pwszVal, RTSTR_MAX, &pDev->Core.pszName, cbName, NULL);
    10771071                            if (RT_SUCCESS(rc))
    1078                             {
    1079                                 RTStrCopy(pDev->Core.szName, sizeof(pDev->Core.szName), pszName);
    1080                                 RTStrFree(pszName);
    1081 
    10821072                                PDMAudioHostEnumAppend(pDevEnm, &pDev->Core);
    1083                             }
    10841073                            else
    10851074                                PDMAudioHostDevFree(&pDev->Core);
  • trunk/src/VBox/Devices/Audio/DrvHostAudioPulseAudio.cpp

    r89487 r89500  
    118118    /** The part we share with others. */
    119119    PDMAUDIOHOSTDEV         Core;
    120     /** The pulse audio name.
    121      * @note Kind of must use fixed size field here as that allows
    122      *       PDMAudioHostDevDup() and PDMAudioHostEnumCopy() to work. */
    123     RT_FLEXIBLE_ARRAY_EXTENSION
    124     char                    szPulseName[RT_FLEXIBLE_ARRAY];
    125120} DRVHSTAUDPADEVENTRY;
    126121/** Pointer to a pulse audio device enumeration entry. */
     
    401396 */
    402397static void drvHstAudPaEnumAddDevice(PDRVHSTAUDPAENUMCBCTX pCbCtx, PDMAUDIODIR enmDir, const char *pszName,
    403                                         const char *pszDesc, uint8_t cChannelsInput, uint8_t cChannelsOutput,
    404                                         const char *pszDefaultName)
    405 {
    406     size_t const         cchName = strlen(pszName);
    407     PDRVHSTAUDPADEVENTRY pDev    = (PDRVHSTAUDPADEVENTRY)PDMAudioHostDevAlloc(RT_UOFFSETOF(DRVHSTAUDPADEVENTRY, szPulseName)
    408                                                                             + RT_ALIGN_Z(cchName + 1, 16));
     398                                     const char *pszDesc, uint8_t cChannelsInput, uint8_t cChannelsOutput,
     399                                     const char *pszDefaultName)
     400{
     401    size_t const         cbId    = strlen(pszName) + 1;
     402    size_t const         cbName  = pszDesc && *pszDesc ? strlen(pszDesc) + 1 : cbId;
     403    PDRVHSTAUDPADEVENTRY pDev    = (PDRVHSTAUDPADEVENTRY)PDMAudioHostDevAlloc(sizeof(*pDev), cbName, cbId);
    409404    if (pDev != NULL)
    410405    {
    411         memcpy(pDev->szPulseName, pszName, cchName);
    412         pDev->szPulseName[cchName] = '\0';
    413 
    414406        pDev->Core.enmUsage           = enmDir;
    415407        pDev->Core.enmType            = RTStrIStr(pszDesc, "built-in") != NULL
     
    421413        pDev->Core.cMaxInputChannels  = cChannelsInput;
    422414        pDev->Core.cMaxOutputChannels = cChannelsOutput;
    423         RTStrCopy(pDev->Core.szName, sizeof(pDev->Core.szName),
    424                   pszDesc && *pszDesc ? pszDesc : pszName);
     415
     416        int rc = RTStrCopy(pDev->Core.pszId, cbId, pszName);
     417        AssertRC(rc);
     418
     419        rc = RTStrCopy(pDev->Core.pszName, cbName, pszDesc && *pszDesc ? pszDesc : pszName);
     420        AssertRC(rc);
    425421
    426422        PDMAudioHostEnumAppend(pCbCtx->pDeviceEnum, &pDev->Core);
     
    456452                 pInfo->name, pInfo->description, pInfo->driver, pInfo->flags));
    457453        drvHstAudPaEnumAddDevice(pCbCtx, PDMAUDIODIR_IN, pInfo->name, pInfo->description,
    458                                     pInfo->sample_spec.channels, 0 /*cChannelsOutput*/, pCbCtx->pszDefaultSource);
     454                                 pInfo->sample_spec.channels, 0 /*cChannelsOutput*/, pCbCtx->pszDefaultSource);
    459455    }
    460456    else if (eol == 1 && !pInfo && pCbCtx->rcEnum == VERR_AUDIO_ENUMERATION_FAILED)
  • trunk/src/VBox/Devices/Audio/DrvHostAudioWasApi.cpp

    r89491 r89500  
    15251525                     * Create a enumeration entry for it.
    15261526                     */
    1527                     size_t const cbDev = RT_ALIGN_Z(  RT_OFFSETOF(DRVHOSTAUDIOWASDEV, wszDevId)
    1528                                                     + (cwcDevId + 1) * sizeof(RTUTF16),
    1529                                                     64);
    1530                     PDRVHOSTAUDIOWASDEV pDev = (PDRVHOSTAUDIOWASDEV)PDMAudioHostDevAlloc(cbDev);
     1527                    size_t const cbId   = RTUtf16CalcUtf8Len(pwszDevId) + 1;
     1528                    size_t const cbName = RTUtf16CalcUtf8Len(VarName.pwszVal) + 1;
     1529                    size_t const cbDev  = RT_ALIGN_Z(  RT_OFFSETOF(DRVHOSTAUDIOWASDEV, wszDevId)
     1530                                                     + (cwcDevId + 1) * sizeof(RTUTF16),
     1531                                                     64);
     1532                    PDRVHOSTAUDIOWASDEV pDev = (PDRVHOSTAUDIOWASDEV)PDMAudioHostDevAlloc(cbDev, cbName, cbId);
    15311533                    if (pDev)
    15321534                    {
     
    15431545                        pDev->wszDevId[cwcDevId] = '\0';
    15441546
    1545                         char *pszName;
    1546                         rc = RTUtf16ToUtf8(VarName.pwszVal, &pszName);
     1547                        Assert(pDev->Core.pszName);
     1548                        rc = RTUtf16ToUtf8Ex(VarName.pwszVal, RTSTR_MAX, &pDev->Core.pszName, cbName, NULL);
    15471549                        if (RT_SUCCESS(rc))
    15481550                        {
    1549                             RTStrCopy(pDev->Core.szName, sizeof(pDev->Core.szName), pszName);
    1550                             RTStrFree(pszName);
    1551 
    1552                             rc = RTUtf16ToUtf8(pDev->wszDevId, &pDev->Core.pszId);
     1551                            Assert(pDev->Core.pszId);
     1552                            rc = RTUtf16ToUtf8Ex(pDev->wszDevId, RTSTR_MAX, &pDev->Core.pszId, cbId, NULL);
    15531553                            if (RT_SUCCESS(rc))
    1554                             {
    1555                                 pDev->Core.fFlags |= PDMAUDIOHOSTDEV_F_ID_ALLOC;
    15561554                                PDMAudioHostEnumAppend(pDevEnm, &pDev->Core);
    1557                             }
    15581555                            else
    15591556                                PDMAudioHostDevFree(&pDev->Core);
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