Changeset 63743 in vbox

Timestamp:

Sep 7, 2016 9:26:22 AM (8 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

110532

Message:

Audio: More code for device enumeration and dynamic device handling / switching.

Location:

trunk/src/VBox/Devices/Audio

Files:

• DrvAudio.cpp (modified) (13 diffs)
• DrvAudio.h (modified) (2 diffs)
• DrvAudioCommon.cpp (modified) (4 diffs)
• DrvHostCoreAudio.cpp (modified) (39 diffs)

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

@@ -40 +40 @@
 #include "DrvAudio.h"
 #include "AudioMixBuffer.h"
+
+static int drvAudioDevicesEnumerateInternal(PDRVAUDIO pThis, bool fLog, PPDMAUDIODEVICEENUM pDevEnum);
 
 static DECLCALLBACK(int) drvAudioStreamDestroy(PPDMIAUDIOCONNECTOR pInterface, PPDMAUDIOSTREAM pStream);
@@ -618 +620 @@
  * @param   pThis               Pointer to driver instance.
  */
-static int drvAudioScheduleReInit(PDRVAUDIO pThis)
+static int drvAudioScheduleReInitInternal(PDRVAUDIO pThis)
 {
     AssertPtrReturn(pThis, VERR_INVALID_POINTER);
@@ -624 +626 @@
     LogFunc(("\n"));
 
+    /* Mark all host streams to re-initialize. */
     PPDMAUDIOSTREAM pHstStream;
     RTListForEach(&pThis->lstHstStreams, pHstStream, PDMAUDIOSTREAM, Node)
         pHstStream->fStatus |= PDMAUDIOSTRMSTS_FLAG_PENDING_REINIT;
 
+    /* Re-enumerate all host devices as soon as possible. */
+    pThis->fEnumerateDevices = true;
+
     return VINF_SUCCESS;
 }
@@ -648 +654 @@
 
     PPDMAUDIOSTREAM pHstStream = drvAudioGetHostStream(pStream);
+    AssertPtr(pHstStream);
 
     /*
@@ -673 +680 @@
     if (RT_SUCCESS(rc))
     {
+        PPDMAUDIOSTREAM pGstStream = pHstStream->pPair;
+
         if (fIsEnabled)
+        {
             rc = drvAudioStreamControlInternalBackend(pThis, pHstStream, PDMAUDIOSTREAMCMD_ENABLE);
+            if (RT_SUCCESS(rc))
+            {
+                if (pGstStream)
+                {
+                    /* Also reset the guest stream mixing buffer. */
+                    AudioMixBufReset(&pGstStream->MixBuf);
+                }
+            }
+        }
+
+#ifdef VBOX_WITH_STATISTICS
+        /*
+         * Reset statistics.
+         */
+        if (RT_SUCCESS(rc))
+        {
+            if (pHstStream->enmDir == PDMAUDIODIR_IN)
+            {
+                STAM_COUNTER_RESET(&pHstStream->In.StatBytesElapsed);
+                STAM_COUNTER_RESET(&pHstStream->In.StatBytesTotalRead);
+                STAM_COUNTER_RESET(&pHstStream->In.StatSamplesCaptured);
+
+                if (pGstStream)
+                {
+                    Assert(pGstStream->enmDir == pHstStream->enmDir);
+
+                    STAM_COUNTER_RESET(&pGstStream->In.StatBytesElapsed);
+                    STAM_COUNTER_RESET(&pGstStream->In.StatBytesTotalRead);
+                    STAM_COUNTER_RESET(&pGstStream->In.StatSamplesCaptured);
+                }
+            }
+            else if (pHstStream->enmDir == PDMAUDIODIR_OUT)
+            {
+                STAM_COUNTER_RESET(&pHstStream->Out.StatBytesElapsed);
+                STAM_COUNTER_RESET(&pHstStream->Out.StatBytesTotalWritten);
+                STAM_COUNTER_RESET(&pHstStream->Out.StatSamplesPlayed);
+
+                if (pGstStream)
+                {
+                    Assert(pGstStream->enmDir == pHstStream->enmDir);
+
+                    STAM_COUNTER_RESET(&pGstStream->Out.StatBytesElapsed);
+                    STAM_COUNTER_RESET(&pGstStream->Out.StatBytesTotalWritten);
+                    STAM_COUNTER_RESET(&pGstStream->Out.StatSamplesPlayed);
+                }
+            }
+            else
+                AssertFailed();
+        }
+#endif
     }
 
@@ -857 +917 @@
 
     int rc;
+
+    /* Is the stream scheduled for re-initialization? Do so now. */
+    if (pHstStream->fStatus & PDMAUDIOSTRMSTS_FLAG_PENDING_REINIT)
+    {
+        if (pThis->fEnumerateDevices)
+        {
+            /* Re-enumerate all host devices. */
+            drvAudioDevicesEnumerateInternal(pThis, true /* fLog */, NULL /* pDevEnum */);
+
+            pThis->fEnumerateDevices = false;
+        }
+
+        /* Remove the pending re-init flag in any case, regardless whether the actual re-initialization succeeded
+         * or not. If it failed, the backend needs to notify us again to try again at some later point in time. */
+        pHstStream->fStatus &= ~PDMAUDIOSTRMSTS_FLAG_PENDING_REINIT;
+
+        rc = drvAudioStreamReInitInternal(pThis, pStream);
+        if (RT_FAILURE(rc))
+            return rc;
+    }
 
     /* Whether to try closing a pending to close stream. */
@@ -1020 +1100 @@
                                    pStream->szName, pStream->cRefs, pStream->fStatus, pStream->enmCtx),
                                   rc = VERR_NOT_AVAILABLE);
-
-        /* Is the stream scheduled for re-initialization? Do so now. */
-        if (pHstStream->fStatus & PDMAUDIOSTRMSTS_FLAG_PENDING_REINIT)
-        {
-            /* Remove the pending re-init flag in any case, regardless whether the actual re-initialization succeeded
-             * or not. If it failed, the backend needs to notify us again to try again at some later point in time. */
-            pHstStream->fStatus &= ~PDMAUDIOSTRMSTS_FLAG_PENDING_REINIT;
-
-            rc = drvAudioStreamReInitInternal(pThis, pStream);
-            if (RT_FAILURE(rc))
-                break;
-        }
 
         AssertPtr(pThis->pHostDrvAudio->pfnStreamGetStatus);
@@ -1132 +1200 @@
                                   rc = VERR_NOT_AVAILABLE);
 
-        /* Is the stream scheduled for re-initialization? Do so now. */
-        if (pHstStream->fStatus & PDMAUDIOSTRMSTS_FLAG_PENDING_REINIT)
-        {
-            /* Remove the pending re-init flag in any case, regardless whether the actual re-initialization succeeded
-             * or not. If it failed, the backend needs to notify us again to try again at some later point in time. */
-            pHstStream->fStatus &= ~PDMAUDIOSTRMSTS_FLAG_PENDING_REINIT;
-
-            rc = drvAudioStreamReInitInternal(pThis, pStream);
-            if (RT_FAILURE(rc))
-                break;
-        }
-
         AssertPtr(pThis->pHostDrvAudio->pfnStreamGetStatus);
         PDMAUDIOSTRMSTS strmSts = pThis->pHostDrvAudio->pfnStreamGetStatus(pThis->pHostDrvAudio, pHstStream);
@@ -1340 +1396 @@
  * Important: No calls back to the backend within this function, as the backend
  *            might hold any locks / critical sections while executing this callback.
- *            Will result in some ugly deadlocks then.
+ *            Will result in some ugly deadlocks (or at least locking order violations) then.
  *
  * @copydoc FNPDMHOSTAUDIOCALLBACK
@@ -1366 +1422 @@
         case PDMAUDIOCBTYPE_DEVICES_CHANGED:
             LogRel(("Audio: Host audio device configuration has changed\n"));
-            rc = drvAudioScheduleReInit(pThis);
+            rc = drvAudioScheduleReInitInternal(pThis);
             break;
 
@@ -1382 +1438 @@
 }
 #endif /* VBOX_WITH_AUDIO_CALLBACKS */
+
+/**
+ * Enumerates all host audio devices.
+ * This functionality might not be implemented by all backends and will return VERR_NOT_SUPPORTED
+ * if not being supported.
+ *
+ * @returns IPRT status code.
+ * @param   pThis               Driver instance to be called.
+ * @param   fLog                Whether to print the enumerated device to the release log or not.
+ * @param   pDevEnum            Where to store the device enumeration.
+ */
+static int drvAudioDevicesEnumerateInternal(PDRVAUDIO pThis, bool fLog, PPDMAUDIODEVICEENUM pDevEnum)
+{
+    int rc;
+
+    /*
+     * If the backend supports it, do a device enumeration.
+     */
+    if (pThis->pHostDrvAudio->pfnGetDevices)
+    {
+        PDMAUDIODEVICEENUM DevEnum;
+        rc = pThis->pHostDrvAudio->pfnGetDevices(pThis->pHostDrvAudio, &DevEnum);
+        if (RT_SUCCESS(rc))
+        {
+            if (fLog)
+                LogRel(("Audio: Found %RU16 devices\n", DevEnum.cDevices));
+
+            PPDMAUDIODEVICE pDev;
+            RTListForEach(&DevEnum.lstDevices, pDev, PDMAUDIODEVICE, Node)
+            {
+                if (fLog)
+                {
+                    char *pszFlags = DrvAudioHlpAudDevFlagsToStrA(pDev->fFlags);
+
+                    LogRel(("Audio: Device '%s':\n", pDev->szName));
+                    LogRel(("Audio: \tUsage           = %s\n",   DrvAudioHlpAudDirToStr(pDev->enmUsage)));
+                    LogRel(("Audio: \tFlags           = %s\n",   pszFlags ? pszFlags : "<NONE>"));
+                    LogRel(("Audio: \tInput channels  = %RU8\n", pDev->cMaxInputChannels));
+                    LogRel(("Audio: \tOutput channels = %RU8\n", pDev->cMaxOutputChannels));
+
+                    if (pszFlags)
+                        RTStrFree(pszFlags);
+                }
+            }
+
+            if (pDevEnum)
+                rc = DrvAudioHlpDeviceEnumCopy(pDevEnum, &DevEnum);
+
+            DrvAudioHlpDeviceEnumFree(&DevEnum);
+        }
+        else
+        {
+            if (fLog)
+                LogRel(("Audio: Device enumeration failed with %Rrc\n", rc));
+            /* Not fatal. */
+        }
+    }
+    else
+    {
+        rc = VERR_NOT_SUPPORTED;
+
+        if (fLog)
+            LogRel3(("Audio: Host audio backend does not support audio device enumeration, skipping\n"));
+    }
+
+    LogFunc(("Returning %Rrc\n", rc));
+    return rc;
+}
 
 /**
@@ -1431 +1555 @@
              RT_MIN(64, pThis->cStreamsFreeIn), RT_MIN(64, pThis->cStreamsFreeOut)));
 
-    /*
-     * If the backend supports it, do a device enumeration.
-     */
-    bool fLog = true;
-
-    if (pThis->pHostDrvAudio->pfnGetDevices)
-    {
-        PDMAUDIODEVICEENUM DevEnum;
-        int rc2 = pThis->pHostDrvAudio->pfnGetDevices(pThis->pHostDrvAudio, &DevEnum);
-        if (RT_SUCCESS(rc2))
-        {
-            if (fLog)
-                LogRel(("Audio: Found %RU16 devices\n", DevEnum.cDevices));
-
-            PPDMAUDIODEVICE pDev;
-            RTListForEach(&DevEnum.lstDevices, pDev, PDMAUDIODEVICE, Node)
-            {
-                if (fLog)
-                {
-                    char *pszFlags = DrvAudioHlpAudDevFlagsToStrA(pDev->fFlags);
-
-                    LogRel(("Audio: Device '%s':\n", pDev->szName));
-                    LogRel(("Audio: \tUsage           = %s\n",   DrvAudioHlpAudDirToStr(pDev->enmUsage)));
-                    LogRel(("Audio: \tFlags           = %s\n",   pszFlags ? pszFlags : "<NONE>"));
-                    LogRel(("Audio: \tInput channels  = %RU8\n", pDev->cMaxInputChannels));
-                    LogRel(("Audio: \tOutput channels = %RU8\n", pDev->cMaxOutputChannels));
-
-                    if (pszFlags)
-                        RTStrFree(pszFlags);
-                }
-            }
-
-            DrvAudioHlpDeviceEnumFree(&DevEnum);
-        }
-        else
-        {
-            if (fLog)
-                LogRel(("Audio: Device enumeration failed with %Rrc\n", rc2));
-            /* Not fatal. */
-        }
-    }
-    else if (fLog)
-        LogRel2(("Audio: Selected host audio backend does not support audio device enumeration\n"));
+    int rc2 = drvAudioDevicesEnumerateInternal(pThis, true /* fLog */, NULL /* pDevEnum */);
+    /* Ignore rc. */
 
 #ifdef VBOX_WITH_AUDIO_CALLBACKS
@@ -1481 +1564 @@
     if (pThis->pHostDrvAudio->pfnSetCallback)
     {
-        int rc2 = pThis->pHostDrvAudio->pfnSetCallback(pThis->pHostDrvAudio, drvAudioBackendCallback);
+        rc2 = pThis->pHostDrvAudio->pfnSetCallback(pThis->pHostDrvAudio, drvAudioBackendCallback);
         if (RT_FAILURE(rc2))
              LogRel(("Audio: Error registering backend callback, rc=%Rrc\n", rc2));

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

@@ -118 +118 @@
      *  UINT32_MAX for unlimited streams. */
     uint32_t                cStreamsFreeOut;
+    /** Flag indicating to perform an (re-)enumeration of the host audio devices. */
+    bool                    fEnumerateDevices;
     /** Audio configuration settings retrieved from the backend. */
     PDMAUDIOBACKENDCFG      BackendCfg;
@@ -156 +158 @@
 PPDMAUDIODEVICE DrvAudioHlpDeviceAlloc(size_t cbData);
 void DrvAudioHlpDeviceFree(PPDMAUDIODEVICE pDev);
+PPDMAUDIODEVICE DrvAudioHlpDeviceDup(PPDMAUDIODEVICE pDev, bool fCopyUserData);
 
 int DrvAudioHlpDeviceEnumInit(PPDMAUDIODEVICEENUM pDevEnm);
 void DrvAudioHlpDeviceEnumFree(PPDMAUDIODEVICEENUM pDevEnm);
 int DrvAudioHlpDeviceEnumAdd(PPDMAUDIODEVICEENUM pDevEnm, PPDMAUDIODEVICE pDev);
+int DrvAudioHlpDeviceEnumCopyEx(PPDMAUDIODEVICEENUM pDstDevEnm, PPDMAUDIODEVICEENUM pSrcDevEnm, PDMAUDIODIR enmUsage);
+int DrvAudioHlpDeviceEnumCopy(PPDMAUDIODEVICEENUM pDstDevEnm, PPDMAUDIODEVICEENUM pSrcDevEnm);
+PPDMAUDIODEVICEENUM DrvAudioHlpDeviceEnumDup(PPDMAUDIODEVICEENUM pDevEnm);
+int DrvAudioHlpDeviceEnumCopy(PPDMAUDIODEVICEENUM pDstDevEnm, PPDMAUDIODEVICEENUM pSrcDevEnm);
 PPDMAUDIODEVICE DrvAudioHlpDeviceEnumGetDefaultDevice(PPDMAUDIODEVICEENUM pDevEnm, PDMAUDIODIR enmDir);
 void DrvAudioHlpDeviceEnumPrint(const char *pszDesc, PPDMAUDIODEVICEENUM pDevEnm);

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

@@ -221 +221 @@
     if (cbData)
     {
-        pDev->pvData = RTMemAlloc(cbData);
+        pDev->pvData = RTMemAllocZ(cbData);
         if (!pDev->pvData)
         {
@@ -254 +254 @@
 
         RTMemFree(pDev->pvData);
+        pDev->pvData = NULL;
     }
 
     RTMemFree(pDev);
+    pDev = NULL;
+}
+
+/**
+ * Duplicates an audio device entry.
+ *
+ * @returns Duplicated audio device entry on success, or NULL on failure.
+ * @param   pDev                Audio device entry to duplicate.
+ * @param   fCopyUserData       Whether to also copy the user data portion or not.
+ */
+PPDMAUDIODEVICE DrvAudioHlpDeviceDup(PPDMAUDIODEVICE pDev, bool fCopyUserData)
+{
+    AssertPtrReturn(pDev, NULL);
+
+    PPDMAUDIODEVICE pDevDup = DrvAudioHlpDeviceAlloc(fCopyUserData ? pDev->cbData : 0);
+    if (pDevDup)
+    {
+        memcpy(pDevDup, pDev, sizeof(PDMAUDIODEVICE));
+
+        if (   fCopyUserData
+            && pDevDup->cbData)
+        {
+            memcpy(pDevDup->pvData, pDev->pvData, pDevDup->cbData);
+        }
+        else
+        {
+            pDevDup->cbData = 0;
+            pDevDup->pvData = NULL;
+        }
+    }
+
+    return pDevDup;
 }
 
@@ -305 +338 @@
  * @return IPRT status code.
  * @param  pDevEnm              Device enumeration to add device to.
- * @param  pDev                 Device to add.
+ * @param  pDev                 Device to add. The pointer will be owned by the device enumeration  then.
  */
 int DrvAudioHlpDeviceEnumAdd(PPDMAUDIODEVICEENUM pDevEnm, PPDMAUDIODEVICE pDev)
@@ -316 +349 @@
 
     return VINF_SUCCESS;
+}
+
+/**
+ * Duplicates a device enumeration.
+ *
+ * @returns Duplicated device enumeration, or NULL on failure.
+ *          Must be free'd with DrvAudioHlpDeviceEnumFree().
+ * @param   pDevEnm             Device enumeration to duplicate.
+ */
+PPDMAUDIODEVICEENUM DrvAudioHlpDeviceEnumDup(PPDMAUDIODEVICEENUM pDevEnm)
+{
+    AssertPtrReturn(pDevEnm, NULL);
+
+    PPDMAUDIODEVICEENUM pDevEnmDup = (PPDMAUDIODEVICEENUM)RTMemAlloc(sizeof(PDMAUDIODEVICEENUM));
+    if (!pDevEnmDup)
+        return NULL;
+
+    int rc2 = DrvAudioHlpDeviceEnumInit(pDevEnmDup);
+    AssertRC(rc2);
+
+    PPDMAUDIODEVICE pDev;
+    RTListForEach(&pDevEnm->lstDevices, pDev, PDMAUDIODEVICE, Node)
+    {
+        PPDMAUDIODEVICE pDevDup = DrvAudioHlpDeviceDup(pDev, true /* fCopyUserData */);
+        if (!pDevDup)
+        {
+            rc2 = VERR_NO_MEMORY;
+            break;
+        }
+
+        rc2 = DrvAudioHlpDeviceEnumAdd(pDevEnmDup, pDevDup);
+        if (RT_FAILURE(rc2))
+        {
+            DrvAudioHlpDeviceFree(pDevDup);
+            break;
+        }
+    }
+
+    if (RT_FAILURE(rc2))
+    {
+        DrvAudioHlpDeviceEnumFree(pDevEnmDup);
+        pDevEnmDup = NULL;
+    }
+
+    return pDevEnmDup;
+}
+
+/**
+ * Copies device enumeration entries from the source to the destination enumeration.
+ *
+ * @returns IPRT status code.
+ * @param   pDstDevEnm          Destination enumeration to store enumeration entries into.
+ * @param   pSrcDevEnm          Source enumeration to use.
+ * @param   enmUsage            Which entries to copy. Specify PDMAUDIODIR_ANY to copy all entries.
+ * @param   fCopyUserData       Whether to also copy the user data portion or not.
+ */
+int DrvAudioHlpDeviceEnumCopyEx(PPDMAUDIODEVICEENUM pDstDevEnm, PPDMAUDIODEVICEENUM pSrcDevEnm,
+                                PDMAUDIODIR enmUsage, bool fCopyUserData)
+{
+    AssertPtrReturn(pDstDevEnm, VERR_INVALID_POINTER);
+    AssertPtrReturn(pSrcDevEnm, VERR_INVALID_POINTER);
+
+    int rc = VINF_SUCCESS;
+
+    PPDMAUDIODEVICE pSrcDev;
+    RTListForEach(&pSrcDevEnm->lstDevices, pSrcDev, PDMAUDIODEVICE, Node)
+    {
+        if (   enmUsage != PDMAUDIODIR_ANY
+            && enmUsage != pSrcDev->enmUsage)
+        {
+            continue;
+        }
+
+        PPDMAUDIODEVICE pDstDev = DrvAudioHlpDeviceDup(pSrcDev, fCopyUserData);
+        if (!pDstDev)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+        rc = DrvAudioHlpDeviceEnumAdd(pDstDevEnm, pDstDev);
+        if (RT_FAILURE(rc))
+            break;
+    }
+
+    return rc;
+}
+
+/**
+ * Copies all device enumeration entries from the source to the destination enumeration.
+ *
+ * Note: Does *not* copy the user-specific data assigned to a device enumeration entry.
+ *       To do so, use DrvAudioHlpDeviceEnumCopyEx().
+ *
+ * @returns IPRT status code.
+ * @param   pDstDevEnm          Destination enumeration to store enumeration entries into.
+ * @param   pSrcDevEnm          Source enumeration to use.
+ */
+int DrvAudioHlpDeviceEnumCopy(PPDMAUDIODEVICEENUM pDstDevEnm, PPDMAUDIODEVICEENUM pSrcDevEnm)
+{
+    return DrvAudioHlpDeviceEnumCopyEx(pDstDevEnm, pSrcDevEnm, PDMAUDIODIR_ANY, false /* fCopyUserData */);
 }
 

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

@@ -86 +86 @@
     /** Pointer to driver instance this device is bound to. */
     PDRVHOSTCOREAUDIO pDrv;
-    /** The audio device ID of the currently used device. */
+    /** The audio device ID of the currently used device (UInt32 typedef). */
     AudioDeviceID     deviceID;
     /** List of attached (native) Core Audio streams attached to this device. */
@@ -395 +395 @@
     /** The device is currently uninitializing. */
     COREAUDIOSTATUS_IN_UNINIT,
-    /* The device has to be reinitialized */
+#ifndef VBOX_WITH_AUDIO_CALLBACKS
+    /** The device has to be reinitialized.
+     *  Note: Only needed if VBOX_WITH_AUDIO_CALLBACKS is not defined, as otherwise
+     *        the Audio Connector will take care of this as soon as this backend
+     *        tells it to do so via the provided audio callback. */
     COREAUDIOSTATUS_REINIT,
+#endif
     /** The usual 32-bit hack. */
     COREAUDIOSTATUS_32BIT_HACK = 0x7fffffff
@@ -479 +484 @@
     /** Initialization status tracker. Used when some of the device parameters
      *  or the device itself is changed during the runtime. */
-    volatile uint32_t       status;
+    volatile uint32_t       enmStatus;
     /** An internal ring buffer for transferring data from/to the rendering callbacks. */
     PRTCIRCBUF              pCircBuf;
@@ -485 +490 @@
 
 static int coreAudioStreamInit(PCOREAUDIOSTREAM pCAStream, PDRVHOSTCOREAUDIO pThis, PPDMAUDIODEVICE pDev);
+#ifndef VBOX_WITH_AUDIO_CALLBACKS
 static int coreAudioStreamReinit(PDRVHOSTCOREAUDIO pThis, PCOREAUDIOSTREAM pCAStream, PPDMAUDIODEVICE pDev);
+#endif
 static int coreAudioStreamUninit(PCOREAUDIOSTREAM pCAStream);
 
@@ -729 +736 @@
                 }
 
+                LogFunc(("Device '%s': %RU32\n", pszName, curDevID));
+
                 if (pszName)
                 {
@@ -1023 +1032 @@
          * This make sure this thread isn't blocked and the
          * reinitialization is done when necessary only. */
-        ASMAtomicXchgU32(&pCAStream->status, enmSts);
+        ASMAtomicXchgU32(&pCAStream->enmStatus, enmSts);
     }
 
@@ -1099 +1108 @@
     AssertRC(rc2);
 
-    OSStatus err = noErr;
-
     for (UInt32 idxAddress = 0; idxAddress < nAddresses; idxAddress++)
     {
@@ -1128 +1135 @@
         LogFlowFunc(("pDev=%p\n", pDev));
 
+#ifndef VBOX_WITH_AUDIO_CALLBACKS
         if (pDev)
         {
@@ -1138 +1146 @@
             UInt32 uResp = 0;
 
-            err = AudioObjectGetPropertyData(kAudioObjectSystemObject, pProperty, 0, NULL, &uSize, &uResp);
+            OSStatus err = AudioObjectGetPropertyData(kAudioObjectSystemObject, pProperty, 0, NULL, &uSize, &uResp);
             if (err == noErr)
             {
@@ -1148 +1156 @@
             }
         }
+#endif /* VBOX_WITH_AUDIO_CALLBACKS */
     }
 
 #ifdef VBOX_WITH_AUDIO_CALLBACKS
-    if (pThis->pfnCallback)
-        /* Ignore rc */ pThis->pfnCallback(pThis->pDrvIns, PDMAUDIOCBTYPE_DEVICES_CHANGED, NULL, 0);
+    PFNPDMHOSTAUDIOCALLBACK pfnCallback = pThis->pfnCallback;
 #endif
 
+    /* Make sure to leave the critical section before calling the callback. */
     rc2 = RTCritSectLeave(&pThis->CritSect);
     AssertRC(rc2);
 
+#ifdef VBOX_WITH_AUDIO_CALLBACKS
+    if (pfnCallback)
+        /* Ignore rc */ pfnCallback(pThis->pDrvIns, PDMAUDIOCBTYPE_DEVICES_CHANGED, NULL, 0);
+#endif
+
     return noErr;
 }
 
+#ifndef VBOX_WITH_AUDIO_CALLBACKS
 /**
  * Re-initializes a Core Audio stream with a specific audio device and stream configuration.
@@ -1224 +1239 @@
     return rc;
 }
+#endif /* VBOX_WITH_AUDIO_CALLBACKS */
 
 #ifdef VBOX_WITH_AUDIO_CA_CONVERTER
@@ -1335 +1351 @@
     AssertPtr(pStream->Unit.pDevice);
 
-    if (ASMAtomicReadU32(&pStream->status) != COREAUDIOSTATUS_INIT)
+    if (ASMAtomicReadU32(&pStream->enmStatus) != COREAUDIOSTATUS_INIT)
         return noErr;
 
@@ -1699 +1715 @@
 static int coreAudioStreamInit(PCOREAUDIOSTREAM pCAStream, PDRVHOSTCOREAUDIO pThis, PPDMAUDIODEVICE pDev)
 {
+    AssertPtrReturn(pCAStream, VERR_INVALID_POINTER);
+    AssertPtrReturn(pThis,     VERR_INVALID_POINTER);
+    AssertPtrReturn(pDev,      VERR_INVALID_POINTER);
+
     Assert(pCAStream->Unit.pDevice == NULL); /* Make sure no device is assigned yet. */
+
+    AssertPtr(pDev->pvData);
+    Assert(pDev->cbData == sizeof(COREAUDIODEVICEDATA));
+
+    PCOREAUDIODEVICEDATA pData = (PCOREAUDIODEVICEDATA)pDev->pvData;
+
+    LogFunc(("pCAStream=%p, pDev=%p ('%s', ID=%RU32)\n", pCAStream, pDev, pDev->szName, pData->deviceID));
 
     pCAStream->Unit.pDevice = pDev;
@@ -1720 +1747 @@
     OSStatus err = noErr;
 
+    LogFunc(("pCAStream=%p, pCfgReq=%p, pCfgAcq=%p\n", pCAStream, pCfgReq, pCfgAcq));
+
     PPDMAUDIODEVICE pDev = pCAStream->Unit.pDevice;
     AssertPtr(pDev);
@@ -1727 +1756 @@
 
     AudioDeviceID deviceID = pData->deviceID;
+    LogFunc(("deviceID=%RU32\n", deviceID));
     Assert(deviceID != kAudioDeviceUnknown);
 
     do
     {
-        ASMAtomicXchgU32(&pCAStream->status, COREAUDIOSTATUS_IN_INIT);
+        ASMAtomicXchgU32(&pCAStream->enmStatus, COREAUDIOSTATUS_IN_INIT);
 
         /* Get the default frames buffer size, so that we can setup our internal buffers. */
@@ -2070 +2100 @@
         AssertRC(rc);
 
-        ASMAtomicXchgU32(&pCAStream->status, COREAUDIOSTATUS_INIT);
+        ASMAtomicXchgU32(&pCAStream->enmStatus, COREAUDIOSTATUS_INIT);
 
         pCfgAcq->cSampleBufferSize = cSamples;
@@ -2079 +2109 @@
         AssertRC(rc2);
 
-        ASMAtomicXchgU32(&pCAStream->status, COREAUDIOSTATUS_UNINIT);
+        ASMAtomicXchgU32(&pCAStream->enmStatus, COREAUDIOSTATUS_UNINIT);
     }
 
@@ -2094 +2124 @@
     OSStatus err = noErr;
 
+    LogFunc(("pCAStream=%p, pCfgReq=%p, pCfgAcq=%p\n", pCAStream, pCfgReq, pCfgAcq));
+
     PPDMAUDIODEVICE pDev = pCAStream->Unit.pDevice;
     AssertPtr(pDev);
@@ -2101 +2133 @@
 
     AudioDeviceID deviceID = pData->deviceID;
+    LogFunc(("deviceID=%RU32\n", deviceID));
     Assert(deviceID != kAudioDeviceUnknown);
 
     do
     {
-        ASMAtomicXchgU32(&pCAStream->status, COREAUDIOSTATUS_IN_INIT);
+        ASMAtomicXchgU32(&pCAStream->enmStatus, COREAUDIOSTATUS_IN_INIT);
 
         /* Get the default frames buffer size, so that we can setup our internal buffers. */
@@ -2306 +2339 @@
         AssertRC(rc);
 
-        ASMAtomicXchgU32(&pCAStream->status, COREAUDIOSTATUS_INIT);
+        ASMAtomicXchgU32(&pCAStream->enmStatus, COREAUDIOSTATUS_INIT);
 
         pCfgAcq->cSampleBufferSize = cSamples;
@@ -2315 +2348 @@
         AssertRC(rc2);
 
-        ASMAtomicXchgU32(&pCAStream->status, COREAUDIOSTATUS_UNINIT);
+        ASMAtomicXchgU32(&pCAStream->enmStatus, COREAUDIOSTATUS_UNINIT);
     }
 
@@ -2352 +2385 @@
         }
 
-        pCAStream->status = COREAUDIOSTATUS_UNINIT;
+        pCAStream->enmStatus = COREAUDIOSTATUS_UNINIT;
 
         pCAStream->enmDir = PDMAUDIODIR_UNKNOWN;
@@ -2404 +2437 @@
     if (deviceID != kAudioDeviceUnknown)
     {
+        LogFunc(("deviceID=%RU32\n", deviceID));
+
         /*
          * Register device callbacks.
@@ -2457 +2492 @@
     if (deviceID != kAudioDeviceUnknown)
     {
+        LogFunc(("deviceID=%RU32\n", deviceID));
+
         /*
          * Unregister per-device callbacks.
@@ -2516 +2553 @@
         case kAudioDevicePropertyNominalSampleRate:
         {
+#ifndef VBOX_WITH_AUDIO_CALLBACKS
             int rc2 = coreAudioDevicePropagateStatus(pDev, COREAUDIOSTATUS_REINIT);
             AssertRC(rc2);
+#endif
             break;
         }
@@ -2527 +2566 @@
 
     return noErr;
+}
+
+/**
+ * Enumerates all available host audio devices internally.
+ *
+ * @returns IPRT status code.
+ * @param   pThis               Host audio driver instance.
+ */
+static int coreAudioEnumerateDevices(PDRVHOSTCOREAUDIO pThis)
+{
+    LogFlowFuncEnter();
+
+    /*
+     * Unregister old default devices, if any.
+     */
+    if (pThis->pDefaultDevIn)
+    {
+        coreAudioDeviceUnregisterCallbacks(pThis, pThis->pDefaultDevIn);
+        pThis->pDefaultDevIn = NULL;
+    }
+
+    if (pThis->pDefaultDevOut)
+    {
+        coreAudioDeviceUnregisterCallbacks(pThis, pThis->pDefaultDevOut);
+        pThis->pDefaultDevOut = NULL;
+    }
+
+    /* Remove old / stale device entries. */
+    DrvAudioHlpDeviceEnumFree(&pThis->Devices);
+
+    /* Enumerate all devices internally. */
+    int rc = coreAudioDevicesEnumerateAll(pThis, &pThis->Devices);
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Default input device.
+         */
+        pThis->pDefaultDevIn = DrvAudioHlpDeviceEnumGetDefaultDevice(&pThis->Devices, PDMAUDIODIR_IN);
+        if (pThis->pDefaultDevIn)
+        {
+            LogRel2(("CoreAudio: Default capturing device is '%s'\n", pThis->pDefaultDevIn->szName));
+
+#ifdef DEBUG
+            PCOREAUDIODEVICEDATA pDevData = (PCOREAUDIODEVICEDATA)pThis->pDefaultDevIn->pvData;
+            AssertPtr(pDevData);
+            LogFunc(("pDefaultDevIn=%p, ID=%RU32\n", pThis->pDefaultDevIn, pDevData->deviceID));
+#endif
+            rc = coreAudioDeviceRegisterCallbacks(pThis, pThis->pDefaultDevIn);
+        }
+        else
+            LogRel2(("CoreAudio: No default capturing device found\n"));
+
+        /*
+         * Default output device.
+         */
+        pThis->pDefaultDevOut = DrvAudioHlpDeviceEnumGetDefaultDevice(&pThis->Devices, PDMAUDIODIR_OUT);
+        if (pThis->pDefaultDevOut)
+        {
+            LogRel2(("CoreAudio: Default playback device is '%s'\n", pThis->pDefaultDevOut->szName));
+
+#ifdef DEBUG
+            PCOREAUDIODEVICEDATA pDevData = (PCOREAUDIODEVICEDATA)pThis->pDefaultDevOut->pvData;
+            AssertPtr(pDevData);
+            LogFunc(("pDefaultDevOut=%p, ID=%RU32\n", pThis->pDefaultDevOut, pDevData->deviceID));
+#endif
+            rc = coreAudioDeviceRegisterCallbacks(pThis, pThis->pDefaultDevOut);
+        }
+        else
+            LogRel2(("CoreAudio: No default playback device found\n"));
+    }
+
+    LogFunc(("Returning %Rrc\n", rc));
+    return rc;
 }
 
@@ -2547 +2659 @@
     AssertPtr(pStream->Unit.pDevice);
 
-    if (ASMAtomicReadU32(&pStream->status) != COREAUDIOSTATUS_INIT)
+    if (ASMAtomicReadU32(&pStream->enmStatus) != COREAUDIOSTATUS_INIT)
     {
         pBufData->mBuffers[0].mDataByteSize = 0;
@@ -2617 +2729 @@
     /* pcbRead is optional. */
 
+    PCOREAUDIOSTREAM  pCAStream = (PCOREAUDIOSTREAM)pStream;
     PDRVHOSTCOREAUDIO pThis     = PDMIHOSTAUDIO_2_DRVHOSTCOREAUDIO(pInterface);
-    PCOREAUDIOSTREAM  pCAStream = (PCOREAUDIOSTREAM)pStream;
-
+
+#ifndef VBOX_WITH_AUDIO_CALLBACKS
     /* Check if the audio device should be reinitialized. If so do it. */
-    if (ASMAtomicReadU32(&pCAStream->status) == COREAUDIOSTATUS_REINIT)
+    if (ASMAtomicReadU32(&pCAStream->enmStatus) == COREAUDIOSTATUS_REINIT)
     {
         /* For now re just re-initialize with the current input device. */
@@ -2633 +2746 @@
             return VERR_NOT_AVAILABLE;
     }
-
-    if (ASMAtomicReadU32(&pCAStream->status) != COREAUDIOSTATUS_INIT)
+#else
+    RT_NOREF(pThis);
+#endif
+
+    if (ASMAtomicReadU32(&pCAStream->enmStatus) != COREAUDIOSTATUS_INIT)
     {
         if (pcbRead)
@@ -2734 +2850 @@
     PCOREAUDIOSTREAM  pCAStream = (PCOREAUDIOSTREAM)pStream;
 
+#ifndef VBOX_WITH_AUDIO_CALLBACKS
     /* Check if the audio device should be reinitialized. If so do it. */
-    if (ASMAtomicReadU32(&pCAStream->status) == COREAUDIOSTATUS_REINIT)
+    if (ASMAtomicReadU32(&pCAStream->enmStatus) == COREAUDIOSTATUS_REINIT)
     {
         if (pThis->pDefaultDevOut)
@@ -2747 +2864 @@
             return VERR_NOT_AVAILABLE;
     }
+#else
+    RT_NOREF(pThis);
+#endif
 
     uint32_t cLive = AudioMixBufLive(&pStream->MixBuf);
@@ -2819 +2939 @@
     RT_NOREF(pThis);
 
-    LogFlowFunc(("enmStreamCmd=%RU32\n", enmStreamCmd));
-
-    uint32_t uStatus = ASMAtomicReadU32(&pCAStream->status);
-    if (!(   uStatus == COREAUDIOSTATUS_INIT
-          || uStatus == COREAUDIOSTATUS_REINIT))
+    uint32_t enmStatus = ASMAtomicReadU32(&pCAStream->enmStatus);
+
+    LogFlowFunc(("enmStreamCmd=%RU32, enmStatus=%RU32\n", enmStreamCmd, enmStatus));
+
+    if (!(   enmStatus == COREAUDIOSTATUS_INIT
+#ifndef VBOX_WITH_AUDIO_CALLBACKS
+          || enmStatus == COREAUDIOSTATUS_REINIT
+#endif
+          ))
     {
         return VINF_SUCCESS;
@@ -2923 +3047 @@
     PDRVHOSTCOREAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTCOREAUDIO(pInterface);
 
-    return coreAudioDevicesEnumerateAll(pThis, pDeviceEnum);
+    int rc = RTCritSectEnter(&pThis->CritSect);
+    if (RT_SUCCESS(rc))
+    {
+        rc = coreAudioEnumerateDevices(pThis);
+        if (RT_SUCCESS(rc))
+        {
+            if (pDeviceEnum)
+            {
+                rc = DrvAudioHlpDeviceEnumInit(pDeviceEnum);
+                if (RT_SUCCESS(rc))
+                    rc = DrvAudioHlpDeviceEnumCopy(pDeviceEnum, &pThis->Devices);
+
+                if (RT_FAILURE(rc))
+                    DrvAudioHlpDeviceEnumFree(pDeviceEnum);
+            }
+        }
+
+        int rc2 = RTCritSectLeave(&pThis->CritSect);
+        AssertRC(rc2);
+    }
+
+    LogFlowFunc(("Returning %Rrc\n", rc));
+    return rc;
 }
 
@@ -2990 +3136 @@
     Assert(pStream->enmCtx == PDMAUDIOSTREAMCTX_HOST);
 
-    PCOREAUDIOSTREAM  pCAStream = (PCOREAUDIOSTREAM)pStream;
+    PCOREAUDIOSTREAM pCAStream = (PCOREAUDIOSTREAM)pStream;
 
     int rc;
@@ -3000 +3146 @@
     PPDMAUDIODEVICE pDev = fIn ? pThis->pDefaultDevIn : pThis->pDefaultDevOut;
 
-    /* Init the Core Audio stream. */
-    rc = coreAudioStreamInit(pCAStream, pThis, pDev);
-    if (RT_SUCCESS(rc))
-    {
-        if (pDev) /* (Default) device available? */
+    LogFunc(("pStream=%p, pCfgReq=%p, pCfgAcq=%p, fIn=%RTbool, pDev=%p\n", pStream, pCfgReq, pCfgAcq, fIn, pDev));
+
+    if (pDev) /* (Default) device available? */
+    {
+        /* Init the Core Audio stream. */
+        rc = coreAudioStreamInit(pCAStream, pThis, pDev);
+        if (RT_SUCCESS(rc))
         {
             /* Sanity. */
@@ -3024 +3172 @@
             }
         }
-        else
-            rc = VERR_NOT_AVAILABLE;
+    }
+    else
+        rc = VERR_NOT_AVAILABLE;
+
+    LogFunc(("Returning %Rrc\n", rc));
+    return rc;
+}
+
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO, pfnStreamDestroy}
+ */
+static DECLCALLBACK(int) drvHostCoreAudioStreamDestroy(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
+{
+    AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
+    AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
+
+    PDRVHOSTCOREAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTCOREAUDIO(pInterface);
+
+    Assert(pStream->enmCtx == PDMAUDIOSTREAMCTX_HOST);
+
+    PCOREAUDIOSTREAM pCAStream = (PCOREAUDIOSTREAM)pStream;
+
+    uint32_t status = ASMAtomicReadU32(&pCAStream->enmStatus);
+    if (!(   status == COREAUDIOSTATUS_INIT
+#ifndef VBOX_WITH_AUDIO_CALLBACKS
+          || status == COREAUDIOSTATUS_REINIT
+#endif
+          ))
+    {
+        return VINF_SUCCESS;
+    }
+
+    int rc = coreAudioStreamControl(pThis, pCAStream, PDMAUDIOSTREAMCMD_DISABLE);
+    if (RT_SUCCESS(rc))
+    {
+        ASMAtomicXchgU32(&pCAStream->enmStatus, COREAUDIOSTATUS_IN_UNINIT);
+
+        rc = coreAudioStreamUninit(pCAStream);
+        if (RT_SUCCESS(rc))
+            ASMAtomicXchgU32(&pCAStream->enmStatus, COREAUDIOSTATUS_UNINIT);
     }
 
@@ -3034 +3221 @@
 
 /**
- * @interface_method_impl{PDMIHOSTAUDIO, pfnStreamDestroy}
- */
-static DECLCALLBACK(int) drvHostCoreAudioStreamDestroy(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
+ * @interface_method_impl{PDMIHOSTAUDIO, pfnStreamControl}
+ */
+static DECLCALLBACK(int) drvHostCoreAudioStreamControl(PPDMIHOSTAUDIO pInterface,
+                                                       PPDMAUDIOSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
@@ -3047 +3235 @@
     PCOREAUDIOSTREAM pCAStream = (PCOREAUDIOSTREAM)pStream;
 
-    uint32_t status = ASMAtomicReadU32(&pCAStream->status);
-    if (!(   status == COREAUDIOSTATUS_INIT
-          || status == COREAUDIOSTATUS_REINIT))
-    {
-        return VINF_SUCCESS;
-    }
-
-    int rc = coreAudioStreamControl(pThis, pCAStream, PDMAUDIOSTREAMCMD_DISABLE);
-    if (RT_SUCCESS(rc))
-    {
-        ASMAtomicXchgU32(&pCAStream->status, COREAUDIOSTATUS_IN_UNINIT);
-
-        rc = coreAudioStreamUninit(pCAStream);
-        if (RT_SUCCESS(rc))
-            ASMAtomicXchgU32(&pCAStream->status, COREAUDIOSTATUS_UNINIT);
-    }
-
-    LogFlowFunc(("%s: rc=%Rrc\n", pStream->szName, rc));
-    return rc;
-}
-
-
-/**
- * @interface_method_impl{PDMIHOSTAUDIO, pfnStreamControl}
- */
-static DECLCALLBACK(int) drvHostCoreAudioStreamControl(PPDMIHOSTAUDIO pInterface,
-                                                       PPDMAUDIOSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd)
+    return coreAudioStreamControl(pThis, pCAStream, enmStreamCmd);
+}
+
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO, pfnStreamGetStatus}
+ */
+static DECLCALLBACK(PDMAUDIOSTRMSTS) drvHostCoreAudioStreamGetStatus(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
+{
+    RT_NOREF(pInterface);
+    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
+
+    Assert(pStream->enmCtx == PDMAUDIOSTREAMCTX_HOST);
+
+    PDMAUDIOSTRMSTS strmSts = PDMAUDIOSTRMSTS_FLAG_NONE;
+
+    PCOREAUDIOSTREAM pCAStream = (PCOREAUDIOSTREAM)pStream;
+
+    if (ASMAtomicReadU32(&pCAStream->enmStatus) == COREAUDIOSTATUS_INIT)
+        strmSts |= PDMAUDIOSTRMSTS_FLAG_INITIALIZED | PDMAUDIOSTRMSTS_FLAG_ENABLED;
+
+    if (pStream->enmDir == PDMAUDIODIR_IN)
+    {
+        if (strmSts & PDMAUDIOSTRMSTS_FLAG_ENABLED)
+            strmSts |= PDMAUDIOSTRMSTS_FLAG_DATA_READABLE;
+    }
+    else if (pStream->enmDir == PDMAUDIODIR_OUT)
+    {
+        if (strmSts & PDMAUDIOSTRMSTS_FLAG_ENABLED)
+            strmSts |= PDMAUDIOSTRMSTS_FLAG_DATA_WRITABLE;
+    }
+    else
+        AssertFailed();
+
+    return strmSts;
+}
+
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO, pfnStreamIterate}
+ */
+static DECLCALLBACK(int) drvHostCoreAudioStreamIterate(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
     AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
 
-    PDRVHOSTCOREAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTCOREAUDIO(pInterface);
-
-    Assert(pStream->enmCtx == PDMAUDIOSTREAMCTX_HOST);
-
-    PCOREAUDIOSTREAM pCAStream = (PCOREAUDIOSTREAM)pStream;
-
-    return coreAudioStreamControl(pThis, pCAStream, enmStreamCmd);
-}
-
-
-/**
- * @interface_method_impl{PDMIHOSTAUDIO, pfnStreamGetStatus}
- */
-static DECLCALLBACK(PDMAUDIOSTRMSTS) drvHostCoreAudioStreamGetStatus(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
-{
-    RT_NOREF(pInterface);
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-
-    Assert(pStream->enmCtx == PDMAUDIOSTREAMCTX_HOST);
-
-    PDMAUDIOSTRMSTS strmSts = PDMAUDIOSTRMSTS_FLAG_NONE;
-
-    PCOREAUDIOSTREAM pCAStream = (PCOREAUDIOSTREAM)pStream;
-
-    if (ASMAtomicReadU32(&pCAStream->status) == COREAUDIOSTATUS_INIT)
-        strmSts |= PDMAUDIOSTRMSTS_FLAG_INITIALIZED | PDMAUDIOSTRMSTS_FLAG_ENABLED;
-
-    if (pStream->enmDir == PDMAUDIODIR_IN)
-    {
-        if (strmSts & PDMAUDIOSTRMSTS_FLAG_ENABLED)
-            strmSts |= PDMAUDIOSTRMSTS_FLAG_DATA_READABLE;
-    }
-    else if (pStream->enmDir == PDMAUDIODIR_OUT)
-    {
-        if (strmSts & PDMAUDIOSTRMSTS_FLAG_ENABLED)
-            strmSts |= PDMAUDIOSTRMSTS_FLAG_DATA_WRITABLE;
-    }
-    else
-        AssertFailed();
-
-    return strmSts;
-}
-
-
-/**
- * @interface_method_impl{PDMIHOSTAUDIO, pfnStreamIterate}
- */
-static DECLCALLBACK(int) drvHostCoreAudioStreamIterate(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
-{
-    AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
-    AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
-
     /* Nothing to do here for Core Audio. */
     return VINF_SUCCESS;
@@ -3145 +3296 @@
     if (RT_SUCCESS(rc))
     {
-        /* Enumerate all devices internally. */
-        rc = coreAudioDevicesEnumerateAll(pThis, &pThis->Devices);
-        if (RT_SUCCESS(rc))
-        {
-            if (pThis->pDefaultDevIn)
-                coreAudioDeviceUnregisterCallbacks(pThis, pThis->pDefaultDevIn);
-
-            pThis->pDefaultDevIn  = DrvAudioHlpDeviceEnumGetDefaultDevice(&pThis->Devices, PDMAUDIODIR_IN);
-            if (pThis->pDefaultDevIn)
-            {
-#ifdef DEBUG
-                PCOREAUDIODEVICEDATA pDevData = (PCOREAUDIODEVICEDATA)pThis->pDefaultDevIn;
-                AssertPtr(pDevData);
-                LogFunc(("defaultDevIn ID=%RU32\n", pDevData->deviceID));
-#endif
-                rc = coreAudioDeviceRegisterCallbacks(pThis, pThis->pDefaultDevIn);
-            }
-            else
-                LogRel2(("CoreAudio: No initial default capturing device found!\n"));
-
-            if (pThis->pDefaultDevOut)
-                coreAudioDeviceUnregisterCallbacks(pThis, pThis->pDefaultDevOut);
-
-            pThis->pDefaultDevOut = DrvAudioHlpDeviceEnumGetDefaultDevice(&pThis->Devices, PDMAUDIODIR_OUT);
-            if (pThis->pDefaultDevOut)
-            {
-#ifdef DEBUG
-                PCOREAUDIODEVICEDATA pDevData = (PCOREAUDIODEVICEDATA)pThis->pDefaultDevOut;
-                AssertPtr(pDevData);
-
-                LogFunc(("defaultDevOut ID=%RU32\n", pDevData->deviceID));
-#endif
-                rc = coreAudioDeviceRegisterCallbacks(pThis, pThis->pDefaultDevOut);
-            }
-            else
-                LogRel2(("CoreAudio: No initial default playback device found!\n"));
-        }
+        /* Do the first (initial) internal device enumeration. */
+        rc = coreAudioEnumerateDevices(pThis);
     }