Changeset 65410 in vbox for trunk/src/VBox/Main/src-client

Timestamp:

Jan 24, 2017 10:06:12 AM (8 years ago)

Author:

vboxsync

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

113018

Message:

VideoRec: Interface work, added container / codec configuration stuff.

Location:

trunk/src/VBox/Main/src-client

Files:

• ConsoleImpl.cpp (modified) (2 diffs)
• ConsoleImpl2.cpp (modified) (1 diff)
• DisplayImpl.cpp (modified) (8 diffs)
• DrvAudioVideoRec.cpp (modified) (20 diffs)
• VideoRec.cpp (modified) (1 diff)
• VideoRec.h (modified) (1 diff)

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

@@ -5394 +5394 @@
             int vrc = VINF_SUCCESS;
             if (SUCCEEDED(rc))
-                vrc = mDisplay->i_VideoCaptureEnableScreens(ComSafeArrayAsInParam(screens));
+                vrc = mDisplay->i_videoCaptureEnableScreens(ComSafeArrayAsInParam(screens));
             if (RT_SUCCESS(vrc))
             {
                 if (fEnabled)
                 {
-                    vrc = mDisplay->i_VideoCaptureStart();
+                    vrc = mDisplay->i_videoCaptureStart();
                     if (RT_FAILURE(vrc))
                         rc = setError(E_FAIL, tr("Unable to start video capturing (%Rrc)"), vrc);
                 }
                 else
-                    mDisplay->i_VideoCaptureStop();
+                    mDisplay->i_videoCaptureStop();
             }
             else
@@ -6575 +6575 @@
     return S_OK;
 }
+
+#ifdef VBOX_WITH_AUDIO_VIDEOREC
+HRESULT Console::i_audioVideoRecSendAudio(const void *pvData, size_t cbData, uint64_t uTimestampMs)
+{
+    if (mDisplay)
+    {
+        int rc2 = mDisplay->i_videoCaptureSendAudio(pvData, cbData, uTimestampMs);
+        AssertRC(rc2);
+    }
+
+    return S_OK;
+}
+#endif /* VBOX_WITH_AUDIO_VIDEOREC */
 
 /**

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

@@ -2968 +2968 @@
             InsertConfigString(pCfg, "StreamName", bstr);
             InsertConfigInteger(pCfg, "Object", (uintptr_t)mAudioVideoRec);
+            InsertConfigInteger(pCfg, "ObjectConsole", (uintptr_t)this /* Console */);
 #endif /* VBOX_WITH_AUDIO_VIDEOREC */
 

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

@@ -131 +131 @@
     mfHostCursorCapabilities = 0;
 #endif
+
 #ifdef VBOX_WITH_VIDEOREC
     rc = RTCritSectInit(&mVideoCaptureLock);
@@ -145 +146 @@
     AssertRC(rc);
 #endif
+
 #ifdef VBOX_WITH_CROGL
     RT_ZERO(mCrOglCallbacks);
@@ -2263 +2265 @@
 }
 
-
-int Display::i_VideoCaptureEnableScreens(ComSafeArrayIn(BOOL, aScreens))
+int Display::i_videoCaptureEnableScreens(ComSafeArrayIn(BOOL, aScreens))
 {
 #ifdef VBOX_WITH_VIDEOREC
@@ -2286 +2287 @@
 
 /**
+ * Sends belonging audio samples to the video capturing code.
+ * Does nothing if capturing is disabled or if audio support for video capturing is disabled.
+ *
+ * @returns IPRT status code.
+ * @param   pvData              Audio data.
+ * @param   cbData              Size (in bytes) of audio data.
+ * @param   uTimestampMs        Timestamp (in ms) of the audio data.
+ */
+int Display::i_videoCaptureSendAudio(const void *pvData, size_t cbData, uint64_t uTimestampMs)
+{
+#ifdef VBOX_WITH_AUDIO_VIDEOREC
+    if (!VideoRecIsEnabled(mpVideoRecCtx))
+        return VINF_SUCCESS;
+
+    return VideoRecSendAudio(mpVideoRecCtx, pvData, cbData, uTimestampMs);
+#else
+    RT_NOREF(pvData, cbData, uTimestampMs);
+    return VERR_NOT_SUPPORTED;
+#endif
+}
+
+/**
  * Start video capturing. Does nothing if capturing is already active.
+ *
+ * @returns IPRT status code.
  */
-int Display::i_VideoCaptureStart()
+int Display::i_videoCaptureStart(void)
 {
 #ifdef VBOX_WITH_VIDEOREC
@@ -2403 +2428 @@
  * Stop video capturing. Does nothing if video capturing is not active.
  */
-void Display::i_VideoCaptureStop()
+void Display::i_videoCaptureStop()
 {
 #ifdef VBOX_WITH_VIDEOREC
@@ -3185 +3210 @@
                 if (VideoRecLimitReached(pDisplay->mpVideoRecCtx, uScreenId, u64Now))
                 {
-                    pDisplay->i_VideoCaptureStop();
+                    pDisplay->i_videoCaptureStop();
                     pDisplay->mParent->i_machine()->COMSETTER(VideoCaptureEnabled)(false);
                     break;
@@ -4287 +4312 @@
         AutoWriteLock displayLock(pThis->pDisplay COMMA_LOCKVAL_SRC_POS);
 #ifdef VBOX_WITH_VIDEOREC
-        pThis->pDisplay->i_VideoCaptureStop();
+        pThis->pDisplay->i_videoCaptureStop();
 #endif
 #ifdef VBOX_WITH_CRHGSMI
@@ -4405 +4430 @@
     if (fEnabled)
     {
-        rc = pDisplay->i_VideoCaptureStart();
+        rc = pDisplay->i_videoCaptureStart();
         fireVideoCaptureChangedEvent(pDisplay->mParent->i_getEventSource());
     }

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

@@ -16 +16 @@
  */
 
+/**
+ * This driver is part of Main and is responsible for providing audio
+ * data to Main's video capturing feature.
+ *
+ * The driver itself implements a PDM host audio backend, which in turn
+ * provides the driver with the required audio data and audio events.
+ *
+ * For now there is support for the following destinations (called "sinks"):
+ *
+ * - Direct writing of .webm files to the host.
+ * - Communicating with Main via the Console object to send the encoded audio data to.
+ *   The Console object in turn then will route the data to the Display / video capturing interface then.
+ */
 
 /*********************************************************************************************************************************
@@ -48 +61 @@
 
 /**
- * Enumeration for audio/video recording driver recording mode.
- */
-typedef enum AVRECMODE
-{
-    /** Unknown / invalid recording mode. */
-    AVRECMODE_UNKNOWN     = 0,
-    /** Only record audio.
-     *  This mode does not need to talk to the video recording driver,
-     *  as this driver then simply creates an own WebM container. */
-    AVRECMODE_AUDIO       = 1,
-    /** Records audio and video.
-     *  Needs to work together with the video recording driver in
-     *  order to get a full-featured WebM container. */
-    AVRECMODE_AUDIO_VIDEO = 2
-} AVRECMODE;
-
-/**
- * Structure for keeping codec specific data.
+ * Enumeration for specifying the recording container type.
+ */
+typedef enum AVRECCONTAINERTYPE
+{
+    /** Unknown / invalid container type. */
+    AVRECCONTAINERTYPE_UNKNOWN      = 0,
+    /** Recorded data goes to Main / Console. */
+    AVRECCONTAINERTYPE_MAIN_CONSOLE = 1,
+    /** Recorded data will be written a .webm file. */
+    AVRECCONTAINERTYPE_WEBM         = 2
+} AVRECCONTAINERTYPE;
+
+/**
+ * Structure for keeping generic container parameters.
+ */
+typedef struct AVRECCONTAINERPARMS
+{
+    /** The container's type. */
+    AVRECCONTAINERTYPE      enmType;
+
+} AVRECCONTAINERPARMS, *PAVRECCONTAINERPARMS;
+
+/**
+ * Structure for keeping container-specific data.
+ */
+typedef struct AVRECCONTAINER
+{
+    /** Generic container parameters. */
+    AVRECCONTAINERPARMS     Parms;
+
+    union
+    {
+        struct
+        {
+            /** Pointer to Console. */
+            Console        *pConsole;
+        } Main;
+
+        struct
+        {
+            /** Pointer to WebM container to write recorded audio data to.
+             *  See the AVRECMODE enumeration for more information. */
+            WebMWriter     *pWebM;
+            /** Assigned track number from WebM container. */
+            uint8_t         uTrack;
+        } WebM;
+    };
+} AVRECCONTAINER, *PAVRECCONTAINER;
+
+/**
+ * Structure for keeping generic codec parameters.
+ */
+typedef struct AVRECCODECPARMS
+{
+    /** The encoding rate to use. */
+    uint32_t                uHz;
+    /** Duration of the frame in samples (per channel).
+     *
+     *  For Opus, valid frame size are:
+     *  ms           Frame size
+     *  2.5          120
+     *  5            240
+     *  10           480
+     *  20 (Default) 960
+     *  40           1920
+     *  60           2880
+     */
+    /** Number of audio channels to encode.
+     *  Currently we only supported stereo (2) channels. */
+    uint8_t                 cChannels;
+    /** The codec's bitrate. 0 if not used / cannot be specified. */
+    uint32_t                uBitrate;
+
+} AVRECCODECPARMS, *PAVRECCODECPARMS;
+
+/**
+ * Structure for keeping codec-specific data.
  */
 typedef struct AVRECCODEC
 {
+    /** Generic codec parameters. */
+    AVRECCODECPARMS         Parms;
     union
     {
@@ -76 +150 @@
             /** Encoder we're going to use. */
             OpusEncoder    *pEnc;
-            /** The encoding rate to use. */
-            uint32_t        uHz;
-            /** Duration of the frame in samples (per channel).
-             *  Valid frame size are:
-             *
-             *  ms           Frame size
-             *  2.5          120
-             *  5            240
-             *  10           480
-             *  20 (Default) 960
-             *  40           1920
-             *  60           2880
-             */
             uint32_t        csFrame;
             /** The maximum frame size (in samples) we can handle. */
             uint32_t        csFrameMax;
-# ifdef DEBUG /** @todo Make these a STAM value? */
-            /** Number of frames encoded. */
-            uint64_t        cEncFrames;
-            /** Total time (in ms) of already encoded audio data. */
-            uint64_t        msEncTotal;
-# endif
         } Opus;
 #endif /* VBOX_WITH_LIBOPUS */
     };
+
+#ifdef VBOX_WITH_STATISTICS /** @todo Make these real STAM values. */
+    struct
+    {
+        /** Number of frames encoded. */
+        uint64_t        cEncFrames;
+        /** Total time (in ms) of already encoded audio data. */
+        uint64_t        msEncTotal;
+    } STAM;
+#endif /* VBOX_WITH_STATISTICS */
+
 } AVRECCODEC, *PAVRECCODEC;
+
+typedef struct AVRECSINK
+{
+    /** @todo Add types for container / codec as soon as we implement more stuff. */
+
+    /** Container data to use for data processing. */
+    AVRECCONTAINER       Con;
+    /** Codec data this stream uses for encoding. */
+    AVRECCODEC           Codec;
+} AVRECSINK, *PAVRECSINK;
 
 /**
@@ -112 +188 @@
     /** The PCM properties of this stream. */
     PDMAUDIOPCMPROPS     Props;
-    /** Codec-specific data.
-     *  As every stream can be different, one codec per stream is needed. */
-    AVRECCODEC           Codec;
     /** (Audio) frame buffer. */
     PRTCIRCBUF           pCircBuf;
-    /** Pointer to WebM container to write recorded audio data to.
-     *  See the AVRECMODE enumeration for more information. */
-    WebMWriter          *pWebM;
-    /** Assigned track number from WebM container. */
-    uint8_t              uTrack;
+    /** Pointer to sink to use for writing. */
+    PAVRECSINK           pSink;
 } AVRECSTREAMOUT, *PAVRECSTREAMOUT;
 
@@ -135 +205 @@
     /** Pointer to host audio interface. */
     PDMIHOSTAUDIO        IHostAudio;
+    /** Pointer to the console object. */
+    ComObjPtr<Console>   pConsole;
     /** Pointer to the DrvAudio port interface that is above us. */
     PPDMIAUDIOCONNECTOR  pDrvAudio;
-    /** Recording mode. */
-    AVRECMODE            enmMode;
+    /** The driver's sink for writing output to. */
+    AVRECSINK            Sink;
 } DRVAUDIOVIDEOREC, *PDRVAUDIOVIDEOREC;
 
@@ -145 +217 @@
     ( (PDRVAUDIOVIDEOREC)((uintptr_t)pInterface - RT_OFFSETOF(DRVAUDIOVIDEOREC, IHostAudio)) )
 
-
-static int avRecCreateStreamOut(PPDMIHOSTAUDIO pInterface,
-                                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);
-
-    PAVRECSTREAMOUT pStreamOut = (PAVRECSTREAMOUT)pStream;
-
-    int rc = DrvAudioHlpStreamCfgToProps(pCfgReq, &pStreamOut->Props);
-    if (RT_FAILURE(rc))
-        return rc;
-
-#ifdef VBOX_WITH_LIBOPUS
-    PDRVAUDIOVIDEOREC pThis = PDMIHOSTAUDIO_2_DRVAUDIOVIDEOREC(pInterface);
-
-    uint32_t uHz = pStreamOut->Props.uHz;
+/**
+ * Initializes a recording sink.
+ *
+ * @returns IPRT status code.
+ * @param   pThis               Driver instance.
+ * @param   pSink               Sink to initialize.
+ * @param   pConParms           Container parameters to set.
+ * @param   pCodecParms         Codec parameters to set.
+ */
+static int avRecSinkInit(PDRVAUDIOVIDEOREC pThis, PAVRECSINK pSink, PAVRECCONTAINERPARMS pConParms, PAVRECCODECPARMS pCodecParms)
+{
+    uint32_t uHz = pCodecParms->uHz;
 
     /* Opus only supports certain input sample rates in an efficient manner.
@@ -173 +238 @@
     else     uHz = 8000;
 
-    LogFunc(("%RU16Hz -> %RU16Hz\n", pStreamOut->Props.uHz, uHz));
-
-    pStreamOut->Codec.Opus.uHz        = uHz;
-    pStreamOut->Codec.Opus.csFrame    = uHz / 50;
-#ifdef DEBUG
-    pStreamOut->Codec.Opus.cEncFrames = 0;
-    pStreamOut->Codec.Opus.msEncTotal = 0;
-#endif
-
-    /* Calculate the maximum frame size. */
-    pStreamOut->Codec.Opus.csFrameMax = 48000                        /* Maximum sample rate Opus can handle */
-                                      * pStreamOut->Props.cChannels; /* Number of channels */
-
-    /* If we only record audio, create our own WebM writer instance here. */
-    if (pThis->enmMode == AVRECMODE_AUDIO)
-    {
-        pStreamOut->pWebM = new WebMWriter();
-        rc = pStreamOut->pWebM->Create("/tmp/acap.webm", RTFILE_O_CREATE_REPLACE | RTFILE_O_WRITE | RTFILE_O_DENY_WRITE, /** @todo Fix path! */
-                                       WebMWriter::AudioCodec_Opus, WebMWriter::VideoCodec_None);
-        if (RT_SUCCESS(rc))
-            rc = pStreamOut->pWebM->AddAudioTrack(pStreamOut->Codec.Opus.uHz, pStreamOut->Props.cChannels, pStreamOut->Props.cBits,
-                                                  &pStreamOut->uTrack);
-    }
-
-    if (RT_FAILURE(rc))
-        return rc;
-
-    rc = RTCircBufCreate(&pStreamOut->pCircBuf, (pStreamOut->Codec.Opus.csFrame * pStreamOut->Props.cChannels) * sizeof(uint16_t));
-    if (RT_SUCCESS(rc))
-    {
-        OpusEncoder *pEnc = NULL;
-
-        int orc;
-        pEnc = opus_encoder_create(pStreamOut->Codec.Opus.uHz, pStreamOut->Props.cChannels, OPUS_APPLICATION_AUDIO, &orc);
-        if (orc != OPUS_OK)
-        {
-            LogRel(("VideoRec: Audio codec failed to initialize: %s\n", opus_strerror(orc)));
-            return VERR_AUDIO_BACKEND_INIT_FAILED;
-        }
-
-        AssertPtr(pEnc);
-
-        opus_encoder_ctl(pEnc, OPUS_SET_BITRATE(196000)); /** @todo Make this configurable. */
-        if (orc != OPUS_OK)
-        {
-            LogRel(("VideoRec: Audio codec failed to set bitrate: %s\n", opus_strerror(orc)));
-            rc = VERR_AUDIO_BACKEND_INIT_FAILED;
-        }
-        else
-        {
-            pStreamOut->Codec.Opus.pEnc = pEnc;
-
-            if (pCfgAcq)
+    OpusEncoder *pEnc = NULL;
+
+    int orc;
+    pEnc = opus_encoder_create(pCodecParms->uHz, pCodecParms->cChannels, OPUS_APPLICATION_AUDIO, &orc);
+    if (orc != OPUS_OK)
+    {
+        LogRel(("VideoRec: Audio codec failed to initialize: %s\n", opus_strerror(orc)));
+        return VERR_AUDIO_BACKEND_INIT_FAILED;
+    }
+
+    AssertPtr(pEnc);
+
+    opus_encoder_ctl(pEnc, OPUS_SET_BITRATE(pCodecParms->uBitrate));
+    if (orc != OPUS_OK)
+    {
+        LogRel(("VideoRec: Audio codec failed to set bitrate (%RU32): %s\n", pCodecParms->uBitrate, opus_strerror(orc)));
+        return VERR_AUDIO_BACKEND_INIT_FAILED;
+    }
+
+    LogRel(("VideoRec: Recording audio in %RU16Hz, %RU8 channels, %RU32 bpS\n",
+            pCodecParms->uHz, pCodecParms->cChannels, pCodecParms->uBitrate / 1000));
+
+    int rc;
+
+    try
+    {
+        switch (pConParms->enmType)
+        {
+            case AVRECCONTAINERTYPE_MAIN_CONSOLE:
             {
-                /* Make sure to let the driver backend know that we need the audio data in
-                 * a specific sampling rate Opus is optimized for. */
-                pCfgAcq->uHz               = pStreamOut->Codec.Opus.uHz;
-                pCfgAcq->cSampleBufferSize = _4K; /** @todo Make this configurable. */
+                pSink->Con.Main.pConsole = pThis->pConsole;
+
+                rc = VINF_SUCCESS;
+                break;
             }
 
-            LogRel(("VideoRec: Recording audio in %RU16Hz, %RU8 channels, %RU16 bpS\n",
-                    uHz, pStreamOut->Props.cChannels, pStreamOut->Props.cBits));
-        }
-    }
-#else
-    rc = VERR_NOT_SUPPORTED;
-#endif /* VBOX_WITH_LIBOPUS */
-
-    LogFlowFuncLeaveRC(rc);
-    return rc;
-}
-
-
-static int avRecControlStreamOut(PPDMIHOSTAUDIO pInterface,
-                                 PPDMAUDIOSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd)
-{
-    AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
-    AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
-    RT_NOREF(enmStreamCmd);
-
-    PDRVAUDIOVIDEOREC pThis = PDMIHOSTAUDIO_2_DRVAUDIOVIDEOREC(pInterface);
-    RT_NOREF(pThis);
-
-    LogFlowFunc(("enmStreamCmd=%ld\n", enmStreamCmd));
-
-    switch (enmStreamCmd)
-    {
-        case PDMAUDIOSTREAMCMD_ENABLE:
-        case PDMAUDIOSTREAMCMD_RESUME:
-            break;
-
-        case PDMAUDIOSTREAMCMD_DISABLE:
-        {
-            AudioMixBufReset(&pStream->MixBuf);
-            break;
-        }
-
-        case PDMAUDIOSTREAMCMD_PAUSE:
-            break;
-
-        default:
-            AssertMsgFailed(("Invalid command %ld\n", enmStreamCmd));
-            break;
-    }
-
-    return VINF_SUCCESS;
-}
-
-
-/**
- * @interface_method_impl{PDMIHOSTAUDIO,pfnInit}
- */
-static DECLCALLBACK(int) drvAudioVideoRecInit(PPDMIHOSTAUDIO pInterface)
-{
-    AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
-
-    LogFlowFuncEnter();
-
-    PDRVAUDIOVIDEOREC pThis = PDMIHOSTAUDIO_2_DRVAUDIOVIDEOREC(pInterface);
-
-    pThis->enmMode = AVRECMODE_AUDIO; /** @todo Fix mode! */
-
-    int rc;
-
-    try
-    {
-        switch (pThis->enmMode)
-        {
-            /* In audio-only mode we're creating our own WebM writer instance,
-             * as we don't have to synchronize with any external source, such as video recording data.*/
-            case AVRECMODE_AUDIO:
+            case AVRECCONTAINERTYPE_WEBM:
             {
                 rc = VINF_SUCCESS;
@@ -309 +280 @@
             }
 
-            case AVRECMODE_AUDIO_VIDEO:
-            {
-                rc = VERR_NOT_SUPPORTED;
-                break;
-            }
-
             default:
                 rc = VERR_NOT_SUPPORTED;
@@ -325 +290 @@
     }
 
+    if (RT_SUCCESS(rc))
+    {
+        pSink->Codec.Parms.uHz       = uHz;
+        pSink->Codec.Parms.cChannels = pCodecParms->cChannels;
+        pSink->Codec.Parms.uBitrate  = pCodecParms->uBitrate;
+
+        pSink->Codec.Opus.pEnc       = pEnc;
+        pSink->Codec.Opus.csFrame    = uHz / 50;
+
+#ifdef VBOX_WITH_STATISTICS
+        pSink->Codec.STAM.cEncFrames = 0;
+        pSink->Codec.STAM.msEncTotal = 0;
+#endif
+
+        /* Calculate the maximum frame size. */
+        pSink->Codec.Opus.csFrameMax = 48000                   /* Maximum sample rate Opus can handle */
+                                     * pCodecParms->cChannels; /* Number of channels */
+    }
+
+    return rc;
+}
+
+
+/**
+ * Shuts down (closes) a recording sink,
+ *
+ * @returns IPRT status code.
+ * @param   pSink               Recording sink to shut down.
+ */
+static void avRecSinkShutdown(PAVRECSINK pSink)
+{
+    AssertPtrReturnVoid(pSink);
+
+#ifdef VBOX_WITH_LIBOPUS
+    if (pSink->Codec.Opus.pEnc)
+    {
+        opus_encoder_destroy(pSink->Codec.Opus.pEnc);
+        pSink->Codec.Opus.pEnc = NULL;
+    }
+#endif
+    switch (pSink->Con.Parms.enmType)
+    {
+        case AVRECCONTAINERTYPE_WEBM:
+        {
+            if (pSink->Con.WebM.pWebM)
+            {
+                int rc2 = pSink->Con.WebM.pWebM->Close();
+                AssertRC(rc2);
+
+                delete pSink->Con.WebM.pWebM;
+                pSink->Con.WebM.pWebM = NULL;
+            }
+            break;
+        }
+
+        case AVRECCONTAINERTYPE_MAIN_CONSOLE:
+        default:
+            break;
+    }
+}
+
+
+/**
+ * Creates an audio output stream and associates it with the specified recording sink.
+ *
+ * @returns IPRT status code.
+ * @param   pThis               Driver instance.
+ * @param   pStream             Audio output stream to create.
+ * @param   pSink               Recording sink to associate audio output stream to.
+ * @param   pCfgReq             Requested configuration by the audio backend.
+ * @param   pCfgAcq             Acquired configuration by the audio output stream.
+ */
+static int avRecCreateStreamOut(PDRVAUDIOVIDEOREC pThis, PPDMAUDIOSTREAM pStream,
+                                PAVRECSINK pSink, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
+{
+    AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
+    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
+    AssertPtrReturn(pSink,   VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgReq, VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfgAcq, VERR_INVALID_POINTER);
+
+    PAVRECSTREAMOUT pStreamOut = (PAVRECSTREAMOUT)pStream;
+
+    if (pCfgReq->DestSource.Dest != PDMAUDIOPLAYBACKDEST_FRONT)
+    {
+        AssertFailed();
+
+        if (pCfgAcq)
+            pCfgAcq->cSampleBufferSize = 0;
+
+        LogRel2(("VideoRec: Support for surround audio not implemented yet\n"));
+        return VERR_NOT_SUPPORTED;
+    }
+
+    int rc = DrvAudioHlpStreamCfgToProps(pCfgReq, &pStreamOut->Props);
+    if (RT_FAILURE(rc))
+        return rc;
+
+#ifdef VBOX_WITH_LIBOPUS
+    /* If we only record audio, create our own WebM writer instance here. */
+    if (pSink->Con.Parms.enmType == AVRECCONTAINERTYPE_WEBM)
+    {
+        pSink->Con.WebM.pWebM = new WebMWriter();
+        rc = pSink->Con.WebM.pWebM->Create("/tmp/acap.webm", RTFILE_O_CREATE_REPLACE | RTFILE_O_WRITE | RTFILE_O_DENY_WRITE, /** @todo Fix path! */
+                                           WebMWriter::AudioCodec_Opus, WebMWriter::VideoCodec_None);
+        if (RT_SUCCESS(rc))
+            rc = pSink->Con.WebM.pWebM->AddAudioTrack(pSink->Codec.Parms.uHz, pStreamOut->Props.cChannels, pStreamOut->Props.cBits,
+                                                      &pSink->Con.WebM.uTrack);
+    }
+
+    if (RT_FAILURE(rc))
+        return rc;
+
+    rc = RTCircBufCreate(&pStreamOut->pCircBuf, (pSink->Codec.Opus.csFrame * pSink->Codec.Parms.cChannels) * sizeof(uint16_t));
+    if (RT_SUCCESS(rc))
+    {
+        pStreamOut->pSink = pSink; /* Assign sink to stream. */
+
+        if (pCfgAcq)
+        {
+            /* Make sure to let the driver backend know that we need the audio data in
+             * a specific sampling rate Opus is optimized for. */
+            pCfgAcq->uHz               = pSink->Codec.Parms.uHz;
+            pCfgAcq->cSampleBufferSize = _4K; /** @todo Make this configurable. */
+        }
+    }
+#else
+    RT_NOREF(pThis, pSink, pStream, pCfgReq, pCfgAcq);
+    rc = VERR_NOT_SUPPORTED;
+#endif /* VBOX_WITH_LIBOPUS */
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+
+/**
+ * Destroys (closes) an audio output stream.
+ *
+ * @returns IPRT status code.
+ * @param   pThis               Driver instance.
+ * @param   pStream             Audio output stream to destroy.
+ */
+static int avRecDestroyStreamOut(PDRVAUDIOVIDEOREC pThis, PPDMAUDIOSTREAM pStream)
+{
+    RT_NOREF(pThis);
+    PAVRECSTREAMOUT pStreamOut = (PAVRECSTREAMOUT)pStream;
+
+    if (pStreamOut->pCircBuf)
+    {
+        RTCircBufDestroy(pStreamOut->pCircBuf);
+        pStreamOut->pCircBuf = NULL;
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Controls an audio output stream
+ *
+ * @returns IPRT status code.
+ * @param   pThis               Driver instance.
+ * @param   pStream             Audio output stream to control.
+ * @param   enmStreamCmd        Stream command to issue.
+ */
+static int avRecControlStreamOut(PDRVAUDIOVIDEOREC pThis,
+                                 PPDMAUDIOSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd)
+{
+    AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
+    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
+    RT_NOREF(enmStreamCmd);
+
+    RT_NOREF(pThis);
+
+    LogFlowFunc(("enmStreamCmd=%ld\n", enmStreamCmd));
+
+    switch (enmStreamCmd)
+    {
+        case PDMAUDIOSTREAMCMD_ENABLE:
+        case PDMAUDIOSTREAMCMD_RESUME:
+            break;
+
+        case PDMAUDIOSTREAMCMD_DISABLE:
+        {
+            AudioMixBufReset(&pStream->MixBuf);
+            break;
+        }
+
+        case PDMAUDIOSTREAMCMD_PAUSE:
+            break;
+
+        default:
+            AssertMsgFailed(("Invalid command %ld\n", enmStreamCmd));
+            break;
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{PDMIHOSTAUDIO,pfnInit}
+ */
+static DECLCALLBACK(int) drvAudioVideoRecInit(PPDMIHOSTAUDIO pInterface)
+{
+    AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
+
+    LogFlowFuncEnter();
+
+    PDRVAUDIOVIDEOREC pThis = PDMIHOSTAUDIO_2_DRVAUDIOVIDEOREC(pInterface);
+
+    AVRECCONTAINERPARMS ContainerParms;
+    ContainerParms.enmType = AVRECCONTAINERTYPE_MAIN_CONSOLE; /** @todo Make this configurable. */
+
+    AVRECCODECPARMS CodecParms;
+    CodecParms.uHz       = 48000;  /** @todo Make this configurable. */
+    CodecParms.cChannels = 2;      /** @todo Make this configurable. */
+    CodecParms.uBitrate  = 196000; /** @todo Make this configurable. */
+
+    int rc = avRecSinkInit(pThis, &pThis->Sink, &ContainerParms, &CodecParms);
     if (RT_FAILURE(rc))
     {
@@ -385 +571 @@
      */
 #ifdef VBOX_WITH_LIBOPUS
+    PAVRECSINK pSink    = pStreamOut->pSink;
+    AssertPtr(pSink);
     PRTCIRCBUF pCircBuf = pStreamOut->pCircBuf;
+    AssertPtr(pCircBuf);
 
     void  *pvBuf;
@@ -430 +619 @@
     size_t  cbSrc;
 
-    const uint32_t csFrame = pStreamOut->Codec.Opus.csFrame;
+    const uint32_t csFrame = pSink->Codec.Opus.csFrame;
     const uint32_t cbFrame = AUDIOMIXBUF_S2B(&pStream->MixBuf, csFrame);
 
@@ -455 +644 @@
         }
 
-#ifdef DEBUG_andy
+# ifdef DEBUG_andy
         RTFILE fh;
         RTFileOpen(&fh, "/tmp/acap.pcm", RTFILE_O_OPEN_CREATE | RTFILE_O_APPEND | RTFILE_O_WRITE | RTFILE_O_DENY_NONE);
         RTFileWrite(fh, abSrc, cbSrc, NULL);
         RTFileClose(fh);
-#endif
+# endif
 
         Assert(cbSrc == cbFrame);
@@ -475 +664 @@
 
         /* Call the encoder to encode one frame per iteration. */
-        opus_int32 cbWritten = opus_encode(pStreamOut->Codec.Opus.pEnc,
+        opus_int32 cbWritten = opus_encode(pSink->Codec.Opus.pEnc,
                                            (opus_int16 *)abSrc, csFrame, abDst, cbDst);
         if (cbWritten > 0)
         {
-#ifdef DEBUG
+# ifdef VBOX_WITH_STATISTICS
             /* Get overall frames encoded. */
             uint32_t cEncFrames          = opus_packet_get_nb_frames(abDst, cbDst);
-            uint32_t cEncSamplesPerFrame = opus_packet_get_samples_per_frame(abDst, pStreamOut->Codec.Opus.uHz);
+            uint32_t cEncSamplesPerFrame = opus_packet_get_samples_per_frame(abDst, pSink->Codec.Parms.uHz);
             uint32_t csEnc               = cEncFrames * cEncSamplesPerFrame;
 
-            pStreamOut->Codec.Opus.cEncFrames += cEncFrames;
-            pStreamOut->Codec.Opus.msEncTotal += 20 /* Default 20 ms */ * cEncFrames;
+            pSink->Codec.STAM.cEncFrames += cEncFrames;
+            pSink->Codec.STAM.msEncTotal += 20 /* Default 20 ms */ * cEncFrames;
 
             LogFunc(("%RU64ms [%RU64 frames]: cbSrc=%zu, cbDst=%zu, cEncFrames=%RU32, cEncSamplesPerFrame=%RU32, csEnc=%RU32\n",
-                     pStreamOut->Codec.Opus.msEncTotal, pStreamOut->Codec.Opus.cEncFrames,
+                     pSink->Codec.STAM.msEncTotal, pSink->Codec.STAM.cEncFrames,
                      cbSrc, cbDst, cEncFrames, cEncSamplesPerFrame, csEnc));
-#endif
+# endif
             Assert((uint32_t)cbWritten <= cbDst);
             cbDst = RT_MIN((uint32_t)cbWritten, cbDst); /* Update cbDst to actual bytes encoded (written). */
 
-            /* Call the WebM writer to actually write the encoded audio data. */
-            WebMWriter::BlockData_Opus blockData = { abDst, cbDst };
-            rc = pStreamOut->pWebM->WriteBlock(pStreamOut->uTrack, &blockData, sizeof(blockData));
-            AssertRC(rc);
+            switch (pSink->Con.Parms.enmType)
+            {
+                case AVRECCONTAINERTYPE_MAIN_CONSOLE:
+                {
+                    HRESULT hr = pSink->Con.Main.pConsole->i_audioVideoRecSendAudio(abDst, cbDst, RTTimeMilliTS() /* Now */);
+                    Assert(hr == S_OK);
+
+                    break;
+                }
+
+                case AVRECCONTAINERTYPE_WEBM:
+                {
+                    WebMWriter::BlockData_Opus blockData = { abDst, cbDst };
+                    rc = pSink->Con.WebM.pWebM->WriteBlock(pSink->Con.WebM.uTrack, &blockData, sizeof(blockData));
+                    AssertRC(rc);
+
+                    break;
+                }
+
+                default:
+                    AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
+                    break;
+            }
         }
         else if (cbWritten < 0)
@@ -525 +733 @@
 
 
-static int avRecDestroyStreamOut(PPDMIHOSTAUDIO pInterface, PPDMAUDIOSTREAM pStream)
-{
-    PDRVAUDIOVIDEOREC pThis      = PDMIHOSTAUDIO_2_DRVAUDIOVIDEOREC(pInterface);
-    RT_NOREF(pThis);
-    PAVRECSTREAMOUT   pStreamOut = (PAVRECSTREAMOUT)pStream;
-
-    if (pStreamOut->pCircBuf)
-    {
-        RTCircBufDestroy(pStreamOut->pCircBuf);
-        pStreamOut->pCircBuf = NULL;
-    }
-
-#ifdef VBOX_WITH_LIBOPUS
-    if (pStreamOut->Codec.Opus.pEnc)
-    {
-        opus_encoder_destroy(pStreamOut->Codec.Opus.pEnc);
-        pStreamOut->Codec.Opus.pEnc = NULL;
-    }
-#endif
-
-    switch (pThis->enmMode)
-    {
-        case AVRECMODE_AUDIO:
-        {
-            if (pStreamOut->pWebM)
-                pStreamOut->pWebM->Close();
-            break;
-        }
-
-        case AVRECMODE_AUDIO_VIDEO:
-        default:
-            break;
-    }
-
-    return VINF_SUCCESS;
-}
-
-
 /**
  * @interface_method_impl{PDMIHOSTAUDIO,pfnGetConfig}
@@ -589 +759 @@
     PDRVAUDIOVIDEOREC pThis = PDMIHOSTAUDIO_2_DRVAUDIOVIDEOREC(pInterface);
 
-    switch (pThis->enmMode)
-    {
-        case AVRECMODE_AUDIO:
-        case AVRECMODE_AUDIO_VIDEO:
-        default:
-            break;
-    }
+    avRecSinkShutdown(&pThis->Sink);
 }
 
@@ -622 +786 @@
     AssertPtrReturn(pCfgAcq,    VERR_INVALID_POINTER);
 
+    PDRVAUDIOVIDEOREC pThis = PDMIHOSTAUDIO_2_DRVAUDIOVIDEOREC(pInterface);
+
+    /* For now we only have one sink, namely the driver's one.
+     * Later each stream could have its own one, to e.g. router different stream to different sinks .*/
+    PAVRECSINK pSink = &pThis->Sink;
+
     if (pCfgReq->enmDir == PDMAUDIODIR_OUT)
-        return avRecCreateStreamOut(pInterface, pStream, pCfgReq, pCfgAcq);
+        return avRecCreateStreamOut(pThis, pStream, pSink, pCfgReq, pCfgAcq);
 
     return VERR_NOT_SUPPORTED;
@@ -637 +807 @@
     AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
 
+    PDRVAUDIOVIDEOREC pThis = PDMIHOSTAUDIO_2_DRVAUDIOVIDEOREC(pInterface);
+
     if (pStream->enmDir == PDMAUDIODIR_OUT)
-        return avRecDestroyStreamOut(pInterface, pStream);
+        return avRecDestroyStreamOut(pThis, pStream);
 
     return VINF_SUCCESS;
@@ -653 +825 @@
     AssertPtrReturn(pStream,    VERR_INVALID_POINTER);
 
+    PDRVAUDIOVIDEOREC pThis = PDMIHOSTAUDIO_2_DRVAUDIOVIDEOREC(pInterface);
+
     Assert(pStream->enmCtx == PDMAUDIOSTREAMCTX_HOST);
 
     if (pStream->enmDir == PDMAUDIODIR_OUT)
-        return avRecControlStreamOut(pInterface,  pStream, enmStreamCmd);
+        return avRecControlStreamOut(pThis,  pStream, enmStreamCmd);
 
     return VINF_SUCCESS;
@@ -705 +879 @@
 
 AudioVideoRec::AudioVideoRec(Console *pConsole)
-    : mpDrv(NULL),
-      mParent(pConsole)
+    : mpDrv(NULL)
+    , mpConsole(pConsole)
 {
 }
@@ -754 +928 @@
 
     /*
-     * Get the AudioVideoRec object pointer.
+     * Get the Console object pointer.
      */
-    void *pvUser = NULL;
-    int rc = CFGMR3QueryPtr(pCfg, "Object", &pvUser); /** @todo r=andy Get rid of this hack and use IHostAudio::SetCallback. */
+    void *pvUser;
+    int rc = CFGMR3QueryPtr(pCfg, "ObjectConsole", &pvUser); /** @todo r=andy Get rid of this hack and use IHostAudio::SetCallback. */
+    AssertMsgRCReturn(rc, ("Confguration error: No/bad \"ObjectConsole\" value, rc=%Rrc\n", rc), rc);
+
+    /* CFGM tree saves the pointer to Console in the Object node of AudioVideoRec. */
+    pThis->pConsole = (Console *)pvUser;
+
+    /*
+     * Get the pointer to the audio driver instance.
+     */
+    rc = CFGMR3QueryPtr(pCfg, "Object", &pvUser); /** @todo r=andy Get rid of this hack and use IHostAudio::SetCallback. */
     AssertMsgRCReturn(rc, ("Confguration error: No/bad \"Object\" value, rc=%Rrc\n", rc), rc);
 

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

@@ -1041 +1041 @@
 }
 
+int VideoRecSendAudio(PVIDEORECCONTEXT pCtx, const void *pvData, size_t cbData, uint64_t uTimestampMs)
+{
+    RT_NOREF(pCtx, pvData, cbData, uTimestampMs);
+    return VINF_SUCCESS;
+}
+
 /**
  * VideoRec utility function to copy a source image (FrameBuf) to the intermediate

trunk/src/VBox/Main/src-client/VideoRec.h

@@ -33 +33 @@
 
 bool VideoRecIsEnabled(PVIDEORECCONTEXT pCtx);
+int  VideoRecSendAudio(PVIDEORECCONTEXT pCtx, const void *pvData, size_t cbData, uint64_t uTimestampMs);
 int  VideoRecCopyToIntBuf(PVIDEORECCONTEXT pCtx, uint32_t uScreen,
                           uint32_t x, uint32_t y, uint32_t uPixelFormat, uint32_t uBitsPerPixel,