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

Timestamp:

Nov 5, 2018 5:55:29 PM (6 years ago)

Author:

vboxsync

Message:

Capturing: Separated capturing settings into new interfaces ICaptureSettings and ICaptureScreenSettings to unload stuff from IMachine; a lot of internal interface / code cleanups. Also see #9286. Work in progress.

Location:

trunk/src/VBox/Main/src-client

Files:

• ConsoleImpl.cpp (modified) (11 diffs)
• ConsoleImpl2.cpp (modified) (1 diff)
• DisplayImpl.cpp (modified) (11 diffs)
• DrvAudioVideoRec.cpp (modified) (3 diffs)
• SessionImpl.cpp (modified) (1 diff)
• VideoRec.cpp (modified) (24 diffs)
• VideoRecStream.cpp (modified) (34 diffs)

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

@@ -402 +402 @@
     , m_pVMMDev(NULL)
     , mAudioVRDE(NULL)
-#ifdef VBOX_WITH_AUDIO_VIDEOREC
-    , mAudioVideoRec(NULL)
-#endif
     , mNvram(NULL)
 #ifdef VBOX_WITH_USB_CARDREADER
@@ -590 +587 @@
 #endif
 #ifdef VBOX_WITH_AUDIO_VIDEOREC
-        unconst(mAudioVideoRec) = new AudioVideoRec(this);
-        AssertReturn(mAudioVideoRec, E_FAIL);
+        unconst(Capture.mAudioVideoRec) = new AudioVideoRec(this);
+        AssertReturn(Capture.mAudioVideoRec, E_FAIL);
 #endif
         FirmwareType_T enmFirmwareType;
@@ -738 +735 @@
 
 #ifdef VBOX_WITH_AUDIO_VIDEOREC
-    if (mAudioVideoRec)
-    {
-        delete mAudioVideoRec;
-        unconst(mAudioVideoRec) = NULL;
+    if (Capture.mAudioVideoRec)
+    {
+        delete Capture.mAudioVideoRec;
+        unconst(Capture.mAudioVideoRec) = NULL;
     }
 #endif
@@ -5619 +5616 @@
     if (pDisplay)
     {
-        if (RT_BOOL(fEnable) != pDisplay->i_videoRecStarted())
+        if (RT_BOOL(fEnable) != Capture.mpVideoRecCtx->IsStarted())
         {
             LogRel(("VideoRec: %s\n", fEnable ? "Enabling" : "Disabling"));
@@ -5629 +5626 @@
 # ifdef VBOX_WITH_AUDIO_VIDEOREC
                 /* Attach the video recording audio driver if required. */
-                if (   pDisplay->i_videoRecGetFeatures() & VIDEORECFEATURE_AUDIO
-                    && mAudioVideoRec)
+                if (   Capture.mpVideoRecCtx->IsFeatureEnabled(CaptureFeature_Audio)
+                    && Capture.mAudioVideoRec)
                 {
-                    vrc = mAudioVideoRec->applyConfiguration(pDisplay->i_videoRecGetConfig());
+                    vrc = Capture.mAudioVideoRec->applyConfiguration(Capture.mpVideoRecCtx->GetConfig());
                     if (RT_SUCCESS(vrc))
-                        vrc = mAudioVideoRec->doAttachDriverViaEmt(mpUVM, pAutoLock);
+                        vrc = Capture.mAudioVideoRec->doAttachDriverViaEmt(mpUVM, pAutoLock);
                 }
 # endif
                 if (   RT_SUCCESS(vrc)
-                    && pDisplay->i_videoRecGetFeatures()) /* Any video recording (audio and/or video) feature enabled? */
+                    && Capture.mpVideoRecCtx->IsReady()) /* Any video recording (audio and/or video) feature enabled? */
                 {
-                    vrc = pDisplay->i_videoRecStart();
+                    vrc = i_videoRecStart();
                 }
             }
             else
             {
-                mDisplay->i_videoRecStop();
+                i_videoRecStop();
 # ifdef VBOX_WITH_AUDIO_VIDEOREC
-                mAudioVideoRec->doDetachDriverViaEmt(mpUVM, pAutoLock);
+                Capture.mAudioVideoRec->doDetachDriverViaEmt(mpUVM, pAutoLock);
 # endif
             }
@@ -5662 +5659 @@
 #endif /* VBOX_WITH_VIDEOREC */
 
-HRESULT Console::i_onVideoCaptureChange()
+HRESULT Console::i_onCaptureChange()
 {
     AutoCaller autoCaller(this);
@@ -5675 +5672 @@
     if (ptrVM.isOk())
     {
+        ComPtr<ICaptureSettings> CaptureSettings;
+        rc = mMachine->COMGETTER(CaptureSettings)(CaptureSettings.asOutParam());
+        AssertComRCReturnRC(rc);
+
         BOOL fEnabled;
-        rc = mMachine->COMGETTER(VideoCaptureEnabled)(&fEnabled);
+        rc = CaptureSettings->COMGETTER(Enabled)(&fEnabled);
         AssertComRCReturnRC(rc);
 
@@ -5683 +5684 @@
         {
             alock.release();
-            fireVideoCaptureChangedEvent(mEventSource);
+            fireCaptureChangedEvent(mEventSource);
         }
 
@@ -6867 +6868 @@
  * @param   uTimestampMs        Timestamp (in ms) of audio data.
  */
-HRESULT Console::i_audioVideoRecSendAudio(const void *pvData, size_t cbData, uint64_t uTimestampMs)
-{
-    if (mDisplay)
-    {
-        int rc2 = mDisplay->i_videoRecSendAudio(pvData, cbData, uTimestampMs);
-        AssertRC(rc2);
+HRESULT Console::i_videoRecSendAudio(const void *pvData, size_t cbData, uint64_t uTimestampMs)
+{
+    if (!Capture.mpVideoRecCtx)
+        return S_OK;
+
+    if (   Capture.mpVideoRecCtx->IsStarted()
+        && Capture.mpVideoRecCtx->IsFeatureEnabled(CaptureFeature_Audio))
+    {
+        return Capture.mpVideoRecCtx->SendAudioFrame(pvData, cbData, uTimestampMs);
     }
 
@@ -6878 +6882 @@
 }
 #endif /* VBOX_WITH_AUDIO_VIDEOREC */
+
+#ifdef VBOX_WITH_VIDEOREC
+int Console::i_videoRecLoad(settings::CaptureSettings &Settings)
+{
+    Assert(mMachine.isNotNull());
+
+    ComPtr<ICaptureSettings> pCaptureSettings;
+    HRESULT hrc = mMachine->COMGETTER(CaptureSettings)(pCaptureSettings.asOutParam());
+    AssertComRCReturn(hrc, VERR_INVALID_PARAMETER);
+
+    SafeIfaceArray<ICaptureScreenSettings> paCaptureScreens;
+    hrc = pCaptureSettings->GetScreens(ComSafeArrayAsOutParam(paCaptureScreens));
+    AssertComRCReturn(hrc, VERR_INVALID_PARAMETER);
+
+    Settings.mapScreens.clear();
+
+    for (size_t i = 0; i < paCaptureScreens.size(); ++i)
+    {
+        settings::CaptureScreenSettings CaptureScreenSettings;
+        ComPtr<ICaptureScreenSettings> pCaptureScreenSettings = paCaptureScreens[i];
+
+        hrc = pCaptureScreenSettings->COMGETTER(MaxTime)((ULONG *)&CaptureScreenSettings.ulMaxTimeS);
+        AssertComRCReturn(hrc, VERR_INVALID_PARAMETER);
+        hrc = pCaptureScreenSettings->COMGETTER(MaxFileSize)((ULONG *)&CaptureScreenSettings.File.ulMaxSizeMB);
+        AssertComRCReturn(hrc, VERR_INVALID_PARAMETER);
+        Bstr bstrTemp;
+        hrc = pCaptureScreenSettings->COMGETTER(FileName)(bstrTemp.asOutParam());
+        AssertComRCReturn(hrc, VERR_INVALID_PARAMETER);
+        CaptureScreenSettings.File.strName = bstrTemp;
+        hrc = pCaptureScreenSettings->COMGETTER(Options)(bstrTemp.asOutParam());
+        AssertComRCReturn(hrc, VERR_INVALID_PARAMETER);
+        CaptureScreenSettings.strOptions = bstrTemp;
+        hrc = pCaptureScreenSettings->COMGETTER(VideoWidth)((ULONG *)&CaptureScreenSettings.Video.ulWidth);
+        AssertComRCReturn(hrc, VERR_INVALID_PARAMETER);
+        hrc = pCaptureScreenSettings->COMGETTER(VideoHeight)((ULONG *)&CaptureScreenSettings.Video.ulHeight);
+        AssertComRCReturn(hrc, VERR_INVALID_PARAMETER);
+        hrc = pCaptureScreenSettings->COMGETTER(VideoRate)((ULONG *)&CaptureScreenSettings.Video.ulRate);
+        AssertComRCReturn(hrc, VERR_INVALID_PARAMETER);
+        hrc = pCaptureScreenSettings->COMGETTER(VideoFPS)((ULONG *)&CaptureScreenSettings.Video.ulFPS);
+        AssertComRCReturn(hrc, VERR_INVALID_PARAMETER);
+
+        Settings.mapScreens[i] = CaptureScreenSettings;
+    }
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Starts capturing. Does nothing if capturing is already active.
+ *
+ * @returns IPRT status code.
+ */
+int Console::i_videoRecStart(void)
+{
+    if (Capture.mpVideoRecCtx && Capture.mpVideoRecCtx->IsStarted())
+        return VINF_SUCCESS;
+
+    LogRel(("VideoRec: Starting ...\n"));
+
+    try
+    {
+        Capture.mpVideoRecCtx = new CaptureContext(this);
+    }
+    catch (std::bad_alloc &)
+    {
+        return VERR_NO_MEMORY;
+    }
+    catch (int &rc)
+    {
+        return rc;
+    }
+
+    settings::CaptureSettings Settings;
+    int rc = i_videoRecLoad(Settings);
+    if (RT_SUCCESS(rc))
+    {
+        rc = Capture.mpVideoRecCtx->Create(Settings);
+        if (RT_SUCCESS(rc))
+        {
+            for (unsigned uScreen = 0; uScreen < Capture.mpVideoRecCtx->GetStreamCount(); uScreen++)
+                mDisplay->i_videoRecScreenChanged(uScreen);
+        }
+    }
+
+    if (RT_FAILURE(rc))
+        LogRel(("VideoRec: Failed to start video recording (%Rrc)\n", rc));
+
+    return rc;
+}
+
+/**
+ * Stops capturing. Does nothing if capturing is not active.
+ */
+int Console::i_videoRecStop(void)
+{
+    if (Capture.mpVideoRecCtx && Capture.mpVideoRecCtx->IsStarted())
+        return VINF_SUCCESS;
+
+    LogRel(("VideoRec: Stopping ...\n"));
+
+    const size_t cStreams = Capture.mpVideoRecCtx->GetStreamCount();
+
+    for (unsigned uScreen = 0; uScreen < cStreams; ++uScreen)
+        mDisplay->i_videoRecScreenChanged(uScreen);
+
+    delete Capture.mpVideoRecCtx;
+    Capture.mpVideoRecCtx = NULL;
+
+    ComPtr<ICaptureSettings> pCaptureSettings;
+    HRESULT hrc = mMachine->COMGETTER(CaptureSettings)(pCaptureSettings.asOutParam());
+    ComAssertComRC(hrc);
+    hrc = pCaptureSettings->COMSETTER(Enabled)(false);
+    ComAssertComRC(hrc);
+
+    LogRel(("VideoRec: Stopped\n"));
+
+    return VINF_SUCCESS;
+}
+#endif /* VBOX_WITH_VIDEOREC */
 
 /**
@@ -9966 +10089 @@
 
 #ifdef VBOX_WITH_VIDEOREC
-        BOOL fVideoRecEnabled = FALSE;
-        rc = pConsole->mMachine->COMGETTER(VideoCaptureEnabled)(&fVideoRecEnabled);
+        ComPtr<ICaptureSettings> CaptureSettings;
+        rc = pConsole->mMachine->COMGETTER(CaptureSettings)(CaptureSettings.asOutParam());
         AssertComRCReturnVoid(rc);
 
-        if (fVideoRecEnabled)
-        {
-            int vrc2 = pConsole->i_videoCaptureEnable(fVideoRecEnabled, &alock);
+        BOOL fCaptureEnabled;
+        rc = CaptureSettings->COMGETTER(Enabled)(&fCaptureEnabled);
+        AssertComRCReturnVoid(rc);
+
+        if (fCaptureEnabled)
+        {
+            int vrc2 = pConsole->i_videoCaptureEnable(fCaptureEnabled, &alock);
             if (RT_SUCCESS(vrc2))
             {
-                fireVideoCaptureChangedEvent(pConsole->mEventSource);
+                fireCaptureChangedEvent(pConsole->mEventSource);
             }
             else

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

@@ -2998 +2998 @@
                 InsertConfigString(pLunL0, "Driver", "AUDIO");
             AudioDriverCfg DrvCfgVideoRec(strAudioDevice, 0 /* Instance */, uAudioLUN, "AudioVideoRec");
-            rc = mAudioVideoRec->InitializeConfig(&DrvCfgVideoRec);
+            rc = Capture.mAudioVideoRec->InitializeConfig(&DrvCfgVideoRec);
             if (RT_SUCCESS(rc))
                 uAudioLUN++;

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

@@ -150 +150 @@
     AssertRC(rc);
 
-    mpVideoRecCtx = NULL;
     for (unsigned i = 0; i < RT_ELEMENTS(maVideoRecEnabled); i++)
         maVideoRecEnabled[i] = true;
@@ -2408 +2407 @@
 #ifdef VBOX_WITH_VIDEOREC
 /**
- * Returns the currently enabled video capturing features.
+ * Invalidates the capturing configuration.
  *
- * @returns Enables video capturing features.
+ * @returns IPRT status code.
  */
-VIDEORECFEATURES Display::i_videoRecGetFeatures(void)
-{
-    return VideoRecGetFeatures(&mVideoRecCfg);
-}
-
-/**
- * Returns whether video capturing is currently is active or not.
- *
- * @returns True if video capturing is active, false if not.
- */
-bool Display::i_videoRecStarted(void)
-{
-    return VideoRecIsStarted(mpVideoRecCtx);
-}
-
-/**
- * Invalidates the video recording configuration.
- */
-void Display::i_videoRecInvalidate(void)
-{
-    AssertPtr(mParent);
-    ComPtr<IMachine> pMachine = mParent->i_machine();
-    Assert(pMachine.isNotNull());
-
-    mVideoRecCfg.enmDst = VIDEORECDEST_FILE; /** @todo Make this configurable once we have more variations. */
-
-    /*
-     * Cache parameters from API.
-     */
-    com::SafeArray<BOOL> aScreens;
-    HRESULT hrc = pMachine->COMGETTER(VideoCaptureScreens)(ComSafeArrayAsOutParam(aScreens));
-    AssertComRCReturnVoid(hrc);
-
-    mVideoRecCfg.aScreens.resize(aScreens.size());
-    for (size_t i = 0; i < aScreens.size(); ++i)
-        mVideoRecCfg.aScreens[i] = aScreens[i];
-
-    hrc = pMachine->COMGETTER(VideoCaptureWidth)((ULONG *)&mVideoRecCfg.Video.uWidth);
-    AssertComRCReturnVoid(hrc);
-    hrc = pMachine->COMGETTER(VideoCaptureHeight)((ULONG *)&mVideoRecCfg.Video.uHeight);
-    AssertComRCReturnVoid(hrc);
-    hrc = pMachine->COMGETTER(VideoCaptureRate)((ULONG *)&mVideoRecCfg.Video.uRate);
-    AssertComRCReturnVoid(hrc);
-    hrc = pMachine->COMGETTER(VideoCaptureFPS)((ULONG *)&mVideoRecCfg.Video.uFPS);
-    AssertComRCReturnVoid(hrc);
-    hrc = pMachine->COMGETTER(VideoCaptureFile)(mVideoRecCfg.File.strName.asOutParam());
-    AssertComRCReturnVoid(hrc);
-    hrc = pMachine->COMGETTER(VideoCaptureMaxFileSize)((ULONG *)&mVideoRecCfg.File.uMaxSizeMB);
-    AssertComRCReturnVoid(hrc);
-    hrc = pMachine->COMGETTER(VideoCaptureMaxTime)((ULONG *)&mVideoRecCfg.uMaxTimeS);
-    AssertComRCReturnVoid(hrc);
-    BSTR bstrOptions;
-    hrc = pMachine->COMGETTER(VideoCaptureOptions)(&bstrOptions);
-    AssertComRCReturnVoid(hrc);
-
-    /*
-     * Set sensible defaults.
-     */
-    mVideoRecCfg.Video.fEnabled = true; /* Enabled by default. */
-
-    if (!mVideoRecCfg.Video.uFPS) /* Prevent division by zero. */
-        mVideoRecCfg.Video.uFPS = 15;
-
-#ifdef VBOX_WITH_LIBVPX
-    mVideoRecCfg.Video.Codec.VPX.uEncoderDeadline = 1000000 / mVideoRecCfg.Video.uFPS;
-#endif
-
-#ifdef VBOX_WITH_AUDIO_VIDEOREC
-    mVideoRecCfg.Audio.fEnabled  = false; /* Disabled by default, unless set otherwise below. */
-    /* By default we use 22,5kHz, 16-bit, stereo for the audio track. */
-    mVideoRecCfg.Audio.uHz       = 22050;
-    mVideoRecCfg.Audio.cBits     = 16;
-    mVideoRecCfg.Audio.cChannels = 2;
-#endif
-
-    /*
-     * Parse options string.
-     */
-    com::Utf8Str strOptions(bstrOptions);
-    size_t pos = 0;
-    com::Utf8Str key, value;
-    while ((pos = strOptions.parseKeyValue(key, value, pos)) != com::Utf8Str::npos)
-    {
-        if (key.compare("vc_quality", Utf8Str::CaseInsensitive) == 0)
-        {
-#ifdef VBOX_WITH_LIBVPX
-            if (value.compare("realtime", Utf8Str::CaseInsensitive) == 0)
-                mVideoRecCfg.Video.Codec.VPX.uEncoderDeadline = VPX_DL_REALTIME;
-            else if (value.compare("good", Utf8Str::CaseInsensitive) == 0)
-                mVideoRecCfg.Video.Codec.VPX.uEncoderDeadline = 1000000 / mVideoRecCfg.Video.uFPS;
-            else if (value.compare("best", Utf8Str::CaseInsensitive) == 0)
-                mVideoRecCfg.Video.Codec.VPX.uEncoderDeadline = VPX_DL_BEST_QUALITY;
-            else
-            {
-                LogRel(("VideoRec: Setting quality deadline to '%s'\n", value.c_str()));
-                mVideoRecCfg.Video.Codec.VPX.uEncoderDeadline = value.toUInt32();
-#endif
-            }
-        }
-        else if (key.compare("vc_enabled", Utf8Str::CaseInsensitive) == 0)
-        {
-            if (value.compare("false", Utf8Str::CaseInsensitive) == 0)
-            {
-                mVideoRecCfg.Video.fEnabled = false;
-#ifdef VBOX_WITH_AUDIO_VIDEOREC
-                LogRel(("VideoRec: Only audio will be recorded\n"));
-#endif
-            }
-        }
-        else if (key.compare("ac_enabled", Utf8Str::CaseInsensitive) == 0)
-        {
-#ifdef VBOX_WITH_AUDIO_VIDEOREC
-            if (value.compare("true", Utf8Str::CaseInsensitive) == 0)
-            {
-                mVideoRecCfg.Audio.fEnabled = true;
-
-            }
-            else
-                LogRel(("VideoRec: Only video will be recorded\n"));
-#endif
-        }
-        else if (key.compare("ac_profile", Utf8Str::CaseInsensitive) == 0)
-        {
-#ifdef VBOX_WITH_AUDIO_VIDEOREC
-            if (value.compare("low", Utf8Str::CaseInsensitive) == 0)
-            {
-                mVideoRecCfg.Audio.uHz       = 8000;
-                mVideoRecCfg.Audio.cBits     = 16;
-                mVideoRecCfg.Audio.cChannels = 1;
-            }
-            else if (value.startsWith("med" /* "med[ium]" */, Utf8Str::CaseInsensitive) == 0)
-            {
-                /* Stay with the default set above. */
-            }
-            else if (value.compare("high", Utf8Str::CaseInsensitive) == 0)
-            {
-                mVideoRecCfg.Audio.uHz       = 48000;
-                mVideoRecCfg.Audio.cBits     = 16;
-                mVideoRecCfg.Audio.cChannels = 2;
-            }
-#endif
-        }
-        else
-            LogRel(("VideoRec: Unknown option '%s' (value '%s'), skipping\n", key.c_str(), value.c_str()));
-
-    } /* while */
+int Display::i_videoRecInvalidate(void)
+{
+    CaptureContext *pCtx = mParent->i_videoRecGetContext();
+    if (!pCtx || !pCtx->IsStarted())
+        return VINF_SUCCESS;
 
     /*
      * Invalidate screens.
      */
-    for (unsigned i = 0; i < mVideoRecCfg.aScreens.size(); i++)
-    {
-        bool fChanged = maVideoRecEnabled[i] != RT_BOOL(mVideoRecCfg.aScreens[i]);
-
-        maVideoRecEnabled[i] = RT_BOOL(mVideoRecCfg.aScreens[i]);
-
-        if (fChanged && i < mcMonitors)
-            i_videoRecScreenChanged(i);
-
-    }
-}
-
-/**
- * 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_videoRecSendAudio(const void *pvData, size_t cbData, uint64_t uTimestampMs)
-{
-    if (   VideoRecIsStarted(mpVideoRecCtx)
-        && VideoRecGetFeatures(&mVideoRecCfg) & VIDEORECFEATURE_AUDIO)
-    {
-        return VideoRecSendAudioFrame(mpVideoRecCtx, pvData, cbData, uTimestampMs);
+    for (unsigned uScreen = 0; uScreen < mcMonitors; uScreen++)
+    {
+        CaptureStream *pCaptureStream = pCtx->GetStream(uScreen);
+
+        const bool fStreamEnabled = pCaptureStream->IsReady();
+              bool fChanged       = maVideoRecEnabled[uScreen] != fStreamEnabled;
+
+        maVideoRecEnabled[uScreen] = fStreamEnabled;
+
+        if (fChanged && uScreen < mcMonitors)
+            i_videoRecScreenChanged(uScreen);
     }
 
@@ -2594 +2436 @@
 }
 
-/**
- * Start video capturing. Does nothing if capturing is already active.
- *
- * @param   pVideoRecCfg        Video recording configuration to use.
- * @returns IPRT status code.
- */
-int Display::i_videoRecStart(void)
-{
-    if (VideoRecIsStarted(mpVideoRecCtx))
-        return VINF_SUCCESS;
-
-    LogRel(("VideoRec: Starting ...\n"));
-
-    int rc = VideoRecContextCreate(mcMonitors, &mVideoRecCfg, &mpVideoRecCtx);
-    if (RT_SUCCESS(rc))
-    {
-        for (unsigned uScreen = 0; uScreen < mcMonitors; uScreen++)
-        {
-            int rc2 = VideoRecStreamInit(VideoRecGetStream(mpVideoRecCtx, uScreen), mpVideoRecCtx, uScreen);
-            if (RT_SUCCESS(rc2))
-            {
-                i_videoRecScreenChanged(uScreen);
-            }
-            else
-                LogRel(("VideoRec: Failed to initialize video recording context #%u (%Rrc)\n", uScreen, rc2));
-
-            if (RT_SUCCESS(rc))
-                rc = rc2;
-        }
-    }
-
-    if (RT_FAILURE(rc))
-        LogRel(("VideoRec: Failed to start video recording (%Rrc)\n", rc));
-
-    return rc;
-}
-
-/**
- * Stops video capturing. Does nothing if video capturing is not active.
- */
-void Display::i_videoRecStop(void)
-{
-    if (!VideoRecIsStarted(mpVideoRecCtx))
-        return;
-
-    LogRel(("VideoRec: Stopping ...\n"));
-
-    VideoRecContextDestroy(mpVideoRecCtx);
-    mpVideoRecCtx = NULL;
-
-    unsigned uScreenId;
-    for (uScreenId = 0; uScreenId < mcMonitors; ++uScreenId)
-        i_videoRecScreenChanged(uScreenId);
-}
-
 void Display::i_videoRecScreenChanged(unsigned uScreenId)
 {
-    if (   !VideoRecIsStarted(mpVideoRecCtx)
-        || !maVideoRecEnabled[uScreenId])
+    CaptureContext *pCtx = mParent->i_videoRecGetContext();
+
+    if (   RT_LIKELY(!maVideoRecEnabled[uScreenId])
+        || !pCtx || !pCtx->IsStarted())
     {
         /* Skip recording this screen. */
@@ -3599 +3388 @@
 
 #ifdef VBOX_WITH_VIDEOREC
-    if (   VideoRecIsStarted(pDisplay->mpVideoRecCtx)
-        && VideoRecGetFeatures(&pDisplay->mVideoRecCfg) & VIDEORECFEATURE_VIDEO)
+    AssertPtr(pDisplay->mParent);
+    CaptureContext *pCtx = pDisplay->mParent->i_videoRecGetContext();
+
+    if (   pCtx
+        && pCtx->IsStarted()
+        && pCtx->IsFeatureEnabled(CaptureFeature_Video))
     {
         do {
@@ -3638 +3431 @@
 # endif /* VBOX_WITH_HGCM && VBOX_WITH_CROGL */
 
-            uint64_t u64Now = RTTimeProgramMilliTS();
+            uint64_t tsNowMs = RTTimeProgramMilliTS();
             for (uScreenId = 0; uScreenId < pDisplay->mcMonitors; uScreenId++)
             {
@@ -3644 +3437 @@
                     continue;
 
-                if (VideoRecIsLimitReached(pDisplay->mpVideoRecCtx, uScreenId, u64Now))
+                if (pCtx->IsLimitReached(uScreenId, tsNowMs))
                 {
-                    pDisplay->i_videoRecStop();
-                    pDisplay->mParent->i_machine()->COMSETTER(VideoCaptureEnabled)(false);
+                    pDisplay->mParent->i_videoRecStop();
                     break;
                 }
@@ -3677 +3469 @@
                                                                     &bitmapFormat);
                         if (SUCCEEDED(hr) && pbAddress)
-                            rc = VideoRecSendVideoFrame(pDisplay->mpVideoRecCtx, uScreenId, 0, 0,
-                                                        BitmapFormat_BGR,
-                                                        ulBitsPerPixel, ulBytesPerLine, ulWidth, ulHeight,
-                                                        pbAddress, u64Now);
+                            rc = pCtx->SendVideoFrame(uScreenId, 0, 0, BitmapFormat_BGR,
+                                                      ulBitsPerPixel, ulBytesPerLine, ulWidth, ulHeight,
+                                                      pbAddress, tsNowMs);
                         else
                             rc = VERR_NOT_SUPPORTED;
@@ -4039 +3830 @@
 }
 
-bool  Display::i_handleCrVRecScreenshotBegin(uint32_t uScreen, uint64_t u64Timestamp)
-{
-    /** @todo r=bird: u64Timestamp - using the 'u64' prefix add nothing.
-     *        However, using one of the prefixes indicating the timestamp unit
-     *        would be very valuable!  */
+bool  Display::i_handleCrVRecScreenshotBegin(uint32_t uScreen, uint64_t uTimestampMs)
+{
 # ifdef VBOX_WITH_VIDEOREC
-    return VideoRecIsReady(mpVideoRecCtx, uScreen, u64Timestamp);
+    CaptureContext *pCtx = mParent->i_videoRecGetContext();
+    return (      pCtx
+               && pCtx->IsReady(uScreen, uTimestampMs));
 # else
-    RT_NOREF(uScreen, u64Timestamp);
+    RT_NOREF(uScreen, uTimestampMs);
     return false;
 # endif
 }
 
-void  Display::i_handleCrVRecScreenshotEnd(uint32_t uScreen, uint64_t u64Timestamp)
-{
-    RT_NOREF(uScreen, u64Timestamp);
+void  Display::i_handleCrVRecScreenshotEnd(uint32_t uScreen, uint64_t uTimestampMs)
+{
+    RT_NOREF(uScreen, uTimestampMs);
 }
 
@@ -4061 +3851 @@
                                                uint32_t uBitsPerPixel, uint32_t uBytesPerLine,
                                                uint32_t uGuestWidth, uint32_t uGuestHeight,
-                                               uint8_t *pu8BufferAddress, uint64_t u64Timestamp)
+                                               uint8_t *pu8BufferAddress, uint64_t uTimestampMs)
 {
     Assert(mfCrOglVideoRecState == CRVREC_STATE_SUBMITTED);
 # ifdef VBOX_WITH_VIDEOREC
-    if (   VideoRecIsStarted(mpVideoRecCtx)
-        && VideoRecGetFeatures(&mVideoRecCfg) & VIDEORECFEATURE_VIDEO)
-    {
-        int rc2 = VideoRecSendVideoFrame(mpVideoRecCtx, uScreen, x, y,
-                                         uPixelFormat,
-                                         uBitsPerPixel, uBytesPerLine,
-                                         uGuestWidth, uGuestHeight,
-                                         pu8BufferAddress, u64Timestamp);
+    CaptureContext *pCtx = mParent->i_videoRecGetContext();
+
+    if (   pCtx
+        && pCtx->IsStarted()
+        && pCtx->IsFeatureEnabled(CaptureFeature_Video))
+    {
+        int rc2 = pCtx->SendVideoFrame(uScreen, x, y,
+                                       uPixelFormat,
+                                       uBitsPerPixel, uBytesPerLine,
+                                       uGuestWidth, uGuestHeight,
+                                       pu8BufferAddress, uTimestampMs);
         RT_NOREF(rc2);
         Assert(rc2 == VINF_SUCCESS /* || rc == VERR_TRY_AGAIN || rc == VINF_TRY_AGAIN*/);
@@ -4078 +3871 @@
 # else
     RT_NOREF(uScreen, x, y, uPixelFormat, \
-             uBitsPerPixel, uBytesPerLine, uGuestWidth, uGuestHeight, pu8BufferAddress, u64Timestamp);
+             uBitsPerPixel, uBytesPerLine, uGuestWidth, uGuestHeight, pu8BufferAddress, uTimestampMs);
 # endif /* VBOX_WITH_VIDEOREC */
 }
@@ -4706 +4499 @@
         AutoWriteLock displayLock(pThis->pDisplay COMMA_LOCKVAL_SRC_POS);
 #ifdef VBOX_WITH_VIDEOREC
-        pThis->pDisplay->i_videoRecStop();
+        pThis->pDisplay->mParent->i_videoRecStop();
 #endif
 #ifdef VBOX_WITH_CRHGSMI

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

@@ -828 +828 @@
                 case AVRECCONTAINERTYPE_MAIN_CONSOLE:
                 {
-                    HRESULT hr = pSink->Con.Main.pConsole->i_audioVideoRecSendAudio(pStreamAV->pvDstBuf, cbDst, uPTSMs);
+                    HRESULT hr = pSink->Con.Main.pConsole->i_videoRecSendAudio(pStreamAV->pvDstBuf, cbDst, uPTSMs);
                     Assert(hr == S_OK);
                     RT_NOREF(hr);
@@ -1086 +1086 @@
  *
  * @returns IPRT status code.
- * @param   pVideoRecCfg        Pointer to video recording configuration to apply.
- */
-int AudioVideoRec::applyConfiguration(const PVIDEORECCFG pVideoRecCfg)
+ * @param   Settings        Capturing configuration to apply.
+ */
+int AudioVideoRec::applyConfiguration(const settings::CaptureSettings &a_Settings)
 {
     /** @todo Do some validation here. */
-    mVideoRecCfg = *pVideoRecCfg; /* Note: Does have an own copy operator. */
+    mVideoRecCfg = a_Settings; /* Note: Does have an own copy operator. */
     return VINF_SUCCESS;
 }
@@ -1101 +1101 @@
 int AudioVideoRec::configureDriver(PCFGMNODE pLunCfg)
 {
-    int rc = CFGMR3InsertInteger(pLunCfg, "Object",    (uintptr_t)mpConsole->i_getAudioVideoRec());
+    int rc = CFGMR3InsertInteger(pLunCfg, "Object",    (uintptr_t)mpConsole->i_videoRecGetAudioDrv());
     AssertRCReturn(rc, rc);
     rc = CFGMR3InsertInteger(pLunCfg, "ObjectConsole", (uintptr_t)mpConsole);
     AssertRCReturn(rc, rc);
 
-    rc = CFGMR3InsertInteger(pLunCfg, "ContainerType", (uint64_t)mVideoRecCfg.enmDst);
+    /** @todo For now we're using the configuration of the first screen here audio-wise. */
+    Assert(mVideoRecCfg.mapScreens.size() >= 1);
+    const settings::CaptureScreenSettings &Screen0Settings = mVideoRecCfg.mapScreens[0];
+
+    rc = CFGMR3InsertInteger(pLunCfg, "ContainerType", (uint64_t)Screen0Settings.enmDest);
     AssertRCReturn(rc, rc);
-    if (mVideoRecCfg.enmDst == VIDEORECDEST_FILE)
-    {
-        rc = CFGMR3InsertString(pLunCfg, "ContainerFileName", Utf8Str(mVideoRecCfg.File.strName).c_str());
+    if (Screen0Settings.enmDest == CaptureDestination_File)
+    {
+        rc = CFGMR3InsertString(pLunCfg, "ContainerFileName", Utf8Str(Screen0Settings.File.strName).c_str());
         AssertRCReturn(rc, rc);
     }
-    rc = CFGMR3InsertInteger(pLunCfg, "CodecHz", mVideoRecCfg.Audio.uHz);
+    rc = CFGMR3InsertInteger(pLunCfg, "CodecHz", Screen0Settings.Audio.uHz);
     AssertRCReturn(rc, rc);
-    rc = CFGMR3InsertInteger(pLunCfg, "CodecBits", mVideoRecCfg.Audio.cBits);
+    rc = CFGMR3InsertInteger(pLunCfg, "CodecBits", Screen0Settings.Audio.cBits);
     AssertRCReturn(rc, rc);
-    rc = CFGMR3InsertInteger(pLunCfg, "CodecChannels", mVideoRecCfg.Audio.cChannels);
+    rc = CFGMR3InsertInteger(pLunCfg, "CodecChannels", Screen0Settings.Audio.cChannels);
     AssertRCReturn(rc, rc);
     rc = CFGMR3InsertInteger(pLunCfg, "CodecBitrate", 0); /* Let Opus decide for now. */

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

@@ -725 +725 @@
 }
 
-HRESULT Session::onVideoCaptureChange()
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-#ifndef VBOX_COM_INPROC_API_CLIENT
-    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
-
-    return mConsole->i_onVideoCaptureChange();
+HRESULT Session::onCaptureChange()
+{
+    LogFlowThisFunc(("\n"));
+
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
+    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
+#ifndef VBOX_COM_INPROC_API_CLIENT
+    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
+
+    return mConsole->i_onCaptureChange();
 #else
     return S_OK;

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

@@ -43 +43 @@
 #include <VBox/com/VirtualBox.h>
 
-#include "WebMWriter.h"
+#include "ConsoleImpl.h"
 #include "VideoRec.h"
 #include "VideoRecInternals.h"
 #include "VideoRecStream.h"
 #include "VideoRecUtils.h"
+#include "WebMWriter.h"
 
 using namespace com;
@@ -103 +104 @@
 
 
+CaptureContext::CaptureContext(Console *a_pConsole)
+    : pConsole(a_pConsole) { }
+
+CaptureContext::CaptureContext(Console *a_pConsole, const settings::CaptureSettings &a_Settings)
+    : pConsole(a_pConsole)
+{
+    int rc = CaptureContext::createInternal(a_Settings);
+    if (RT_FAILURE(rc))
+        throw rc;
+}
+
+CaptureContext::~CaptureContext(void)
+{
+    destroyInternal();
+}
+
 /**
  * Worker thread for all streams of a video recording context.
@@ -108 +125 @@
  * For video frames, this also does the RGB/YUV conversion and encoding.
  */
-static DECLCALLBACK(int) videoRecThread(RTTHREAD hThreadSelf, void *pvUser)
-{
-    PVIDEORECCONTEXT pCtx = (PVIDEORECCONTEXT)pvUser;
+DECLCALLBACK(int) CaptureContext::threadMain(RTTHREAD hThreadSelf, void *pvUser)
+{
+    CaptureContext *pThis = (CaptureContext *)pvUser;
 
     /* Signal that we're up and rockin'. */
@@ -119 +136 @@
     for (;;)
     {
-        int rc = RTSemEventWait(pCtx->WaitEvent, RT_INDEFINITE_WAIT);
+        int rc = RTSemEventWait(pThis->WaitEvent, RT_INDEFINITE_WAIT);
         AssertRCBreak(rc);
 
-        Log2Func(("Processing %zu streams\n", pCtx->vecStreams.size()));
+        Log2Func(("Processing %zu streams\n", pThis->vecStreams.size()));
 
         /** @todo r=andy This is inefficient -- as we already wake up this thread
          *               for every screen from Main, we here go again (on every wake up) through
          *               all screens.  */
-        VideoRecStreams::iterator itStream = pCtx->vecStreams.begin();
-        while (itStream != pCtx->vecStreams.end())
-        {
-            PVIDEORECSTREAM pStream = (*itStream);
-
-            rc = VideoRecStreamProcess(pStream);
+        VideoRecStreams::iterator itStream = pThis->vecStreams.begin();
+        while (itStream != pThis->vecStreams.end())
+        {
+            CaptureStream *pStream = (*itStream);
+
+            rc = pStream->Process(pThis->mapBlocksCommon);
             if (RT_FAILURE(rc))
                 break;
@@ -144 +161 @@
         /* Keep going in case of errors. */
 
-        if (ASMAtomicReadBool(&pCtx->fShutdown))
+        if (ASMAtomicReadBool(&pThis->fShutdown))
         {
             LogFunc(("Thread is shutting down ...\n"));
@@ -160 +177 @@
  *
  * @returns IPRT status code.
- * @param   pCtx                Video recording context to notify thread for.
- */
-static int videoRecThreadNotify(PVIDEORECCONTEXT pCtx)
-{
-    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
-
-    return RTSemEventSignal(pCtx->WaitEvent);
+ */
+int CaptureContext::threadNotify(void)
+{
+    return RTSemEventSignal(this->WaitEvent);
 }
 
@@ -175 +189 @@
  * @param   cScreens            Number of screens to create context for.
  * @param   pVideoRecCfg        Pointer to video recording configuration to use.
- * @param   ppCtx               Pointer to created video recording context on success.
- */
-int VideoRecContextCreate(uint32_t cScreens, PVIDEORECCFG pVideoRecCfg, PVIDEORECCONTEXT *ppCtx)
-{
-    AssertReturn(cScreens,        VERR_INVALID_PARAMETER);
-    AssertPtrReturn(pVideoRecCfg, VERR_INVALID_POINTER);
-    AssertPtrReturn(ppCtx,        VERR_INVALID_POINTER);
-
-    VIDEORECCONTEXT *pCtx = NULL;
-    try
-    {
-        pCtx = new VIDEORECCONTEXT();
-    }
-    catch (std::bad_alloc &)
-    {
-        return VERR_NO_MEMORY;
-    }
-
-    int rc = RTCritSectInit(&pCtx->CritSect);
+ */
+int CaptureContext::createInternal(const settings::CaptureSettings &a_Settings)
+{
+    int rc = RTCritSectInit(&this->CritSect);
     if (RT_FAILURE(rc))
-    {
-        delete pCtx;
         return rc;
-    }
-
-    for (uint32_t uScreen = 0; uScreen < cScreens; uScreen++)
-    {
-        VIDEORECSTREAM *pStream = NULL;
+
+    settings::CaptureScreenMap::const_iterator itScreen = a_Settings.mapScreens.begin();
+    while (itScreen != a_Settings.mapScreens.end())
+    {
+        CaptureStream *pStream = NULL;
         try
         {
-            pStream = new VIDEORECSTREAM();
+            pStream = new CaptureStream(itScreen->first /* Screen ID */, itScreen->second);
+            this->vecStreams.push_back(pStream);
         }
         catch (std::bad_alloc &)
@@ -212 +210 @@
             break;
         }
-
-        rc = RTCritSectInit(&pStream->CritSect);
-        if (RT_FAILURE(rc))
-            break;
-
-        try
-        {
-            pStream->uScreenID = uScreen;
-
-            pCtx->vecStreams.push_back(pStream);
-
-            pStream->File.pWEBM = new WebMWriter();
-        }
-        catch (std::bad_alloc &)
-        {
-            rc = VERR_NO_MEMORY;
-            break;
-        }
     }
 
     if (RT_SUCCESS(rc))
     {
-        pCtx->tsStartMs = RTTimeMilliTS();
-        pCtx->enmState  = VIDEORECSTS_UNINITIALIZED;
-        pCtx->fStarted  = false;
-        pCtx->fShutdown = false;
-
-        /* Copy the configuration to our context. */
-        pCtx->Cfg       = *pVideoRecCfg;
-
-        rc = RTSemEventCreate(&pCtx->WaitEvent);
+        this->tsStartMs = RTTimeMilliTS();
+        this->enmState  = VIDEORECSTS_UNINITIALIZED;
+        this->fStarted  = false;
+        this->fShutdown = false;
+
+        /* Copy the settings to our context. */
+        this->Settings  = a_Settings;
+
+        rc = RTSemEventCreate(&this->WaitEvent);
         AssertRCReturn(rc, rc);
 
-        rc = RTThreadCreate(&pCtx->Thread, videoRecThread, (void *)pCtx, 0,
+        rc = RTThreadCreate(&this->Thread, CaptureContext::threadMain, (void *)this, 0,
                             RTTHREADTYPE_MAIN_WORKER, RTTHREADFLAGS_WAITABLE, "VideoRec");
 
         if (RT_SUCCESS(rc)) /* Wait for the thread to start. */
-            rc = RTThreadUserWait(pCtx->Thread, 30 * RT_MS_1SEC /* 30s timeout */);
+            rc = RTThreadUserWait(this->Thread, 30 * RT_MS_1SEC /* 30s timeout */);
 
         if (RT_SUCCESS(rc))
         {
-            pCtx->enmState = VIDEORECSTS_INITIALIZED;
-            pCtx->fStarted = true;
-
-            if (ppCtx)
-                *ppCtx = pCtx;
+            this->enmState = VIDEORECSTS_INITIALIZED;
+            this->fStarted = true;
         }
     }
@@ -263 +240 @@
     if (RT_FAILURE(rc))
     {
-        int rc2 = VideoRecContextDestroy(pCtx);
+        int rc2 = destroyInternal();
         AssertRC(rc2);
     }
@@ -272 +249 @@
 /**
  * Destroys a video recording context.
- *
- * @param pCtx                  Video recording context to destroy.
- */
-int VideoRecContextDestroy(PVIDEORECCONTEXT pCtx)
-{
-    if (!pCtx)
-        return VINF_SUCCESS;
-
+ */
+int CaptureContext::destroyInternal(void)
+{
     int rc = VINF_SUCCESS;
 
-    if (pCtx->enmState == VIDEORECSTS_INITIALIZED)
+    if (this->enmState == VIDEORECSTS_INITIALIZED)
     {
         LogFunc(("Shutting down thread ...\n"));
 
         /* Set shutdown indicator. */
-        ASMAtomicWriteBool(&pCtx->fShutdown, true);
+        ASMAtomicWriteBool(&this->fShutdown, true);
 
         /* Signal the thread and wait for it to shut down. */
-        rc = videoRecThreadNotify(pCtx);
+        rc = threadNotify();
         if (RT_SUCCESS(rc))
-            rc = RTThreadWait(pCtx->Thread, 30 * 1000 /* 10s timeout */, NULL);
+            rc = RTThreadWait(this->Thread, 30 * 1000 /* 10s timeout */, NULL);
 
         if (RT_SUCCESS(rc))
         {
             /* Disable the context. */
-            ASMAtomicWriteBool(&pCtx->fStarted, false);
-
-            int rc2 = RTSemEventDestroy(pCtx->WaitEvent);
+            ASMAtomicWriteBool(&this->fStarted, false);
+
+            int rc2 = RTSemEventDestroy(this->WaitEvent);
             AssertRC(rc2);
 
-            pCtx->WaitEvent = NIL_RTSEMEVENT;
+            this->WaitEvent = NIL_RTSEMEVENT;
         }
     }
@@ -312 +284 @@
     }
 
-    rc = RTCritSectEnter(&pCtx->CritSect);
+    rc = RTCritSectEnter(&this->CritSect);
     if (RT_SUCCESS(rc))
     {
-        VideoRecStreams::iterator it = pCtx->vecStreams.begin();
-        while (it != pCtx->vecStreams.end())
-        {
-            PVIDEORECSTREAM pStream = (*it);
-
-            VideoRecStreamLock(pStream);
-
-            int rc2 = VideoRecStreamClose(pStream);
+        VideoRecStreams::iterator it = this->vecStreams.begin();
+        while (it != this->vecStreams.end())
+        {
+            CaptureStream *pStream = (*it);
+
+            int rc2 = pStream->Uninit();
             if (RT_SUCCESS(rc))
                 rc = rc2;
 
-            rc2 = VideoRecStreamUninit(pStream);
-            if (RT_SUCCESS(rc))
-                rc = rc2;
-
-            pCtx->vecStreams.erase(it);
-            it = pCtx->vecStreams.begin();
-
-            VideoRecStreamUnlock(pStream);
-
-            RTCritSectDelete(&pStream->CritSect);
-
             delete pStream;
             pStream = NULL;
+
+            this->vecStreams.erase(it);
+            it = this->vecStreams.begin();
+
+            delete pStream;
+            pStream = NULL;
         }
 
         /* Sanity. */
-        Assert(pCtx->vecStreams.empty());
-        Assert(pCtx->mapBlocksCommon.size() == 0);
-
-        int rc2 = RTCritSectLeave(&pCtx->CritSect);
+        Assert(this->vecStreams.empty());
+        Assert(this->mapBlocksCommon.size() == 0);
+
+        int rc2 = RTCritSectLeave(&this->CritSect);
         AssertRC(rc2);
 
-        RTCritSectDelete(&pCtx->CritSect);
-
-        delete pCtx;
-        pCtx = NULL;
+        RTCritSectDelete(&this->CritSect);
     }
 
@@ -357 +319 @@
 }
 
-/**
- * Returns which recording features currently are enabled for a given configuration.
- *
- * @returns Enabled video recording features.
- * @param   pCfg                Pointer to recording configuration.
- */
-VIDEORECFEATURES VideoRecGetFeatures(PVIDEORECCFG pCfg)
-{
-    if (!pCfg)
-        return VIDEORECFEATURE_NONE;
-
-    VIDEORECFEATURES fFeatures = VIDEORECFEATURE_NONE;
-
-    if (pCfg->Video.fEnabled)
-        fFeatures |= VIDEORECFEATURE_VIDEO;
-
-#ifdef VBOX_WITH_AUDIO_VIDEOREC
-    if (pCfg->Audio.fEnabled)
-        fFeatures |= VIDEORECFEATURE_AUDIO;
-#endif
-
-    return fFeatures;
+const settings::CaptureSettings &CaptureContext::GetConfig(void) const
+{
+    return this->Settings;
+}
+
+CaptureStream *CaptureContext::getStreamInternal(unsigned uScreen) const
+{
+    CaptureStream *pStream;
+
+    try
+    {
+        pStream = this->vecStreams.at(uScreen);
+    }
+    catch (std::out_of_range &)
+    {
+        pStream = NULL;
+    }
+
+    return pStream;
 }
 
@@ -385 +344 @@
  *
  * @returns Pointer to recording stream if found, or NULL if not found.
- * @param   pCtx                Recording context to look up stream for.
  * @param   uScreen             Screen number of recording stream to look up.
  */
-PVIDEORECSTREAM VideoRecGetStream(PVIDEORECCONTEXT pCtx, uint32_t uScreen)
-{
-    AssertPtrReturn(pCtx, NULL);
-
-    PVIDEORECSTREAM pStream;
-
-    try
-    {
-        pStream = pCtx->vecStreams.at(uScreen);
-    }
-    catch (std::out_of_range &)
-    {
-        pStream = NULL;
-    }
-
-    return pStream;
+CaptureStream *CaptureContext::GetStream(unsigned uScreen) const
+{
+    return getStreamInternal(uScreen);
+}
+
+size_t CaptureContext::GetStreamCount(void) const
+{
+    return this->vecStreams.size();
+}
+
+int CaptureContext::Create(const settings::CaptureSettings &a_Settings)
+{
+    return createInternal(a_Settings);
+}
+
+int CaptureContext::Destroy(void)
+{
+    return destroyInternal();
+}
+
+bool CaptureContext::IsFeatureEnabled(CaptureFeature_T enmFeature) const
+{
+    VideoRecStreams::const_iterator itStream = this->vecStreams.begin();
+    while (itStream != this->vecStreams.end())
+    {
+        if ((*itStream)->GetConfig().isFeatureEnabled(enmFeature))
+            return true;
+        ++itStream;
+    }
+
+    return false;
+}
+
+bool CaptureContext::IsReady(void) const
+{
+    return this->fStarted;
 }
 
@@ -410 +388 @@
  *
  * @returns true if recording engine is ready, false if not.
- * @param   pCtx                Pointer to video recording context.
  * @param   uScreen             Screen ID.
  * @param   uTimeStampMs        Current time stamp (in ms). Currently not being used.
  */
-bool VideoRecIsReady(PVIDEORECCONTEXT pCtx, uint32_t uScreen, uint64_t uTimeStampMs)
-{
-    AssertPtrReturn(pCtx, false);
+bool CaptureContext::IsReady(uint32_t uScreen, uint64_t uTimeStampMs) const
+{
     RT_NOREF(uTimeStampMs);
 
-    if (ASMAtomicReadU32(&pCtx->enmState) != VIDEORECSTS_INITIALIZED)
+    if (this->enmState != VIDEORECSTS_INITIALIZED)
         return false;
 
     bool fIsReady = false;
 
-    PVIDEORECSTREAM pStream = VideoRecGetStream(pCtx, uScreen);
+    const CaptureStream *pStream = GetStream(uScreen);
     if (pStream)
-    {
-        VideoRecStreamLock(pStream);
-        fIsReady = pStream->fEnabled;
-        VideoRecStreamUnlock(pStream);
-    }
+        fIsReady = pStream->IsReady();
 
     /* Note: Do not check for other constraints like the video FPS rate here,
@@ -443 +415 @@
  *
  * @returns true if active, false if not.
- * @param   pCtx                 Pointer to video recording context.
- */
-bool VideoRecIsStarted(PVIDEORECCONTEXT pCtx)
-{
-    if (!pCtx)
-        return false;
-
-    return ASMAtomicReadBool(&pCtx->fStarted);
+ */
+bool CaptureContext::IsStarted(void) const
+{
+    return this->fStarted;
 }
 
@@ -457 +425 @@
  *
  * @returns true if any limit has been reached.
- * @param   pCtx                Pointer to video recording context.
  * @param   uScreen             Screen ID.
  * @param   tsNowMs             Current time stamp (in ms).
  */
-bool VideoRecIsLimitReached(PVIDEORECCONTEXT pCtx, uint32_t uScreen, uint64_t tsNowMs)
-{
-    PVIDEORECSTREAM pStream = VideoRecGetStream(pCtx, uScreen);
+bool CaptureContext::IsLimitReached(uint32_t uScreen, uint64_t tsNowMs) const
+{
+    const CaptureStream *pStream = GetStream(uScreen);
     if (   !pStream
-        || !pStream->fEnabled)
-    {
-        return false;
-    }
-
-    const PVIDEORECCFG pCfg = &pCtx->Cfg;
-
-    if (   pCfg->uMaxTimeS
-        && tsNowMs >= pCtx->tsStartMs + (pCfg->uMaxTimeS * RT_MS_1SEC))
+        || pStream->IsLimitReached(tsNowMs))
     {
         return true;
     }
 
-    if (pCfg->enmDst == VIDEORECDEST_FILE)
-    {
-
-        if (pCfg->File.uMaxSizeMB)
-        {
-            uint64_t sizeInMB = pStream->File.pWEBM->GetFileSize() / _1M;
-            if(sizeInMB >= pCfg->File.uMaxSizeMB)
-                return true;
-        }
-
-        /* Check for available free disk space */
-        if (   pStream->File.pWEBM
-            && pStream->File.pWEBM->GetAvailableSpace() < 0x100000) /** @todo r=andy WTF? Fix this. */
-        {
-            LogRel(("VideoRec: Not enough free storage space available, stopping video capture\n"));
-            return true;
-        }
-    }
-
     return false;
 }
@@ -506 +446 @@
  *
  * @returns IPRT status code.
- * @param   pCtx                Pointer to the video recording context.
  * @param   pvData              Audio frame data to send.
  * @param   cbData              Size (in bytes) of (encoded) audio frame data.
  * @param   uTimeStampMs        Time stamp (in ms) of audio playback.
  */
-int VideoRecSendAudioFrame(PVIDEORECCONTEXT pCtx, const void *pvData, size_t cbData, uint64_t uTimeStampMs)
+int CaptureContext::SendAudioFrame(const void *pvData, size_t cbData, uint64_t uTimeStampMs)
 {
 #ifdef VBOX_WITH_AUDIO_VIDEOREC
@@ -537 +476 @@
     pBlock->pvData       = pFrame;
     pBlock->cbData       = sizeof(VIDEORECAUDIOFRAME) + cbData;
-    pBlock->cRefs        = (uint16_t)pCtx->vecStreams.size(); /* All streams need the same audio data. */
+    pBlock->cRefs        = (uint16_t)this->vecStreams.size(); /* All streams need the same audio data. */
     pBlock->uTimeStampMs = uTimeStampMs;
 
-    int rc = RTCritSectEnter(&pCtx->CritSect);
+    int rc = RTCritSectEnter(&this->CritSect);
     if (RT_FAILURE(rc))
         return rc;
@@ -546 +485 @@
     try
     {
-        VideoRecBlockMap::iterator itBlocks = pCtx->mapBlocksCommon.find(uTimeStampMs);
-        if (itBlocks == pCtx->mapBlocksCommon.end())
-        {
-            VideoRecBlocks *pVideoRecBlocks = new VideoRecBlocks();
+        VideoRecBlockMap::iterator itBlocks = this->mapBlocksCommon.find(uTimeStampMs);
+        if (itBlocks == this->mapBlocksCommon.end())
+        {
+            CaptureBlocks *pVideoRecBlocks = new CaptureBlocks();
             pVideoRecBlocks->List.push_back(pBlock);
 
-            pCtx->mapBlocksCommon.insert(std::make_pair(uTimeStampMs, pVideoRecBlocks));
+            this->mapBlocksCommon.insert(std::make_pair(uTimeStampMs, pVideoRecBlocks));
         }
         else
@@ -563 +502 @@
     }
 
-    int rc2 = RTCritSectLeave(&pCtx->CritSect);
+    int rc2 = RTCritSectLeave(&this->CritSect);
     AssertRC(rc2);
 
     if (RT_SUCCESS(rc))
-        rc = videoRecThreadNotify(pCtx);
+        rc = threadNotify();
 
     return rc;
@@ -583 +522 @@
  *
  * @returns IPRT status code.
- * @param   pCtx               Pointer to the video recording context.
- * @param   uScreen            Screen number.
+ * @param   uScreen            Screen number to send video frame to.
  * @param   x                  Starting x coordinate of the video frame.
  * @param   y                  Starting y coordinate of the video frame.
@@ -595 +533 @@
  * @param   uTimeStampMs       Time stamp (in ms).
  */
-int VideoRecSendVideoFrame(PVIDEORECCONTEXT pCtx, uint32_t uScreen, uint32_t x, uint32_t y,
-                           uint32_t uPixelFormat, uint32_t uBPP, uint32_t uBytesPerLine,
-                           uint32_t uSrcWidth, uint32_t uSrcHeight, uint8_t *puSrcData,
-                           uint64_t uTimeStampMs)
-{
-    AssertPtrReturn(pCtx,    VERR_INVALID_POINTER);
+int CaptureContext::SendVideoFrame(uint32_t uScreen, uint32_t x, uint32_t y,
+                                   uint32_t uPixelFormat, uint32_t uBPP, uint32_t uBytesPerLine,
+                                   uint32_t uSrcWidth, uint32_t uSrcHeight, uint8_t *puSrcData,
+                                   uint64_t uTimeStampMs)
+{
     AssertReturn(uSrcWidth,  VERR_INVALID_PARAMETER);
     AssertReturn(uSrcHeight, VERR_INVALID_PARAMETER);
     AssertReturn(puSrcData,  VERR_INVALID_POINTER);
 
-    int rc = RTCritSectEnter(&pCtx->CritSect);
+    int rc = RTCritSectEnter(&this->CritSect);
     AssertRC(rc);
 
-    PVIDEORECSTREAM pStream = VideoRecGetStream(pCtx, uScreen);
+    CaptureStream *pStream = GetStream(uScreen);
     if (!pStream)
     {
-        rc = RTCritSectLeave(&pCtx->CritSect);
+        rc = RTCritSectLeave(&this->CritSect);
         AssertRC(rc);
 
@@ -617 +554 @@
     }
 
-    VideoRecStreamLock(pStream);
-
-    PVIDEORECVIDEOFRAME pFrame = NULL;
-
-    do
-    {
-        if (!pStream->fEnabled)
-        {
-            rc = VINF_TRY_AGAIN; /* Not (yet) enabled. */
-            break;
-        }
-
-        if (uTimeStampMs < pStream->Video.uLastTimeStampMs + pStream->Video.uDelayMs)
-        {
-            rc = VINF_TRY_AGAIN; /* Respect maximum frames per second. */
-            break;
-        }
-
-        pStream->Video.uLastTimeStampMs = uTimeStampMs;
-
-        int xDiff = ((int)pStream->Video.uWidth - (int)uSrcWidth) / 2;
-        uint32_t w = uSrcWidth;
-        if ((int)w + xDiff + (int)x <= 0)  /* Nothing visible. */
-        {
-            rc = VERR_INVALID_PARAMETER;
-            break;
-        }
-
-        uint32_t destX;
-        if ((int)x < -xDiff)
-        {
-            w += xDiff + x;
-            x = -xDiff;
-            destX = 0;
-        }
-        else
-            destX = x + xDiff;
-
-        uint32_t h = uSrcHeight;
-        int yDiff = ((int)pStream->Video.uHeight - (int)uSrcHeight) / 2;
-        if ((int)h + yDiff + (int)y <= 0)  /* Nothing visible. */
-        {
-            rc = VERR_INVALID_PARAMETER;
-            break;
-        }
-
-        uint32_t destY;
-        if ((int)y < -yDiff)
-        {
-            h += yDiff + (int)y;
-            y = -yDiff;
-            destY = 0;
-        }
-        else
-            destY = y + yDiff;
-
-        if (   destX > pStream->Video.uWidth
-            || destY > pStream->Video.uHeight)
-        {
-            rc = VERR_INVALID_PARAMETER;  /* Nothing visible. */
-            break;
-        }
-
-        if (destX + w > pStream->Video.uWidth)
-            w = pStream->Video.uWidth - destX;
-
-        if (destY + h > pStream->Video.uHeight)
-            h = pStream->Video.uHeight - destY;
-
-        pFrame = (PVIDEORECVIDEOFRAME)RTMemAllocZ(sizeof(VIDEORECVIDEOFRAME));
-        AssertBreakStmt(pFrame, rc = VERR_NO_MEMORY);
-
-        /* Calculate bytes per pixel and set pixel format. */
-        const unsigned uBytesPerPixel = uBPP / 8;
-        if (uPixelFormat == BitmapFormat_BGR)
-        {
-            switch (uBPP)
-            {
-                case 32:
-                    pFrame->uPixelFormat = VIDEORECPIXELFMT_RGB32;
-                    break;
-                case 24:
-                    pFrame->uPixelFormat = VIDEORECPIXELFMT_RGB24;
-                    break;
-                case 16:
-                    pFrame->uPixelFormat = VIDEORECPIXELFMT_RGB565;
-                    break;
-                default:
-                    AssertMsgFailed(("Unknown color depth (%RU32)\n", uBPP));
-                    break;
-            }
-        }
-        else
-            AssertMsgFailed(("Unknown pixel format (%RU32)\n", uPixelFormat));
-
-        const size_t cbRGBBuf =   pStream->Video.uWidth
-                                * pStream->Video.uHeight
-                                * uBytesPerPixel;
-        AssertBreakStmt(cbRGBBuf, rc = VERR_INVALID_PARAMETER);
-
-        pFrame->pu8RGBBuf = (uint8_t *)RTMemAlloc(cbRGBBuf);
-        AssertBreakStmt(pFrame->pu8RGBBuf, rc = VERR_NO_MEMORY);
-        pFrame->cbRGBBuf  = cbRGBBuf;
-        pFrame->uWidth    = uSrcWidth;
-        pFrame->uHeight   = uSrcHeight;
-
-        /* If the current video frame is smaller than video resolution we're going to encode,
-         * clear the frame beforehand to prevent artifacts. */
-        if (   uSrcWidth  < pStream->Video.uWidth
-            || uSrcHeight < pStream->Video.uHeight)
-        {
-            RT_BZERO(pFrame->pu8RGBBuf, pFrame->cbRGBBuf);
-        }
-
-        /* Calculate start offset in source and destination buffers. */
-        uint32_t offSrc = y * uBytesPerLine + x * uBytesPerPixel;
-        uint32_t offDst = (destY * pStream->Video.uWidth + destX) * uBytesPerPixel;
-
-#ifdef VBOX_VIDEOREC_DUMP
-        VIDEORECBMPHDR bmpHdr;
-        RT_ZERO(bmpHdr);
-
-        VIDEORECBMPDIBHDR bmpDIBHdr;
-        RT_ZERO(bmpDIBHdr);
-
-        bmpHdr.u16Magic   = 0x4d42; /* Magic */
-        bmpHdr.u32Size    = (uint32_t)(sizeof(VIDEORECBMPHDR) + sizeof(VIDEORECBMPDIBHDR) + (w * h * uBytesPerPixel));
-        bmpHdr.u32OffBits = (uint32_t)(sizeof(VIDEORECBMPHDR) + sizeof(VIDEORECBMPDIBHDR));
-
-        bmpDIBHdr.u32Size          = sizeof(VIDEORECBMPDIBHDR);
-        bmpDIBHdr.u32Width         = w;
-        bmpDIBHdr.u32Height        = h;
-        bmpDIBHdr.u16Planes        = 1;
-        bmpDIBHdr.u16BitCount      = uBPP;
-        bmpDIBHdr.u32XPelsPerMeter = 5000;
-        bmpDIBHdr.u32YPelsPerMeter = 5000;
-
-        char szFileName[RTPATH_MAX];
-        RTStrPrintf2(szFileName, sizeof(szFileName), "/tmp/VideoRecFrame-%RU32.bmp", uScreen);
-
-        RTFILE fh;
-        int rc2 = RTFileOpen(&fh, szFileName,
-                             RTFILE_O_CREATE_REPLACE | RTFILE_O_WRITE | RTFILE_O_DENY_NONE);
-        if (RT_SUCCESS(rc2))
-        {
-            RTFileWrite(fh, &bmpHdr,    sizeof(bmpHdr),    NULL);
-            RTFileWrite(fh, &bmpDIBHdr, sizeof(bmpDIBHdr), NULL);
-        }
-#endif
-        Assert(pFrame->cbRGBBuf >= w * h * uBytesPerPixel);
-
-        /* Do the copy. */
-        for (unsigned int i = 0; i < h; i++)
-        {
-            /* Overflow check. */
-            Assert(offSrc + w * uBytesPerPixel <= uSrcHeight * uBytesPerLine);
-            Assert(offDst + w * uBytesPerPixel <= pStream->Video.uHeight * pStream->Video.uWidth * uBytesPerPixel);
-
-            memcpy(pFrame->pu8RGBBuf + offDst, puSrcData + offSrc, w * uBytesPerPixel);
-
-#ifdef VBOX_VIDEOREC_DUMP
-            if (RT_SUCCESS(rc2))
-                RTFileWrite(fh, pFrame->pu8RGBBuf + offDst, w * uBytesPerPixel, NULL);
-#endif
-            offSrc += uBytesPerLine;
-            offDst += pStream->Video.uWidth * uBytesPerPixel;
-        }
-
-#ifdef VBOX_VIDEOREC_DUMP
-        if (RT_SUCCESS(rc2))
-            RTFileClose(fh);
-#endif
-
-    } while (0);
-
-    if (rc == VINF_SUCCESS) /* Note: Also could be VINF_TRY_AGAIN. */
-    {
-        PVIDEORECBLOCK pBlock = (PVIDEORECBLOCK)RTMemAlloc(sizeof(VIDEORECBLOCK));
-        if (pBlock)
-        {
-            AssertPtr(pFrame);
-
-            pBlock->enmType = VIDEORECBLOCKTYPE_VIDEO;
-            pBlock->pvData  = pFrame;
-            pBlock->cbData  = sizeof(VIDEORECVIDEOFRAME) + pFrame->cbRGBBuf;
-
-            try
-            {
-                VideoRecBlocks *pVideoRecBlocks = new VideoRecBlocks();
-                pVideoRecBlocks->List.push_back(pBlock);
-
-                Assert(pStream->Blocks.Map.find(uTimeStampMs) == pStream->Blocks.Map.end());
-                pStream->Blocks.Map.insert(std::make_pair(uTimeStampMs, pVideoRecBlocks));
-            }
-            catch (const std::exception &ex)
-            {
-                RT_NOREF(ex);
-
-                RTMemFree(pBlock);
-                rc = VERR_NO_MEMORY;
-            }
-        }
-        else
-            rc = VERR_NO_MEMORY;
-    }
-
-    if (RT_FAILURE(rc))
-        VideoRecVideoFrameFree(pFrame);
-
-    VideoRecStreamUnlock(pStream);
-
-    int rc2 = RTCritSectLeave(&pCtx->CritSect);
+    rc = pStream->SendVideoFrame(x, y, uPixelFormat, uBPP, uBytesPerLine, uSrcWidth, uSrcHeight, puSrcData, uTimeStampMs);
+
+    int rc2 = RTCritSectLeave(&this->CritSect);
     AssertRC(rc2);
 
@@ -834 +562 @@
         && rc != VINF_TRY_AGAIN) /* Only signal the thread if operation was successful. */
     {
-        videoRecThreadNotify(pCtx);
+        threadNotify();
     }
 

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

@@ -42 +42 @@
 
 
-/**
- * Locks a recording stream.
- *
- * @param   pStream             Recording stream to lock.
- */
-void VideoRecStreamLock(PVIDEORECSTREAM pStream)
-{
-    int rc = RTCritSectEnter(&pStream->CritSect);
-    AssertRC(rc);
-}
-
-/**
- * Unlocks a locked recording stream.
- *
- * @param   pStream             Recording stream to unlock.
- */
-void VideoRecStreamUnlock(PVIDEORECSTREAM pStream)
-{
-    int rc = RTCritSectLeave(&pStream->CritSect);
-    AssertRC(rc);
+CaptureStream::CaptureStream(void)
+    : tsStartMs(0)
+{
+}
+
+CaptureStream::CaptureStream(uint32_t a_uScreen, const settings::CaptureScreenSettings &a_Settings)
+    : tsStartMs(0)
+{
+    int rc2 = initInternal(a_uScreen, a_Settings);
+    if (RT_FAILURE(rc2))
+        throw rc2;
+}
+
+CaptureStream::~CaptureStream(void)
+{
+    int rc2 = uninitInternal();
+    AssertRC(rc2);
 }
 
@@ -68 +65 @@
  *
  * @returns IPRT status code.
- * @param   pStream             Recording stream to open.
- * @param   pCfg                Recording configuration to use.
- */
-int VideoRecStreamOpen(PVIDEORECSTREAM pStream, PVIDEORECCFG pCfg)
-{
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-    AssertPtrReturn(pCfg,    VERR_INVALID_POINTER);
-
-    Assert(pStream->enmDst == VIDEORECDEST_INVALID);
+ */
+int CaptureStream::open(void)
+{
+    Assert(Settings.enmDest == CaptureDestination_None);
 
     int rc;
 
-    switch (pCfg->enmDst)
-    {
-        case VIDEORECDEST_FILE:
-        {
-            Assert(pCfg->File.strName.isNotEmpty());
-
-            char *pszAbsPath = RTPathAbsDup(com::Utf8Str(pCfg->File.strName).c_str());
+    switch (Settings.enmDest)
+    {
+        case CaptureDestination_File:
+        {
+            Assert(Settings.File.strName.isNotEmpty());
+
+            char *pszAbsPath = RTPathAbsDup(Settings.File.strName.c_str());
             AssertPtrReturn(pszAbsPath, VERR_NO_MEMORY);
 
@@ -101 +93 @@
             char *pszFile = NULL;
 
-            if (pCfg->aScreens.size() > 1)
-                rc = RTStrAPrintf(&pszFile, "%s-%u%s", pszAbsPath, pStream->uScreenID + 1, pszSuff);
+            if (this->uScreenID > 0)
+                rc = RTStrAPrintf(&pszFile, "%s-%u%s", pszAbsPath, this->uScreenID + 1, pszSuff);
             else
                 rc = RTStrAPrintf(&pszFile, "%s%s", pszAbsPath, pszSuff);
@@ -127 +119 @@
                     RTTimeExplode(&time, &ts);
 
-                    if (pCfg->aScreens.size() > 1)
+                    if (this->uScreenID > 0)
                         rc = RTStrAPrintf(&pszFile, "%s-%04d-%02u-%02uT%02u-%02u-%02u-%09uZ-%u%s",
                                           pszAbsPath, time.i32Year, time.u8Month, time.u8MonthDay,
                                           time.u8Hour, time.u8Minute, time.u8Second, time.u32Nanosecond,
-                                          pStream->uScreenID + 1, pszSuff);
+                                          this->uScreenID + 1, pszSuff);
                     else
                         rc = RTStrAPrintf(&pszFile, "%s-%04d-%02u-%02uT%02u-%02u-%02u-%09uZ%s",
@@ -144 +136 @@
                 if (RT_SUCCESS(rc))
                 {
-                    pStream->enmDst       = VIDEORECDEST_FILE;
-                    pStream->File.hFile   = hFile;
-                    pStream->File.pszFile = pszFile; /* Assign allocated string to our stream's config. */
+                    this->File.hFile   = hFile;
+                    this->File.strName = pszFile;
                 }
             }
@@ -156 +147 @@
             {
                 LogRel(("VideoRec: Failed to open file '%s' for screen %RU32, rc=%Rrc\n",
-                        pszFile ? pszFile : "<Unnamed>", pStream->uScreenID, rc));
-                RTStrFree(pszFile);
-            }
-
+                        pszFile ? pszFile : "<Unnamed>", this->uScreenID, rc));
+            }
+
+            RTStrFree(pszFile);
             break;
         }
@@ -170 +161 @@
     LogFlowFuncLeaveRC(rc);
     return rc;
+}
+
+int CaptureStream::parseOptionsString(const com::Utf8Str &strOptions)
+{
+    size_t pos = 0;
+    com::Utf8Str key, value;
+    while ((pos = strOptions.parseKeyValue(key, value, pos)) != com::Utf8Str::npos)
+    {
+        if (key.compare("vc_quality", Utf8Str::CaseInsensitive) == 0)
+        {
+#ifdef VBOX_WITH_LIBVPX
+            Assert(this->Settings.Video.ulFPS);
+            if (value.compare("realtime", Utf8Str::CaseInsensitive) == 0)
+                this->Video.Codec.VPX.uEncoderDeadline = VPX_DL_REALTIME;
+            else if (value.compare("good", Utf8Str::CaseInsensitive) == 0)
+                this->Video.Codec.VPX.uEncoderDeadline = 1000000 / this->Settings.Video.ulFPS;
+            else if (value.compare("best", Utf8Str::CaseInsensitive) == 0)
+                this->Video.Codec.VPX.uEncoderDeadline = VPX_DL_BEST_QUALITY;
+            else
+            {
+                LogRel(("VideoRec: Setting encoder deadline to '%s'\n", value.c_str()));
+                this->Video.Codec.VPX.uEncoderDeadline = value.toUInt32();
+#endif
+            }
+        }
+        else if (key.compare("vc_enabled", Utf8Str::CaseInsensitive) == 0)
+        {
+            if (value.compare("false", Utf8Str::CaseInsensitive) == 0)
+            {
+                this->Settings.featureMap[CaptureFeature_Video] = false;
+#ifdef VBOX_WITH_AUDIO_VIDEOREC
+                LogRel(("VideoRec: Only audio will be recorded\n"));
+#endif
+            }
+        }
+        else if (key.compare("ac_enabled", Utf8Str::CaseInsensitive) == 0)
+        {
+#ifdef VBOX_WITH_AUDIO_VIDEOREC
+            if (value.compare("true", Utf8Str::CaseInsensitive) == 0)
+            {
+                this->Settings.featureMap[CaptureFeature_Audio] = true;
+            }
+            else
+                LogRel(("VideoRec: Only video will be recorded\n"));
+#endif
+        }
+        else if (key.compare("ac_profile", Utf8Str::CaseInsensitive) == 0)
+        {
+#ifdef VBOX_WITH_AUDIO_VIDEOREC
+            if (value.compare("low", Utf8Str::CaseInsensitive) == 0)
+            {
+                this->Settings.Audio.uHz       = 8000;
+                this->Settings.Audio.cBits     = 16;
+                this->Settings.Audio.cChannels = 1;
+            }
+            else if (value.startsWith("med" /* "med[ium]" */, Utf8Str::CaseInsensitive) == 0)
+            {
+                /* Stay with the default set above. */
+            }
+            else if (value.compare("high", Utf8Str::CaseInsensitive) == 0)
+            {
+                this->Settings.Audio.uHz       = 48000;
+                this->Settings.Audio.cBits     = 16;
+                this->Settings.Audio.cChannels = 2;
+            }
+#endif
+        }
+        else
+            LogRel(("VideoRec: Unknown option '%s' (value '%s'), skipping\n", key.c_str(), value.c_str()));
+
+    } /* while */
+
+    return VINF_SUCCESS;
+}
+
+const settings::CaptureScreenSettings &CaptureStream::GetConfig(void) const
+{
+    return this->Settings;
+}
+
+/**
+ * Checks if a specified limit for recording has been reached.
+ *
+ * @returns true if any limit has been reached.
+ * @param   tsNowMs             Current time stamp (in ms).
+ */
+bool CaptureStream::IsLimitReached(uint64_t tsNowMs) const
+{
+    if (!IsReady())
+        return true;
+
+    if (   Settings.ulMaxTimeS
+        && tsNowMs >= this->tsStartMs + (Settings.ulMaxTimeS * RT_MS_1SEC))
+    {
+        return true;
+    }
+
+    if (Settings.enmDest == CaptureDestination_File)
+    {
+
+        if (Settings.File.ulMaxSizeMB)
+        {
+            uint64_t sizeInMB = this->File.pWEBM->GetFileSize() / _1M;
+            if(sizeInMB >= Settings.File.ulMaxSizeMB)
+                return true;
+        }
+
+        /* Check for available free disk space */
+        if (   this->File.pWEBM
+            && this->File.pWEBM->GetAvailableSpace() < 0x100000) /** @todo r=andy WTF? Fix this. */
+        {
+            LogRel(("VideoRec: Not enough free storage space available, stopping video capture\n"));
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool CaptureStream::IsReady(void) const
+{
+    return this->fEnabled;
 }
 
@@ -178 +291 @@
  *
  * @returns IPRT status code.
- * @param   pStream             Recording stream to process.
- */
-int VideoRecStreamProcess(PVIDEORECSTREAM pStream)
-{
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-
-    VideoRecStreamLock(pStream);
-
-    if (!pStream->fEnabled)
-    {
-        VideoRecStreamUnlock(pStream);
+ * @param   mapBlocksCommon     Map of common block to process for this stream.
+ */
+int CaptureStream::Process(VideoRecBlockMap &mapBlocksCommon)
+{
+    lock();
+
+    if (!Settings.fEnabled)
+    {
+        unlock();
         return VINF_SUCCESS;
     }
@@ -194 +305 @@
     int rc = VINF_SUCCESS;
 
-    const PVIDEORECCONTEXT pCtx = pStream->pCtx;
-    AssertPtr(pCtx);
-
-    VideoRecBlockMap::iterator itStreamBlocks = pStream->Blocks.Map.begin();
-    while (itStreamBlocks != pStream->Blocks.Map.end())
+    VideoRecBlockMap::iterator itStreamBlocks = Blocks.Map.begin();
+    while (itStreamBlocks != Blocks.Map.end())
     {
         const uint64_t        uTimeStampMs = itStreamBlocks->first;
-              VideoRecBlocks *pBlocks      = itStreamBlocks->second;
+              CaptureBlocks *pBlocks       = itStreamBlocks->second;
 
         AssertPtr(pBlocks);
@@ -217 +325 @@
                 rc = videoRecRGBToYUV(pVideoFrame->uPixelFormat,
                                       /* Destination */
-                                      pStream->Video.Codec.VPX.pu8YuvBuf, pVideoFrame->uWidth, pVideoFrame->uHeight,
+                                      this->Video.Codec.VPX.pu8YuvBuf, pVideoFrame->uWidth, pVideoFrame->uHeight,
                                       /* Source */
-                                      pVideoFrame->pu8RGBBuf, pStream->Video.uWidth, pStream->Video.uHeight);
+                                      pVideoFrame->pu8RGBBuf, this->Settings.Video.ulWidth, this->Settings.Video.ulHeight);
                 if (RT_SUCCESS(rc))
                 {
-                    rc = VideoRecStreamWriteVideoVPX(pStream, uTimeStampMs, pVideoFrame);
+                    rc = writeVideoVPX(uTimeStampMs, pVideoFrame);
                 }
                 else
@@ -238 +346 @@
 
 #ifdef VBOX_WITH_AUDIO_VIDEOREC
+    AssertPtr(pCtx);
+
     /* As each (enabled) screen has to get the same audio data, look for common (audio) data which needs to be
      * written to the screen's assigned recording stream. */
-    VideoRecBlockMap::iterator itCommonBlocks = pCtx->mapBlocksCommon.begin();
-    while (itCommonBlocks != pCtx->mapBlocksCommon.end())
+    VideoRecBlockMap::iterator itCommonBlocks = mapBlocksCommon.begin();
+    while (itCommonBlocks != mapBlocksCommon.end())
     {
         VideoRecBlockList::iterator itBlock = itCommonBlocks->second->List.begin();
@@ -258 +368 @@
                     WebMWriter::BlockData_Opus blockData = { pAudioFrame->pvBuf, pAudioFrame->cbBuf,
                                                              pBlockCommon->uTimeStampMs };
-                    AssertPtr(pStream->File.pWEBM);
-                    rc = pStream->File.pWEBM->WriteBlock(pStream->uTrackAudio, &blockData, sizeof(blockData));
+                    AssertPtr(this->File.pWEBM);
+                    rc = this->File.pWEBM->WriteBlock(this->uTrackAudio, &blockData, sizeof(blockData));
                     break;
                 }
@@ -287 +397 @@
         {
             delete itCommonBlocks->second;
-            pCtx->mapBlocksCommon.erase(itCommonBlocks);
-            itCommonBlocks = pCtx->mapBlocksCommon.begin();
+            mapBlocksCommon.erase(itCommonBlocks);
+            itCommonBlocks = mapBlocksCommon.begin();
         }
         else
             ++itCommonBlocks;
 
-        LogFunc(("Common blocks: %zu\n", pCtx->mapBlocksCommon.size()));
+        LogFunc(("Common blocks: %zu\n", mapBlocksCommon.size()));
 
         if (RT_FAILURE(rc))
@@ -300 +410 @@
 #endif
 
-    VideoRecStreamUnlock(pStream);
+    unlock();
 
     return rc;
 }
 
+int CaptureStream::SendVideoFrame(uint32_t x, uint32_t y, uint32_t uPixelFormat, uint32_t uBPP, uint32_t uBytesPerLine,
+                                  uint32_t uSrcWidth, uint32_t uSrcHeight, uint8_t *puSrcData, uint64_t uTimeStampMs)
+{
+    lock();
+
+    PVIDEORECVIDEOFRAME pFrame = NULL;
+
+    int rc = VINF_SUCCESS;
+
+    do
+    {
+        if (!this->fEnabled)
+        {
+            rc = VINF_TRY_AGAIN; /* Not (yet) enabled. */
+            break;
+        }
+
+        if (uTimeStampMs < this->Video.uLastTimeStampMs + this->Video.uDelayMs)
+        {
+            rc = VINF_TRY_AGAIN; /* Respect maximum frames per second. */
+            break;
+        }
+
+        this->Video.uLastTimeStampMs = uTimeStampMs;
+
+        int xDiff = ((int)this->Settings.Video.ulWidth - (int)uSrcWidth) / 2;
+        uint32_t w = uSrcWidth;
+        if ((int)w + xDiff + (int)x <= 0)  /* Nothing visible. */
+        {
+            rc = VERR_INVALID_PARAMETER;
+            break;
+        }
+
+        uint32_t destX;
+        if ((int)x < -xDiff)
+        {
+            w += xDiff + x;
+            x = -xDiff;
+            destX = 0;
+        }
+        else
+            destX = x + xDiff;
+
+        uint32_t h = uSrcHeight;
+        int yDiff = ((int)this->Settings.Video.ulHeight - (int)uSrcHeight) / 2;
+        if ((int)h + yDiff + (int)y <= 0)  /* Nothing visible. */
+        {
+            rc = VERR_INVALID_PARAMETER;
+            break;
+        }
+
+        uint32_t destY;
+        if ((int)y < -yDiff)
+        {
+            h += yDiff + (int)y;
+            y = -yDiff;
+            destY = 0;
+        }
+        else
+            destY = y + yDiff;
+
+        if (   destX > this->Settings.Video.ulWidth
+            || destY > this->Settings.Video.ulHeight)
+        {
+            rc = VERR_INVALID_PARAMETER;  /* Nothing visible. */
+            break;
+        }
+
+        if (destX + w > this->Settings.Video.ulWidth)
+            w = this->Settings.Video.ulWidth - destX;
+
+        if (destY + h > this->Settings.Video.ulHeight)
+            h = this->Settings.Video.ulHeight - destY;
+
+        pFrame = (PVIDEORECVIDEOFRAME)RTMemAllocZ(sizeof(VIDEORECVIDEOFRAME));
+        AssertBreakStmt(pFrame, rc = VERR_NO_MEMORY);
+
+        /* Calculate bytes per pixel and set pixel format. */
+        const unsigned uBytesPerPixel = uBPP / 8;
+        if (uPixelFormat == BitmapFormat_BGR)
+        {
+            switch (uBPP)
+            {
+                case 32:
+                    pFrame->uPixelFormat = VIDEORECPIXELFMT_RGB32;
+                    break;
+                case 24:
+                    pFrame->uPixelFormat = VIDEORECPIXELFMT_RGB24;
+                    break;
+                case 16:
+                    pFrame->uPixelFormat = VIDEORECPIXELFMT_RGB565;
+                    break;
+                default:
+                    AssertMsgFailedBreakStmt(("Unknown color depth (%RU32)\n", uBPP), rc = VERR_NOT_SUPPORTED);
+                    break;
+            }
+        }
+        else
+            AssertMsgFailedBreakStmt(("Unknown pixel format (%RU32)\n", uPixelFormat), rc = VERR_NOT_SUPPORTED);
+
+        const size_t cbRGBBuf =   this->Settings.Video.ulWidth
+                                * this->Settings.Video.ulHeight
+                                * uBytesPerPixel;
+        AssertBreakStmt(cbRGBBuf, rc = VERR_INVALID_PARAMETER);
+
+        pFrame->pu8RGBBuf = (uint8_t *)RTMemAlloc(cbRGBBuf);
+        AssertBreakStmt(pFrame->pu8RGBBuf, rc = VERR_NO_MEMORY);
+        pFrame->cbRGBBuf  = cbRGBBuf;
+        pFrame->uWidth    = uSrcWidth;
+        pFrame->uHeight   = uSrcHeight;
+
+        /* If the current video frame is smaller than video resolution we're going to encode,
+         * clear the frame beforehand to prevent artifacts. */
+        if (   uSrcWidth  < this->Settings.Video.ulWidth
+            || uSrcHeight < this->Settings.Video.ulHeight)
+        {
+            RT_BZERO(pFrame->pu8RGBBuf, pFrame->cbRGBBuf);
+        }
+
+        /* Calculate start offset in source and destination buffers. */
+        uint32_t offSrc = y * uBytesPerLine + x * uBytesPerPixel;
+        uint32_t offDst = (destY * this->Settings.Video.ulWidth + destX) * uBytesPerPixel;
+
+#ifdef VBOX_VIDEOREC_DUMP
+        VIDEORECBMPHDR bmpHdr;
+        RT_ZERO(bmpHdr);
+
+        VIDEORECBMPDIBHDR bmpDIBHdr;
+        RT_ZERO(bmpDIBHdr);
+
+        bmpHdr.u16Magic   = 0x4d42; /* Magic */
+        bmpHdr.u32Size    = (uint32_t)(sizeof(VIDEORECBMPHDR) + sizeof(VIDEORECBMPDIBHDR) + (w * h * uBytesPerPixel));
+        bmpHdr.u32OffBits = (uint32_t)(sizeof(VIDEORECBMPHDR) + sizeof(VIDEORECBMPDIBHDR));
+
+        bmpDIBHdr.u32Size          = sizeof(VIDEORECBMPDIBHDR);
+        bmpDIBHdr.u32Width         = w;
+        bmpDIBHdr.u32Height        = h;
+        bmpDIBHdr.u16Planes        = 1;
+        bmpDIBHdr.u16BitCount      = uBPP;
+        bmpDIBHdr.u32XPelsPerMeter = 5000;
+        bmpDIBHdr.u32YPelsPerMeter = 5000;
+
+        char szFileName[RTPATH_MAX];
+        RTStrPrintf2(szFileName, sizeof(szFileName), "/tmp/VideoRecFrame-%RU32.bmp", this->uScreenID);
+
+        RTFILE fh;
+        int rc2 = RTFileOpen(&fh, szFileName,
+                             RTFILE_O_CREATE_REPLACE | RTFILE_O_WRITE | RTFILE_O_DENY_NONE);
+        if (RT_SUCCESS(rc2))
+        {
+            RTFileWrite(fh, &bmpHdr,    sizeof(bmpHdr),    NULL);
+            RTFileWrite(fh, &bmpDIBHdr, sizeof(bmpDIBHdr), NULL);
+        }
+#endif
+        Assert(pFrame->cbRGBBuf >= w * h * uBytesPerPixel);
+
+        /* Do the copy. */
+        for (unsigned int i = 0; i < h; i++)
+        {
+            /* Overflow check. */
+            Assert(offSrc + w * uBytesPerPixel <= uSrcHeight * uBytesPerLine);
+            Assert(offDst + w * uBytesPerPixel <= this->Settings.Video.ulHeight * this->Settings.Video.ulWidth * uBytesPerPixel);
+
+            memcpy(pFrame->pu8RGBBuf + offDst, puSrcData + offSrc, w * uBytesPerPixel);
+
+#ifdef VBOX_VIDEOREC_DUMP
+            if (RT_SUCCESS(rc2))
+                RTFileWrite(fh, pFrame->pu8RGBBuf + offDst, w * uBytesPerPixel, NULL);
+#endif
+            offSrc += uBytesPerLine;
+            offDst += this->Settings.Video.ulWidth * uBytesPerPixel;
+        }
+
+#ifdef VBOX_VIDEOREC_DUMP
+        if (RT_SUCCESS(rc2))
+            RTFileClose(fh);
+#endif
+
+    } while (0);
+
+    if (rc == VINF_SUCCESS) /* Note: Also could be VINF_TRY_AGAIN. */
+    {
+        PVIDEORECBLOCK pBlock = (PVIDEORECBLOCK)RTMemAlloc(sizeof(VIDEORECBLOCK));
+        if (pBlock)
+        {
+            AssertPtr(pFrame);
+
+            pBlock->enmType = VIDEORECBLOCKTYPE_VIDEO;
+            pBlock->pvData  = pFrame;
+            pBlock->cbData  = sizeof(VIDEORECVIDEOFRAME) + pFrame->cbRGBBuf;
+
+            try
+            {
+                CaptureBlocks *pVideoRecBlocks = new CaptureBlocks();
+                pVideoRecBlocks->List.push_back(pBlock);
+
+                Assert(this->Blocks.Map.find(uTimeStampMs) == this->Blocks.Map.end());
+                this->Blocks.Map.insert(std::make_pair(uTimeStampMs, pVideoRecBlocks));
+            }
+            catch (const std::exception &ex)
+            {
+                RT_NOREF(ex);
+
+                RTMemFree(pBlock);
+                rc = VERR_NO_MEMORY;
+            }
+        }
+        else
+            rc = VERR_NO_MEMORY;
+    }
+
+    if (RT_FAILURE(rc))
+        VideoRecVideoFrameFree(pFrame);
+
+    lock();
+
+    return rc;
+}
+
+int CaptureStream::Init(uint32_t a_uScreen, const settings::CaptureScreenSettings &a_Settings)
+{
+    return initInternal(a_uScreen, a_Settings);
+}
+
 /**
  * Initializes a recording stream.
  *
  * @returns IPRT status code.
- * @param   pStream             Recording stream to initialize.
- * @param   pCtx                Recording context to use for initialization.
- * @param   uScreen             Screen number to record.
- */
-int VideoRecStreamInit(PVIDEORECSTREAM pStream, PVIDEORECCONTEXT pCtx, uint32_t uScreen)
-{
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-    AssertPtrReturn(pCtx,    VERR_INVALID_POINTER);
-
-    PVIDEORECCFG pCfg = &pCtx->Cfg;
-
-#ifdef VBOX_WITH_AUDIO_VIDEOREC
-    if (pCfg->Audio.fEnabled)
-    {
-        /* Sanity. */
-        AssertReturn(pCfg->Audio.uHz,       VERR_INVALID_PARAMETER);
-        AssertReturn(pCfg->Audio.cBits,     VERR_INVALID_PARAMETER);
-        AssertReturn(pCfg->Audio.cChannels, VERR_INVALID_PARAMETER);
-    }
-#endif
-
-    int rc = VideoRecStreamOpen(pStream, pCfg);
+ * @param   uScreen             Screen number to use for this recording stream.
+ * @param   Cfg                 Recording screen configuration to use for initialization.
+ */
+int CaptureStream::initInternal(uint32_t a_uScreen, const settings::CaptureScreenSettings &a_Settings)
+{
+    int rc = parseOptionsString(a_Settings.strOptions);
     if (RT_FAILURE(rc))
         return rc;
 
-    if (pCfg->Video.fEnabled)
-        rc = VideoRecStreamInitVideo(pStream, pCfg);
-
-    switch (pStream->enmDst)
-    {
-        case VIDEORECDEST_FILE:
-        {
-            rc = pStream->File.pWEBM->OpenEx(pStream->File.pszFile, &pStream->File.hFile,
+    rc = RTCritSectInit(&this->CritSect);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    rc = open();
+    if (RT_FAILURE(rc))
+        return rc;
+
+    const bool fVideoEnabled = a_Settings.isFeatureEnabled(CaptureFeature_Video);
+    const bool fAudioEnabled = a_Settings.isFeatureEnabled(CaptureFeature_Audio);
+
+    if (fVideoEnabled)
+        rc = initVideo();
+
+    if (fAudioEnabled)
+        rc = initAudio();
+
+    switch (this->Settings.enmDest)
+    {
+        case CaptureDestination_File:
+        {
+            const char *pszFile = this->Settings.File.strName.c_str();
+
+            rc = File.pWEBM->OpenEx(pszFile, &this->File.hFile,
 #ifdef VBOX_WITH_AUDIO_VIDEOREC
-                                             pCfg->Audio.fEnabled ? WebMWriter::AudioCodec_Opus : WebMWriter::AudioCodec_None,
+                                      a_Settings.isFeatureEnabled(CaptureFeature_Audio)
+                                    ? WebMWriter::AudioCodec_Opus : WebMWriter::AudioCodec_None,
 #else
-                                             WebMWriter::AudioCodec_None,
-#endif
-                                             pCfg->Video.fEnabled ? WebMWriter::VideoCodec_VP8 : WebMWriter::VideoCodec_None);
+                                      WebMWriter::AudioCodec_None,
+#endif
+                                      a_Settings.isFeatureEnabled(CaptureFeature_Video)
+                                    ? WebMWriter::VideoCodec_VP8 : WebMWriter::VideoCodec_None);
             if (RT_FAILURE(rc))
             {
-                LogRel(("VideoRec: Failed to create the capture output file '%s' (%Rrc)\n", pStream->File.pszFile, rc));
+                LogRel(("VideoRec: Failed to create the capture output file '%s' (%Rrc)\n", pszFile, rc));
                 break;
             }
 
-            const char *pszFile = pStream->File.pszFile;
-
-            if (pCfg->Video.fEnabled)
-            {
-                rc = pStream->File.pWEBM->AddVideoTrack(pCfg->Video.uWidth, pCfg->Video.uHeight, pCfg->Video.uFPS,
-                                                        &pStream->uTrackVideo);
+            if (fVideoEnabled)
+            {
+                rc = this->File.pWEBM->AddVideoTrack(a_Settings.Video.ulWidth, a_Settings.Video.ulHeight,
+                                                     a_Settings.Video.ulFPS, &this->uTrackVideo);
                 if (RT_FAILURE(rc))
                 {
@@ -367 +701 @@
 
                 LogRel(("VideoRec: Recording video of screen #%u with %RU32x%RU32 @ %RU32 kbps, %RU32 FPS (track #%RU8)\n",
-                        uScreen, pCfg->Video.uWidth, pCfg->Video.uHeight, pCfg->Video.uRate, pCfg->Video.uFPS,
-                        pStream->uTrackVideo));
+                        this->uScreenID, a_Settings.Video.ulWidth, a_Settings.Video.ulHeight, a_Settings.Video.ulRate,
+                        a_Settings.Video.ulFPS, this->uTrackVideo));
             }
 
 #ifdef VBOX_WITH_AUDIO_VIDEOREC
-            if (pCfg->Audio.fEnabled)
-            {
-                rc = pStream->File.pWEBM->AddAudioTrack(pCfg->Audio.uHz, pCfg->Audio.cChannels, pCfg->Audio.cBits,
-                                                        &pStream->uTrackAudio);
+            if (fAudioEnabled)
+            {
+                rc = this->File.pWEBM->AddAudioTrack(a_Settings.Audio.uHz, a_Settings.Audio.cChannels, a_Settings.Audio.cBits,
+                                                     &this->uTrackAudio);
                 if (RT_FAILURE(rc))
                 {
@@ -383 +717 @@
 
                 LogRel(("VideoRec: Recording audio in %RU16Hz, %RU8 bit, %RU8 %s (track #%RU8)\n",
-                        pCfg->Audio.uHz, pCfg->Audio.cBits, pCfg->Audio.cChannels, pCfg->Audio.cChannels ? "channels" : "channel",
-                        pStream->uTrackAudio));
-            }
-#endif
-
-            if (   pCfg->Video.fEnabled
+                        a_Settings.Audio.uHz, a_Settings.Audio.cBits, a_Settings.Audio.cChannels,
+                        a_Settings.Audio.cChannels ? "channels" : "channel", this->uTrackAudio));
+            }
+#endif
+
+            if (   fVideoEnabled
 #ifdef VBOX_WITH_AUDIO_VIDEOREC
-                || pCfg->Audio.fEnabled
+                || fAudioEnabled
 #endif
                )
             {
                 char szWhat[32] = { 0 };
-                if (pCfg->Video.fEnabled)
+                if (fVideoEnabled)
                     RTStrCat(szWhat, sizeof(szWhat), "video");
 #ifdef VBOX_WITH_AUDIO_VIDEOREC
-                if (pCfg->Audio.fEnabled)
+                if (fAudioEnabled)
                 {
-                    if (pCfg->Video.fEnabled)
+                    if (fVideoEnabled)
                         RTStrCat(szWhat, sizeof(szWhat), " + ");
                     RTStrCat(szWhat, sizeof(szWhat), "audio");
@@ -419 +753 @@
     if (RT_SUCCESS(rc))
     {
-        pStream->pCtx     = pCtx;
-        pStream->fEnabled = true;
+        this->pCtx      = pCtx;
+        this->fEnabled  = true;
+        this->uScreenID = a_uScreen;
+        this->tsStartMs = RTTimeMilliTS();
+        this->Settings  = a_Settings;
     }
     else
     {
-        int rc2 = VideoRecStreamClose(pStream);
+        int rc2 = uninitInternal();
         AssertRC(rc2);
         return rc;
@@ -438 +775 @@
  *
  * @returns IPRT status code.
- * @param   pStream             Recording stream to close.
- *
- */
-int VideoRecStreamClose(PVIDEORECSTREAM pStream)
+ */
+int CaptureStream::close(void)
 {
     int rc = VINF_SUCCESS;
 
-    if (pStream->fEnabled)
-    {
-        switch (pStream->enmDst)
-        {
-            case VIDEORECDEST_FILE:
-            {
-                if (pStream->File.pWEBM)
-                    rc = pStream->File.pWEBM->Close();
+    if (this->fEnabled)
+    {
+        switch (this->Settings.enmDest)
+        {
+            case CaptureDestination_File:
+            {
+                if (this->File.pWEBM)
+                    rc = this->File.pWEBM->Close();
                 break;
             }
@@ -461 +796 @@
         }
 
-        pStream->Blocks.Clear();
-
-        LogRel(("VideoRec: Recording screen #%u stopped\n", pStream->uScreenID));
+        this->Blocks.Clear();
+
+        LogRel(("VideoRec: Recording screen #%u stopped\n", this->uScreenID));
     }
 
     if (RT_FAILURE(rc))
     {
-        LogRel(("VideoRec: Error stopping recording screen #%u, rc=%Rrc\n", pStream->uScreenID, rc));
+        LogRel(("VideoRec: Error stopping recording screen #%u, rc=%Rrc\n", this->uScreenID, rc));
         return rc;
     }
 
-    switch (pStream->enmDst)
-    {
-        case VIDEORECDEST_FILE:
-        {
-            AssertPtr(pStream->File.pszFile);
-            if (RTFileIsValid(pStream->File.hFile))
-            {
-                rc = RTFileClose(pStream->File.hFile);
+    switch (this->Settings.enmDest)
+    {
+        case CaptureDestination_File:
+        {
+            if (RTFileIsValid(this->File.hFile))
+            {
+                rc = RTFileClose(this->File.hFile);
                 if (RT_SUCCESS(rc))
                 {
-                    LogRel(("VideoRec: Closed file '%s'\n", pStream->File.pszFile));
+                    LogRel(("VideoRec: Closed file '%s'\n", this->Settings.File.strName.c_str()));
                 }
                 else
                 {
-                    LogRel(("VideoRec: Error closing file '%s', rc=%Rrc\n", pStream->File.pszFile, rc));
+                    LogRel(("VideoRec: Error closing file '%s', rc=%Rrc\n", this->Settings.File.strName.c_str(), rc));
                     break;
                 }
             }
 
-            RTStrFree(pStream->File.pszFile);
-            pStream->File.pszFile = NULL;
-
-            if (pStream->File.pWEBM)
-            {
-                delete pStream->File.pWEBM;
-                pStream->File.pWEBM = NULL;
+            if (this->File.pWEBM)
+            {
+                delete this->File.pWEBM;
+                this->File.pWEBM = NULL;
             }
             break;
@@ -507 +838 @@
     }
 
-    if (RT_SUCCESS(rc))
-    {
-        pStream->enmDst = VIDEORECDEST_INVALID;
-    }
-
     LogFlowFuncLeaveRC(rc);
     return rc;
@@ -520 +846 @@
  *
  * @returns IPRT status code.
- * @param   pStream             Recording stream to uninitialize.
- */
-int VideoRecStreamUninit(PVIDEORECSTREAM pStream)
-{
-    int rc = VINF_SUCCESS;
-
-    if (pStream->pCtx->Cfg.Video.fEnabled)
-    {
-        int rc2 = VideoRecStreamUnitVideo(pStream);
+ */
+int CaptureStream::Uninit(void)
+{
+    return uninitInternal();
+}
+
+int CaptureStream::uninitInternal(void)
+{
+    int rc = close();
+    if (RT_FAILURE(rc))
+        return rc;
+
+    if (this->Settings.isFeatureEnabled(CaptureFeature_Video))
+    {
+        int rc2 = unitVideo();
         if (RT_SUCCESS(rc))
             rc = rc2;
     }
 
+    RTCritSectDelete(&this->CritSect);
+
+    this->fEnabled = false;
+
     return rc;
 }
@@ -540 +876 @@
  *
  * @returns IPRT status code.
- * @param   pStream             Recording stream to uninitialize video recording for.
- */
-int VideoRecStreamUnitVideo(PVIDEORECSTREAM pStream)
+ */
+int CaptureStream::unitVideo(void)
 {
 #ifdef VBOX_WITH_LIBVPX
     /* At the moment we only have VPX. */
-    return VideoRecStreamUninitVideoVPX(pStream);
+    return uninitVideoVPX();
 #else
     return VERR_NOT_SUPPORTED;
@@ -557 +892 @@
  *
  * @returns IPRT status code.
- * @param   pStream             Recording stream to uninitialize VPX codec for.
- */
-int VideoRecStreamUninitVideoVPX(PVIDEORECSTREAM pStream)
-{
-    vpx_img_free(&pStream->Video.Codec.VPX.RawImage);
-    vpx_codec_err_t rcv = vpx_codec_destroy(&pStream->Video.Codec.VPX.Ctx);
+ */
+int CaptureStream::uninitVideoVPX(void)
+{
+    vpx_img_free(&this->Video.Codec.VPX.RawImage);
+    vpx_codec_err_t rcv = vpx_codec_destroy(&this->Video.Codec.VPX.Ctx);
     Assert(rcv == VPX_CODEC_OK); RT_NOREF(rcv);
 
@@ -573 +907 @@
  *
  * @returns IPRT status code.
- * @param   pStream             Recording stream to initialize video recording for.
- * @param   pCfg                Video recording configuration to use for initialization.
- */
-int VideoRecStreamInitVideo(PVIDEORECSTREAM pStream, PVIDEORECCFG pCfg)
-{
+ */
+int CaptureStream::initVideo(void)
+{
+    /* Sanity. */
+    AssertReturn(this->Settings.Video.ulRate,   VERR_INVALID_PARAMETER);
+    AssertReturn(this->Settings.Video.ulWidth,  VERR_INVALID_PARAMETER);
+    AssertReturn(this->Settings.Video.ulHeight, VERR_INVALID_PARAMETER);
+    AssertReturn(this->Settings.Video.ulFPS,    VERR_INVALID_PARAMETER);
+
+    this->Video.cFailedEncodingFrames = 0;
+    this->Video.uDelayMs = RT_MS_1SEC / this->Settings.Video.ulFPS;
+
 #ifdef VBOX_WITH_LIBVPX
     /* At the moment we only have VPX. */
-    return VideoRecStreamInitVideoVPX(pStream, pCfg);
+    return initVideoVPX();
 #else
-    return VERR_NOT_SUPPORTED;
+    return VINF_SUCCESS;
 #endif
 }
@@ -591 +932 @@
  *
  * @returns IPRT status code.
- * @param   pStream             Recording stream to initialize VPX codec for.
- * @param   pCfg                Video recording configuration to use for initialization.
- */
-int VideoRecStreamInitVideoVPX(PVIDEORECSTREAM pStream, PVIDEORECCFG pCfg)
-{
-    pStream->Video.uWidth                = pCfg->Video.uWidth;
-    pStream->Video.uHeight               = pCfg->Video.uHeight;
-    pStream->Video.cFailedEncodingFrames = 0;
-
-    PVIDEORECVIDEOCODEC pVC = &pStream->Video.Codec;
-
-    pStream->Video.uDelayMs = RT_MS_1SEC / pCfg->Video.uFPS;
-
-    pVC->enmType = VIDEORECVIDEOCODECTYPE_VP8; /** @todo Make this configurable. */
-
+ */
+int CaptureStream::initVideoVPX(void)
+{
 # ifdef VBOX_WITH_LIBVPX_VP9
     vpx_codec_iface_t *pCodecIface = vpx_codec_vp9_cx();
@@ -612 +941 @@
 # endif
 
-    vpx_codec_err_t rcv = vpx_codec_enc_config_default(pCodecIface, &pVC->VPX.Cfg, 0 /* Reserved */);
+    PVIDEORECVIDEOCODEC pCodec = &this->Video.Codec;
+
+    vpx_codec_err_t rcv = vpx_codec_enc_config_default(pCodecIface, &pCodec->VPX.Cfg, 0 /* Reserved */);
     if (rcv != VPX_CODEC_OK)
     {
@@ -620 +951 @@
 
     /* Target bitrate in kilobits per second. */
-    pVC->VPX.Cfg.rc_target_bitrate = pCfg->Video.uRate;
+    pCodec->VPX.Cfg.rc_target_bitrate = this->Settings.Video.ulRate;
     /* Frame width. */
-    pVC->VPX.Cfg.g_w = pCfg->Video.uWidth;
+    pCodec->VPX.Cfg.g_w = this->Settings.Video.ulWidth;
     /* Frame height. */
-    pVC->VPX.Cfg.g_h = pCfg->Video.uHeight;
+    pCodec->VPX.Cfg.g_h = this->Settings.Video.ulHeight;
     /* 1ms per frame. */
-    pVC->VPX.Cfg.g_timebase.num = 1;
-    pVC->VPX.Cfg.g_timebase.den = 1000;
+    pCodec->VPX.Cfg.g_timebase.num = 1;
+    pCodec->VPX.Cfg.g_timebase.den = 1000;
     /* Disable multithreading. */
-    pVC->VPX.Cfg.g_threads = 0;
+    pCodec->VPX.Cfg.g_threads = 0;
 
     /* Initialize codec. */
-    rcv = vpx_codec_enc_init(&pVC->VPX.Ctx, pCodecIface, &pVC->VPX.Cfg, 0 /* Flags */);
+    rcv = vpx_codec_enc_init(&pCodec->VPX.Ctx, pCodecIface, &pCodec->VPX.Cfg, 0 /* Flags */);
     if (rcv != VPX_CODEC_OK)
     {
@@ -639 +970 @@
     }
 
-    if (!vpx_img_alloc(&pVC->VPX.RawImage, VPX_IMG_FMT_I420, pCfg->Video.uWidth, pCfg->Video.uHeight, 1))
-    {
-        LogRel(("VideoRec: Failed to allocate image %RU32x%RU32\n", pCfg->Video.uWidth, pCfg->Video.uHeight));
+    if (!vpx_img_alloc(&pCodec->VPX.RawImage, VPX_IMG_FMT_I420,
+                       this->Settings.Video.ulWidth, this->Settings.Video.ulHeight, 1))
+    {
+        LogRel(("VideoRec: Failed to allocate image %RU32x%RU32\n",
+                this->Settings.Video.ulWidth, this->Settings.Video.ulHeight));
         return VERR_NO_MEMORY;
     }
 
     /* Save a pointer to the first raw YUV plane. */
-    pStream->Video.Codec.VPX.pu8YuvBuf = pVC->VPX.RawImage.planes[0];
+    pCodec->VPX.pu8YuvBuf = pCodec->VPX.RawImage.planes[0];
 
     return VINF_SUCCESS;
@@ -652 +985 @@
 #endif
 
+int CaptureStream::initAudio(void)
+{
+#ifdef VBOX_WITH_AUDIO_VIDEOREC
+    if (this->Settings.isFeatureEnabled(CaptureFeature_Audio))
+    {
+        /* Sanity. */
+        AssertReturn(this->Settings.Audio.uHz,       VERR_INVALID_PARAMETER);
+        AssertReturn(this->Settings.Audio.cBits,     VERR_INVALID_PARAMETER);
+        AssertReturn(this->Settings.Audio.cChannels, VERR_INVALID_PARAMETER);
+    }
+#endif
+
+    return VINF_SUCCESS;
+}
+
 #ifdef VBOX_WITH_LIBVPX
 /**
@@ -657 +1005 @@
  *
  * @returns IPRT status code.
- * @param   pStream             Stream to encode and submit to.
  * @param   uTimeStampMs        Absolute timestamp (PTS) of frame (in ms) to encode.
  * @param   pFrame              Frame to encode and submit.
  */
-int VideoRecStreamWriteVideoVPX(PVIDEORECSTREAM pStream, uint64_t uTimeStampMs, PVIDEORECVIDEOFRAME pFrame)
-{
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-    AssertPtrReturn(pFrame,  VERR_INVALID_POINTER);
+int CaptureStream::writeVideoVPX(uint64_t uTimeStampMs, PVIDEORECVIDEOFRAME pFrame)
+{
+    AssertPtrReturn(pFrame, VERR_INVALID_POINTER);
 
     int rc;
 
-    AssertPtr(pStream->pCtx);
-    PVIDEORECCFG        pCfg = &pStream->pCtx->Cfg;
-    PVIDEORECVIDEOCODEC pVC  = &pStream->Video.Codec;
+    PVIDEORECVIDEOCODEC pCodec = &this->Video.Codec;
 
     /* Presentation Time Stamp (PTS). */
     vpx_codec_pts_t pts = uTimeStampMs;
-    vpx_codec_err_t rcv = vpx_codec_encode(&pVC->VPX.Ctx,
-                                           &pVC->VPX.RawImage,
-                                           pts                                    /* Time stamp */,
-                                           pStream->Video.uDelayMs                /* How long to show this frame */,
-                                           0                                      /* Flags */,
-                                           pCfg->Video.Codec.VPX.uEncoderDeadline /* Quality setting */);
+    vpx_codec_err_t rcv = vpx_codec_encode(&pCodec->VPX.Ctx,
+                                           &pCodec->VPX.RawImage,
+                                           pts                          /* Time stamp */,
+                                           this->Video.uDelayMs         /* How long to show this frame */,
+                                           0                            /* Flags */,
+                                           pCodec->VPX.uEncoderDeadline /* Quality setting */);
     if (rcv != VPX_CODEC_OK)
     {
-        if (pStream->Video.cFailedEncodingFrames++ < 64)
+        if (this->Video.cFailedEncodingFrames++ < 64) /** @todo Make this configurable. */
         {
             LogRel(("VideoRec: Failed to encode video frame: %s\n", vpx_codec_err_to_string(rcv)));
@@ -689 +1033 @@
     }
 
-    pStream->Video.cFailedEncodingFrames = 0;
+    this->Video.cFailedEncodingFrames = 0;
 
     vpx_codec_iter_t iter = NULL;
@@ -695 +1039 @@
     for (;;)
     {
-        const vpx_codec_cx_pkt_t *pPacket = vpx_codec_get_cx_data(&pVC->VPX.Ctx, &iter);
+        const vpx_codec_cx_pkt_t *pPacket = vpx_codec_get_cx_data(&pCodec->VPX.Ctx, &iter);
         if (!pPacket)
             break;
@@ -703 +1047 @@
             case VPX_CODEC_CX_FRAME_PKT:
             {
-                WebMWriter::BlockData_VP8 blockData = { &pVC->VPX.Cfg, pPacket };
-                rc = pStream->File.pWEBM->WriteBlock(pStream->uTrackVideo, &blockData, sizeof(blockData));
+                WebMWriter::BlockData_VP8 blockData = { &pCodec->VPX.Cfg, pPacket };
+                rc = this->File.pWEBM->WriteBlock(this->uTrackVideo, &blockData, sizeof(blockData));
                 break;
             }
@@ -719 +1063 @@
 #endif /* VBOX_WITH_LIBVPX */
 
+/**
+ * Locks a recording stream.
+ *
+ * @param   pStream             Recording stream to lock.
+ */
+void CaptureStream::lock(void)
+{
+    int rc = RTCritSectEnter(&CritSect);
+    AssertRC(rc);
+}
+
+/**
+ * Unlocks a locked recording stream.
+ *
+ * @param   pStream             Recording stream to unlock.
+ */
+void CaptureStream::unlock(void)
+{
+    int rc = RTCritSectLeave(&CritSect);
+    AssertRC(rc);
+}
+