VirtualBox

Changeset 89218 in vbox for trunk


Ignore:
Timestamp:
May 21, 2021 11:57:55 AM (4 years ago)
Author:
vboxsync
Message:

Audio: Converted PDMAUDIODSTSRCUNION, PDMAUDIORECSRC and PDMAUDIOPLAYBACKDST into a single enum type PDMAUDIOPATH. bugref:9890

Location:
trunk
Files:
11 edited

Legend:

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

    r89214 r89218  
    487487typedef PDMAUDIOFRAME const *PCPDMAUDIOFRAME;
    488488
    489 /**
    490  * Audio playback destinations.
    491  */
    492 typedef enum PDMAUDIOPLAYBACKDST
    493 {
    494     /** Invalid zero value as per usual (guards against using unintialized values). */
    495     PDMAUDIOPLAYBACKDST_INVALID = 0,
    496     /** Unknown destination. */
    497     PDMAUDIOPLAYBACKDST_UNKNOWN,
    498     /** Front channel. */
    499     PDMAUDIOPLAYBACKDST_FRONT,
    500     /** Center / LFE (Subwoofer) channel. */
    501     PDMAUDIOPLAYBACKDST_CENTER_LFE,
    502     /** Rear channel. */
    503     PDMAUDIOPLAYBACKDST_REAR,
     489
     490/**
     491 * Audio path: input sources and playback destinations.
     492 *
     493 * Think of this as the name of the socket you plug the virtual audio stream
     494 * jack into.
     495 *
     496 * @note Not quite sure what the purpose of this type is.  It used to be two
     497 * separate enums (PDMAUDIOPLAYBACKDST & PDMAUDIORECSRC) without overlapping
     498 * values and most commonly used in a union (PDMAUDIODSTSRCUNION).  The output
     499 * values were designated "channel" (e.g. "Front channel"), whereas this was not
     500 * done to the input ones.  So, I'm (bird) a little confused what the actual
     501 * meaning was.
     502 */
     503typedef enum PDMAUDIOPATH
     504{
     505    /** Customary invalid zero value. */
     506    PDMAUDIOPATH_INVALID = 0,
     507
     508    /** Unknown path / Doesn't care. */
     509    PDMAUDIOPATH_UNKNOWN,
     510
     511    /** First output value. */
     512    PDMAUDIOPATH_OUT_FIRST,
     513    /** Output: Front. */
     514    PDMAUDIOPATH_OUT_FRONT = PDMAUDIOPATH_OUT_FIRST,
     515    /** Output: Center / LFE (Subwoofer). */
     516    PDMAUDIOPATH_OUT_CENTER_LFE,
     517    /** Output: Rear. */
     518    PDMAUDIOPATH_OUT_REAR,
     519    /** Last output value (inclusive)   */
     520    PDMAUDIOPATH_OUT_END = PDMAUDIOPATH_OUT_REAR,
     521
     522    /** First input value. */
     523    PDMAUDIOPATH_IN_FIRST,
     524    /** Input: Microphone. */
     525    PDMAUDIOPATH_IN_MIC = PDMAUDIOPATH_IN_FIRST,
     526    /** Input: CD. */
     527    PDMAUDIOPATH_IN_CD,
     528    /** Input: Video-In. */
     529    PDMAUDIOPATH_IN_VIDEO,
     530    /** Input: AUX. */
     531    PDMAUDIOPATH_IN_AUX,
     532    /** Input: Line-In. */
     533    PDMAUDIOPATH_IN_LINE,
     534    /** Input: Phone-In. */
     535    PDMAUDIOPATH_IN_PHONE,
     536    /** Last intput value (inclusive). */
     537    PDMAUDIOPATH_IN_LAST = PDMAUDIOPATH_IN_PHONE,
     538
    504539    /** End of valid values. */
    505     PDMAUDIOPLAYBACKDST_END,
    506     /** Hack to blow the type up to 32-bit. */
    507     PDMAUDIOPLAYBACKDST_32BIT_HACK = 0x7fffffff
    508 } PDMAUDIOPLAYBACKDST;
    509 
    510 /**
    511  * Audio recording sources.
    512  *
    513  * @note Because this is almost exclusively used in PDMAUDIODSTSRCUNION where it
    514  *       overlaps with PDMAUDIOPLAYBACKDST, the values starts at 64 instead of 0.
    515  */
    516 typedef enum PDMAUDIORECSRC
    517 {
    518     /** Unknown recording source. */
    519     PDMAUDIORECSRC_UNKNOWN = 64,
    520     /** Microphone-In. */
    521     PDMAUDIORECSRC_MIC,
    522     /** CD. */
    523     PDMAUDIORECSRC_CD,
    524     /** Video-In. */
    525     PDMAUDIORECSRC_VIDEO,
    526     /** AUX. */
    527     PDMAUDIORECSRC_AUX,
    528     /** Line-In. */
    529     PDMAUDIORECSRC_LINE,
    530     /** Phone-In. */
    531     PDMAUDIORECSRC_PHONE,
    532     /** End of valid values. */
    533     PDMAUDIORECSRC_END,
    534     /** Hack to blow the type up to 32-bit. */
    535     PDMAUDIORECSRC_32BIT_HACK = 0x7fffffff
    536 } PDMAUDIORECSRC;
    537 
    538 /**
    539  * Union for keeping an audio stream destination or source.
    540  */
    541 typedef union PDMAUDIODSTSRCUNION
    542 {
    543     /** Desired playback destination (for an output stream). */
    544     PDMAUDIOPLAYBACKDST enmDst;
    545     /** Desired recording source (for an input stream). */
    546     PDMAUDIORECSRC      enmSrc;
    547 } PDMAUDIODSTSRCUNION;
    548 /** Pointer to an audio stream src/dst union. */
    549 typedef PDMAUDIODSTSRCUNION *PPDMAUDIODSTSRCUNION;
     540    PDMAUDIOPATH_END,
     541    /** Hack to blow the typ up to 32 bits. */
     542    PDMAUDIOPATH_32BIT_HACK = 0x7fffffff
     543} PDMAUDIOPATH;
    550544
    551545/**
     
    756750    /** Direction of the stream. */
    757751    PDMAUDIODIR             enmDir;
    758     /** Destination / source indicator, depending on enmDir. */
    759     PDMAUDIODSTSRCUNION     u;
     752    /** Destination / source path. */
     753    PDMAUDIOPATH            enmPath;
    760754    /** The stream's PCM properties. */
    761755    PDMAUDIOPCMPROPS        Props;
     
    12501244
    12511245/** PDMIAUDIOCONNECTOR interface ID. */
    1252 #define PDMIAUDIOCONNECTOR_IID                  "69d01cd1-df73-48db-86f4-2f97519ac585"
     1246#define PDMIAUDIOCONNECTOR_IID                  "ff9cabf0-4138-4c3a-aa99-28bf7a6feae7"
    12531247
    12541248
     
    15311525
    15321526/** PDMIHOSTAUDIO interface ID. */
    1533 #define PDMIHOSTAUDIO_IID                           "cd27862d-9aa2-4270-876e-7d660b87ecd3"
     1527#define PDMIHOSTAUDIO_IID                           "ad56b303-0c1f-4b79-9bd1-4ec04ae08c4f"
    15341528
    15351529
     
    16161610
    16171611/** PDMIHOSTAUDIOPORT interface ID. */
    1618 #define PDMIHOSTAUDIOPORT_IID                    "cd006383-7be1-4dbe-a69e-21236413cf30"
     1612#define PDMIHOSTAUDIOPORT_IID                    "9f91ec59-95ba-4925-92dc-e75be1c63352"
    16191613
    16201614/** @} */
  • trunk/include/VBox/vmm/pdmaudioinline.h

    r88991 r89218  
    107107
    108108/**
    109  * Gets the name of a playback destination enum value.
     109 * Gets the name of a path enum value.
    110110 *
    111111 * @returns Pointer to read-only name, "bad" if invalid input.
    112  * @param   enmPlaybackDst      The playback destination value.
    113  */
    114 DECLINLINE(const char *) PDMAudioPlaybackDstGetName(PDMAUDIOPLAYBACKDST enmPlaybackDst)
    115 {
    116     switch (enmPlaybackDst)
    117     {
    118         case PDMAUDIOPLAYBACKDST_UNKNOWN:    return "Unknown";
    119         case PDMAUDIOPLAYBACKDST_FRONT:      return "Front";
    120         case PDMAUDIOPLAYBACKDST_CENTER_LFE: return "Center / LFE";
    121         case PDMAUDIOPLAYBACKDST_REAR:       return "Rear";
     112 * @param   enmPath     The path value to name.
     113 */
     114DECLINLINE(const char *) PDMAudioPathGetName(PDMAUDIOPATH enmPath)
     115{
     116    switch (enmPath)
     117    {
     118        case PDMAUDIOPATH_UNKNOWN:          return "Unknown";
     119
     120        case PDMAUDIOPATH_OUT_FRONT:        return "Front";
     121        case PDMAUDIOPATH_OUT_CENTER_LFE:   return "Center / LFE";
     122        case PDMAUDIOPATH_OUT_REAR:         return "Rear";
     123
     124        case PDMAUDIOPATH_IN_MIC:           return "Microphone In";
     125        case PDMAUDIOPATH_IN_CD:            return "CD";
     126        case PDMAUDIOPATH_IN_VIDEO:         return "Video";
     127        case PDMAUDIOPATH_IN_AUX:           return "AUX";
     128        case PDMAUDIOPATH_IN_LINE:          return "Line In";
     129        case PDMAUDIOPATH_IN_PHONE:         return "Phone";
     130
    122131        /* no default */
    123         case PDMAUDIOPLAYBACKDST_INVALID:
    124         case PDMAUDIOPLAYBACKDST_END:
    125         case PDMAUDIOPLAYBACKDST_32BIT_HACK:
     132        case PDMAUDIOPATH_INVALID:
     133        case PDMAUDIOPATH_END:
     134        case PDMAUDIOPATH_32BIT_HACK:
    126135            break;
    127136    }
    128     AssertMsgFailedReturn(("Invalid playback destination %ld\n", enmPlaybackDst), "bad");
    129 }
    130 
    131 /**
    132  * Gets the name of a recording source enum value.
    133  *
    134  * @returns Pointer to read-only name, "bad" if invalid input.
    135  * @param   enmRecSrc       The recording source value.
    136  */
    137 DECLINLINE(const char *) PDMAudioRecSrcGetName(PDMAUDIORECSRC enmRecSrc)
    138 {
    139     switch (enmRecSrc)
    140     {
    141         case PDMAUDIORECSRC_UNKNOWN: return "Unknown";
    142         case PDMAUDIORECSRC_MIC:     return "Microphone In";
    143         case PDMAUDIORECSRC_CD:      return "CD";
    144         case PDMAUDIORECSRC_VIDEO:   return "Video";
    145         case PDMAUDIORECSRC_AUX:     return "AUX";
    146         case PDMAUDIORECSRC_LINE:    return "Line In";
    147         case PDMAUDIORECSRC_PHONE:   return "Phone";
    148         /* no default */
    149         case PDMAUDIORECSRC_END:
    150         case PDMAUDIORECSRC_32BIT_HACK:
    151             break;
    152     }
    153     AssertMsgFailedReturn(("Invalid recording source %ld\n", enmRecSrc), "bad");
     137    AssertMsgFailedReturn(("Unknown enmPath=%d\n", enmPath), "bad");
    154138}
    155139
     
    954938    if (PDMAudioPropsAreEqual(&pCfg1->Props, &pCfg2->Props))
    955939        return pCfg1->enmDir    == pCfg2->enmDir
    956             && pCfg1->u.enmDst  == pCfg2->u.enmDst
     940            && pCfg1->enmPath   == pCfg2->enmPath
    957941            && pCfg1->enmLayout == pCfg2->enmLayout
    958942            && pCfg1->Device.cMsSchedulingHint == pCfg2->Device.cMsSchedulingHint
  • trunk/src/VBox/Devices/Audio/AudioMixer.cpp

    r89213 r89218  
    623623                AssertRC(rc); /* cannot fail */
    624624                CfgHost.enmDir    = pSink->enmDir;
    625                 CfgHost.u         = pCfg->u;
     625                CfgHost.enmPath   = pCfg->enmPath;
    626626                CfgHost.enmLayout = pCfg->enmLayout;
    627627                CfgHost.Device    = pCfg->Device;
  • trunk/src/VBox/Devices/Audio/DevHda.cpp

    r89213 r89218  
    16741674            RTStrPrintf(pCfg->szName, RT_ELEMENTS(pCfg->szName), "Front");
    16751675
    1676             pCfg->u.enmDst          = PDMAUDIOPLAYBACKDST_FRONT;
     1676            pCfg->enmPath           = PDMAUDIOPATH_OUT_FRONT;
    16771677            pCfg->enmLayout         = PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED;
    16781678            /// @todo PDMAudioPropsSetChannels(&pCfg->Props, 2); ?
     
    16871687            RTStrPrintf(pCfg->szName, RT_ELEMENTS(pCfg->szName), "Center/LFE");
    16881688
    1689             pCfg->u.enmDst          = PDMAUDIOPLAYBACKDST_CENTER_LFE;
     1689            pCfg->enmPath           = PDMAUDIOPATH_OUT_CENTER_LFE;
    16901690            pCfg->enmLayout         = PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED;
    16911691            PDMAudioPropsSetChannels(&pCfg->Props, fUseCenter && fUseLFE ? 2 : 1);
     
    16991699            RTStrPrintf(pCfg->szName, RT_ELEMENTS(pCfg->szName), "Rear");
    17001700
    1701             pCfg->u.enmDst          = PDMAUDIOPLAYBACKDST_REAR;
     1701            pCfg->enmPath           = PDMAUDIOPATH_OUT_REAR;
    17021702            pCfg->enmLayout         = PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED;
    17031703            PDMAudioPropsSetChannels(&pCfg->Props, 2);
     
    17261726    AssertReturn(pCfg->enmDir == PDMAUDIODIR_IN, VERR_INVALID_PARAMETER);
    17271727
    1728     LogFlowFunc(("Stream=%s, Source=%ld\n", pCfg->szName, pCfg->u.enmSrc));
     1728    LogFlowFunc(("Stream=%s enmPath=%ld\n", pCfg->szName, pCfg->enmPath));
    17291729
    17301730    int rc;
    1731     switch (pCfg->u.enmSrc)
    1732     {
    1733         case PDMAUDIORECSRC_LINE:
     1731    switch (pCfg->enmPath)
     1732    {
     1733        case PDMAUDIOPATH_IN_LINE:
    17341734            rc = hdaR3CodecAddStream(pThisCC->pCodec, PDMAUDIOMIXERCTL_LINE_IN, pCfg);
    17351735            break;
    17361736# ifdef VBOX_WITH_AUDIO_HDA_MIC_IN
    1737         case PDMAUDIORECSRC_MIC:
     1737        case PDMAUDIOPATH_IN_MIC:
    17381738            rc = hdaR3CodecAddStream(pThisCC->pCodec, PDMAUDIOMIXERCTL_MIC_IN, pCfg);
    17391739            break;
     
    18031803        case PDMAUDIODIR_IN:
    18041804        {
    1805             LogFlowFunc(("Stream=%s, Source=%ld\n", pCfg->szName, pCfg->u.enmSrc));
    1806 
    1807             switch (pCfg->u.enmSrc)
     1805            LogFlowFunc(("Stream=%s enmPath=%d (src)\n", pCfg->szName, pCfg->enmPath));
     1806
     1807            switch (pCfg->enmPath)
    18081808            {
    1809                 case PDMAUDIORECSRC_UNKNOWN: break;
    1810                 case PDMAUDIORECSRC_LINE:    enmMixerCtl = PDMAUDIOMIXERCTL_LINE_IN; break;
     1809                case PDMAUDIOPATH_UNKNOWN: break;
     1810                case PDMAUDIOPATH_IN_LINE:  enmMixerCtl = PDMAUDIOMIXERCTL_LINE_IN; break;
    18111811# ifdef VBOX_WITH_AUDIO_HDA_MIC_IN
    1812                 case PDMAUDIORECSRC_MIC:     enmMixerCtl = PDMAUDIOMIXERCTL_MIC_IN;  break;
     1812                case PDMAUDIOPATH_IN_MIC:   enmMixerCtl = PDMAUDIOMIXERCTL_MIC_IN;  break;
    18131813# endif
    18141814                default:
     
    18161816                    break;
    18171817            }
    1818 
    18191818            break;
    18201819        }
     
    18221821        case PDMAUDIODIR_OUT:
    18231822        {
    1824             LogFlowFunc(("Stream=%s, Source=%ld\n", pCfg->szName, pCfg->u.enmDst));
    1825 
    1826             switch (pCfg->u.enmDst)
     1823            LogFlowFunc(("Stream=%s, enmPath=%d (dst)\n", pCfg->szName, pCfg->enmPath));
     1824
     1825            switch (pCfg->enmPath)
    18271826            {
    1828                 case PDMAUDIOPLAYBACKDST_UNKNOWN:    break;
    1829                 case PDMAUDIOPLAYBACKDST_FRONT:      enmMixerCtl = PDMAUDIOMIXERCTL_FRONT;      break;
     1827                case PDMAUDIOPATH_UNKNOWN:          break;
     1828                case PDMAUDIOPATH_OUT_FRONT:        enmMixerCtl = PDMAUDIOMIXERCTL_FRONT;      break;
    18301829# ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND
    1831                 case PDMAUDIOPLAYBACKDST_CENTER_LFE: enmMixerCtl = PDMAUDIOMIXERCTL_CENTER_LFE; break;
    1832                 case PDMAUDIOPLAYBACKDST_REAR:       enmMixerCtl = PDMAUDIOMIXERCTL_REAR;       break;
     1830                case PDMAUDIOPATH_OUT_CENTER_LFE:  enmMixerCtl = PDMAUDIOMIXERCTL_CENTER_LFE; break;
     1831                case PDMAUDIOPATH_OUT_REAR:         enmMixerCtl = PDMAUDIOMIXERCTL_REAR;       break;
    18331832# endif
    18341833                default:
     
    22812280    if (pCfg->enmDir == PDMAUDIODIR_IN)
    22822281    {
    2283         LogFunc(("enmSrc=%d\n", pCfg->u.enmSrc));
    2284         switch (pCfg->u.enmSrc)
    2285         {
    2286             case PDMAUDIORECSRC_LINE:
     2282        LogFunc(("enmPath=%d (src)\n", pCfg->enmPath));
     2283        switch (pCfg->enmPath)
     2284        {
     2285            case PDMAUDIOPATH_IN_LINE:
    22872286                pDrvStream = &pDrv->LineIn;
    22882287                break;
    22892288# ifdef VBOX_WITH_AUDIO_HDA_MIC_IN
    2290             case PDMAUDIORECSRC_MIC:
     2289            case PDMAUDIOPATH_IN_MIC:
    22912290                pDrvStream = &pDrv->MicIn;
    22922291                break;
    22932292# endif
    22942293            default:
    2295                 LogFunc(("returns VERR_NOT_SUPPORTED - enmSrc=%d\n", pCfg->u.enmSrc));
     2294                LogFunc(("returns VERR_NOT_SUPPORTED - enmPath=%d\n", pCfg->enmPath));
    22962295                return VERR_NOT_SUPPORTED;
    22972296        }
     
    22992298    else if (pCfg->enmDir == PDMAUDIODIR_OUT)
    23002299    {
    2301         LogFunc(("enmDst=%d %s\n", pCfg->u.enmDst, PDMAudioPlaybackDstGetName(pCfg->u.enmDst)));
    2302         switch (pCfg->u.enmDst)
    2303         {
    2304             case PDMAUDIOPLAYBACKDST_FRONT:
     2300        LogFunc(("enmDst=%d %s (dst)\n", pCfg->enmPath, PDMAudioPathGetName(pCfg->enmPath)));
     2301        switch (pCfg->enmPath)
     2302        {
     2303            case PDMAUDIOPATH_OUT_FRONT:
    23052304                pDrvStream = &pDrv->Front;
    23062305                break;
    23072306# ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND
    2308             case PDMAUDIOPLAYBACKDST_CENTER_LFE:
     2307            case PDMAUDIOPATH_OUT_CENTER_LFE:
    23092308                pDrvStream = &pDrv->CenterLFE;
    23102309                break;
    2311             case PDMAUDIOPLAYBACKDST_REAR:
     2310            case PDMAUDIOPATH_OUT_REAR:
    23122311                pDrvStream = &pDrv->Rear;
    23132312                break;
    23142313# endif
    23152314            default:
    2316                 LogFunc(("returns VERR_NOT_SUPPORTED - enmDst=%d %s\n", pCfg->u.enmDst, PDMAudioPlaybackDstGetName(pCfg->u.enmDst)));
     2315                LogFunc(("returns VERR_NOT_SUPPORTED - enmPath=%d %s\n", pCfg->enmPath, PDMAudioPathGetName(pCfg->enmPath)));
    23172316                return VERR_NOT_SUPPORTED;
    23182317        }
     
    44514450                    RT_ZERO(Cfg);
    44524451                    Cfg.enmDir                        = PDMAUDIODIR_OUT;
    4453                     Cfg.u.enmDst                      = PDMAUDIOPLAYBACKDST_FRONT;
     4452                    Cfg.enmPath                       = PDMAUDIOPATH_OUT_FRONT;
    44544453                    Cfg.enmLayout                     = PDMAUDIOSTREAMLAYOUT_INTERLEAVED;
    44554454                    Cfg.Device.cMsSchedulingHint      = 10;
  • trunk/src/VBox/Devices/Audio/DevHdaStream.cpp

    r88991 r89218  
    9494    if (fIsInput)
    9595    {
    96         pStreamShared->State.Cfg.u.enmSrc = PDMAUDIORECSRC_UNKNOWN;
    97         pStreamShared->State.Cfg.enmDir   = PDMAUDIODIR_IN;
     96        pStreamShared->State.Cfg.enmPath = PDMAUDIOPATH_UNKNOWN;
     97        pStreamShared->State.Cfg.enmDir  = PDMAUDIODIR_IN;
    9898    }
    9999    else
    100100    {
    101         pStreamShared->State.Cfg.u.enmDst = PDMAUDIOPLAYBACKDST_UNKNOWN;
    102         pStreamShared->State.Cfg.enmDir   = PDMAUDIODIR_OUT;
     101        pStreamShared->State.Cfg.enmPath = PDMAUDIOPATH_UNKNOWN;
     102        pStreamShared->State.Cfg.enmDir  = PDMAUDIODIR_OUT;
    103103    }
    104104
     
    548548#  error "Implement me!"
    549549# else
    550             pCfg->u.enmSrc  = PDMAUDIORECSRC_LINE;
     550            pCfg->enmPath   = PDMAUDIOPATH_IN_LINE;
    551551            pCfg->enmLayout = PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED;
    552552            RTStrCopy(pCfg->szName, sizeof(pCfg->szName), "Line In");
  • trunk/src/VBox/Devices/Audio/DevIchAc97.cpp

    r89213 r89218  
    659659
    660660static void               ichac97R3MixerRemoveDrvStreams(PPDMDEVINS pDevIns, PAC97STATER3 pThisCC, PAUDMIXSINK pMixSink,
    661                                                          PDMAUDIODIR enmDir, PDMAUDIODSTSRCUNION dstSrc);
     661                                                         PDMAUDIODIR enmDir, PDMAUDIOPATH enmPath);
    662662
    663663DECLINLINE(PDMAUDIODIR)   ichac97GetDirFromSD(uint8_t uSD);
     
    11501150     * Destroy all sinks.
    11511151     */
    1152     PDMAUDIODSTSRCUNION dstSrc; /** @todo r=bird: this is just impractical. combine the two enums into one, they already have no overlapping values. */
    11531152    if (pThisCC->pSinkLineIn)
    11541153    {
    1155         dstSrc.enmSrc = PDMAUDIORECSRC_LINE;
    1156         ichac97R3MixerRemoveDrvStreams(pDevIns, pThisCC, pThisCC->pSinkLineIn, PDMAUDIODIR_IN, dstSrc);
     1154        ichac97R3MixerRemoveDrvStreams(pDevIns, pThisCC, pThisCC->pSinkLineIn, PDMAUDIODIR_IN, PDMAUDIOPATH_IN_LINE);
    11571155
    11581156        AudioMixerSinkDestroy(pThisCC->pSinkLineIn, pDevIns);
     
    11621160    if (pThisCC->pSinkMicIn)
    11631161    {
    1164         dstSrc.enmSrc = PDMAUDIORECSRC_MIC;
    1165         ichac97R3MixerRemoveDrvStreams(pDevIns, pThisCC, pThisCC->pSinkMicIn, PDMAUDIODIR_IN, dstSrc);
     1162        ichac97R3MixerRemoveDrvStreams(pDevIns, pThisCC, pThisCC->pSinkMicIn, PDMAUDIODIR_IN, PDMAUDIOPATH_IN_MIC);
    11661163
    11671164        AudioMixerSinkDestroy(pThisCC->pSinkMicIn, pDevIns);
     
    11711168    if (pThisCC->pSinkOut)
    11721169    {
    1173         dstSrc.enmDst = PDMAUDIOPLAYBACKDST_FRONT;
    1174         ichac97R3MixerRemoveDrvStreams(pDevIns, pThisCC, pThisCC->pSinkOut, PDMAUDIODIR_OUT, dstSrc);
     1170        ichac97R3MixerRemoveDrvStreams(pDevIns, pThisCC, pThisCC->pSinkOut, PDMAUDIODIR_OUT, PDMAUDIOPATH_OUT_FRONT);
    11751171
    11761172        AudioMixerSinkDestroy(pThisCC->pSinkOut, pDevIns);
     
    14341430 *
    14351431 * @returns Pointer to driver stream if found, or NULL if not found.
    1436  * @param   pDrv                Driver to retrieve driver stream for.
    1437  * @param   enmDir              Stream direction to retrieve.
    1438  * @param   dstSrc              Stream destination / source to retrieve.
    1439  */
    1440 static PAC97DRIVERSTREAM ichac97R3MixerGetDrvStream(PAC97DRIVER pDrv, PDMAUDIODIR enmDir, PDMAUDIODSTSRCUNION dstSrc)
     1432 * @param   pDrv        Driver to retrieve driver stream for.
     1433 * @param   enmDir      Stream direction to retrieve.
     1434 * @param   enmPath     Stream destination / source to retrieve.
     1435 */
     1436static PAC97DRIVERSTREAM ichac97R3MixerGetDrvStream(PAC97DRIVER pDrv, PDMAUDIODIR enmDir, PDMAUDIOPATH enmPath)
    14411437{
    14421438    PAC97DRIVERSTREAM pDrvStream = NULL;
     
    14441440    if (enmDir == PDMAUDIODIR_IN)
    14451441    {
    1446         LogFunc(("enmRecSource=%d\n", dstSrc.enmSrc));
    1447 
    1448         switch (dstSrc.enmSrc)
     1442        LogFunc(("enmRecSource=%d\n", enmPath));
     1443
     1444        switch (enmPath)
    14491445        {
    1450             case PDMAUDIORECSRC_LINE:
     1446            case PDMAUDIOPATH_IN_LINE:
    14511447                pDrvStream = &pDrv->LineIn;
    14521448                break;
    1453             case PDMAUDIORECSRC_MIC:
     1449            case PDMAUDIOPATH_IN_MIC:
    14541450                pDrvStream = &pDrv->MicIn;
    14551451                break;
     
    14611457    else if (enmDir == PDMAUDIODIR_OUT)
    14621458    {
    1463         LogFunc(("enmPlaybackDest=%d\n", dstSrc.enmDst));
    1464 
    1465         switch (dstSrc.enmDst)
     1459        LogFunc(("enmPlaybackDst=%d\n", enmPath));
     1460
     1461        switch (enmPath)
    14661462        {
    1467             case PDMAUDIOPLAYBACKDST_FRONT:
     1463            case PDMAUDIOPATH_OUT_FRONT:
    14681464                pDrvStream = &pDrv->Out;
    14691465                break;
     
    15031499    int rc;
    15041500
    1505     PAC97DRIVERSTREAM pDrvStream = ichac97R3MixerGetDrvStream(pDrv, pStreamCfg->enmDir, pStreamCfg->u);
     1501    PAC97DRIVERSTREAM pDrvStream = ichac97R3MixerGetDrvStream(pDrv, pStreamCfg->enmDir, pStreamCfg->enmPath);
    15061502    if (pDrvStream)
    15071503    {
     
    16781674 * @param   pMixSink    Mixer sink to remove audio streams from.
    16791675 * @param   enmDir      Stream direction to remove.
    1680  * @param   dstSrc      Stream destination / source to remove.
     1676 * @param   enmPath     Stream destination / source to remove.
    16811677 * @param   pDrv        Driver stream to remove.
    16821678 */
    16831679static void ichac97R3MixerRemoveDrvStream(PPDMDEVINS pDevIns, PAUDMIXSINK pMixSink, PDMAUDIODIR enmDir,
    1684                                           PDMAUDIODSTSRCUNION dstSrc, PAC97DRIVER pDrv)
    1685 {
    1686     PAC97DRIVERSTREAM pDrvStream = ichac97R3MixerGetDrvStream(pDrv, enmDir, dstSrc);
     1680                                          PDMAUDIOPATH enmPath, PAC97DRIVER pDrv)
     1681{
     1682    PAC97DRIVERSTREAM pDrvStream = ichac97R3MixerGetDrvStream(pDrv, enmDir, enmPath);
    16871683    if (pDrvStream)
    16881684    {
     
    17041700 * @param   pMixSink    Mixer sink to remove audio streams from.
    17051701 * @param   enmDir      Stream direction to remove.
    1706  * @param   dstSrc      Stream destination / source to remove.
     1702 * @param   enmPath     Stream destination / source to remove.
    17071703 */
    17081704static void ichac97R3MixerRemoveDrvStreams(PPDMDEVINS pDevIns, PAC97STATER3 pThisCC, PAUDMIXSINK pMixSink,
    1709                                            PDMAUDIODIR enmDir, PDMAUDIODSTSRCUNION dstSrc)
     1705                                           PDMAUDIODIR enmDir, PDMAUDIOPATH enmPath)
    17101706{
    17111707    AssertPtrReturnVoid(pMixSink);
     
    17141710    RTListForEach(&pThisCC->lstDrv, pDrv, AC97DRIVER, Node)
    17151711    {
    1716         ichac97R3MixerRemoveDrvStream(pDevIns, pMixSink, enmDir, dstSrc, pDrv);
     1712        ichac97R3MixerRemoveDrvStream(pDevIns, pMixSink, enmDir, enmPath, pDrv);
    17171713    }
    17181714}
     
    17931789                              ichac97MixerGet(pThis, AC97_PCM_LR_ADC_Rate));
    17941790            Cfg.enmDir      = PDMAUDIODIR_IN;
    1795             Cfg.u.enmSrc    = PDMAUDIORECSRC_LINE;
     1791            Cfg.enmPath     = PDMAUDIOPATH_IN_LINE;
    17961792            Cfg.enmLayout   = PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED;
    17971793            RTStrCopy(Cfg.szName, sizeof(Cfg.szName), "Line-In");
     
    18061802                              ichac97MixerGet(pThis, AC97_MIC_ADC_Rate));
    18071803            Cfg.enmDir      = PDMAUDIODIR_IN;
    1808             Cfg.u.enmSrc    = PDMAUDIORECSRC_MIC;
     1804            Cfg.enmPath     = PDMAUDIOPATH_IN_MIC;
    18091805            Cfg.enmLayout   = PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED;
    18101806            RTStrCopy(Cfg.szName, sizeof(Cfg.szName), "Mic-In");
     
    18191815                              ichac97MixerGet(pThis, AC97_PCM_Front_DAC_Rate));
    18201816            Cfg.enmDir      = PDMAUDIODIR_OUT;
    1821             Cfg.u.enmDst    = PDMAUDIOPLAYBACKDST_FRONT;
     1817            Cfg.enmPath     = PDMAUDIOPATH_OUT_FRONT;
    18221818            Cfg.enmLayout   = PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED;
    18231819            RTStrCopy(Cfg.szName, sizeof(Cfg.szName), "Output");
     
    18771873                    pStreamCC->State.StatDmaBufSize = (uint32_t)RTCircBufSize(pStreamCC->State.pCircBuf);
    18781874
    1879                     ichac97R3MixerRemoveDrvStreams(pDevIns, pThisCC, pMixSink, Cfg.enmDir, Cfg.u);
     1875                    ichac97R3MixerRemoveDrvStreams(pDevIns, pThisCC, pMixSink, Cfg.enmDir, Cfg.enmPath);
    18801876                    rc = ichac97R3MixerAddDrvStreams(pDevIns, pThisCC, pMixSink, &Cfg);
    18811877                    if (RT_SUCCESS(rc))
     
    21822178 * @param   uIdx                AC'97 index to convert.
    21832179 */
    2184 static PDMAUDIORECSRC ichac97R3IdxToRecSource(uint8_t uIdx)
     2180static PDMAUDIOPATH ichac97R3IdxToRecSource(uint8_t uIdx)
    21852181{
    21862182    switch (uIdx)
    21872183    {
    2188         case AC97_REC_MIC:     return PDMAUDIORECSRC_MIC;
    2189         case AC97_REC_CD:      return PDMAUDIORECSRC_CD;
    2190         case AC97_REC_VIDEO:   return PDMAUDIORECSRC_VIDEO;
    2191         case AC97_REC_AUX:     return PDMAUDIORECSRC_AUX;
    2192         case AC97_REC_LINE_IN: return PDMAUDIORECSRC_LINE;
    2193         case AC97_REC_PHONE:   return PDMAUDIORECSRC_PHONE;
     2184        case AC97_REC_MIC:     return PDMAUDIOPATH_IN_MIC;
     2185        case AC97_REC_CD:      return PDMAUDIOPATH_IN_CD;
     2186        case AC97_REC_VIDEO:   return PDMAUDIOPATH_IN_VIDEO;
     2187        case AC97_REC_AUX:     return PDMAUDIOPATH_IN_AUX;
     2188        case AC97_REC_LINE_IN: return PDMAUDIOPATH_IN_LINE;
     2189        case AC97_REC_PHONE:   return PDMAUDIOPATH_IN_PHONE;
    21942190        default:
    21952191            break;
     
    21972193
    21982194    LogFlowFunc(("Unknown record source %d, using MIC\n", uIdx));
    2199     return PDMAUDIORECSRC_MIC;
     2195    return PDMAUDIOPATH_IN_MIC;
    22002196}
    22012197
     
    22062202 * @param   enmRecSrc           PDM audio recording source to convert.
    22072203 */
    2208 static uint8_t ichac97R3RecSourceToIdx(PDMAUDIORECSRC enmRecSrc)
     2204static uint8_t ichac97R3RecSourceToIdx(PDMAUDIOPATH enmRecSrc)
    22092205{
    22102206    switch (enmRecSrc)
    22112207    {
    2212         case PDMAUDIORECSRC_MIC:     return AC97_REC_MIC;
    2213         case PDMAUDIORECSRC_CD:      return AC97_REC_CD;
    2214         case PDMAUDIORECSRC_VIDEO:   return AC97_REC_VIDEO;
    2215         case PDMAUDIORECSRC_AUX:     return AC97_REC_AUX;
    2216         case PDMAUDIORECSRC_LINE:    return AC97_REC_LINE_IN;
    2217         case PDMAUDIORECSRC_PHONE:   return AC97_REC_PHONE;
    2218         /* no default */
    2219         case PDMAUDIORECSRC_UNKNOWN:
    2220         case PDMAUDIORECSRC_END:
    2221         case PDMAUDIORECSRC_32BIT_HACK:
    2222             break;
     2208        case PDMAUDIOPATH_IN_MIC:    return AC97_REC_MIC;
     2209        case PDMAUDIOPATH_IN_CD:     return AC97_REC_CD;
     2210        case PDMAUDIOPATH_IN_VIDEO:  return AC97_REC_VIDEO;
     2211        case PDMAUDIOPATH_IN_AUX:    return AC97_REC_AUX;
     2212        case PDMAUDIOPATH_IN_LINE:   return AC97_REC_LINE_IN;
     2213        case PDMAUDIOPATH_IN_PHONE:  return AC97_REC_PHONE;
     2214        default:
     2215            AssertMsgFailedBreak(("%d\n", enmRecSrc));
    22232216    }
    22242217
     
    22612254    uint8_t ls = (val >> 8) & AC97_REC_MASK;
    22622255
    2263     const PDMAUDIORECSRC ars = ichac97R3IdxToRecSource(rs);
    2264     const PDMAUDIORECSRC als = ichac97R3IdxToRecSource(ls);
     2256    PDMAUDIOPATH const ars = ichac97R3IdxToRecSource(rs);
     2257    PDMAUDIOPATH const als = ichac97R3IdxToRecSource(ls);
    22652258
    22662259    rs = ichac97R3RecSourceToIdx(ars);
    22672260    ls = ichac97R3RecSourceToIdx(als);
    22682261
    2269     LogRel(("AC97: Record select to left=%s, right=%s\n", PDMAudioRecSrcGetName(ars), PDMAudioRecSrcGetName(als)));
     2262    LogRel(("AC97: Record select to left=%s, right=%s\n", PDMAudioPathGetName(ars), PDMAudioPathGetName(als)));
    22702263
    22712264    ichac97MixerSet(pThis, AC97_Record_Select, rs | (ls << 8));
     
    36713664 * and we pick a different one here?  I also don't get why we need to do this in revese order, given that
    36723665 * the primary device is first.  I guess this code isn't really tested. */
    3673     PDMAUDIODSTSRCUNION dstSrc;
    36743666    PAC97DRIVER pDrvCur;
    36753667    RTListForEachReverse(&pThisCC->lstDrv, pDrvCur, AC97DRIVER, Node)
     
    36833675            continue;
    36843676
    3685         dstSrc.enmSrc = PDMAUDIORECSRC_MIC;
    3686         PAC97DRIVERSTREAM pDrvStrm = ichac97R3MixerGetDrvStream(pDrvCur, PDMAUDIODIR_IN, dstSrc);
     3677        PAC97DRIVERSTREAM pDrvStrm = ichac97R3MixerGetDrvStream(pDrvCur, PDMAUDIODIR_IN, PDMAUDIOPATH_IN_MIC);
    36873678        if (   pDrvStrm
    36883679            && pDrvStrm->pMixStrm)
     
    36933684        }
    36943685
    3695         dstSrc.enmSrc = PDMAUDIORECSRC_LINE;
    3696         pDrvStrm = ichac97R3MixerGetDrvStream(pDrvCur, PDMAUDIODIR_IN, dstSrc);
     3686        pDrvStrm = ichac97R3MixerGetDrvStream(pDrvCur, PDMAUDIODIR_IN, PDMAUDIOPATH_IN_LINE);
    36973687        if (   pDrvStrm
    36983688            && pDrvStrm->pMixStrm)
  • trunk/src/VBox/Devices/Audio/DevSB16.cpp

    r89213 r89218  
    17471747 * @param   pDrv                Driver to retrieve driver stream for.
    17481748 * @param   enmDir              Stream direction to retrieve.
    1749  * @param   dstSrc              Stream destination / source to retrieve.
    1750  */
    1751 static PSB16DRIVERSTREAM sb16GetDrvStream(PSB16DRIVER pDrv, PDMAUDIODIR enmDir, PDMAUDIODSTSRCUNION dstSrc)
     1749 * @param   enmPath             Stream destination / source to retrieve.
     1750 */
     1751static PSB16DRIVERSTREAM sb16GetDrvStream(PSB16DRIVER pDrv, PDMAUDIODIR enmDir, PDMAUDIOPATH enmPath)
    17521752{
    17531753    PSB16DRIVERSTREAM pDrvStream = NULL;
    17541754
    1755     if (enmDir == PDMAUDIODIR_IN)
    1756         return NULL; /** @todo Recording not implemented yet. */
    1757 
    17581755    if (enmDir == PDMAUDIODIR_OUT)
    17591756    {
    1760         LogFunc(("enmDst=%RU32\n", dstSrc.enmDst));
    1761 
    1762         switch (dstSrc.enmDst)
     1757        LogFunc(("enmPath=%d\n", enmPath));
     1758
     1759        switch (enmPath)
    17631760        {
    1764             case PDMAUDIOPLAYBACKDST_FRONT:
     1761            case PDMAUDIOPATH_OUT_FRONT:
    17651762                pDrvStream = &pDrv->Out;
    17661763                break;
     
    17711768    }
    17721769    else
    1773         AssertFailed();
     1770        Assert(enmDir == PDMAUDIODIR_IN /** @todo Recording not implemented yet. */);
    17741771
    17751772    return pDrvStream;
     
    18001797    int rc;
    18011798
    1802     PSB16DRIVERSTREAM pDrvStream = sb16GetDrvStream(pDrv, pStreamCfg->enmDir, pStreamCfg->u);
     1799    PSB16DRIVERSTREAM pDrvStream = sb16GetDrvStream(pDrv, pStreamCfg->enmDir, pStreamCfg->enmPath);
    18031800    if (pDrvStream)
    18041801    {
     
    18681865 * @param   pMixSink    Mixer sink to remove audio streams from.
    18691866 * @param   enmDir      Stream direction to remove.
    1870  * @param   dstSrc      Stream destination / source to remove.
     1867 * @param   enmPath     Stream destination / source to remove.
    18711868 * @param   pDrv        Driver stream to remove.
    18721869 */
    18731870static void sb16RemoveDrvStream(PPDMDEVINS pDevIns, PAUDMIXSINK pMixSink, PDMAUDIODIR enmDir,
    1874                                 PDMAUDIODSTSRCUNION dstSrc, PSB16DRIVER pDrv)
    1875 {
    1876     PSB16DRIVERSTREAM pDrvStream = sb16GetDrvStream(pDrv, enmDir, dstSrc);
     1871                                PDMAUDIOPATH enmPath, PSB16DRIVER pDrv)
     1872{
     1873    PSB16DRIVERSTREAM pDrvStream = sb16GetDrvStream(pDrv, enmDir, enmPath);
    18771874    if (pDrvStream)
    18781875    {
     
    18961893 * @param   pMixSink    Mixer sink to remove audio streams from.
    18971894 * @param   enmDir      Stream direction to remove.
    1898  * @param   dstSrc      Stream destination / source to remove.
     1895 * @param   enmPath     Stream destination / source to remove.
    18991896 */
    19001897static void sb16RemoveDrvStreams(PPDMDEVINS pDevIns, PSB16STATE pThis, PAUDMIXSINK pMixSink,
    1901                                  PDMAUDIODIR enmDir, PDMAUDIODSTSRCUNION dstSrc)
     1898                                 PDMAUDIODIR enmDir, PDMAUDIOPATH enmPath)
    19021899{
    19031900    AssertPtrReturnVoid(pMixSink);
     
    19061903    RTListForEach(&pThis->lstDrv, pDrv, SB16DRIVER, Node)
    19071904    {
    1908         sb16RemoveDrvStream(pDevIns, pMixSink, enmDir, dstSrc, pDrv);
     1905        sb16RemoveDrvStream(pDevIns, pMixSink, enmDir, enmPath, pDrv);
    19091906    }
    19101907}
     
    22092206        {
    22102207            pStream->Cfg.enmDir    = PDMAUDIODIR_OUT;
    2211             pStream->Cfg.u.enmDst  = PDMAUDIOPLAYBACKDST_FRONT;
     2208            pStream->Cfg.enmPath   = PDMAUDIOPATH_OUT_FRONT;
    22122209            pStream->Cfg.enmLayout = PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED;
    22132210
     
    22522249    AssertReturn(PDMAudioPropsAreValid(&pStream->Cfg.Props), VERR_INVALID_PARAMETER);
    22532250
    2254     PDMAUDIODSTSRCUNION dstSrc;
    2255     PDMAUDIODIR         enmDir;
    2256 
    22572251    switch (pStream->uIdx)
    22582252    {
    22592253        case SB16_IDX_OUT:
    2260         {
    22612254            pStream->Cfg.enmDir      = PDMAUDIODIR_OUT;
    2262             pStream->Cfg.u.enmDst    = PDMAUDIOPLAYBACKDST_FRONT;
     2255            pStream->Cfg.enmPath     = PDMAUDIOPATH_OUT_FRONT;
    22632256            pStream->Cfg.enmLayout   = PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED;
    22642257
    22652258            RTStrCopy(pStream->Cfg.szName, sizeof(pStream->Cfg.szName), "Output");
    2266 
    2267             dstSrc.enmDst = PDMAUDIOPLAYBACKDST_FRONT;
    2268             enmDir        = PDMAUDIODIR_OUT;
    2269             break;
    2270         }
     2259            break;
    22712260
    22722261        default:
     
    23012290
    23022291    sb16RemoveDrvStreams(pDevIns, pThis,
    2303                          sb16StreamIndexToSink(pThis, pStream->uIdx), pStream->Cfg.enmDir, pStream->Cfg.u);
     2292                         sb16StreamIndexToSink(pThis, pStream->uIdx), pStream->Cfg.enmDir, pStream->Cfg.enmPath);
    23042293
    23052294    rc = sb16AddDrvStreams(pDevIns, pThis, pMixerSink, &pStream->Cfg);
  • trunk/src/VBox/Devices/Audio/DrvHostAudioDSound.cpp

    r89213 r89218  
    624624    {
    625625        PDSOUNDDEV pDev = NULL;
    626         switch (pCfg->u.enmSrc)
    627         {
    628             case PDMAUDIORECSRC_LINE:
     626        switch (pCfg->enmPath)
     627        {
     628            case PDMAUDIOPATH_IN_LINE:
    629629                /*
    630630                 * At the moment we're only supporting line-in in the HDA emulation,
     
    634634                 * So the fall through here is intentional for now.
    635635                 */
    636             case PDMAUDIORECSRC_MIC:
     636            case PDMAUDIOPATH_IN_MIC:
    637637                pDev = (PDSOUNDDEV)DrvAudioHlpDeviceEnumGetDefaultDevice(&pThis->DeviceEnum, PDMAUDIODIR_IN);
    638638                break;
     
    647647        {
    648648            DSLOG(("DSound: Guest source '%s' is using host recording device '%s'\n",
    649                    PDMAudioRecSrcGetName(pCfg->u.enmSrc), pDev->Core.szName));
     649                   PDMAudioPathGetName(pCfg->enmPath), pDev->Core.szName));
    650650            pGUID = &pDev->Guid;
    651651        }
     
    660660    char *pszGUID = dsoundGUIDToUtf8StrA(pGUID);
    661661    LogRel(("DSound: Guest source '%s' is using host recording device with GUID '%s'\n",
    662             PDMAudioRecSrcGetName(pCfg->u.enmSrc), pszGUID ? pszGUID: "{?}"));
     662            PDMAudioPathGetName(pCfg->enmPath), pszGUID ? pszGUID: "{?}"));
    663663    RTStrFree(pszGUID);
    664664
     
    16491649
    16501650    const char * const pszStreamType = pCfgReq->enmDir == PDMAUDIODIR_IN ? "capture" : "playback"; RT_NOREF(pszStreamType);
    1651     LogFlowFunc(("enmSrc/Dst=%s '%s'\n",
    1652                  pCfgReq->enmDir == PDMAUDIODIR_IN ? PDMAudioRecSrcGetName(pCfgReq->u.enmSrc)
    1653                  : PDMAudioPlaybackDstGetName(pCfgReq->u.enmDst), pCfgReq->szName));
     1651    LogFlowFunc(("enmPath=%s '%s'\n", PDMAudioPathGetName(pCfgReq->enmPath), pCfgReq->szName));
    16541652    RTListInit(&pStreamDS->ListEntry); /* paranoia */
    16551653
  • trunk/src/VBox/Devices/Audio/DrvHostAudioPulseAudio.cpp

    r89213 r89218  
    10381038     */
    10391039    char szName[256];
    1040     RTStrPrintf(szName, sizeof(szName), "VirtualBox %s [%s]",
    1041                 pCfgReq->enmDir == PDMAUDIODIR_IN
    1042                 ? PDMAudioRecSrcGetName(pCfgReq->u.enmSrc) : PDMAudioPlaybackDstGetName(pCfgReq->u.enmDst),
    1043                 pThis->szStreamName);
     1040    RTStrPrintf(szName, sizeof(szName), "VirtualBox %s [%s]", PDMAudioPathGetName(pCfgReq->enmPath), pThis->szStreamName);
    10441041
    10451042    pStreamPA->pDrv                = pThis;
  • trunk/src/VBox/Devices/Audio/DrvHostAudioWasApi.cpp

    r89213 r89218  
    17671767
    17681768    const char * const pszStreamType = pCfgReq->enmDir == PDMAUDIODIR_IN ? "capture" : "playback"; RT_NOREF(pszStreamType);
    1769     LogFlowFunc(("enmSrc/Dst=%s '%s'\n",
    1770                  pCfgReq->enmDir == PDMAUDIODIR_IN ? PDMAudioRecSrcGetName(pCfgReq->u.enmSrc)
    1771                  : PDMAudioPlaybackDstGetName(pCfgReq->u.enmDst), pCfgReq->szName));
     1769    LogFlowFunc(("enmPath=%s '%s'\n", PDMAudioPathGetName(pCfgReq->enmPath), pCfgReq->szName));
    17721770#if defined(RTLOG_REL_ENABLED) || defined(LOG_ENABLED)
    17731771    char szTmp[64];
  • trunk/src/VBox/Main/src-client/DrvAudioRec.cpp

    r89213 r89218  
    409409    AssertPtrReturn(pCfgAcq,   VERR_INVALID_POINTER);
    410410
    411     if (pCfgReq->u.enmDst != PDMAUDIOPLAYBACKDST_FRONT)
     411    if (pCfgReq->enmPath != PDMAUDIOPATH_OUT_FRONT)
    412412    {
    413413        LogRel2(("Recording: Support for surround audio not implemented yet\n"));
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