Changeset 63360 in vbox

Timestamp:

Aug 12, 2016 1:58:38 PM (8 years ago)

Author:

vboxsync

Message:

Audio: Added more defines / documentation for the host interfaces to keep the maintenance effort to a minimum in the future, misc. cleanup.

Location:

trunk

Files:

• include/VBox/vmm/pdmaudioifs.h (modified) (8 diffs)
• src/VBox/Devices/Audio/DrvAudio.cpp (modified) (3 diffs)
• src/VBox/Devices/Audio/DrvHostALSAAudio.cpp (modified) (42 diffs)
• src/VBox/Devices/Audio/DrvHostCoreAudio.cpp (modified) (25 diffs)
• src/VBox/Devices/Audio/DrvHostDSound.cpp (modified) (48 diffs)
• src/VBox/Devices/Audio/DrvHostDebugAudio.cpp (modified) (11 diffs)
• src/VBox/Devices/Audio/DrvHostNullAudio.cpp (modified) (13 diffs)
• src/VBox/Devices/Audio/DrvHostOSSAudio.cpp (modified) (36 diffs)
• src/VBox/Devices/Audio/DrvHostPulseAudio.cpp (modified) (40 diffs)
• src/VBox/Main/src-client/DrvAudioVRDE.cpp (modified) (24 diffs)

trunk/include/VBox/vmm/pdmaudioifs.h

@@ -262 +262 @@
     /** @todo Use RT_LE2H_*? */
     PDMAUDIOENDIANNESS       enmEndianness;
+    /** Size of audio sample buffer. */
+    uint32_t                 cSamples;
 } PDMAUDIOSTREAMCFG, *PPDMAUDIOSTREAMCFG;
 
@@ -904 +906 @@
  * Assigns all needed interface callbacks for an audio backend.
  *
- * @param   a_NamePrefix        The function name prefix.
- */
-#define PDMAUDIO_IHOSTAUDIO_CALLBACKS(a_NamePrefix) \
+ * @param   a_Prefix        The function name prefix.
+ */
+#define PDMAUDIO_IHOSTAUDIO_CALLBACKS(a_Prefix) \
     do { \
-        pThis->IHostAudio.pfnInit            = RT_CONCAT(a_NamePrefix,Init); \
-        pThis->IHostAudio.pfnShutdown        = RT_CONCAT(a_NamePrefix,Shutdown); \
-        pThis->IHostAudio.pfnGetConfig       = RT_CONCAT(a_NamePrefix,GetConfig); \
-        pThis->IHostAudio.pfnGetStatus       = RT_CONCAT(a_NamePrefix,GetStatus); \
-        pThis->IHostAudio.pfnStreamCreate    = RT_CONCAT(a_NamePrefix,StreamCreate); \
-        pThis->IHostAudio.pfnStreamDestroy   = RT_CONCAT(a_NamePrefix,StreamDestroy); \
-        pThis->IHostAudio.pfnStreamControl   = RT_CONCAT(a_NamePrefix,StreamControl); \
-        pThis->IHostAudio.pfnStreamGetStatus = RT_CONCAT(a_NamePrefix,StreamGetStatus); \
-        pThis->IHostAudio.pfnStreamIterate   = RT_CONCAT(a_NamePrefix,StreamIterate); \
-        pThis->IHostAudio.pfnStreamPlay      = RT_CONCAT(a_NamePrefix,StreamPlay); \
-        pThis->IHostAudio.pfnStreamCapture   = RT_CONCAT(a_NamePrefix,StreamCapture); \
+        pThis->IHostAudio.pfnInit            = RT_CONCAT(a_Prefix,Init); \
+        pThis->IHostAudio.pfnShutdown        = RT_CONCAT(a_Prefix,Shutdown); \
+        pThis->IHostAudio.pfnGetConfig       = RT_CONCAT(a_Prefix,GetConfig); \
+        pThis->IHostAudio.pfnGetStatus       = RT_CONCAT(a_Prefix,GetStatus); \
+        pThis->IHostAudio.pfnStreamCreate    = RT_CONCAT(a_Prefix,StreamCreate); \
+        pThis->IHostAudio.pfnStreamDestroy   = RT_CONCAT(a_Prefix,StreamDestroy); \
+        pThis->IHostAudio.pfnStreamControl   = RT_CONCAT(a_Prefix,StreamControl); \
+        pThis->IHostAudio.pfnStreamGetStatus = RT_CONCAT(a_Prefix,StreamGetStatus); \
+        pThis->IHostAudio.pfnStreamIterate   = RT_CONCAT(a_Prefix,StreamIterate); \
+        pThis->IHostAudio.pfnStreamPlay      = RT_CONCAT(a_Prefix,StreamPlay); \
+        pThis->IHostAudio.pfnStreamCapture   = RT_CONCAT(a_Prefix,StreamCapture); \
     } while (0)
+
+#define PDMAUDIO_IHOSTAUDIO_FN_RET_INIT    int
+#define PDMAUDIO_IHOSTAUDIO_FN_PARAMS_INIT (PPDMIHOSTAUDIO pInterface)
+
+#define PDMAUDIO_IHOSTAUDIO_FN_RET_SHUTDOWN    void
+#define PDMAUDIO_IHOSTAUDIO_FN_PARAMS_SHUTDOWN (PPDMIHOSTAUDIO pInterface)
+
+#define PDMAUDIO_IHOSTAUDIO_FN_RET_GETCONFIG    int
+#define PDMAUDIO_IHOSTAUDIO_FN_PARAMS_GETCONFIG (PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDCFG pBackendCfg)
+
+#define PDMAUDIO_IHOSTAUDIO_FN_RET_GETSTATUS    PDMAUDIOBACKENDSTS
+#define PDMAUDIO_IHOSTAUDIO_FN_PARAMS_GETSTATUS (PPDMIHOSTAUDIO pInterface, PDMAUDIODIR enmDir)
+
+#define PDMAUDIO_IHOSTAUDIO_FN_RET_STREAMCREATE    int
+#define PDMAUDIO_IHOSTAUDIO_FN_PARAMS_STREAMCREATE (PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
+
+#define PDMAUDIO_IHOSTAUDIO_FN_RET_STREAMDESTROY    int
+#define PDMAUDIO_IHOSTAUDIO_FN_PARAMS_STREAMDESTROY (PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
+
+#define PDMAUDIO_IHOSTAUDIO_FN_RET_STREAMCONTROL    int
+#define PDMAUDIO_IHOSTAUDIO_FN_PARAMS_STREAMCONTROL (PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd)
+
+#define PDMAUDIO_IHOSTAUDIO_FN_RET_STREAMGETSTATUS    PDMAUDIOSTRMSTS
+#define PDMAUDIO_IHOSTAUDIO_FN_PARAMS_STREAMGETSTATUS (PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
+
+#define PDMAUDIO_IHOSTAUDIO_FN_RET_STREAMITERATE    int
+#define PDMAUDIO_IHOSTAUDIO_FN_PARAMS_STREAMITERATE (PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
+
+#define PDMAUDIO_IHOSTAUDIO_FN_RET_STREAMPLAY    int
+#define PDMAUDIO_IHOSTAUDIO_FN_PARAMS_STREAMPLAY (PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream, const void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten)
+
+#define PDMAUDIO_IHOSTAUDIO_FN_RET_STREAMCAPTURE    int
+#define PDMAUDIO_IHOSTAUDIO_FN_PARAMS_STREAMCAPTURE (PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead)
+
+#define PDMAUDIO_IHOSTAUDIO_DEF_FN(a_Prefix, a_Func) \
+    static DECLCALLBACK(PDMAUDIO_IHOSTAUDIO_FN_RET_##a_Func) a_Prefix PDMAUDIO_IHOSTAUDIO_FN_PARAMS_##a_Func
+
+#define PDMAUDIO_IHOSTAUDIO_EMIT_INIT(a_Prefix)            PDMAUDIO_IHOSTAUDIO_DEF_FN(RT_CONCAT(a_Prefix, Init),            INIT)
+#define PDMAUDIO_IHOSTAUDIO_EMIT_SHUTDOWN(a_Prefix)        PDMAUDIO_IHOSTAUDIO_DEF_FN(RT_CONCAT(a_Prefix, Shutdown),        SHUTDOWN)
+#define PDMAUDIO_IHOSTAUDIO_EMIT_GETCONFIG(a_Prefix)       PDMAUDIO_IHOSTAUDIO_DEF_FN(RT_CONCAT(a_Prefix, GetConfig),       GETCONFIG)
+#define PDMAUDIO_IHOSTAUDIO_EMIT_GETSTATUS(a_Prefix)       PDMAUDIO_IHOSTAUDIO_DEF_FN(RT_CONCAT(a_Prefix, GetStatus),       GETSTATUS)
+#define PDMAUDIO_IHOSTAUDIO_EMIT_STREAMCREATE(a_Prefix)    PDMAUDIO_IHOSTAUDIO_DEF_FN(RT_CONCAT(a_Prefix, StreamCreate),    STREAMCREATE)
+#define PDMAUDIO_IHOSTAUDIO_EMIT_STREAMDESTROY(a_Prefix)   PDMAUDIO_IHOSTAUDIO_DEF_FN(RT_CONCAT(a_Prefix, StreamDestroy),   STREAMDESTROY)
+#define PDMAUDIO_IHOSTAUDIO_EMIT_STREAMCONTROL(a_Prefix)   PDMAUDIO_IHOSTAUDIO_DEF_FN(RT_CONCAT(a_Prefix, StreamControl),   STREAMCONTROL)
+#define PDMAUDIO_IHOSTAUDIO_EMIT_STREAMGETSTATUS(a_Prefix) PDMAUDIO_IHOSTAUDIO_DEF_FN(RT_CONCAT(a_Prefix, StreamGetStatus), STREAMGETSTATUS)
+#define PDMAUDIO_IHOSTAUDIO_EMIT_STREAMITERATE(a_Prefix)   PDMAUDIO_IHOSTAUDIO_DEF_FN(RT_CONCAT(a_Prefix, StreamIterate),   STREAMITERATE)
+#define PDMAUDIO_IHOSTAUDIO_EMIT_STREAMPLAY(a_Prefix)      PDMAUDIO_IHOSTAUDIO_DEF_FN(RT_CONCAT(a_Prefix, StreamPlay),      STREAMPLAY)
+#define PDMAUDIO_IHOSTAUDIO_EMIT_STREAMCAPTURE(a_Prefix)   PDMAUDIO_IHOSTAUDIO_DEF_FN(RT_CONCAT(a_Prefix, StreamCapture),   STREAMCAPTURE)
 
 /** Pointer to a host audio interface. */
@@ -934 +984 @@
      * @param   pInterface          Pointer to the interface structure containing the called function pointer.
      */
-    DECLR3CALLBACKMEMBER(int, pfnInit, (PPDMIHOSTAUDIO pInterface));
+    DECLR3CALLBACKMEMBER(PDMAUDIO_IHOSTAUDIO_FN_RET_INIT, pfnInit, PDMAUDIO_IHOSTAUDIO_FN_PARAMS_INIT);
 
     /**
@@ -942 +992 @@
      * @param   pInterface          Pointer to the interface structure containing the called function pointer.
      */
-    DECLR3CALLBACKMEMBER(void, pfnShutdown, (PPDMIHOSTAUDIO pInterface));
+    DECLR3CALLBACKMEMBER(PDMAUDIO_IHOSTAUDIO_FN_RET_SHUTDOWN, pfnShutdown, PDMAUDIO_IHOSTAUDIO_FN_PARAMS_SHUTDOWN);
 
     /**
@@ -951 +1001 @@
      * @param   pBackendCfg         Pointer where to store the backend audio configuration to.
      */
-    DECLR3CALLBACKMEMBER(int, pfnGetConfig, (PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDCFG pBackendCfg));
+    DECLR3CALLBACKMEMBER(PDMAUDIO_IHOSTAUDIO_FN_RET_GETCONFIG, pfnGetConfig, PDMAUDIO_IHOSTAUDIO_FN_PARAMS_GETCONFIG);
 
     /**
@@ -960 +1010 @@
      * @param   enmDir              Audio direction to get status for. Pass PDMAUDIODIR_ANY for overall status.
      */
-    DECLR3CALLBACKMEMBER(PDMAUDIOBACKENDSTS, pfnGetStatus, (PPDMIHOSTAUDIO pInterface, PDMAUDIODIR enmDir));
-
-    /**
-     * Creates an audio stream.
+    DECLR3CALLBACKMEMBER(PDMAUDIO_IHOSTAUDIO_FN_RET_GETSTATUS, pfnGetStatus, PDMAUDIO_IHOSTAUDIO_FN_PARAMS_GETSTATUS);
+
+    /**
+     * Creates an audio stream using the requested stream configuration.
+     * If a backend is not able to create this configuration, it will return its best match in the acquired configuration
+     * structure on success.
      *
      * @returns VBox status code.
      * @param   pInterface          Pointer to the interface structure containing the called function pointer.
      * @param   pStream             Pointer to audio stream.
-     * @param   pStreamCfg          Pointer to stream configuration.
-     * @param   pcSamples           Returns how many samples the backend can handle. Optional.
-     */
-    DECLR3CALLBACKMEMBER(int, pfnStreamCreate, (PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg, uint32_t *pcSamples));
+     * @param   pCfgReq             Pointer to requested stream configuration.
+     * @param   pCfgAcq             Pointer to acquired stream configuration.
+     */
+    DECLR3CALLBACKMEMBER(PDMAUDIO_IHOSTAUDIO_FN_RET_STREAMCREATE, pfnStreamCreate, PDMAUDIO_IHOSTAUDIO_FN_PARAMS_STREAMCREATE);
 
     /**
@@ -980 +1032 @@
      * @param   pStream             Pointer to audio stream.
      */
-    DECLR3CALLBACKMEMBER(int, pfnStreamDestroy, (PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream));
+    DECLR3CALLBACKMEMBER(PDMAUDIO_IHOSTAUDIO_FN_RET_STREAMDESTROY, pfnStreamDestroy, PDMAUDIO_IHOSTAUDIO_FN_PARAMS_STREAMDESTROY);
 
     /**
@@ -990 +1042 @@
      * @param   enmStreamCmd        The stream command to issue.
      */
-    DECLR3CALLBACKMEMBER(int, pfnStreamControl, (PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd));
+    DECLR3CALLBACKMEMBER(PDMAUDIO_IHOSTAUDIO_FN_RET_STREAMCONTROL, pfnStreamControl, PDMAUDIO_IHOSTAUDIO_FN_PARAMS_STREAMCONTROL);
 
     /**
      * Returns whether the specified audio direction in the backend is enabled or not.
      *
+     * @returns PDMAUDIOSTRMSTS
      * @param   pInterface          Pointer to the interface structure containing the called function pointer.
      * @param   enmDir              Audio direction to check status for.
      */
-    DECLR3CALLBACKMEMBER(PDMAUDIOSTRMSTS, pfnStreamGetStatus, (PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream));
-
-    /**
-     ** @todo Docs!
-     */
-    DECLR3CALLBACKMEMBER(int, pfnStreamIterate, (PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream));
-
-    /**
-     * Plays an audio (output) stream.
+    DECLR3CALLBACKMEMBER(PDMAUDIO_IHOSTAUDIO_FN_RET_STREAMGETSTATUS, pfnStreamGetStatus, PDMAUDIO_IHOSTAUDIO_FN_PARAMS_STREAMGETSTATUS);
+
+    /**
+     * Gives the host backend the chance to do some (necessary) iteration work.
      *
      * @returns VBox status code.
      * @param   pInterface          Pointer to the interface structure containing the called function pointer.
      * @param   pStream             Pointer to audio stream.
-     * @param   pcSamplesPlayed     Pointer to number of samples captured.
-     */
-    DECLR3CALLBACKMEMBER(int, pfnStreamPlay, (PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream, uint32_t *pcSamplesPlayed));
-
-    /**
-     * Captures an audio (input) stream.
+     */
+    DECLR3CALLBACKMEMBER(PDMAUDIO_IHOSTAUDIO_FN_RET_STREAMITERATE, pfnStreamIterate, PDMAUDIO_IHOSTAUDIO_FN_PARAMS_STREAMITERATE);
+
+    /**
+     * Plays (writes to) an audio (output) stream.
      *
      * @returns VBox status code.
      * @param   pInterface          Pointer to the interface structure containing the called function pointer.
      * @param   pStream             Pointer to audio stream.
-     * @param   pcSamplesCaptured   Pointer to number of samples captured.
-     */
-    DECLR3CALLBACKMEMBER(int, pfnStreamCapture, (PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream, uint32_t *pcSamplesCaptured));
+     * @param   pvBuf               Pointer to audio data buffer to play.
+     * @param   cbBuf               Size (in bytes) of audio data buffer.
+     * @param   pcbWritten          Returns number of bytes written. Optional.
+     */
+    DECLR3CALLBACKMEMBER(PDMAUDIO_IHOSTAUDIO_FN_RET_STREAMPLAY, pfnStreamPlay, PDMAUDIO_IHOSTAUDIO_FN_PARAMS_STREAMPLAY);
+
+    /**
+     * Captures (reads from) an audio (input) stream.
+     *
+     * @returns VBox status code.
+     * @param   pInterface          Pointer to the interface structure containing the called function pointer.
+     * @param   pStream             Pointer to audio stream.
+     * @param   pvBuf               Buffer where to store read audio data.
+     * @param   cbBuf               Size (in bytes) of buffer.
+     * @param   pcbRead             Returns number of bytes read. Optional.
+     */
+    DECLR3CALLBACKMEMBER(PDMAUDIO_IHOSTAUDIO_FN_RET_STREAMCAPTURE, pfnStreamCapture, PDMAUDIO_IHOSTAUDIO_FN_PARAMS_STREAMCAPTURE);
 
 } PDMIHOSTAUDIO;
 
 /** PDMIHOSTAUDIO interface ID. */
-#define PDMIHOSTAUDIO_IID                           "96AC69D0-F301-42AC-8F1D-1E19BA808887"
+#define PDMIHOSTAUDIO_IID                           "C3B069D4-0543-474B-AE81-769B3E8F40DA"
 
 /** @} */

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

@@ -521 +521 @@
      */
 
+    /* Make the acquired host configuration the requested host configuration by default. */
+    PDMAUDIOSTREAMCFG CfgAcq;
+    memcpy(&CfgAcq, pCfgHost, sizeof(PDMAUDIOSTREAMCFG));
+
     uint32_t cSamples = 0;
-    int rc = pThis->pHostDrvAudio->pfnStreamCreate(pThis->pHostDrvAudio, pHstStream, pCfgHost, &cSamples);
+    int rc = pThis->pHostDrvAudio->pfnStreamCreate(pThis->pHostDrvAudio, pHstStream,
+                                                   pCfgHost /* pCfgReq */, &CfgAcq /* pCfgAcq */);
     if (RT_SUCCESS(rc))
     {
@@ -1028 +1033 @@
             {
                 AssertPtr(pThis->pHostDrvAudio->pfnStreamPlay);
-                rc = pThis->pHostDrvAudio->pfnStreamPlay(pThis->pHostDrvAudio, pHstStream, &cSamplesPlayed);
+                rc = pThis->pHostDrvAudio->pfnStreamPlay(pThis->pHostDrvAudio, pHstStream, NULL /* pvBuf */, 0 /* cbBuf */,
+                                                         &cSamplesPlayed);
                 if (RT_FAILURE(rc))
                 {
@@ -1135 +1141 @@
                 && (strmSts & PDMAUDIOSTRMSTS_FLAG_DATA_READABLE))
             {
-                rc = pThis->pHostDrvAudio->pfnStreamCapture(pThis->pHostDrvAudio, pHstStream, &cSamplesCaptured);
+                rc = pThis->pHostDrvAudio->pfnStreamCapture(pThis->pHostDrvAudio, pHstStream, NULL /* pvBuf */, 0 /* cbBuf */,
+                                                            &cSamplesCaptured);
                 if (RT_FAILURE(rc))
                 {

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

@@ -220 +220 @@
 }
 
+
 static int alsaALSAToAudioFmt(snd_pcm_format_t fmt,
                               PDMAUDIOFMT *pFmt, PDMAUDIOENDIANNESS *pEndianness)
@@ -295 +296 @@
     return VINF_SUCCESS;
 }
+
 
 static int alsaGetSampleShift(snd_pcm_format_t fmt, unsigned *puShift)
@@ -329 +331 @@
 }
 
+
 static int alsaStreamSetThreshold(snd_pcm_t *phPCM, snd_pcm_uframes_t threshold)
 {
@@ -383 +386 @@
 }
 
+
 static int alsaStreamClose(snd_pcm_t **pphPCM)
 {
@@ -404 +408 @@
 }
 
+
 #if 0 /* After Beta. */
 static int alsaSetHWParams(snd_pcm_t *phPCM, PALSAAUDIOSTREAMCFG pCfg)
@@ -532 +537 @@
     return rc;
 }
+
+
 static int alsaSetSWParams(snd_pcm_t *phPCM, PALSAAUDIOCFG pCfg)
 {
@@ -594 +601 @@
 }
 #endif
+
 
 static int alsaStreamOpen(bool fIn, PALSAAUDIOSTREAMCFG pCfgReq, PALSAAUDIOSTREAMCFG pCfgObt, snd_pcm_t **pphPCM)
@@ -884 +892 @@
 }
 
+
 #ifdef DEBUG
 static void alsaDbgErrorHandler(const char *file, int line, const char *function,
@@ -893 +902 @@
 #endif
 
+
 static int alsaStreamGetAvail(snd_pcm_t *phPCM, snd_pcm_sframes_t *pFramesAvail)
 {
@@ -922 +932 @@
 }
 
+
 static int alsaStreamRecover(snd_pcm_t *phPCM)
 {
@@ -936 +947 @@
 }
 
+
 static int alsaStreamResume(snd_pcm_t *phPCM)
 {
@@ -950 +962 @@
 }
 
+
 static int drvHostALSAAudioStreamCtl(snd_pcm_t *phPCM, bool fPause)
 {
@@ -975 +988 @@
 }
 
-static DECLCALLBACK(int) drvHostALSAAudioInit(PPDMIHOSTAUDIO pInterface)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnInit}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_INIT(drvHostALSAAudio)
 {
     NOREF(pInterface);
@@ -994 +1011 @@
 }
 
-static DECLCALLBACK(int) drvHostALSAAudioStreamCapture(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream,
-                                                       uint32_t *pcSamplesCaptured)
-{
-    NOREF(pInterface);
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCapture}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMCAPTURE(drvHostALSAAudio)
+{
+    AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
+    AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
+    /* pcbRead is optional. */
 
     PALSAAUDIOSTREAMIN pThisStream = (PALSAAUDIOSTREAMIN)pStream;
@@ -1036 +1057 @@
         if (!cAvail)
         {
-            if (pcSamplesCaptured)
-                *pcSamplesCaptured = 0;
+            if (pcbRead)
+                *pcbRead = 0;
             return VINF_SUCCESS;
         }
@@ -1134 +1155 @@
                                         &cProcessed);
 
-        if (pcSamplesCaptured)
-            *pcSamplesCaptured = cWrittenTotal;
+        if (pcbRead)
+            *pcbRead = cWrittenTotal;
 
         LogFlowFunc(("cWrittenTotal=%RU32 (%RU32 processed), rc=%Rrc\n",
@@ -1145 +1166 @@
 }
 
-static DECLCALLBACK(int) drvHostALSAAudioStreamPlay(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream,
-                                                    uint32_t *pcSamplesPlayed)
-{
-    NOREF(pInterface);
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamPlay}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMPLAY(drvHostALSAAudio)
+{
+    AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
+    AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
+    /* pcbWritten is optional. */
 
     PALSAAUDIOSTREAMOUT pThisStream = (PALSAAUDIOSTREAMOUT)pStream;
@@ -1255 +1279 @@
             AudioMixBufFinish(&pStream->MixBuf, cReadTotal);
 
-        if (pcSamplesPlayed)
-            *pcSamplesPlayed = cReadTotal;
+        if (pcbWritten)
+            *pcbWritten = cReadTotal;
 
         LogFlowFunc(("cReadTotal=%RU32 (%RU32 bytes), rc=%Rrc\n",
@@ -1266 +1290 @@
 }
 
+
 static int alsaDestroyStreamIn(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
 {
@@ -1284 +1309 @@
 }
 
+
 static int alsaDestroyStreamOut(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
 {
@@ -1302 +1328 @@
 }
 
+
 static int alsaCreateStreamOut(PPDMIHOSTAUDIO pInterface,
-                               PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg,
-                               uint32_t *pcSamples)
-{
-    NOREF(pInterface);
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-    AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
-
+                               PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
+{
     PALSAAUDIOSTREAMOUT pThisStream = (PALSAAUDIOSTREAMOUT)pStream;
+
     snd_pcm_t *phPCM = NULL;
 
@@ -1318 +1341 @@
     {
         ALSAAUDIOSTREAMCFG req;
-        req.fmt         = alsaAudioFmtToALSA(pCfg->enmFormat);
-        req.freq        = pCfg->uHz;
-        req.nchannels   = pCfg->cChannels;
+        req.fmt         = alsaAudioFmtToALSA(pCfgReq->enmFormat);
+        req.freq        = pCfgReq->uHz;
+        req.nchannels   = pCfgReq->cChannels;
         req.period_size = s_ALSAConf.period_size_out;
         req.buffer_size = s_ALSAConf.buffer_size_out;
@@ -1335 +1358 @@
             break;
 
-        PDMAUDIOSTREAMCFG streamCfg;
-        streamCfg.uHz           = obt.freq;
-        streamCfg.cChannels     = obt.nchannels;
-        streamCfg.enmFormat     = enmFormat;
-        streamCfg.enmEndianness = enmEnd;
-
-        rc = DrvAudioHlpStreamCfgToProps(&streamCfg, &pStream->Props);
+        pCfgAcq->uHz           = obt.freq;
+        pCfgAcq->cChannels     = obt.nchannels;
+        pCfgAcq->enmFormat     = enmFormat;
+        pCfgAcq->enmEndianness = enmEnd;
+        pCfgAcq->cSamples      = obt.samples * 4;
+
+        PDMPCMPROPS Props;
+        rc = DrvAudioHlpStreamCfgToProps(pCfgAcq, &Props);
         if (RT_FAILURE(rc))
             break;
 
         AssertBreakStmt(obt.samples, rc = VERR_INVALID_PARAMETER);
-        size_t cbBuf = obt.samples * (1 << pStream->Props.cShift);
+        size_t cbBuf = obt.samples * (1 << Props.cShift); /** @todo Get rid of using Props! */
         AssertBreakStmt(cbBuf, rc = VERR_INVALID_PARAMETER);
         pThisStream->pvBuf = RTMemAlloc(cbBuf);
@@ -1352 +1376 @@
         {
             LogRel(("ALSA: Not enough memory for output DAC buffer (%RU32 samples, each %d bytes)\n",
-                    obt.samples, 1 << pStream->Props.cShift));
+                    obt.samples, 1 << Props.cShift));
             rc = VERR_NO_MEMORY;
             break;
         }
 
-        pThisStream->cbBuf       = cbBuf;
-        pThisStream->phPCM       = phPCM;
-
-        if (pcSamples)
-            *pcSamples = obt.samples * 4;
+        pThisStream->cbBuf = cbBuf;
+        pThisStream->phPCM = phPCM;
     }
     while (0);
@@ -1372 +1393 @@
 }
 
+
 static int alsaCreateStreamIn(PPDMIHOSTAUDIO pInterface,
-                              PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg, uint32_t *pcSamples)
-{
-    NOREF(pInterface);
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-    AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
-
+                              PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
+{
     int rc;
 
@@ -1387 +1405 @@
     {
         ALSAAUDIOSTREAMCFG req;
-        req.fmt         = alsaAudioFmtToALSA(pCfg->enmFormat);
-        req.freq        = pCfg->uHz;
-        req.nchannels   = pCfg->cChannels;
+        req.fmt         = alsaAudioFmtToALSA(pCfgReq->enmFormat);
+        req.freq        = pCfgReq->uHz;
+        req.nchannels   = pCfgReq->cChannels;
         req.period_size = s_ALSAConf.period_size_in;
         req.buffer_size = s_ALSAConf.buffer_size_in;
@@ -1404 +1422 @@
             break;
 
-        PDMAUDIOSTREAMCFG streamCfg;
-        streamCfg.uHz           = obt.freq;
-        streamCfg.cChannels     = obt.nchannels;
-        streamCfg.enmFormat     = enmFormat;
-        streamCfg.enmEndianness = enmEnd;
-
-        rc = DrvAudioHlpStreamCfgToProps(&streamCfg, &pStream->Props);
+        pCfgAcq->uHz           = obt.freq;
+        pCfgAcq->cChannels     = obt.nchannels;
+        pCfgAcq->enmFormat     = enmFormat;
+        pCfgAcq->enmEndianness = enmEnd;
+        pCfgAcq->cSamples      = obt.samples;
+
+        PDMPCMPROPS Props;
+        rc = DrvAudioHlpStreamCfgToProps(pCfgAcq, &Props);
         if (RT_FAILURE(rc))
             break;
 
         AssertBreakStmt(obt.samples, rc = VERR_INVALID_PARAMETER);
-        size_t cbBuf = obt.samples * (1 << pStream->Props.cShift);
+        size_t cbBuf = obt.samples * (1 << Props.cShift); /** @todo Get rid of using Props! */
         AssertBreakStmt(cbBuf, rc = VERR_INVALID_PARAMETER);
         pThisStream->pvBuf = RTMemAlloc(cbBuf);
@@ -1421 +1440 @@
         {
             LogRel(("ALSA: Not enough memory for input ADC buffer (%RU32 samples, each %d bytes)\n",
-                    obt.samples, 1 << pStream->Props.cShift));
+                    obt.samples, 1 << Props.cShift));
             rc = VERR_NO_MEMORY;
             break;
         }
 
-        pThisStream->cbBuf       = cbBuf;
-        pThisStream->phPCM       = phPCM;
-
-        if (pcSamples)
-            *pcSamples = obt.samples;
+        pThisStream->cbBuf = cbBuf;
+        pThisStream->phPCM = phPCM;
     }
     while (0);
@@ -1440 +1456 @@
     return rc;
 }
+
 
 static int alsaControlStreamIn(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream,
@@ -1472 +1489 @@
 }
 
+
 static int alsaControlStreamOut(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream,
                                 PDMAUDIOSTREAMCMD enmStreamCmd)
@@ -1503 +1521 @@
 }
 
-static DECLCALLBACK(int) drvHostALSAAudioGetConfig(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDCFG pCfg)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnGetConfig}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_GETCONFIG(drvHostALSAAudio)
 {
     NOREF(pInterface);
-    AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
-
-    pCfg->cbStreamIn  = sizeof(ALSAAUDIOSTREAMIN);
-    pCfg->cbStreamOut = sizeof(ALSAAUDIOSTREAMOUT);
-
-    pCfg->cSources    = 0;
-    pCfg->cSinks      = 0;
+    AssertPtrReturn(pBackendCfg, VERR_INVALID_POINTER);
+
+    pBackendCfg->cbStreamIn  = sizeof(ALSAAUDIOSTREAMIN);
+    pBackendCfg->cbStreamOut = sizeof(ALSAAUDIOSTREAMOUT);
+
+    pBackendCfg->cSources    = 0;
+    pBackendCfg->cSinks      = 0;
 
     /* Enumerate sound devices. */
@@ -1537 +1559 @@
             {
                 if (!RTStrICmp("input", pszIOID))
-                    pCfg->cSources++;
+                    pBackendCfg->cSources++;
                 else if (!RTStrICmp("output", pszIOID))
-                    pCfg->cSinks++;
+                    pBackendCfg->cSinks++;
             }
             else /* NULL means bidirectional, input + output. */
             {
-                pCfg->cSources++;
-                pCfg->cSinks++;
+                pBackendCfg->cSources++;
+                pBackendCfg->cSinks++;
             }
 
@@ -1563 +1585 @@
         }
 
-        LogRel2(("ALSA: Found %RU8 host playback devices\n",  pCfg->cSinks));
-        LogRel2(("ALSA: Found %RU8 host capturing devices\n", pCfg->cSources));
+        LogRel2(("ALSA: Found %RU8 host playback devices\n",  pBackendCfg->cSinks));
+        LogRel2(("ALSA: Found %RU8 host capturing devices\n", pBackendCfg->cSources));
 
         snd_device_name_free_hint((void **)pszHints);
@@ -1573 +1595 @@
 
     /* ALSA allows exactly one input and one output used at a time for the selected device(s). */
-    pCfg->cMaxStreamsIn  = 1;
-    pCfg->cMaxStreamsOut = 1;
+    pBackendCfg->cMaxStreamsIn  = 1;
+    pBackendCfg->cMaxStreamsOut = 1;
 
     return VINF_SUCCESS;
 }
 
-static DECLCALLBACK(void) drvHostALSAAudioShutdown(PPDMIHOSTAUDIO pInterface)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnShutdown}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_SHUTDOWN(drvHostALSAAudio)
 {
     NOREF(pInterface);
 }
 
-static DECLCALLBACK(PDMAUDIOBACKENDSTS) drvHostALSAAudioGetStatus(PPDMIHOSTAUDIO pInterface, PDMAUDIODIR enmDir)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnGetStatus}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_GETSTATUS(drvHostALSAAudio)
 {
     RT_NOREF(enmDir);
@@ -1592 +1622 @@
 }
 
-static DECLCALLBACK(int) drvHostALSAAudioStreamCreate(PPDMIHOSTAUDIO pInterface,
-                                                      PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg, uint32_t *pcSamples)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCreate}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMCREATE(drvHostALSAAudio)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
     AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
-    AssertPtrReturn(pCfg,       VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgReq,    VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgAcq,    VERR_INVALID_POINTER);
 
     int rc;
-    if (pCfg->enmDir == PDMAUDIODIR_IN)
-        rc = alsaCreateStreamIn(pInterface,  pStream, pCfg, pcSamples);
+    if (pCfgReq->enmDir == PDMAUDIODIR_IN)
+        rc = alsaCreateStreamIn(pInterface,  pStream, pCfgReq, pCfgAcq);
     else
-        rc = alsaCreateStreamOut(pInterface, pStream, pCfg, pcSamples);
+        rc = alsaCreateStreamOut(pInterface, pStream, pCfgReq, pCfgAcq);
 
     LogFlowFunc(("%s: rc=%Rrc\n", pStream->szName, rc));
@@ -1609 +1643 @@
 }
 
-static DECLCALLBACK(int) drvHostALSAAudioStreamDestroy(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamDestroy}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMDESTROY(drvHostALSAAudio)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
@@ -1623 +1661 @@
 }
 
-static DECLCALLBACK(int) drvHostALSAAudioStreamControl(PPDMIHOSTAUDIO pInterface,
-                                                       PPDMAUDIOSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamControl}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMCONTROL(drvHostALSAAudio)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
@@ -1640 +1681 @@
 }
 
-static DECLCALLBACK(PDMAUDIOSTRMSTS) drvHostALSAAudioStreamGetStatus(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnGetStatus}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMGETSTATUS(drvHostALSAAudio)
 {
     NOREF(pInterface);
@@ -1669 +1714 @@
 }
 
-static DECLCALLBACK(int) drvHostALSAAudioStreamIterate(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamIterate}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMITERATE(drvHostALSAAudio)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
@@ -1679 +1728 @@
     return VINF_SUCCESS;
 }
+
 
 /**
@@ -1692 +1742 @@
     return NULL;
 }
+
 
 /**
@@ -1716 +1767 @@
     return VINF_SUCCESS;
 }
+
 
 /**

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

@@ -388 +388 @@
 
 
-static int coreAudioInitIn(PDRVHOSTCOREAUDIO pThis, PPDMAUDIOSTREAM pStream, uint32_t *pcSamples);
-static int coreAudioInitOut(PDRVHOSTCOREAUDIO pThis, PPDMAUDIOSTREAM pStream, uint32_t *pcSamples);
+static int coreAudioInitIn(PDRVHOSTCOREAUDIO pThis, PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq);
+static int coreAudioInitOut(PDRVHOSTCOREAUDIO pThis, PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq);
 static int coreAudioControlStreamIn(PDRVHOSTCOREAUDIO pThis, PPDMAUDIOSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd);
 static int coreAudioControlStreamOut(PDRVHOSTCOREAUDIO pThis, PPDMAUDIOSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd);
-static int coreAudioCreateStreamIn(PDRVHOSTCOREAUDIO pThis, PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg, uint32_t *pcSamples);
-static int coreAudioCreateStreamOut(PDRVHOSTCOREAUDIO pThis, PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg, uint32_t *pcSamples);
+static int coreAudioCreateStreamIn(PDRVHOSTCOREAUDIO pThis, PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq);
+static int coreAudioCreateStreamOut(PDRVHOSTCOREAUDIO pThis, PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq);
 static int coreAudioDestroyStreamIn(PDRVHOSTCOREAUDIO pThis, PPDMAUDIOSTREAM pStream);
 static int coreAudioDestroyStreamOut(PDRVHOSTCOREAUDIO pThis, PPDMAUDIOSTREAM pStream);
@@ -1093 +1093 @@
 
 /** @todo Eventually split up this function, as this already is huge! */
-static int coreAudioInitIn(PDRVHOSTCOREAUDIO pThis, PPDMAUDIOSTREAM pStream, uint32_t *pcSamples)
-{
+static int coreAudioInitIn(PDRVHOSTCOREAUDIO pThis, PPDMAUDIOSTREAM pStream,
+                           PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
+{
+    AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
+    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgReq, VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgAcq, VERR_INVALID_POINTER);
+
     int rc = VINF_SUCCESS;
 
@@ -1485 +1491 @@
         LogFunc(("cSamples=%RU32\n", cSamples));
 
-        if (pcSamples)
-            *pcSamples = cSamples;
+        if (pCfgAcq)
+            pCfgAcq->cSamples = cSamples;
     }
     else
@@ -1508 +1514 @@
 
 /** @todo Eventually split up this function, as this already is huge! */
-static int coreAudioInitOut(PDRVHOSTCOREAUDIO pThis, PPDMAUDIOSTREAM pStream, uint32_t *pcSamples)
-{
+static int coreAudioInitOut(PDRVHOSTCOREAUDIO pThis,
+                            PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
+{
+    AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
+    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgReq, VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgAcq, VERR_INVALID_POINTER);
+
     int rc = VINF_SUCCESS;
 
@@ -1788 +1800 @@
         LogFunc(("cSamples=%RU32\n", cSamples));
 
-        if (pcSamples)
-            *pcSamples = cSamples;
+        if (pCfgAcq)
+            pCfgAcq->cSamples = cSamples;
     }
     else
@@ -1895 +1907 @@
 static DECLCALLBACK(int) drvHostCoreAudioInit(PPDMIHOSTAUDIO pInterface)
 {
-    NOREF(pInterface);
+    RT_NOREF(pInterface);
 
     LogFlowFuncEnter();
@@ -1903 +1915 @@
 
 static DECLCALLBACK(int) drvHostCoreAudioStreamCapture(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream,
-                                                       uint32_t *pcSamplesCaptured)
-{
+                                                       void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead)
+{
+    AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
+    AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
+    /* pcbRead is optional. */
+
     PPDMDRVINS pDrvIns      = PDMIBASE_2_PDMDRV(pInterface);
     PDRVHOSTCOREAUDIO pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTCOREAUDIO);
@@ -1916 +1932 @@
     if (ASMAtomicReadU32(&pStreamIn->status) != CA_STATUS_INIT)
     {
-        if (pcSamplesCaptured)
-            *pcSamplesCaptured = 0;
+        if (pcbRead)
+            *pcbRead = 0;
         return VINF_SUCCESS;
     }
@@ -1995 +2011 @@
             LogFlowFunc(("%RU32 samples captured\n", cCaptured));
 
-        if (pcSamplesCaptured)
-            *pcSamplesCaptured = cCaptured;
+        if (pcbRead)
+            *pcbRead = cCaptured;
     }
 
@@ -2005 +2021 @@
 }
 
-static DECLCALLBACK(int) drvHostCoreAudioStreamPlay(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream,
-                                                    uint32_t *pcSamplesPlayed)
-{
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMPLAY(drvHostCoreAudio)
+{
+    AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
+    AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
+    /* pcbWritten is optional. */
+
     PPDMDRVINS pDrvIns      = PDMIBASE_2_PDMDRV(pInterface);
     PDRVHOSTCOREAUDIO pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTCOREAUDIO);
@@ -2018 +2037 @@
     if (!cLive) /* Not live samples to play? Bail out. */
     {
-        if (pcSamplesPlayed)
-            *pcSamplesPlayed = 0;
+        if (pcbWritten)
+            *pcbWritten = 0;
         return VINF_SUCCESS;
     }
@@ -2074 +2093 @@
         Log3Func(("cReadTotal=%RU32 (%RU32 bytes)\n", cReadTotal, cbReadTotal));
 
-        if (pcSamplesPlayed)
-            *pcSamplesPlayed = cReadTotal;
+        if (pcbWritten)
+            *pcbWritten = cReadTotal;
     }
 
@@ -2449 +2468 @@
 
 static int coreAudioCreateStreamIn(PDRVHOSTCOREAUDIO pThis,
-                                   PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg, uint32_t *pcSamples)
-{
+                                   PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
+{
+    AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
+    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgReq, VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgAcq, VERR_INVALID_POINTER);
+
     PCOREAUDIOSTREAMIN pStreamIn = (PCOREAUDIOSTREAMIN)pStream;
 
-    LogFlowFunc(("enmRecSource=%RU32\n", pCfg->DestSource.Source));
+    LogFlowFunc(("enmRecSource=%RU32\n", pCfgReq->DestSource.Source));
 
     pStreamIn->deviceID            = kAudioDeviceUnknown;
@@ -2471 +2495 @@
     bool fDeviceByUser = false; /* Do we use a device which was set by the user? */
 
-    /* Initialize the hardware info section with the audio settings */
-    int rc = DrvAudioHlpStreamCfgToProps(pCfg, &pStreamIn->Stream.Props);
+#if 0
+    /* Try to find the audio device set by the user */
+    if (DeviceUID.pszInputDeviceUID)
+    {
+        pStreamIn->deviceID = drvHostCoreAudioDeviceUIDtoID(DeviceUID.pszInputDeviceUID);
+        /* Not fatal */
+        if (pStreamIn->deviceID == kAudioDeviceUnknown)
+            LogRel(("CoreAudio: Unable to find recording device %s. Falling back to the default audio device. \n", DeviceUID.pszInputDeviceUID));
+        else
+            fDeviceByUser = true;
+    }
+#endif
+    int rc = coreAudioInitIn(pThis, &pStreamIn->Stream, pCfgReq, pCfgAcq);
     if (RT_SUCCESS(rc))
     {
-#if 0
-        /* Try to find the audio device set by the user */
-        if (DeviceUID.pszInputDeviceUID)
-        {
-            pStreamIn->deviceID = drvHostCoreAudioDeviceUIDtoID(DeviceUID.pszInputDeviceUID);
-            /* Not fatal */
-            if (pStreamIn->deviceID == kAudioDeviceUnknown)
-                LogRel(("CoreAudio: Unable to find recording device %s. Falling back to the default audio device. \n", DeviceUID.pszInputDeviceUID));
+        OSStatus err;
+
+        /* When the devices isn't forced by the user, we want default device change notifications. */
+        if (!fDeviceByUser)
+        {
+            if (!pStreamIn->fDefDevChgListReg)
+            {
+                AudioObjectPropertyAddress propAdr = { kAudioHardwarePropertyDefaultInputDevice, kAudioObjectPropertyScopeGlobal,
+                                                       kAudioObjectPropertyElementMaster };
+                err = AudioObjectAddPropertyListener(kAudioObjectSystemObject, &propAdr,
+                                                     coreAudioDefaultDeviceChanged, &pStreamIn->cbCtx);
+                if (   err == noErr
+                    || err == kAudioHardwareIllegalOperationError)
+                {
+                    pStreamIn->fDefDevChgListReg = true;
+                }
+                else
+                    LogRel(("CoreAudio: Failed to add the default recording device changed listener (%RI32)\n", err));
+            }
+        }
+
+        if (   !pStreamIn->fDevStateChgListReg
+            && (pStreamIn->deviceID != kAudioDeviceUnknown))
+        {
+            /* Register callback for being notified if the device stops being alive. */
+            AudioObjectPropertyAddress propAdr = { kAudioDevicePropertyDeviceIsAlive, kAudioObjectPropertyScopeGlobal,
+                                                   kAudioObjectPropertyElementMaster };
+            err = AudioObjectAddPropertyListener(pStreamIn->deviceID, &propAdr, drvHostCoreAudioDeviceStateChanged,
+                                                 &pStreamIn->cbCtx);
+            if (err == noErr)
+            {
+                pStreamIn->fDevStateChgListReg = true;
+            }
             else
-                fDeviceByUser = true;
-        }
-#endif
-        rc = coreAudioInitIn(pThis, &pStreamIn->Stream, pcSamples);
-    }
-
-    OSStatus err;
-
-    /* When the devices isn't forced by the user, we want default device change notifications. */
-    if (!fDeviceByUser)
-    {
-        if (!pStreamIn->fDefDevChgListReg)
-        {
-            AudioObjectPropertyAddress propAdr = { kAudioHardwarePropertyDefaultInputDevice, kAudioObjectPropertyScopeGlobal,
-                                                   kAudioObjectPropertyElementMaster };
-            err = AudioObjectAddPropertyListener(kAudioObjectSystemObject, &propAdr,
-                                                 coreAudioDefaultDeviceChanged, &pStreamIn->cbCtx);
-            if (   err == noErr
-                || err == kAudioHardwareIllegalOperationError)
-            {
-                pStreamIn->fDefDevChgListReg = true;
-            }
-            else
-                LogRel(("CoreAudio: Failed to add the default recording device changed listener (%RI32)\n", err));
-        }
-    }
-
-    if (   !pStreamIn->fDevStateChgListReg
-        && (pStreamIn->deviceID != kAudioDeviceUnknown))
-    {
-        /* Register callback for being notified if the device stops being alive. */
-        AudioObjectPropertyAddress propAdr = { kAudioDevicePropertyDeviceIsAlive, kAudioObjectPropertyScopeGlobal,
-                                               kAudioObjectPropertyElementMaster };
-        err = AudioObjectAddPropertyListener(pStreamIn->deviceID, &propAdr, drvHostCoreAudioDeviceStateChanged,
-                                             &pStreamIn->cbCtx);
-        if (err == noErr)
-        {
-            pStreamIn->fDevStateChgListReg = true;
-        }
-        else
-            LogRel(("CoreAudio: Failed to add the recording device state changed listener (%RI32)\n", err));
+                LogRel(("CoreAudio: Failed to add the recording device state changed listener (%RI32)\n", err));
+        }
     }
 
@@ -2532 +2553 @@
 
 static int coreAudioCreateStreamOut(PDRVHOSTCOREAUDIO pThis,
-                                    PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg,
-                                    uint32_t *pcSamples)
-{
+                                    PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
+{
+    AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
+    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgReq, VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgAcq, VERR_INVALID_POINTER);
+
     PCOREAUDIOSTREAMOUT pStreamOut = (PCOREAUDIOSTREAMOUT)pStream;
 
@@ -2553 +2578 @@
     bool fDeviceByUser = false; /* Do we use a device which was set by the user? */
 
-    /* If a stream configuration is given, apply that to the stream. */
-    int rc = DrvAudioHlpStreamCfgToProps(pCfg, &pStreamOut->Stream.Props);
+#if 0
+    /* Try to find the audio device set by the user. Use
+     * export VBOX_COREAUDIO_OUTPUT_DEVICE_UID=AppleHDAEngineOutput:0
+     * to set it. */
+    if (DeviceUID.pszOutputDeviceUID)
+    {
+        pStreamOut->audioDeviceId = drvHostCoreAudioDeviceUIDtoID(DeviceUID.pszOutputDeviceUID);
+        /* Not fatal */
+        if (pStreamOut->audioDeviceId == kAudioDeviceUnknown)
+            LogRel(("CoreAudio: Unable to find playback device %s. Falling back to the default audio device. \n", DeviceUID.pszOutputDeviceUID));
+        else
+            fDeviceByUser = true;
+    }
+#endif
+    int rc = coreAudioInitOut(pThis, pStream, pCfgReq, pCfgAcq);
     if (RT_SUCCESS(rc))
     {
-#if 0
-        /* Try to find the audio device set by the user. Use
-         * export VBOX_COREAUDIO_OUTPUT_DEVICE_UID=AppleHDAEngineOutput:0
-         * to set it. */
-        if (DeviceUID.pszOutputDeviceUID)
-        {
-            pStreamOut->audioDeviceId = drvHostCoreAudioDeviceUIDtoID(DeviceUID.pszOutputDeviceUID);
-            /* Not fatal */
-            if (pStreamOut->audioDeviceId == kAudioDeviceUnknown)
-                LogRel(("CoreAudio: Unable to find playback device %s. Falling back to the default audio device. \n", DeviceUID.pszOutputDeviceUID));
+        OSStatus err;
+
+        /* When the devices isn't forced by the user, we want default device change notifications. */
+        if (!fDeviceByUser)
+        {
+            AudioObjectPropertyAddress propAdr = { kAudioHardwarePropertyDefaultOutputDevice, kAudioObjectPropertyScopeGlobal,
+                                                   kAudioObjectPropertyElementMaster };
+            err = AudioObjectAddPropertyListener(kAudioObjectSystemObject, &propAdr,
+                                                 coreAudioDefaultDeviceChanged, &pStreamOut->cbCtx);
+            if (err == noErr)
+            {
+                pStreamOut->fDefDevChgListReg = true;
+            }
             else
-                fDeviceByUser = true;
-        }
-#endif
-        rc = coreAudioInitOut(pThis, pStream, pcSamples);
-    }
-
-    OSStatus err;
-
-    /* When the devices isn't forced by the user, we want default device change notifications. */
-    if (!fDeviceByUser)
-    {
-        AudioObjectPropertyAddress propAdr = { kAudioHardwarePropertyDefaultOutputDevice, kAudioObjectPropertyScopeGlobal,
-                                               kAudioObjectPropertyElementMaster };
-        err = AudioObjectAddPropertyListener(kAudioObjectSystemObject, &propAdr,
-                                             coreAudioDefaultDeviceChanged, &pStreamOut->cbCtx);
-        if (err == noErr)
-        {
-            pStreamOut->fDefDevChgListReg = true;
-        }
-        else
-            LogRel(("CoreAudio: Failed to add the default playback device changed listener (%RI32)\n", err));
-    }
-
-    if (   !pStreamOut->fDevStateChgListReg
-        && (pStreamOut->deviceID != kAudioDeviceUnknown))
-    {
-        /* Register callback for being notified if the device stops being alive. */
-        AudioObjectPropertyAddress propAdr = { kAudioDevicePropertyDeviceIsAlive, kAudioObjectPropertyScopeGlobal,
-                                               kAudioObjectPropertyElementMaster };
-        err = AudioObjectAddPropertyListener(pStreamOut->deviceID, &propAdr, drvHostCoreAudioDeviceStateChanged,
-                                             (void *)&pStreamOut->cbCtx);
-        if (err == noErr)
-        {
-            pStreamOut->fDevStateChgListReg = true;
-        }
-        else
-            LogRel(("CoreAudio: Failed to add the playback device state changed listener (%RI32)\n", err));
+                LogRel(("CoreAudio: Failed to add the default playback device changed listener (%RI32)\n", err));
+        }
+
+        if (   !pStreamOut->fDevStateChgListReg
+            && (pStreamOut->deviceID != kAudioDeviceUnknown))
+        {
+            /* Register callback for being notified if the device stops being alive. */
+            AudioObjectPropertyAddress propAdr = { kAudioDevicePropertyDeviceIsAlive, kAudioObjectPropertyScopeGlobal,
+                                                   kAudioObjectPropertyElementMaster };
+            err = AudioObjectAddPropertyListener(pStreamOut->deviceID, &propAdr, drvHostCoreAudioDeviceStateChanged,
+                                                 (void *)&pStreamOut->cbCtx);
+            if (err == noErr)
+            {
+                pStreamOut->fDevStateChgListReg = true;
+            }
+            else
+                LogRel(("CoreAudio: Failed to add the playback device state changed listener (%RI32)\n", err));
+        }
     }
 
@@ -2611 +2633 @@
 }
 
-static DECLCALLBACK(int) drvHostCoreAudioGetConfig(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDCFG pCfg)
-{
-    AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
-    AssertPtrReturn(pCfg,       VERR_INVALID_POINTER);
+PDMAUDIO_IHOSTAUDIO_EMIT_GETCONFIG(drvHostCoreAudio)
+{
+    AssertPtrReturn(pInterface,  VERR_INVALID_POINTER);
+    AssertPtrReturn(pBackendCfg, VERR_INVALID_POINTER);
 
     PPDMDRVINS        pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
     PDRVHOSTCOREAUDIO pThis   = PDMINS_2_DATA(pDrvIns, PDRVHOSTCOREAUDIO);
 
-    return coreAudioUpdateStatusInternalEx(pThis, pCfg, 0 /* fEnum */);
-}
-
-static DECLCALLBACK(PDMAUDIOBACKENDSTS) drvHostCoreAudioGetStatus(PPDMIHOSTAUDIO pInterface, PDMAUDIODIR enmDir)
+    return coreAudioUpdateStatusInternalEx(pThis, pBackendCfg, 0 /* fEnum */);
+}
+
+PDMAUDIO_IHOSTAUDIO_EMIT_GETSTATUS(drvHostCoreAudio)
 {
     AssertPtrReturn(pInterface, PDMAUDIOBACKENDSTS_UNKNOWN);
@@ -2629 +2651 @@
 }
 
-static DECLCALLBACK(int) drvHostCoreAudioStreamCreate(PPDMIHOSTAUDIO pInterface,
-                                                       PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg, uint32_t *pcSamples)
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMCREATE(drvHostCoreAudio)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
     AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
-    AssertPtrReturn(pCfg,       VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgReq,    VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgAcq,    VERR_INVALID_POINTER);
 
     PPDMDRVINS        pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
@@ -2640 +2662 @@
 
     int rc;
-    if (pCfg->enmDir == PDMAUDIODIR_IN)
-        rc = coreAudioCreateStreamIn(pThis,  pStream, pCfg, pcSamples);
+    if (pCfgReq->enmDir == PDMAUDIODIR_IN)
+        rc = coreAudioCreateStreamIn(pThis,  pStream, pCfgReq, pCfgAcq);
     else
-        rc = coreAudioCreateStreamOut(pThis, pStream, pCfg, pcSamples);
+        rc = coreAudioCreateStreamOut(pThis, pStream, pCfgReq, pCfgAcq);
 
     LogFlowFunc(("%s: rc=%Rrc\n", pStream->szName, rc));
@@ -2649 +2671 @@
 }
 
-static DECLCALLBACK(int) drvHostCoreAudioStreamDestroy(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMDESTROY(drvHostCoreAudio)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
@@ -2666 +2688 @@
 }
 
-static DECLCALLBACK(int) drvHostCoreAudioStreamControl(PPDMIHOSTAUDIO pInterface,
-                                                       PPDMAUDIOSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd)
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMCONTROL(drvHostCoreAudio)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
@@ -2686 +2707 @@
 }
 
-static DECLCALLBACK(PDMAUDIOSTRMSTS) drvHostCoreAudioStreamGetStatus(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
-{
-    NOREF(pInterface);
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMGETSTATUS(drvHostCoreAudio)
+{
+    RT_NOREF(pInterface);
     AssertPtrReturn(pStream, VERR_INVALID_POINTER);
 
@@ -2721 +2742 @@
 }
 
-static DECLCALLBACK(int) drvHostCoreAudioStreamIterate(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMITERATE(drvHostCoreAudio)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
@@ -2730 +2751 @@
 }
 
-static DECLCALLBACK(void) drvHostCoreAudioShutdown(PPDMIHOSTAUDIO pInterface)
-{
-    NOREF(pInterface);
+PDMAUDIO_IHOSTAUDIO_EMIT_SHUTDOWN(drvHostCoreAudio)
+{
+    RT_NOREF(pInterface);
 }
 
@@ -2746 +2767 @@
 }
 
- /* Construct a DirectSound Audio driver instance.
+/* Construct a DirectSound Audio driver instance.
  *
  * @copydoc FNPDMDRVCONSTRUCT

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

@@ -217 +217 @@
 }
 
+
 static int dsoundWaveFmtFromCfg(PPDMAUDIOSTREAMCFG pCfg, PWAVEFORMATEX pFmt)
 {
@@ -259 +260 @@
     return VINF_SUCCESS;
 }
+
 
 static int dsoundGetPosOut(PDRVHOSTDSOUND   pThis,
@@ -305 +307 @@
 }
 
+
 static char *dsoundGUIDToUtf8StrA(LPCGUID pGUID)
 {
@@ -323 +326 @@
     return RTStrDup("{Default device}");
 }
+
 
 /**
@@ -347 +351 @@
 }
 
+
 static HRESULT directSoundPlayRestore(PDRVHOSTDSOUND pThis, LPDIRECTSOUNDBUFFER8 pDSB)
 {
@@ -356 +361 @@
 }
 
+
 static HRESULT directSoundPlayUnlock(PDRVHOSTDSOUND pThis, LPDIRECTSOUNDBUFFER8 pDSB,
                                      PVOID pv1, PVOID pv2,
@@ -367 +373 @@
 }
 
+
 static HRESULT directSoundCaptureUnlock(LPDIRECTSOUNDCAPTUREBUFFER8 pDSCB,
                                         PVOID pv1, PVOID pv2,
@@ -376 +383 @@
     return hr;
 }
+
 
 static HRESULT directSoundPlayLock(PDRVHOSTDSOUND pThis,
@@ -413 +421 @@
 }
 
+
 static HRESULT directSoundCaptureLock(LPDIRECTSOUNDCAPTUREBUFFER8 pDSCB, PPDMPCMPROPS pProps,
                                       DWORD dwOffset, DWORD dwBytes,
@@ -463 +472 @@
 }
 
+
 static HRESULT directSoundPlayInterfaceCreate(PDRVHOSTDSOUND pThis, PDSOUNDSTREAMOUT pDSoundStream)
 {
@@ -501 +511 @@
     return hr;
 }
+
 
 static HRESULT directSoundPlayClose(PDRVHOSTDSOUND pThis, PDSOUNDSTREAMOUT pDSoundStream)
@@ -543 +554 @@
     return hr;
 }
+
 
 static HRESULT directSoundPlayOpen(PDRVHOSTDSOUND pThis, PDSOUNDSTREAMOUT pDSoundStream)
@@ -727 +739 @@
 }
 
+
 static void dsoundPlayClearSamples(PDRVHOSTDSOUND pThis, PDSOUNDSTREAMOUT pDSoundStream)
 {
@@ -753 +766 @@
 }
 
+
 static HRESULT directSoundPlayGetStatus(PDRVHOSTDSOUND pThis, LPDIRECTSOUNDBUFFER8 pDSB, DWORD *pdwStatus)
 {
@@ -786 +800 @@
 }
 
+
 static HRESULT directSoundPlayStop(PDRVHOSTDSOUND pThis, PDSOUNDSTREAMOUT pDSoundStream)
 {
@@ -823 +838 @@
     return hr;
 }
+
 
 static HRESULT directSoundPlayStart(PDRVHOSTDSOUND pThis, PDSOUNDSTREAMOUT pDSoundStream)
@@ -941 +957 @@
 }
 
+
 static void directSoundCaptureInterfaceRelease(PDSOUNDSTREAMIN pDSoundStream)
 {
@@ -950 +967 @@
     }
 }
+
 
 static HRESULT directSoundCaptureInterfaceCreate(PDRVHOSTDSOUND pThis, PDSOUNDSTREAMIN pDSoundStream)
@@ -984 +1002 @@
 }
 
+
 static HRESULT directSoundCaptureClose(PDSOUNDSTREAMIN pDSoundStream)
 {
@@ -1010 +1029 @@
     return hr;
 }
+
 
 static HRESULT directSoundCaptureOpen(PDRVHOSTDSOUND pThis, PDSOUNDSTREAMIN pDSoundStream)
@@ -1143 +1163 @@
 }
 
+
 static HRESULT directSoundCaptureStop(PDRVHOSTDSOUND pThis, PDSOUNDSTREAMIN pDSoundStream)
 {
@@ -1169 +1190 @@
     return hr;
 }
+
 
 static HRESULT directSoundCaptureStart(PDRVHOSTDSOUND pThis, PDSOUNDSTREAMIN pDSoundStream)
@@ -1213 +1235 @@
 }
 
+
 static int dsoundDevAdd(PRTLISTANCHOR pList, LPGUID pGUID, LPCWSTR pwszDescription, PDSOUNDDEV *ppDev)
 {
@@ -1236 +1259 @@
 }
 
+
 static void dsoundDeviceRemove(PDSOUNDDEV pDev)
 {
@@ -1248 +1272 @@
     }
 }
+
 
 static void dsoundLogDevice(const char *pszType, LPGUID pGUID, LPCWSTR pwszDescription, LPCWSTR pwszModule)
@@ -1257 +1282 @@
 }
 
+
 static BOOL CALLBACK dsoundDevicesEnumCbPlayback(LPGUID pGUID, LPCWSTR pwszDescription, LPCWSTR pwszModule, PVOID lpContext)
 {
@@ -1282 +1308 @@
 }
 
+
 static BOOL CALLBACK dsoundDevicesEnumCbCapture(LPGUID pGUID, LPCWSTR pwszDescription, LPCWSTR pwszModule, PVOID lpContext)
 {
@@ -1303 +1330 @@
     return TRUE;
 }
+
 
 /**
@@ -1358 +1386 @@
 }
 
+
 /**
  * Updates this host driver's internal status, according to the global, overall input/output
@@ -1406 +1435 @@
 }
 
+
 static void dsoundUpdateStatusInternal(PDRVHOSTDSOUND pThis)
 {
@@ -1411 +1441 @@
 }
 
-static int dsoundCreateStreamOut(PDRVHOSTDSOUND pThis, PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg, uint32_t *pcSamples)
-{
-    LogFlowFunc(("pStream=%p, pCfg=%p\n", pStream, pCfg));
+
+static int dsoundCreateStreamOut(PDRVHOSTDSOUND pThis, PPDMAUDIOSTREAM pStream,
+                                 PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
+{
+    LogFlowFunc(("pStream=%p, pCfg=%p\n", pStream, pCfgReq));
     PDSOUNDSTREAMOUT pDSoundStream = (PDSOUNDSTREAMOUT)pStream;
 
-    pDSoundStream->streamCfg = *pCfg;
+    pDSoundStream->streamCfg = *pCfgReq;
     pDSoundStream->streamCfg.enmEndianness = PDMAUDIOHOSTENDIANNESS;
 
@@ -1428 +1460 @@
         pDSoundStream->cMaxSamplesInBuffer = 0;
 
-        if (pcSamples)
-            *pcSamples = pThis->cfg.cbBufferOut >> pStream->Props.cShift;
+        if (pCfgAcq)
+            pCfgAcq->cSamples = pThis->cfg.cbBufferOut >> pStream->Props.cShift; /** @todo Get rid of using Props! */
 
         /* Try to open playback in case the device is already there. */
@@ -1497 +1529 @@
  * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamPlay}
  */
-static DECLCALLBACK(int) drvHostDSoundStreamPlay(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream, uint32_t *pcSamplesPlayed)
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMPLAY(drvHostDSound)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
     AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
-    /* pcSamplesPlayed is optional. */
-
-    PDRVHOSTDSOUND pThis = PDMIHOSTAUDIO_2_DRVHOSTDSOUND(pInterface);
+    /* pcbRead is optional. */
+
+    PDRVHOSTDSOUND   pThis         = PDMIHOSTAUDIO_2_DRVHOSTDSOUND(pInterface);
     PDSOUNDSTREAMOUT pDSoundStream = (PDSOUNDSTREAMOUT)pStream;
 
@@ -1634 +1666 @@
     if (RT_FAILURE(rc))
         dsoundUpdateStatusInternal(pThis);
-    else if (pcSamplesPlayed)
-        *pcSamplesPlayed = cReadTotal;
+    else if (pcbRead)
+        *pcbRead = cReadTotal;
 
     LogFlowFuncLeaveRC(rc);
     return rc;
 }
+
 
 static int dsoundDestroyStreamOut(PDRVHOSTDSOUND pThis, PPDMAUDIOSTREAM pStream)
@@ -1656 +1689 @@
 }
 
-static int dsoundCreateStreamIn(PDRVHOSTDSOUND pThis, PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg, uint32_t *pcSamples)
+static int dsoundCreateStreamIn(PDRVHOSTDSOUND pThis, PPDMAUDIOSTREAM pStream,
+                                PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
 {
     PDSOUNDSTREAMIN pDSoundStream = (PDSOUNDSTREAMIN)pStream;
 
-    LogFlowFunc(("pStream=%p, pCfg=%p, enmRecSource=%ld\n", pStream, pCfg, pCfg->DestSource.Source));
-
-    memcpy(&pDSoundStream->streamCfg, pCfg, sizeof(PDMAUDIOSTREAMCFG));
+    LogFlowFunc(("pStream=%p, pCfg=%p, enmRecSource=%ld\n", pStream, pCfgReq, pCfgReq->DestSource.Source));
+
+    memcpy(&pDSoundStream->streamCfg, pCfgReq, sizeof(PDMAUDIOSTREAMCFG));
 
     /** @todo caller should already init Props? */
-    int rc = DrvAudioHlpStreamCfgToProps(&pDSoundStream->streamCfg, &pStream->Props);
+    int rc = DrvAudioHlpStreamCfgToProps(&pDSoundStream->streamCfg, &pStream->Props); /** @todo Get rid of using Props! */
     if (RT_SUCCESS(rc))
     {
@@ -1673 +1707 @@
         pDSoundStream->pDSC                = NULL;
         pDSoundStream->pDSCB               = NULL;
-        pDSoundStream->enmRecSource        = pCfg->DestSource.Source;
+        pDSoundStream->enmRecSource        = pCfgReq->DestSource.Source;
         pDSoundStream->hrLastCapture       = S_OK;
 
-        if (pcSamples)
-            *pcSamples = pThis->cfg.cbBufferIn >> pStream->Props.cShift;
+        if (pCfgAcq)
+            pCfgAcq->cSamples = pThis->cfg.cbBufferIn >> pStream->Props.cShift; /** @todo Get rid of using Props! */
 
         /* Try to open capture in case the device is already there. */
-        directSoundCaptureOpen(pThis, pDSoundStream);
+        directSoundCaptureOpen(pThis, pDSoundStream); /** @todo r=andy Why not checking the result here?? */
     }
     else
@@ -1746 +1780 @@
  * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCapture}
  */
-static DECLCALLBACK(int) drvHostDSoundStreamCapture(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream,
-                                                    uint32_t *pcSamplesCaptured)
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMCAPTURE(drvHostDSound)
 {
     PDRVHOSTDSOUND pThis = PDMIHOSTAUDIO_2_DRVHOSTDSOUND(pInterface);
@@ -1861 +1894 @@
     if (RT_FAILURE(rc))
         dsoundUpdateStatusInternal(pThis);
-    else if (pcSamplesCaptured)
-        *pcSamplesCaptured = cSamplesProcessed;
+    else if (pcbWritten)
+        *pcbWritten = cSamplesProcessed;
 
     LogFlowFuncLeaveRC(rc);
@@ -1885 +1918 @@
  * @interface_method_impl{PDMIHOSTAUDIO,pfnGetConfig}
  */
-static DECLCALLBACK(int) drvHostDSoundGetConfig(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDCFG pCfg)
-{
-    AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
-    AssertPtrReturn(pCfg,       VERR_INVALID_POINTER);
+PDMAUDIO_IHOSTAUDIO_EMIT_GETCONFIG(drvHostDSound)
+{
+    AssertPtrReturn(pInterface,  VERR_INVALID_POINTER);
+    AssertPtrReturn(pBackendCfg, VERR_INVALID_POINTER);
 
     PDRVHOSTDSOUND pThis = PDMIHOSTAUDIO_2_DRVHOSTDSOUND(pInterface);
 
-    dsoundUpdateStatusInternalEx(pThis, pCfg, 0 /* fEnum */);
+    dsoundUpdateStatusInternalEx(pThis, pBackendCfg, 0 /* fEnum */);
 
     return VINF_SUCCESS;
@@ -2012 +2045 @@
  * @interface_method_impl{PDMIHOSTAUDIO,pfnShutdown}
  */
-static DECLCALLBACK(void) drvHostDSoundShutdown(PPDMIHOSTAUDIO pInterface)
+PDMAUDIO_IHOSTAUDIO_EMIT_SHUTDOWN(drvHostDSound)
 {
     PDRVHOSTDSOUND pThis = PDMIHOSTAUDIO_2_DRVHOSTDSOUND(pInterface);
@@ -2044 +2077 @@
  * @interface_method_impl{PDMIHOSTAUDIO,pfnInit}
  */
-static DECLCALLBACK(int) drvHostDSoundInit(PPDMIHOSTAUDIO pInterface)
+PDMAUDIO_IHOSTAUDIO_EMIT_INIT(drvHostDSound)
 {
     PDRVHOSTDSOUND pThis = PDMIHOSTAUDIO_2_DRVHOSTDSOUND(pInterface);
@@ -2139 +2172 @@
  * @interface_method_impl{PDMIHOSTAUDIO,pfnGetStatus}
  */
-static DECLCALLBACK(PDMAUDIOBACKENDSTS) drvHostDSoundGetStatus(PPDMIHOSTAUDIO pInterface, PDMAUDIODIR enmDir)
+PDMAUDIO_IHOSTAUDIO_EMIT_GETSTATUS(drvHostDSound)
 {
     RT_NOREF(enmDir);
@@ -2151 +2184 @@
  * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCreate}
  */
-static DECLCALLBACK(int)
-drvHostDSoundStreamCreate(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg, uint32_t *pcSamples)
-{
-    AssertPtrReturn(pInterface,    VERR_INVALID_POINTER);
-    AssertPtrReturn(pStream,       VERR_INVALID_POINTER);
-    AssertPtrReturn(pCfg,          VERR_INVALID_POINTER);
-    AssertPtrNullReturn(pcSamples, VERR_INVALID_POINTER);
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMCREATE(drvHostDSound)
+{
+    AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
+    AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgReq,    VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgAcq,    VERR_INVALID_POINTER);
+
     PDRVHOSTDSOUND pThis = PDMIHOSTAUDIO_2_DRVHOSTDSOUND(pInterface);
 
     int rc;
-    if (pCfg->enmDir == PDMAUDIODIR_IN)
-        rc = dsoundCreateStreamIn(pThis,  pStream, pCfg, pcSamples);
+    if (pCfgReq->enmDir == PDMAUDIODIR_IN)
+        rc = dsoundCreateStreamIn(pThis,  pStream, pCfgReq, pCfgAcq);
     else
-        rc = dsoundCreateStreamOut(pThis, pStream, pCfg, pcSamples);
-
-    LogFlowFunc(("%s: rc=%Rrc\n", pStream->szName, rc));
+        rc = dsoundCreateStreamOut(pThis, pStream, pCfgReq, pCfgAcq);
+
     return rc;
 }
@@ -2174 +2206 @@
  * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamDestroy}
  */
-static DECLCALLBACK(int) drvHostDSoundStreamDestroy(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMDESTROY(drvHostDSound)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
     AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
+
     PDRVHOSTDSOUND pThis = PDMIHOSTAUDIO_2_DRVHOSTDSOUND(pInterface);
 
@@ -2193 +2226 @@
  * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamControl}
  */
-static DECLCALLBACK(int)
-drvHostDSoundStreamControl(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd)
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMCONTROL(drvHostDSound)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
     AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
+
     PDRVHOSTDSOUND pThis = PDMIHOSTAUDIO_2_DRVHOSTDSOUND(pInterface);
 
@@ -2215 +2248 @@
  * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetStatus}
  */
-static DECLCALLBACK(PDMAUDIOSTRMSTS) drvHostDSoundStreamGetStatus(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMGETSTATUS(drvHostDSound)
 {
     AssertPtrReturn(pInterface, PDMAUDIOSTRMSTS_FLAG_NONE);
@@ -2254 +2287 @@
  * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamIterate}
  */
-static DECLCALLBACK(int) drvHostDSoundStreamIterate(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMITERATE(drvHostDSound)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
@@ -2368 +2401 @@
     return VINF_SUCCESS;
 }
+
 
 /**

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

@@ -72 +72 @@
 
 
-static DECLCALLBACK(int) drvHostDebugAudioGetConfig(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDCFG pCfg)
-{
-    NOREF(pInterface);
-    AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
-
-    pCfg->cbStreamOut    = sizeof(DEBUGAUDIOSTREAM);
-    pCfg->cbStreamIn     = sizeof(DEBUGAUDIOSTREAM);
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnGetConfig}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_GETCONFIG(drvHostDebugAudio)
+{
+    NOREF(pInterface);
+    AssertPtrReturn(pBackendCfg, VERR_INVALID_POINTER);
+
+    pBackendCfg->cbStreamOut    = sizeof(DEBUGAUDIOSTREAM);
+    pBackendCfg->cbStreamIn     = sizeof(DEBUGAUDIOSTREAM);
 
     /* The NULL backend has exactly one input source and one output sink. */
-    pCfg->cSources       = 1;
-    pCfg->cSinks         = 1;
-
-    pCfg->cMaxStreamsOut = 1; /* Output */
-    pCfg->cMaxStreamsIn  = 2; /* Line input + microphone input. */
-
-    return VINF_SUCCESS;
-}
-
-static DECLCALLBACK(int) drvHostDebugAudioInit(PPDMIHOSTAUDIO pInterface)
+    pBackendCfg->cSources       = 1;
+    pBackendCfg->cSinks         = 1;
+
+    pBackendCfg->cMaxStreamsOut = 1; /* Output */
+    pBackendCfg->cMaxStreamsIn  = 2; /* Line input + microphone input. */
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnInit}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_INIT(drvHostDebugAudio)
 {
     NOREF(pInterface);
@@ -98 +105 @@
 }
 
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnShutdown}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_SHUTDOWN(drvHostDebugAudio)
+{
+    NOREF(pInterface);
+}
+
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnGetStatus}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_GETSTATUS(drvHostDebugAudio)
+{
+    RT_NOREF(enmDir);
+    AssertPtrReturn(pInterface, PDMAUDIOBACKENDSTS_UNKNOWN);
+
+    return PDMAUDIOBACKENDSTS_RUNNING;
+}
+
+
 static int debugCreateStreamIn(PPDMIHOSTAUDIO pInterface,
-                               PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg, uint32_t *pcSamples)
+                               PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
 {
     NOREF(pInterface);
 
     /* Just adopt the wanted stream configuration. */
-    int rc = DrvAudioHlpStreamCfgToProps(pCfg, &pStream->Props);
+    int rc = DrvAudioHlpStreamCfgToProps(pCfgReq, &pStream->Props);
     if (RT_SUCCESS(rc))
     {
-        if (pcSamples)
-            *pcSamples = _1K;
+        if (pCfgAcq)
+            pCfgAcq->cSamples = _1K;
     }
 
@@ -115 +144 @@
 }
 
+
 static int debugCreateStreamOut(PPDMIHOSTAUDIO pInterface,
-                                PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg,
-                                uint32_t *pcSamples)
+                                PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
 {
     NOREF(pInterface);
@@ -125 +154 @@
     /* Just adopt the wanted stream configuration. */
     PDMPCMPROPS Props;
-    int rc = DrvAudioHlpStreamCfgToProps(pCfg, &Props);
+    int rc = DrvAudioHlpStreamCfgToProps(pCfgReq, &Props);
     if (RT_SUCCESS(rc))
     {
@@ -152 +181 @@
     if (RT_SUCCESS(rc))
     {
-        if (pcSamples)
-            *pcSamples = pDbgStream->Out.cMaxSamplesInPlayBuffer;
+        if (pCfgAcq)
+            pCfgAcq->cSamples = pDbgStream->Out.cMaxSamplesInPlayBuffer;
     }
 
@@ -160 +189 @@
 }
 
-static DECLCALLBACK(int) drvHostDebugAudioStreamPlay(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream,
-                                                     uint32_t *pcSamplesPlayed)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCreate}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMCREATE(drvHostDebugAudio)
+{
+    AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
+    AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgReq,    VERR_INVALID_POINTER);
+
+    int rc;
+    if (pCfgReq->enmDir == PDMAUDIODIR_IN)
+        rc = debugCreateStreamIn( pInterface, pStream, pCfgReq, pCfgAcq);
+    else
+        rc = debugCreateStreamOut(pInterface, pStream, pCfgReq, pCfgAcq);
+
+    LogFlowFunc(("%s: rc=%Rrc\n", pStream->szName, rc));
+    return rc;
+}
+
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamPlay}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMPLAY(drvHostDebugAudio)
 {
     PDRVHOSTDEBUGAUDIO pDrv       = RT_FROM_MEMBER(pInterface, DRVHOSTDEBUGAUDIO, IHostAudio);
@@ -215 +267 @@
 
         cSamplesPlayed += cSamplesRead;
-    };
+    }
 
     /* Remember when samples were consumed. */
     pDbgStream->Out.tsLastPlayed = u64TicksNow;
 
-    if (pcSamplesPlayed)
-        *pcSamplesPlayed = cSamplesPlayed;
-
-    return VINF_SUCCESS;
-}
-
-static DECLCALLBACK(int) drvHostDebugAudioStreamCapture(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream,
-                                                        uint32_t *pcSamplesCaptured)
+    if (pcbWritten)
+        *pcbWritten = cSamplesPlayed;
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCapture}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMCAPTURE(drvHostDebugAudio)
 {
     RT_NOREF(pInterface, pStream);
 
     /* Never capture anything. */
-    if (pcSamplesCaptured)
-        *pcSamplesCaptured = 0;
-
-    return VINF_SUCCESS;
-}
+    if (pcbRead)
+        *pcbRead = 0;
+
+    return VINF_SUCCESS;
+}
+
 
 static int debugDestroyStreamIn(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
@@ -244 +300 @@
     return VINF_SUCCESS;
 }
+
 
 static int debugDestroyStreamOut(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
@@ -270 +327 @@
 }
 
-static DECLCALLBACK(PDMAUDIOBACKENDSTS) drvHostDebugAudioGetStatus(PPDMIHOSTAUDIO pInterface, PDMAUDIODIR enmDir)
-{
-    RT_NOREF(enmDir);
-    AssertPtrReturn(pInterface, PDMAUDIOBACKENDSTS_UNKNOWN);
-
-    return PDMAUDIOBACKENDSTS_RUNNING;
-}
-
-static DECLCALLBACK(int) drvHostDebugAudioStreamCreate(PPDMIHOSTAUDIO pInterface,
-                                                       PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg, uint32_t *pcSamples)
-{
-    AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
-    AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
-    AssertPtrReturn(pCfg,       VERR_INVALID_POINTER);
-
-    int rc;
-    if (pCfg->enmDir == PDMAUDIODIR_IN)
-        rc = debugCreateStreamIn(pInterface,  pStream, pCfg, pcSamples);
-    else
-        rc = debugCreateStreamOut(pInterface, pStream, pCfg, pcSamples);
-
-    LogFlowFunc(("%s: rc=%Rrc\n", pStream->szName, rc));
-    return rc;
-}
 
 static DECLCALLBACK(int) drvHostDebugAudioStreamDestroy(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
@@ -338 +371 @@
 }
 
+
 /**
  * @interface_method_impl{PDMIBASE,pfnQueryInterface}
@@ -351 +385 @@
 }
 
-static DECLCALLBACK(void) drvHostDebugAudioShutdown(PPDMIHOSTAUDIO pInterface)
-{
-    NOREF(pInterface);
-}
 
 /**

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

@@ -93 +93 @@
  * @interface_method_impl{PDMIHOSTAUDIO,pfnGetConfig}
  */
-static DECLCALLBACK(int) drvHostNullAudioGetConfig(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDCFG pCfg)
+PDMAUDIO_IHOSTAUDIO_EMIT_GETCONFIG(drvHostNullAudio)
 {
     NOREF(pInterface);
-    AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
-
-    pCfg->cbStreamOut    = sizeof(NULLAUDIOSTREAMOUT);
-    pCfg->cbStreamIn     = sizeof(NULLAUDIOSTREAMIN);
+    AssertPtrReturn(pBackendCfg, VERR_INVALID_POINTER);
+
+    pBackendCfg->cbStreamOut    = sizeof(NULLAUDIOSTREAMOUT);
+    pBackendCfg->cbStreamIn     = sizeof(NULLAUDIOSTREAMIN);
 
     /* The NULL backend has exactly one input source and one output sink. */
-    pCfg->cSources       = 1;
-    pCfg->cSinks         = 1;
-
-    pCfg->cMaxStreamsOut = 1; /* Output */
-    pCfg->cMaxStreamsIn  = 2; /* Line input + microphone input. */
+    pBackendCfg->cSources       = 1;
+    pBackendCfg->cSinks         = 1;
+
+    pBackendCfg->cMaxStreamsOut = 1; /* Output */
+    pBackendCfg->cMaxStreamsIn  = 2; /* Line input + microphone input. */
 
     return VINF_SUCCESS;
@@ -115 +115 @@
  * @interface_method_impl{PDMIHOSTAUDIO,pfnInit}
  */
-static DECLCALLBACK(int) drvHostNullAudioInit(PPDMIHOSTAUDIO pInterface)
+PDMAUDIO_IHOSTAUDIO_EMIT_INIT(drvHostNullAudio)
 {
     NOREF(pInterface);
@@ -125 +125 @@
 
 /**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnShutdown}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_SHUTDOWN(drvHostNullAudio)
+{
+    RT_NOREF(pInterface);
+}
+
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnGetStatus}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_GETSTATUS(drvHostNullAudio)
+{
+    RT_NOREF(enmDir);
+    AssertPtrReturn(pInterface, PDMAUDIOBACKENDSTS_UNKNOWN);
+
+    return PDMAUDIOBACKENDSTS_RUNNING;
+}
+
+
+/**
  * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamPlay}
  */
-static DECLCALLBACK(int) drvHostNullAudioStreamPlay(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream, uint32_t *pcSamplesPlayed)
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMPLAY(drvHostNullAudio)
 {
     PDRVHOSTNULLAUDIO   pDrv        = RT_FROM_MEMBER(pInterface, DRVHOSTNULLAUDIO, IHostAudio);
@@ -159 +180 @@
     AudioMixBufFinish(&pStream->MixBuf, cSamplesToRead);
 
-    if (pcSamplesPlayed)
-        *pcSamplesPlayed = cSamplesToRead;
+    if (pcbWritten)
+        *pcbWritten = cSamplesToRead;
 
     return VINF_SUCCESS;
@@ -169 +190 @@
  * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCapture}
  */
-static DECLCALLBACK(int)
-drvHostNullAudioStreamCapture(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream, uint32_t *pcSamplesCaptured)
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMCAPTURE(drvHostNullAudio)
 {
     RT_NOREF(pInterface, pStream);
 
     /* Never capture anything. */
-    if (pcSamplesCaptured)
-        *pcSamplesCaptured = 0;
-
-    return VINF_SUCCESS;
-}
-
-
-/**
- * @interface_method_impl{PDMIHOSTAUDIO,pfnGetStatus}
- */
-static DECLCALLBACK(PDMAUDIOBACKENDSTS) drvHostNullAudioGetStatus(PPDMIHOSTAUDIO pInterface, PDMAUDIODIR enmDir)
-{
-    RT_NOREF(enmDir);
-    AssertPtrReturn(pInterface, PDMAUDIOBACKENDSTS_UNKNOWN);
-
-    return PDMAUDIOBACKENDSTS_RUNNING;
-}
-
-
-static int nullCreateStreamIn(PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg, uint32_t *pcSamples)
+    if (pcbRead)
+        *pcbRead = 0;
+
+    return VINF_SUCCESS;
+}
+
+
+static int nullCreateStreamIn(PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
 {
     /* Just adopt the wanted stream configuration. */
-    int rc = DrvAudioHlpStreamCfgToProps(pCfg, &pStream->Props);
+    int rc = DrvAudioHlpStreamCfgToProps(pCfgReq, &pStream->Props);
     if (RT_SUCCESS(rc))
     {
-        if (pcSamples)
-            *pcSamples = _1K;
+        if (pCfgAcq)
+            pCfgAcq->cSamples = _1K;
     }
 
@@ -209 +217 @@
 
 
-static int nullCreateStreamOut(PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg, uint32_t *pcSamples)
+static int nullCreateStreamOut(PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
 {
     /* Just adopt the wanted stream configuration. */
-    int rc = DrvAudioHlpStreamCfgToProps(pCfg, &pStream->Props);
+    int rc = DrvAudioHlpStreamCfgToProps(pCfgReq, &pStream->Props);
     if (RT_SUCCESS(rc))
     {
         PNULLAUDIOSTREAMOUT pNullStream = RT_FROM_MEMBER(pStream, NULLAUDIOSTREAMOUT, Stream);
+
         pNullStream->u64TicksLast  = 0;
         pNullStream->cMaxSamplesInPlayBuffer = _1K;
+
         pNullStream->pbPlayBuffer = (uint8_t *)RTMemAlloc(_1K << pStream->Props.cShift);
         if (pNullStream->pbPlayBuffer)
         {
-            if (pcSamples)
-                *pcSamples = pNullStream->cMaxSamplesInPlayBuffer;
+            if (pCfgAcq)
+                pCfgAcq->cSamples = pNullStream->cMaxSamplesInPlayBuffer;
         }
         else
@@ -236 +246 @@
  * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCreate}
  */
-static DECLCALLBACK(int)
-drvHostNullAudioStreamCreate(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg, uint32_t *pcSamples)
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMCREATE(drvHostNullAudio)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
     AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
-    AssertPtrReturn(pCfg,       VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgReq,    VERR_INVALID_POINTER);
 
     int rc;
-    if (pCfg->enmDir == PDMAUDIODIR_IN)
-        rc = nullCreateStreamIn( pStream, pCfg, pcSamples);
+    if (pCfgReq->enmDir == PDMAUDIODIR_IN)
+        rc = nullCreateStreamIn( pStream, pCfgReq, pCfgAcq);
     else
-        rc = nullCreateStreamOut(pStream, pCfg, pcSamples);
+        rc = nullCreateStreamOut(pStream, pCfgReq, pCfgAcq);
 
     LogFlowFunc(("%s: rc=%Rrc\n", pStream->szName, rc));
@@ -279 +288 @@
  * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamDestroy}
  */
-static DECLCALLBACK(int) drvHostNullAudioStreamDestroy(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMDESTROY(drvHostNullAudio)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
@@ -297 +306 @@
  * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamControl}
  */
-static DECLCALLBACK(int)
-drvHostNullAudioStreamControl(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd)
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMCONTROL(drvHostNullAudio)
 {
     RT_NOREF(enmStreamCmd);
@@ -313 +321 @@
  * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetStatus}
  */
-static DECLCALLBACK(PDMAUDIOSTRMSTS) drvHostNullAudioStreamGetStatus(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMGETSTATUS(drvHostNullAudio)
 {
     RT_NOREF(pInterface, pStream);
@@ -324 +332 @@
  * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamIterate}
  */
-static DECLCALLBACK(int) drvHostNullAudioStreamIterate(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMITERATE(drvHostNullAudio)
 {
     NOREF(pInterface);
@@ -330 +338 @@
 
     return VINF_SUCCESS;
-}
-
-
-/**
- * @interface_method_impl{PDMIHOSTAUDIO,pfnShutdown}
- */
-static DECLCALLBACK(void) drvHostNullAudioShutdown(PPDMIHOSTAUDIO pInterface)
-{
-    RT_NOREF(pInterface);
 }
 
@@ -382 +381 @@
     return VINF_SUCCESS;
 }
+
 
 /**

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

@@ -149 +149 @@
 }
 
+
 static uint32_t lsbindex(uint32_t u)
 {
     return popcount ((u&-u)-1);
 }
+
 
 static int ossAudioFmtToOSS(PDMAUDIOFMT fmt)
@@ -177 +179 @@
     return AFMT_U8;
 }
+
 
 static int ossOSSToAudioFmt(int fmt, PDMAUDIOFMT *pFmt, PDMAUDIOENDIANNESS *pENDIANNESS)
@@ -226 +229 @@
 }
 
+
 static int ossStreamClose(int *phFile)
 {
@@ -246 +250 @@
 }
 
+
 static int ossStreamOpen(const char *pszDev, int fOpen, POSSAUDIOSTREAMCFG pReq, POSSAUDIOSTREAMCFG pObt, int *phFile)
 {
-    AssertPtrReturn(pszDev, VERR_INVALID_POINTER);
-    AssertPtrReturn(pReq,   VERR_INVALID_POINTER);
-    AssertPtrReturn(pObt,   VERR_INVALID_POINTER);
-    AssertPtrReturn(phFile, VERR_INVALID_POINTER);
-
     int rc;
 
@@ -336 +336 @@
 }
 
-static int ossControlStreamIn(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream,
-                              PDMAUDIOSTREAMCMD enmStreamCmd)
-{
-    NOREF(pInterface);
-    NOREF(pStream);
-    NOREF(enmStreamCmd);
+
+static int ossControlStreamIn(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd)
+{
 
     /** @todo Nothing to do here right now!? */
@@ -348 +345 @@
 }
 
-static int ossControlStreamOut(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream,
-                               PDMAUDIOSTREAMCMD enmStreamCmd)
-{
-    NOREF(pInterface);
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-
-    POSSAUDIOSTREAMOUT pThisStream = (POSSAUDIOSTREAMOUT)pStream;
+
+static int ossControlStreamOut(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd)
+{
+    POSSAUDIOSTREAMOUT pStreamOut = (POSSAUDIOSTREAMOUT)pStream;
 
 #ifdef RT_OS_L4
     return VINF_SUCCESS;
 #else
-    if (!pThisStream->fMemMapped)
+    if (!pStreamOut->fMemMapped)
         return VINF_SUCCESS;
 #endif
@@ -370 +364 @@
         case PDMAUDIOSTREAMCMD_RESUME:
         {
-            DrvAudioHlpClearBuf(&pStream->Props,
-                             pThisStream->pvBuf, pThisStream->cbBuf, AudioMixBufSize(&pStream->MixBuf));
+            DrvAudioHlpClearBuf(&pStream->Props, /** @todo Get rid of using Props! */
+                                pStreamOut->pvBuf, pStreamOut->cbBuf, AudioMixBufSize(&pStream->MixBuf));
 
             mask = PCM_ENABLE_OUTPUT;
-            if (ioctl(pThisStream->hFile, SNDCTL_DSP_SETTRIGGER, &mask) < 0)
+            if (ioctl(pStreamOut->hFile, SNDCTL_DSP_SETTRIGGER, &mask) < 0)
             {
                 LogRel(("OSS: Failed to enable output stream: %s\n", strerror(errno)));
@@ -387 +381 @@
         {
             mask = 0;
-            if (ioctl(pThisStream->hFile, SNDCTL_DSP_SETTRIGGER, &mask) < 0)
+            if (ioctl(pStreamOut->hFile, SNDCTL_DSP_SETTRIGGER, &mask) < 0)
             {
                 LogRel(("OSS: Failed to disable output stream: %s\n", strerror(errno)));
@@ -406 +400 @@
 }
 
-static DECLCALLBACK(int) drvHostOSSAudioInit(PPDMIHOSTAUDIO pInterface)
-{
-    NOREF(pInterface);
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnInit}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_INIT(drvHostOSSAudio)
+{
+    RT_NOREF(pInterface);
 
     LogFlowFuncEnter();
@@ -415 +413 @@
 }
 
-static DECLCALLBACK(int) drvHostOSSAudioStreamCapture(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream,
-                                                      uint32_t *pcSamplesCaptured)
-{
-    NOREF(pInterface);
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCapture}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMCAPTURE(drvHostOSSAudio)
+{
+    RT_NOREF(pInterface);
     AssertPtrReturn(pStream, VERR_INVALID_POINTER);
 
@@ -494 +495 @@
             rc = AudioMixBufMixToParent(&pStream->MixBuf, cWrittenTotal, &cProcessed);
 
-        if (pcSamplesCaptured)
-            *pcSamplesCaptured = cWrittenTotal;
+        if (pcbRead)
+            *pcbRead = cWrittenTotal;
 
         LogFlowFunc(("cWrittenTotal=%RU32 (%RU32 processed), rc=%Rrc\n",
@@ -505 +506 @@
 }
 
+
 static int ossDestroyStreamIn(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
 {
-    NOREF(pInterface);
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-
     POSSAUDIOSTREAMIN pStrm = (POSSAUDIOSTREAMIN)pStream;
 
@@ -529 +528 @@
 }
 
+
 static int ossDestroyStreamOut(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
 {
-    NOREF(pInterface);
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-
     POSSAUDIOSTREAMOUT pStrm = (POSSAUDIOSTREAMOUT)pStream;
 
@@ -578 +575 @@
 }
 
-static DECLCALLBACK(int) drvHostOSSAudioGetConfig(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDCFG pCfg)
-{
-    NOREF(pInterface);
-
-    pCfg->cbStreamIn  = sizeof(OSSAUDIOSTREAMIN);
-    pCfg->cbStreamOut = sizeof(OSSAUDIOSTREAMOUT);
-
-    pCfg->cSources    = 0;
-    pCfg->cSinks      = 0;
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnGetConfig}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_GETCONFIG(drvHostOSSAudio)
+{
+    RT_NOREF(pInterface);
+
+    pBackendCfg->cbStreamIn  = sizeof(OSSAUDIOSTREAMIN);
+    pBackendCfg->cbStreamOut = sizeof(OSSAUDIOSTREAMOUT);
+
+    pBackendCfg->cSources    = 0;
+    pBackendCfg->cSinks      = 0;
 
     int hFile = open("/dev/dsp", O_WRONLY | O_NONBLOCK, 0);
@@ -619 +620 @@
                     cDev = ossInfo.numaudios;
 
-                pCfg->cSources        = cDev;
-                pCfg->cSinks          = cDev;
-
-                pCfg->cMaxStreamsIn   = UINT32_MAX;
-                pCfg->cMaxStreamsOut  = UINT32_MAX;
+                pBackendCfg->cSources        = cDev;
+                pBackendCfg->cSinks          = cDev;
+
+                pBackendCfg->cMaxStreamsIn   = UINT32_MAX;
+                pBackendCfg->cMaxStreamsOut  = UINT32_MAX;
             }
             else
@@ -630 +631 @@
                 /* Since we cannot query anything, assume that we have at least
                  * one input and one output if we found "/dev/dsp" or "/dev/mixer". */
-                pCfg->cSources        = 1;
-                pCfg->cSinks          = 1;
-
-                pCfg->cMaxStreamsIn   = UINT32_MAX;
-                pCfg->cMaxStreamsOut  = UINT32_MAX;
+                pBackendCfg->cSources        = 1;
+                pBackendCfg->cSinks          = 1;
+
+                pBackendCfg->cMaxStreamsIn   = UINT32_MAX;
+                pBackendCfg->cMaxStreamsOut  = UINT32_MAX;
 #ifdef VBOX_WITH_AUDIO_OSS_SYSINFO
             }
@@ -648 +649 @@
 }
 
+
 static int ossCreateStreamIn(PPDMIHOSTAUDIO pInterface,
-                             PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg, uint32_t *pcSamples)
-{
-    AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-    AssertPtrReturn(pCfg,       VERR_INVALID_POINTER);
-
+                             PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
+{
+    PDRVHOSTOSSAUDIO  pThis = PDMIHOSTAUDIO_2_DRVHOSTOSSAUDIO(pInterface);
     POSSAUDIOSTREAMIN pStrm = (POSSAUDIOSTREAMIN)pStream;
 
@@ -665 +664 @@
 
         OSSAUDIOSTREAMCFG reqStream, obtStream;
-        reqStream.enmFormat      = pCfg->enmFormat;
-        reqStream.uFreq          = pCfg->uHz;
-        reqStream.cChannels      = pCfg->cChannels;
+        reqStream.enmFormat      = pCfgReq->enmFormat;
+        reqStream.uFreq          = pCfgReq->uHz;
+        reqStream.cChannels      = pCfgReq->cChannels;
         reqStream.cFragments     = s_OSSConf.nfrags;
         reqStream.cbFragmentSize = s_OSSConf.fragsize;
@@ -674 +673 @@
         if (RT_SUCCESS(rc))
         {
-            if (obtStream.cFragments * obtStream.cbFragmentSize & pStream->Props.uAlign)
-                LogRel(("OSS: Warning: Misaligned capturing buffer: Size = %zu, Alignment = %u\n",
-                        obtStream.cFragments * obtStream.cbFragmentSize,
-                        pStream->Props.uAlign + 1));
-
-            PDMAUDIOSTREAMCFG streamCfg;
-            streamCfg.enmFormat     = obtStream.enmFormat;
-            streamCfg.uHz           = obtStream.uFreq;
-            streamCfg.cChannels     = pCfg->cChannels;
-            streamCfg.enmEndianness = obtStream.enmENDIANNESS;
-
-            rc = DrvAudioHlpStreamCfgToProps(&streamCfg, &pStream->Props);
+            pCfgAcq->enmFormat     = obtStream.enmFormat;
+            pCfgAcq->uHz           = obtStream.uFreq;
+            pCfgAcq->cChannels     = pCfgReq->cChannels; /** @todo r=andy Why not using obtStream? */
+            pCfgAcq->enmEndianness = obtStream.enmENDIANNESS;
+
+            PDMPCMPROPS Props;
+            rc = DrvAudioHlpStreamCfgToProps(pCfgAcq, &Props);
             if (RT_SUCCESS(rc))
             {
-                cSamples = (obtStream.cFragments * obtStream.cbFragmentSize)
-                           >> pStream->Props.cShift;
+                if (obtStream.cFragments * obtStream.cbFragmentSize & Props.uAlign)
+                {
+                    LogRel(("OSS: Warning: Misaligned capturing buffer: Size = %zu, Alignment = %u\n",
+                            obtStream.cFragments * obtStream.cbFragmentSize, Props.uAlign + 1));
+                }
+
+                cSamples = (obtStream.cFragments * obtStream.cbFragmentSize) >> Props.cShift;
                 if (!cSamples)
                     rc = VERR_INVALID_PARAMETER;
             }
-        }
-
-        if (RT_SUCCESS(rc))
-        {
-            size_t cbSample = (1 << pStream->Props.cShift);
-
-            size_t cbBuf = cSamples * cbSample;
-            void  *pvBuf = RTMemAlloc(cbBuf);
-            if (!pvBuf)
-            {
-                LogRel(("OSS: Failed allocating capturing buffer with %RU32 samples (%zu bytes per sample)\n",
-                        cSamples, cbSample));
-                rc = VERR_NO_MEMORY;
-                break;
-            }
-
-            pStrm->hFile = hFile;
-            pStrm->pvBuf = pvBuf;
-            pStrm->cbBuf = cbBuf;
-
-            if (pcSamples)
-                *pcSamples = cSamples;
+
+            if (RT_SUCCESS(rc))
+            {
+                size_t cbSample = (1 << Props.cShift);
+
+                size_t cbBuf = cSamples * cbSample;
+                void  *pvBuf = RTMemAlloc(cbBuf);
+                if (!pvBuf)
+                {
+                    LogRel(("OSS: Failed allocating capturing buffer with %RU32 samples (%zu bytes per sample)\n",
+                            cSamples, cbSample));
+                    rc = VERR_NO_MEMORY;
+                    break;
+                }
+
+                pStrm->hFile = hFile;
+                pStrm->pvBuf = pvBuf;
+                pStrm->cbBuf = cbBuf;
+
+                pCfgAcq->cSamples = cSamples;
+            }
         }
 
@@ -726 +724 @@
 }
 
+
 static int ossCreateStreamOut(PPDMIHOSTAUDIO pInterface,
-                              PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg,
-                              uint32_t *pcSamples)
-{
-    AssertPtrReturn(pInterface,  VERR_INVALID_POINTER);
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-    AssertPtrReturn(pCfg,        VERR_INVALID_POINTER);
-
+                              PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
+{
+    PDRVHOSTOSSAUDIO   pThis = PDMIHOSTAUDIO_2_DRVHOSTOSSAUDIO(pInterface);
     POSSAUDIOSTREAMOUT pStrm = (POSSAUDIOSTREAMOUT)pStream;
 
@@ -744 +739 @@
 
         OSSAUDIOSTREAMCFG reqStream, obtStream;
-        reqStream.enmFormat      = pCfg->enmFormat;
-        reqStream.uFreq          = pCfg->uHz;
-        reqStream.cChannels      = pCfg->cChannels;
+        reqStream.enmFormat      = pCfgReq->enmFormat;
+        reqStream.uFreq          = pCfgReq->uHz;
+        reqStream.cChannels      = pCfgReq->cChannels;
         reqStream.cFragments     = s_OSSConf.nfrags;
         reqStream.cbFragmentSize = s_OSSConf.fragsize;
 
+        PDMPCMPROPS Props;
+        RT_ZERO(Props);
+
         rc = ossStreamOpen(s_OSSConf.devpath_out, O_WRONLY | O_NONBLOCK, &reqStream, &obtStream, &hFile);
         if (RT_SUCCESS(rc))
         {
-            if (obtStream.cFragments * obtStream.cbFragmentSize & pStream->Props.uAlign)
-                LogRel(("OSS: Warning: Misaligned playback buffer: Size = %zu, Alignment = %u\n",
-                        obtStream.cFragments * obtStream.cbFragmentSize,
-                        pStream->Props.uAlign + 1));
-
-            PDMAUDIOSTREAMCFG streamCfg;
-            streamCfg.enmFormat     = obtStream.enmFormat;
-            streamCfg.uHz           = obtStream.uFreq;
-            streamCfg.cChannels     = pCfg->cChannels;
-            streamCfg.enmEndianness = obtStream.enmENDIANNESS;
-
-            rc = DrvAudioHlpStreamCfgToProps(&streamCfg, &pStream->Props);
+            pCfgAcq->enmFormat     = obtStream.enmFormat;
+            pCfgAcq->uHz           = obtStream.uFreq;
+            pCfgAcq->cChannels     = pCfgReq->cChannels; /** @todo r=andy Why not using obtStream? */
+            pCfgAcq->enmEndianness = obtStream.enmENDIANNESS;
+
+            rc = DrvAudioHlpStreamCfgToProps(pCfgReq, &Props);
             if (RT_SUCCESS(rc))
-                cSamples = (obtStream.cFragments * obtStream.cbFragmentSize)
-                           >> pStream->Props.cShift;
+            {
+                cSamples = (obtStream.cFragments * obtStream.cbFragmentSize) >> Props.cShift;
+
+                if (obtStream.cFragments * obtStream.cbFragmentSize & Props.uAlign)
+                {
+                    LogRel(("OSS: Warning: Misaligned playback buffer: Size = %zu, Alignment = %u\n",
+                            obtStream.cFragments * obtStream.cbFragmentSize, Props.uAlign + 1));
+                }
+            }
         }
 
@@ -774 +773 @@
             pStrm->fMemMapped = false;
 
-            size_t cbSamples =  cSamples << pStream->Props.cShift;
+            size_t cbSamples =  cSamples << Props.cShift;
             Assert(cbSamples);
 
@@ -839 +838 @@
             }
 #endif
-            if (pcSamples)
-                *pcSamples = cSamples;
+            pCfgAcq->cSamples = cSamples;
         }
 
@@ -852 +850 @@
 }
 
-static DECLCALLBACK(int) drvHostOSSAudioStreamPlay(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream, uint32_t *pcSamplesPlayed)
-{
-    NOREF(pInterface);
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamPlay}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMPLAY(drvHostOSSAudio)
+{
+    RT_NOREF(pInterface);
     AssertPtrReturn(pStream, VERR_INVALID_POINTER);
 
@@ -865 +867 @@
     do
     {
-        size_t cbBuf = AudioMixBufSizeBytes(&pStream->MixBuf);
+        size_t cbBufSize = AudioMixBufSizeBytes(&pStream->MixBuf);
 
         uint32_t cLive = AudioMixBufLive(&pStream->MixBuf);
@@ -891 +893 @@
                 cbData = cntinfo.ptr - pStrm->old_optr;
             else
-                cbData = cbBuf + cntinfo.ptr - pStrm->old_optr;
+                cbData = cbBufSize + cntinfo.ptr - pStrm->old_optr;
             Assert(cbData);
 
@@ -909 +911 @@
             }
 
-            if ((size_t)abinfo.bytes > cbBuf)
-            {
-                LogFlowFunc(("Warning: Invalid available size, size=%d, bufsize=%zu\n", abinfo.bytes, cbBuf));
-                abinfo.bytes = cbBuf;
+            if ((size_t)abinfo.bytes > cbBufSize)
+            {
+                LogFlowFunc(("Warning: Invalid available size, size=%d, bufsize=%zu\n", abinfo.bytes, cbBufSize));
+                abinfo.bytes = cbBufSize;
                 /* Keep going. */
             }
@@ -918 +920 @@
             if (abinfo.bytes < 0)
             {
-                LogFlowFunc(("Warning: Invalid available size, size=%d, bufsize=%zu\n", abinfo.bytes, cbBuf));
+                LogFlowFunc(("Warning: Invalid available size, size=%d, bufsize=%zu\n", abinfo.bytes, cbBufSize));
                 rc = VERR_INVALID_PARAMETER;
                 break;
@@ -967 +969 @@
             AudioMixBufFinish(&pStream->MixBuf, cReadTotal);
 
-        if (pcSamplesPlayed)
-            *pcSamplesPlayed = cReadTotal;
+        if (pcbWritten)
+            *pcbWritten = cReadTotal;
 
         LogFlowFunc(("cReadTotal=%RU32 (%RU32 bytes), rc=%Rrc\n", cReadTotal, cbReadTotal, rc));
@@ -977 +979 @@
 }
 
-static DECLCALLBACK(void) drvHostOSSAudioShutdown(PPDMIHOSTAUDIO pInterface)
-{
-    NOREF(pInterface);
-}
-
-static DECLCALLBACK(PDMAUDIOBACKENDSTS) drvHostOSSAudioGetStatus(PPDMIHOSTAUDIO pInterface, PDMAUDIODIR enmDir)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnShutdown}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_SHUTDOWN(drvHostOSSAudio)
+{
+    RT_NOREF(pInterface);
+}
+
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnGetStatus}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_GETSTATUS(drvHostOSSAudio)
 {
     AssertPtrReturn(pInterface, PDMAUDIOBACKENDSTS_UNKNOWN);
@@ -990 +1000 @@
 }
 
-static DECLCALLBACK(int) drvHostOSSAudioStreamCreate(PPDMIHOSTAUDIO pInterface,
-                                                     PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg, uint32_t *pcSamples)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCreate}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMCREATE(drvHostOSSAudio)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
     AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
-    AssertPtrReturn(pCfg,       VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgReq,    VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgAcq,    VERR_INVALID_POINTER);
 
     int rc;
-    if (pCfg->enmDir == PDMAUDIODIR_IN)
-        rc = ossCreateStreamIn(pInterface,  pStream, pCfg, pcSamples);
+    if (pCfgReq->enmDir == PDMAUDIODIR_IN)
+        rc = ossCreateStreamIn(pInterface,  pStream, pCfgReq, pCfgAcq);
     else
-        rc = ossCreateStreamOut(pInterface, pStream, pCfg, pcSamples);
-
-    LogFlowFunc(("%s: rc=%Rrc\n", pStream->szName, rc));
+        rc = ossCreateStreamOut(pInterface, pStream, pCfgReq, pCfgAcq);
+
     return rc;
 }
 
-static DECLCALLBACK(int) drvHostOSSAudioStreamDestroy(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamDestroy}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMDESTROY(drvHostOSSAudio)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
@@ -1021 +1038 @@
 }
 
-static DECLCALLBACK(int) drvHostOSSAudioStreamControl(PPDMIHOSTAUDIO pInterface,
-                                                      PPDMAUDIOSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamControl}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMCONTROL(drvHostOSSAudio)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
@@ -1038 +1058 @@
 }
 
-static DECLCALLBACK(int) drvHostOSSAudioStreamIterate(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamIterate}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMITERATE(drvHostOSSAudio)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
@@ -1049 +1073 @@
 }
 
-static DECLCALLBACK(PDMAUDIOSTRMSTS) drvHostOSSAudioStreamGetStatus(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
-{
-    NOREF(pInterface);
-    NOREF(pStream);
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetStatus}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMGETSTATUS(drvHostOSSAudio)
+{
+    RT_NOREF(pInterface);
+    RT_NOREF(pStream);
 
     PDMAUDIOSTRMSTS strmSts =   PDMAUDIOSTRMSTS_FLAG_INITIALIZED
@@ -1063 +1091 @@
     return strmSts;
 }
+
 /**
  * @interface_method_impl{PDMIBASE,pfnQueryInterface}
@@ -1068 +1097 @@
 static DECLCALLBACK(void *) drvHostOSSAudioQueryInterface(PPDMIBASE pInterface, const char *pszIID)
 {
-    PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
-    PDRVHOSTOSSAUDIO  pThis   = PDMINS_2_DATA(pDrvIns, PDRVHOSTOSSAUDIO);
+    PPDMDRVINS       pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
+    PDRVHOSTOSSAUDIO pThis   = PDMINS_2_DATA(pDrvIns, PDRVHOSTOSSAUDIO);
+
     PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
     PDMIBASE_RETURN_INTERFACE(pszIID, PDMIHOSTAUDIO, &pThis->IHostAudio);

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

@@ -167 +167 @@
 static void paStreamCbSuccess(pa_stream *pStream, int fSuccess, void *pvContext);
 
+
+
 /**
  * Signal the main loop to abort. Just signalling isn't sufficient as the
@@ -179 +181 @@
     pa_threaded_mainloop_signal(pThis->pMainLoop, 0);
 }
+
 
 static pa_sample_format_t paFmtToPulse(PDMAUDIOFMT fmt)
@@ -202 +205 @@
 }
 
+
 static int paPulseToFmt(pa_sample_format_t pulsefmt,
                         PDMAUDIOFMT *pFmt, PDMAUDIOENDIANNESS *pEndianness)
@@ -244 +248 @@
 }
 
+
 /**
  * Synchronously wait until an operation completed.
@@ -277 +282 @@
 }
 
+
 static int paWaitFor(PDRVHOSTPULSEAUDIO pThis, pa_operation *pOP)
 {
     return paWaitForEx(pThis, pOP, 10 * 1000 /* 10s timeout */);
 }
+
 
 /**
@@ -309 +316 @@
 }
 
+
 /**
  * Callback called when our pa_stream_drain operation was completed.
@@ -334 +342 @@
     }
 }
+
 
 /**
@@ -358 +367 @@
 }
 
+
 static void paStreamCbSuccess(pa_stream *pStream, int fSuccess, void *pvUser)
 {
@@ -372 +382 @@
         paError(pStrm->pDrv, "Failed to finish stream operation");
 }
+
 
 static int paStreamOpen(PDRVHOSTPULSEAUDIO pThis, bool fIn, const char *pszName,
@@ -508 +519 @@
 }
 
-static DECLCALLBACK(int) drvHostPulseAudioInit(PPDMIHOSTAUDIO pInterface)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnInit}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_INIT(drvHostPulseAudio)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
@@ -616 +631 @@
 }
 
+
 static int paCreateStreamOut(PPDMIHOSTAUDIO pInterface,
-                             PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg, uint32_t *pcSamples)
-{
-    AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
-    AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
-    AssertPtrReturn(pCfg,       VERR_INVALID_POINTER);
-    /* pcSamples is optional. */
-
+                             PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
+{
     PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
     PPULSEAUDIOSTREAM  pStrm = (PPULSEAUDIOSTREAM)pStream;
@@ -631 +642 @@
     pStrm->pDrainOp            = NULL;
 
-    pStrm->SampleSpec.format   = paFmtToPulse(pCfg->enmFormat);
-    pStrm->SampleSpec.rate     = pCfg->uHz;
-    pStrm->SampleSpec.channels = pCfg->cChannels;
+    pStrm->SampleSpec.format   = paFmtToPulse(pCfgReq->enmFormat);
+    pStrm->SampleSpec.rate     = pCfgReq->uHz;
+    pStrm->SampleSpec.channels = pCfgReq->cChannels;
 
     /* Note that setting maxlength to -1 does not work on PulseAudio servers
@@ -648 +659 @@
         return rc;
 
-    PDMAUDIOSTREAMCFG streamCfg;
     rc = paPulseToFmt(pStrm->SampleSpec.format,
-                      &streamCfg.enmFormat, &streamCfg.enmEndianness);
+                      &pCfgAcq->enmFormat, &pCfgAcq->enmEndianness);
     if (RT_FAILURE(rc))
     {
@@ -657 +667 @@
     }
 
-    streamCfg.uHz       = pStrm->SampleSpec.rate;
-    streamCfg.cChannels = pStrm->SampleSpec.channels;
-
-    rc = DrvAudioHlpStreamCfgToProps(&streamCfg, &pStream->Props);
+    pCfgAcq->uHz       = pStrm->SampleSpec.rate;
+    pCfgAcq->cChannels = pStrm->SampleSpec.channels;
+
+    rc = DrvAudioHlpStreamCfgToProps(pCfgAcq, &pStream->Props);
     if (RT_SUCCESS(rc))
     {
@@ -672 +682 @@
                 pStrm->cbPCMBuf = cbBuf;
 
-                uint32_t cSamples = cbBuf >> pStream->Props.cShift;
-                if (pcSamples)
-                    *pcSamples = cSamples;
+                pCfgAcq->cSamples = cbBuf >> pStream->Props.cShift; /** @todo Get rid of using Props! */
 
                 /* Save pointer to driver instance. */
                 pStrm->pDrv = pThis;
-
-                LogFunc(("cbBuf=%RU32, cSamples=%RU32\n", cbBuf, cSamples));
             }
             else
@@ -692 +698 @@
 }
 
+
 static int paCreateStreamIn(PPDMIHOSTAUDIO pInterface,
-                            PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg, uint32_t *pcSamples)
-{
-    AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-    AssertPtrReturn(pCfg,       VERR_INVALID_POINTER);
-    /* pcSamples is optional. */
-
+                            PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
+{
     PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
     PPULSEAUDIOSTREAM  pStrm = (PPULSEAUDIOSTREAM)pStream;
 
-    pStrm->SampleSpec.format   = paFmtToPulse(pCfg->enmFormat);
-    pStrm->SampleSpec.rate     = pCfg->uHz;
-    pStrm->SampleSpec.channels = pCfg->cChannels;
+    pStrm->SampleSpec.format   = paFmtToPulse(pCfgReq->enmFormat);
+    pStrm->SampleSpec.rate     = pCfgReq->uHz;
+    pStrm->SampleSpec.channels = pCfgReq->cChannels;
 
     /* XXX check these values */
@@ -718 +720 @@
         return rc;
 
-    PDMAUDIOSTREAMCFG streamCfg;
-    rc = paPulseToFmt(pStrm->SampleSpec.format, &streamCfg.enmFormat,
-                      &streamCfg.enmEndianness);
+    rc = paPulseToFmt(pStrm->SampleSpec.format, &pCfgAcq->enmFormat,
+                      &pCfgAcq->enmEndianness);
     if (RT_FAILURE(rc))
     {
@@ -727 +728 @@
     }
 
-    streamCfg.uHz       = pStrm->SampleSpec.rate;
-    streamCfg.cChannels = pStrm->SampleSpec.channels;
-
-    rc = DrvAudioHlpStreamCfgToProps(&streamCfg, &pStream->Props);
+    pCfgAcq->uHz       = pStrm->SampleSpec.rate;
+    pCfgAcq->cChannels = pStrm->SampleSpec.channels;
+
+    rc = DrvAudioHlpStreamCfgToProps(pCfgAcq, &pStream->Props);
     if (RT_SUCCESS(rc))
     {
-        uint32_t cSamples = RT_MIN(pStrm->BufAttr.fragsize * 10, pStrm->BufAttr.maxlength)
-                            >> pStream->Props.cShift;
-
-        LogFunc(("uHz=%RU32, cChannels=%RU8, cShift=%RU8, cSamples=%RU32\n",
-                 pStream->Props.uHz, pStream->Props.cChannels, pStream->Props.cShift, cSamples));
+        pCfgAcq->cSamples = RT_MIN(pStrm->BufAttr.fragsize * 10, pStrm->BufAttr.maxlength)
+                            >> pStream->Props.cShift; /** @todo Get rid of using Props! */
 
         /* Save pointer to driver instance. */
         pStrm->pDrv       = pThis;
         pStrm->pu8PeekBuf = NULL;
-
-        if (pcSamples)
-            *pcSamples = cSamples;
     }
 
@@ -751 +746 @@
 }
 
-static DECLCALLBACK(int) drvHostPulseAudioStreamCapture(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream,
-                                                        uint32_t *pcSamplesCaptured)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCapture}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMCAPTURE(drvHostPulseAudio)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
     AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
-    /* pcSamplesPlayed is optional. */
+    /* pcbRead is optional. */
 
     PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
@@ -780 +778 @@
     if (!cbAvail) /* No data? Bail out. */
     {
-        if (pcSamplesCaptured)
-            *pcSamplesCaptured = 0;
+        if (pcbRead)
+            *pcbRead = 0;
         return VINF_SUCCESS;
     }
@@ -861 +859 @@
             rc = AudioMixBufMixToParent(&pStream->MixBuf, cWrittenTotal,
                                         &cProcessed);*/
-
-        if (pcSamplesCaptured)
-            *pcSamplesCaptured = cWrittenTotal;
+        if (pcbRead)
+            *pcbRead = cWrittenTotal;
 
         LogFlowFunc(("cWrittenTotal=%RU32 (%RU32 processed), rc=%Rrc\n",
@@ -873 +870 @@
 }
 
-static DECLCALLBACK(int) drvHostPulseAudioStreamPlay(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream,
-                                                     uint32_t *pcSamplesPlayed)
-{
-    AssertPtrReturn(pInterface,  VERR_INVALID_POINTER);
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-    /* pcSamplesPlayed is optional. */
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamPlay}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMPLAY(drvHostPulseAudio)
+{
+    AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
+    AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
+    /* pcbWritten is optional. */
 
     PDRVHOSTPULSEAUDIO pThis     = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
@@ -890 +890 @@
     {
         LogFlowFunc(("No live samples, skipping\n"));
-        if (pcSamplesPlayed)
-            *pcSamplesPlayed = 0;
+        if (pcbWritten)
+            *pcbWritten = 0;
         return VINF_SUCCESS;
     }
@@ -949 +949 @@
             AudioMixBufFinish(&pStream->MixBuf, cReadTotal);
 
-        if (pcSamplesPlayed)
-            *pcSamplesPlayed = cReadTotal;
+        if (pcbWritten)
+            *pcbWritten = cReadTotal;
 
         LogFlowFunc(("cReadTotal=%RU32 (%RU32 bytes), rc=%Rrc\n", cReadTotal, cbReadTotal, rc));
@@ -959 +959 @@
 }
 
+
 /** @todo Implement va handling. */
 static int paError(PDRVHOSTPULSEAUDIO pThis, const char *szMsg)
@@ -974 +975 @@
     return VERR_GENERAL_FAILURE;
 }
+
 
 static void paEnumSinkCb(pa_context *pCtx, const pa_sink_info *pInfo, int eol, void *pvUserData)
@@ -995 +997 @@
 }
 
+
 static void paEnumSourceCb(pa_context *pCtx, const pa_source_info *pInfo, int eol, void *pvUserData)
 {
@@ -1015 +1018 @@
 }
 
+
 static void paEnumServerCb(pa_context *pCtx, const pa_server_info *pInfo, void *pvUserData)
 {
@@ -1040 +1044 @@
     pa_threaded_mainloop_signal(pThis->pMainLoop, 0);
 }
+
 
 static int paEnumerate(PDRVHOSTPULSEAUDIO pThis, PPDMAUDIOBACKENDCFG pCfg, uint32_t fEnum)
@@ -1134 +1139 @@
 }
 
+
 static int paDestroyStreamIn(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
 {
@@ -1158 +1164 @@
     return VINF_SUCCESS;
 }
+
 
 static int paDestroyStreamOut(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
@@ -1197 +1204 @@
     return VINF_SUCCESS;
 }
+
 
 static int paControlStreamOut(PPDMIHOSTAUDIO pInterface,
@@ -1261 +1269 @@
 }
 
+
 static int paControlStreamIn(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream,
                              PDMAUDIOSTREAMCMD enmStreamCmd)
@@ -1309 +1318 @@
 }
 
-static DECLCALLBACK(void) drvHostPulseAudioShutdown(PPDMIHOSTAUDIO pInterface)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnShutdown}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_SHUTDOWN(drvHostPulseAudio)
 {
     AssertPtrReturnVoid(pInterface);
@@ -1336 +1349 @@
 }
 
-static DECLCALLBACK(int) drvHostPulseAudioGetConfig(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDCFG pCfg)
-{
-    AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
-    AssertPtrReturn(pCfg,       VERR_INVALID_POINTER);
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnGetConfig}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_GETCONFIG(drvHostPulseAudio)
+{
+    AssertPtrReturn(pInterface,  VERR_INVALID_POINTER);
+    AssertPtrReturn(pBackendCfg, VERR_INVALID_POINTER);
 
     PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
 
-    return paEnumerate(pThis, pCfg, PULSEAUDIOENUMCBFLAGS_LOG /* fEnum */);
-}
-
-static DECLCALLBACK(PDMAUDIOBACKENDSTS) drvHostPulseAudioGetStatus(PPDMIHOSTAUDIO pInterface, PDMAUDIODIR enmDir)
+    return paEnumerate(pThis, pBackendCfg, PULSEAUDIOENUMCBFLAGS_LOG /* fEnum */);
+}
+
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnGetStatus}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_GETSTATUS(drvHostPulseAudio)
 {
     RT_NOREF(enmDir);
@@ -1354 +1375 @@
 }
 
-static DECLCALLBACK(int) drvHostPulseAudioStreamCreate(PPDMIHOSTAUDIO pInterface,
-                                                       PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg, uint32_t *pcSamples)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCreate}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMCREATE(drvHostPulseAudio)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
     AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
-    AssertPtrReturn(pCfg,       VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgReq,    VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgAcq,    VERR_INVALID_POINTER);
 
     int rc;
-    if (pCfg->enmDir == PDMAUDIODIR_IN)
-        rc = paCreateStreamIn(pInterface,  pStream, pCfg, pcSamples);
+    if (pCfgReq->enmDir == PDMAUDIODIR_IN)
+        rc = paCreateStreamIn(pInterface,  pStream, pCfgReq, pCfgAcq);
     else if (pStream->enmDir == PDMAUDIODIR_OUT)
-        rc = paCreateStreamOut(pInterface, pStream, pCfg, pcSamples);
+        rc = paCreateStreamOut(pInterface, pStream, pCfgReq, pCfgAcq);
     else
         AssertFailedReturn(VERR_NOT_IMPLEMENTED);
 
-    LogFlowFunc(("%s: rc=%Rrc\n", pStream->szName, rc));
     return rc;
 }
 
-static DECLCALLBACK(int) drvHostPulseAudioStreamDestroy(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamDestroy}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMDESTROY(drvHostPulseAudio)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
     AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
-
-    LogFlowFunc(("%s\n", pStream->szName));
 
     int rc;
@@ -1388 +1414 @@
         AssertFailedReturn(VERR_NOT_IMPLEMENTED);
 
-    LogFlowFunc(("%s: rc=%Rrc\n", pStream->szName, rc));
     return rc;
 }
 
-static DECLCALLBACK(int) drvHostPulseAudioStreamControl(PPDMIHOSTAUDIO pInterface,
-                                                        PPDMAUDIOSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamControl}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMCONTROL(drvHostPulseAudio)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
@@ -1408 +1436 @@
         AssertFailedReturn(VERR_NOT_IMPLEMENTED);
 
-    LogFlowFunc(("%s: rc=%Rrc\n", pStream->szName, rc));
     return rc;
 }
 
-static DECLCALLBACK(PDMAUDIOSTRMSTS) drvHostPulseAudioStreamGetStatus(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetStatus}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMGETSTATUS(drvHostPulseAudio)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
@@ -1449 +1480 @@
 }
 
-static DECLCALLBACK(int) drvHostPulseAudioStreamIterate(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetConfig}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMITERATE(drvHostPulseAudio)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
     AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
+
     LogFlowFuncEnter();
 
@@ -1458 +1494 @@
     return VINF_SUCCESS;
 }
+
 
 /**

trunk/src/VBox/Main/src-client/DrvAudioVRDE.cpp

@@ -85 +85 @@
 
 
+
 static int vrdeCreateStreamIn(PPDMIHOSTAUDIO pInterface,
-                              PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg, uint32_t *pcSamples)
-{
-    PDRVAUDIOVRDE pDrv = RT_FROM_MEMBER(pInterface, DRVAUDIOVRDE, IHostAudio);
-    AssertPtrReturn(pDrv, VERR_INVALID_POINTER);
-
+                              PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
+{
+    AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
+    AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgReq,    VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgAcq,    VERR_INVALID_POINTER);
+
+    PDRVAUDIOVRDE pDrv        = RT_FROM_MEMBER(pInterface, DRVAUDIOVRDE, IHostAudio);
     PVRDESTREAMIN pVRDEStrmIn = (PVRDESTREAMIN)pStream;
-    AssertPtrReturn(pVRDEStrmIn, VERR_INVALID_POINTER);
-
-    if (pcSamples)
-        *pcSamples = _4K; /** @todo Make this configurable. */
-
-    return DrvAudioHlpStreamCfgToProps(pCfg, &pVRDEStrmIn->Stream.Props);
-}
+
+    if (pCfgAcq)
+        pCfgAcq->cSamples = _4K; /** @todo Make this configurable. */
+
+    LogFlowFuncLeaveRC(VINF_SUCCESS);
+    return VINF_SUCCESS;
+}
+
 
 static int vrdeCreateStreamOut(PPDMIHOSTAUDIO pInterface,
-                               PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg, uint32_t *pcSamples)
-{
-    PDRVAUDIOVRDE pDrv = RT_FROM_MEMBER(pInterface, DRVAUDIOVRDE, IHostAudio);
-    AssertPtrReturn(pDrv, VERR_INVALID_POINTER);
-
-    LogFlowFunc(("pStream=%p, pCfg=%p\n", pStream, pCfg));
-
+                               PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
+{
+    AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
+    AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgReq,    VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgAcq,    VERR_INVALID_POINTER);
+
+    PDRVAUDIOVRDE  pDrv         = RT_FROM_MEMBER(pInterface, DRVAUDIOVRDE, IHostAudio);
     PVRDESTREAMOUT pVRDEStrmOut = (PVRDESTREAMOUT)pStream;
-    AssertPtrReturn(pVRDEStrmOut, VERR_INVALID_POINTER);
-
-    if (pcSamples)
-        *pcSamples = _4K; /** @todo Make this configurable. */
-
-    return DrvAudioHlpStreamCfgToProps(pCfg, &pVRDEStrmOut->Stream.Props);
-}
+
+    if (pCfgAcq)
+        pCfgAcq->cSamples = _4K; /** @todo Make this configurable. */
+
+    LogFlowFuncLeaveRC(VINF_SUCCESS);
+    return VINF_SUCCESS;
+}
+
 
 static int vrdeControlStreamOut(PPDMIHOSTAUDIO pInterface,
@@ -133 +140 @@
     return VINF_SUCCESS;
 }
+
 
 static int vrdeControlStreamIn(PPDMIHOSTAUDIO pInterface,
@@ -174 +182 @@
 }
 
-static DECLCALLBACK(int) drvAudioVRDEInit(PPDMIHOSTAUDIO pInterface)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnInit}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_INIT(drvAudioVRDE)
 {
     RT_NOREF(pInterface);
@@ -182 +194 @@
 }
 
-/**
- * {FIXME - Missing brief description - FIXME}
- *
- * Transfers audio input formerly sent by a connected RDP client / VRDE backend
- * (using the onVRDEInputXXX methods) over to the VRDE host (VM). The audio device
- * emulation then will read and send the data to the guest.
- *
- * @return  IPRT status code.
- * @param   pInterface
- * @param   pStream
- * @param   pcSamplesCaptured
- */
-static DECLCALLBACK(int) drvAudioVRDEStreamCapture(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream,
-                                                   uint32_t *pcSamplesCaptured)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCapture}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMCAPTURE(drvAudioVRDE)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-    AssertPtrReturn(pcSamplesCaptured, VERR_INVALID_POINTER);
-
-    PDRVAUDIOVRDE pDrv = RT_FROM_MEMBER(pInterface, DRVAUDIOVRDE, IHostAudio);
-    AssertPtrReturn(pDrv, VERR_INVALID_POINTER);
-
+    AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
+    /* pcbRead is optional. */
+
+    PDRVAUDIOVRDE pDrv        = RT_FROM_MEMBER(pInterface, DRVAUDIOVRDE, IHostAudio);
     PVRDESTREAMIN pVRDEStrmIn = (PVRDESTREAMIN)pStream;
-    AssertPtrReturn(pVRDEStrmIn, VERR_INVALID_POINTER);
 
     /** @todo Use CritSect! */
@@ -222 +222 @@
     if (RT_SUCCESS(rc))
     {
-        *pcSamplesCaptured = cProcessed;
-
         Assert(pVRDEStrmIn->cSamplesCaptured >= cProcessed);
         pVRDEStrmIn->cSamplesCaptured -= cProcessed;
+
+        if (pcbRead)
+            *pcbRead = cProcessed;
     }
 
@@ -232 +233 @@
 }
 
-/**
- * Transfers VM audio output to remote client.
- *
- * Transfers VM audio output over to the VRDE instance for playing remotely
- * on the client.
- *
- * @return  IPRT status code.
- * @param   pInterface
- * @param   pStream
- * @param   pcSamplesPlayed
- */
-static DECLCALLBACK(int) drvAudioVRDEStreamPlay(PPDMIHOSTAUDIO pInterface,
-                                                PPDMAUDIOSTREAM pStream, uint32_t *pcSamplesPlayed)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamPlay}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMPLAY(drvAudioVRDE)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
     AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
-    /* pcSamplesPlayed is optional. */
-
-    PDRVAUDIOVRDE pDrv = RT_FROM_MEMBER(pInterface, DRVAUDIOVRDE, IHostAudio);
-    AssertPtrReturn(pDrv, VERR_INVALID_POINTER);
-
+    /* pcbWritten is optional. */
+
+    PDRVAUDIOVRDE  pDrv         = RT_FROM_MEMBER(pInterface, DRVAUDIOVRDE, IHostAudio);
     PVRDESTREAMOUT pVRDEStrmOut = (PVRDESTREAMOUT)pStream;
-    AssertPtrReturn(pVRDEStrmOut, VERR_INVALID_POINTER);
 
     uint32_t cLive = AudioMixBufLive(&pStream->MixBuf);
@@ -316 +306 @@
      * VRDP server actually did process those.
      */
-    if (pcSamplesPlayed)
-        *pcSamplesPlayed = cReadTotal;
+    if (pcbWritten)
+        *pcbWritten = cReadTotal;
 
     LogFlowFunc(("cReadTotal=%RU32, rc=%Rrc\n", cReadTotal, rc));
     return rc;
 }
+
 
 static int vrdeDestroyStreamIn(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
@@ -335 +326 @@
 }
 
+
 static int vrdeDestroyStreamOut(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
 {
@@ -344 +336 @@
 }
 
-static DECLCALLBACK(int) drvAudioVRDEGetConfig(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDCFG pCfg)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnGetConfig}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_GETCONFIG(drvAudioVRDE)
 {
     NOREF(pInterface);
-    AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
-
-    pCfg->cbStreamOut    = sizeof(VRDESTREAMOUT);
-    pCfg->cbStreamIn     = sizeof(VRDESTREAMIN);
-    pCfg->cMaxStreamsIn  = UINT32_MAX;
-    pCfg->cMaxStreamsOut = UINT32_MAX;
-    pCfg->cSources       = 1;
-    pCfg->cSinks         = 1;
-
-    return VINF_SUCCESS;
-}
-
-static DECLCALLBACK(void) drvAudioVRDEShutdown(PPDMIHOSTAUDIO pInterface)
+    AssertPtrReturn(pBackendCfg, VERR_INVALID_POINTER);
+
+    pBackendCfg->cbStreamOut    = sizeof(VRDESTREAMOUT);
+    pBackendCfg->cbStreamIn     = sizeof(VRDESTREAMIN);
+    pBackendCfg->cMaxStreamsIn  = UINT32_MAX;
+    pBackendCfg->cMaxStreamsOut = UINT32_MAX;
+    pBackendCfg->cSources       = 1;
+    pBackendCfg->cSinks         = 1;
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnShutdown}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_SHUTDOWN(drvAudioVRDE)
 {
     PDRVAUDIOVRDE pDrv = RT_FROM_MEMBER(pInterface, DRVAUDIOVRDE, IHostAudio);
@@ -368 +368 @@
 }
 
-static DECLCALLBACK(PDMAUDIOBACKENDSTS) drvAudioVRDEGetStatus(PPDMIHOSTAUDIO pInterface, PDMAUDIODIR enmDir)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnGetStatus}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_GETSTATUS(drvAudioVRDE)
 {
     RT_NOREF(enmDir);
@@ -376 +380 @@
 }
 
-static DECLCALLBACK(int) drvAudioVRDEStreamCreate(PPDMIHOSTAUDIO pInterface,
-                                                  PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg, uint32_t *pcSamples)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCreate}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMCREATE(drvAudioVRDE)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
     AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
-    AssertPtrReturn(pCfg,       VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgReq,    VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgAcq,    VERR_INVALID_POINTER);
 
     int rc;
-    if (pCfg->enmDir == PDMAUDIODIR_IN)
-        rc = vrdeCreateStreamIn(pInterface,  pStream, pCfg, pcSamples);
+    if (pCfgReq->enmDir == PDMAUDIODIR_IN)
+        rc = vrdeCreateStreamIn(pInterface,  pStream, pCfgReq, pCfgAcq);
     else
-        rc = vrdeCreateStreamOut(pInterface, pStream, pCfg, pcSamples);
-
-    LogFlowFunc(("%s: rc=%Rrc\n", pStream->szName, rc));
+        rc = vrdeCreateStreamOut(pInterface, pStream, pCfgReq, pCfgAcq);
+
     return rc;
 }
 
-static DECLCALLBACK(int) drvAudioVRDEStreamDestroy(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamDestroy}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMDESTROY(drvAudioVRDE)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
@@ -407 +418 @@
 }
 
-static DECLCALLBACK(int) drvAudioVRDEStreamControl(PPDMIHOSTAUDIO pInterface,
-                                                   PPDMAUDIOSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamControl}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMCONTROL(drvAudioVRDE)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
@@ -424 +438 @@
 }
 
-static DECLCALLBACK(PDMAUDIOSTRMSTS) drvAudioVRDEStreamGetStatus(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetStatus}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMGETSTATUS(drvAudioVRDE)
 {
     NOREF(pInterface);
@@ -433 +451 @@
 }
 
-static DECLCALLBACK(int) drvAudioVRDEStreamIterate(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamIterate}
+ */
+PDMAUDIO_IHOSTAUDIO_EMIT_STREAMITERATE(drvAudioVRDE)
 {
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
@@ -443 +465 @@
     return VINF_SUCCESS;
 }
+
 
 /**
@@ -457 +480 @@
 }
 
+
 AudioVRDE::AudioVRDE(Console *pConsole)
     : mpDrv(NULL),
@@ -462 +486 @@
 {
 }
+
 
 AudioVRDE::~AudioVRDE(void)
@@ -472 +497 @@
 }
 
+
 int AudioVRDE::onVRDEControl(bool fEnable, uint32_t uFlags)
 {
@@ -484 +510 @@
     return VINF_SUCCESS; /* Never veto. */
 }
+
 
 /**
@@ -515 +542 @@
 }
 
+
 int AudioVRDE::onVRDEInputData(void *pvContext, const void *pvData, uint32_t cbData)
 {
@@ -535 +563 @@
 }
 
+
 int AudioVRDE::onVRDEInputEnd(void *pvContext)
 {
@@ -541 +570 @@
     return VINF_SUCCESS;
 }
+
 
 int AudioVRDE::onVRDEInputIntercept(bool fEnabled)
@@ -547 +577 @@
     return VINF_SUCCESS; /* Never veto. */
 }
+
 
 /**
@@ -557 +588 @@
 {
     RT_NOREF(fFlags);
+
     PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
     PDRVAUDIOVRDE pThis = PDMINS_2_DATA(pDrvIns, PDRVAUDIOVRDE);
+
     AssertPtrReturn(pDrvIns, VERR_INVALID_POINTER);
     AssertPtrReturn(pCfg, VERR_INVALID_POINTER);