Changeset 68798 in vbox for trunk/src/VBox/Main

Timestamp:

Sep 20, 2017 10:27:16 AM (7 years ago)

Author:

vboxsync

Message:

VideoRec: Overhauled configuration handling to also support audio configuration changes.

Location:

trunk/src/VBox/Main

Files:

• include/ConsoleImpl.h (modified) (1 diff)
• include/DisplayImpl.h (modified) (4 diffs)
• src-client/ConsoleImpl.cpp (modified) (5 diffs)
• src-client/DisplayImpl.cpp (modified) (10 diffs)
• src-client/VideoRec.cpp (modified) (33 diffs)
• src-client/VideoRec.h (modified) (2 diffs)

trunk/src/VBox/Main/include/ConsoleImpl.h

@@ -155 +155 @@
     HRESULT i_updateMachineState(MachineState_T aMachineState);
     HRESULT i_getNominalState(MachineState_T &aNominalState);
+    Utf8Str i_getAudioAdapterDeviceName(IAudioAdapter *aAudioAdapter);
 
     // events from IInternalSessionControl

trunk/src/VBox/Main/include/DisplayImpl.h

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2016 Oracle Corporation
+ * Copyright (C) 2006-2017 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -32 +32 @@
 #endif
 
+#ifdef VBOX_WITH_VIDEOREC
+# include "../src-client/VideoRec.h"
+struct VIDEORECCONTEXT;
+#endif
+
 #include "DisplaySourceBitmapWrap.h"
 
 
 class Console;
-struct VIDEORECCONTEXT;
 
 typedef struct _DISPLAYFBINFO
@@ -204 +208 @@
     void VideoAccelFlushVMMDev(void);
 
-    int  i_videoCaptureEnableScreens(ComSafeArrayIn(BOOL, aScreens));
+#ifdef VBOX_WITH_VIDEOREC
+    VIDEORECFEATURES i_videoCaptureGetEnabled(void);
+    bool i_videoCaptureStarted(void);
+    int  i_videoCaptureInvalidate(void);
     int  i_videoCaptureSendAudio(const void *pvData, size_t cbData, uint64_t uTimestampMs);
-    int  i_videoCaptureStart();
-    void i_videoCaptureStop();
-#ifdef VBOX_WITH_VIDEOREC
-    void videoCaptureScreenChanged(unsigned uScreenId);
+    int  i_videoCaptureStart(void);
+    void i_videoCaptureStop(void);
+    void i_videoCaptureScreenChanged(unsigned uScreenId);
 #endif
 
@@ -509 +515 @@
 
 #ifdef VBOX_WITH_VIDEOREC
+    VIDEORECCFG          mVideoRecCfg;
     VIDEORECCONTEXT     *mpVideoRecCtx;
     bool                 maVideoRecEnabled[SchemaDefs::MaxGuestMonitors];

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

@@ -82 +82 @@
 #include "AutoCaller.h"
 #include "ThreadTask.h"
+
+#ifdef VBOX_WITH_VIDEOREC
+# include "VideoRec.h"
+#endif
 
 #include <VBox/com/array.h>
@@ -4965 +4969 @@
 }
 
+Utf8Str Console::i_getAudioAdapterDeviceName(IAudioAdapter *aAudioAdapter)
+{
+    Utf8Str strDevice;
+
+    AudioControllerType_T audioController;
+    HRESULT hrc = aAudioAdapter->COMGETTER(AudioController)(&audioController);
+    AssertComRC(hrc);
+    if (SUCCEEDED(hrc))
+    {
+        switch (audioController)
+        {
+            case AudioControllerType_AC97: strDevice = "ichac97"; break;
+            case AudioControllerType_SB16: strDevice = "sb16";    break;
+            case AudioControllerType_HDA:  strDevice = "hda";     break;
+            default:                                              break; /* None. */
+        }
+    }
+
+    return strDevice;
+}
+
 /**
  * Called by IInternalSessionControl::OnAudioAdapterChange().
@@ -4992 +5017 @@
             if (SUCCEEDED(hrc))
             {
-                AudioControllerType_T audioController;
-                hrc = aAudioAdapter->COMGETTER(AudioController)(&audioController);
-                AssertComRC(hrc);
-                if (SUCCEEDED(hrc))
+                int rc = VINF_SUCCESS;
+
+                for (ULONG ulLUN = 0; ulLUN < 16 /** @todo Use a define */; ulLUN++)
                 {
-                    Utf8Str strDevice;
-
-                    switch (audioController)
+                    PPDMIBASE pBase;
+                    int rc2 = PDMR3QueryDriverOnLun(ptrVM.rawUVM(),
+                                                    i_getAudioAdapterDeviceName(aAudioAdapter).c_str(), 0 /* iInstance */,
+                                                    ulLUN, "AUDIO", &pBase);
+                    if (RT_FAILURE(rc2))
+                        continue;
+
+                    if (pBase)
                     {
-                        case AudioControllerType_AC97: strDevice = "ichac97"; break;
-                        case AudioControllerType_SB16: strDevice = "sb16";    break;
-                        case AudioControllerType_HDA:  strDevice = "hda";     break;
-                        default:
-                            AssertFailed(); break; /* Should never happen. */
-                    }
-
-                    int rc = VINF_SUCCESS;
-
-                    for (ULONG ulLUN = 0; ulLUN < 16 /** @todo Use a define */; ulLUN++)
-                    {
-                        PPDMIBASE pBase;
-                        int rc2 = PDMR3QueryDriverOnLun(ptrVM.rawUVM(),
-                                                        strDevice.c_str(), 0 /* iInstance */, ulLUN, "AUDIO", &pBase);
-                        if (RT_FAILURE(rc2))
-                            continue;
-
-                        Log(("%s: LUN#%RU32\n", strDevice.c_str(), ulLUN));
-
-                        if (pBase)
+                        PPDMIAUDIOCONNECTOR pAudioCon =
+                             (PPDMIAUDIOCONNECTOR)pBase->pfnQueryInterface(pBase, PDMIAUDIOCONNECTOR_IID);
+
+                        if (   pAudioCon
+                            && pAudioCon->pfnEnable)
                         {
-                            PPDMIAUDIOCONNECTOR pAudioCon =
-                                 (PPDMIAUDIOCONNECTOR)pBase->pfnQueryInterface(pBase, PDMIAUDIOCONNECTOR_IID);
-
-                            if (   pAudioCon
-                                && pAudioCon->pfnEnable)
-                            {
-                                int rcIn = pAudioCon->pfnEnable(pAudioCon, PDMAUDIODIR_IN, RT_BOOL(fEnabledIn));
-                                if (RT_FAILURE(rcIn))
-                                    LogRel(("Audio: Failed to %s input of LUN#%RU32, rc=%Rrc\n",
-                                            fEnabledIn ? "enable" : "disable", ulLUN, rcIn));
-
-                                if (RT_SUCCESS(rc))
-                                    rc = rcIn;
-
-                                int rcOut = pAudioCon->pfnEnable(pAudioCon, PDMAUDIODIR_OUT, RT_BOOL(fEnabledOut));
-                                if (RT_FAILURE(rcOut))
-                                    LogRel(("Audio: Failed to %s output of LUN#%RU32, rc=%Rrc\n",
-                                            fEnabledIn ? "enable" : "disable", ulLUN, rcOut));
-
-                                if (RT_SUCCESS(rc))
-                                    rc = rcOut;
-                            }
+                            int rcIn = pAudioCon->pfnEnable(pAudioCon, PDMAUDIODIR_IN, RT_BOOL(fEnabledIn));
+                            if (RT_FAILURE(rcIn))
+                                LogRel(("Audio: Failed to %s input of LUN#%RU32, rc=%Rrc\n",
+                                        fEnabledIn ? "enable" : "disable", ulLUN, rcIn));
+
+                            if (RT_SUCCESS(rc))
+                                rc = rcIn;
+
+                            int rcOut = pAudioCon->pfnEnable(pAudioCon, PDMAUDIODIR_OUT, RT_BOOL(fEnabledOut));
+                            if (RT_FAILURE(rcOut))
+                                LogRel(("Audio: Failed to %s output of LUN#%RU32, rc=%Rrc\n",
+                                        fEnabledIn ? "enable" : "disable", ulLUN, rcOut));
+
+                            if (RT_SUCCESS(rc))
+                                rc = rcOut;
                         }
                     }
-
-                    if (RT_SUCCESS(rc))
-                        LogRel(("Audio: Status has changed (input is %s, output is %s)\n",
-                                fEnabledIn  ? "enabled" : "disabled", fEnabledOut ? "enabled" : "disabled"));
                 }
+
+                if (RT_SUCCESS(rc))
+                    LogRel(("Audio: Status has changed (input is %s, output is %s)\n",
+                            fEnabledIn  ? "enabled" : "disabled", fEnabledOut ? "enabled" : "disabled"));
             }
         }
@@ -5486 +5493 @@
     HRESULT rc = S_OK;
 
-    /* don't trigger video capture changes if the VM isn't running */
+#ifdef VBOX_WITH_VIDEOREC
+    /* Don't trigger video capture changes if the VM isn't running. */
     SafeVMPtrQuiet ptrVM(this);
     if (ptrVM.isOk())
     {
-        BOOL fEnabled;
-        rc = mMachine->COMGETTER(VideoCaptureEnabled)(&fEnabled);
-        SafeArray<BOOL> screens;
-        if (SUCCEEDED(rc))
-            rc = mMachine->COMGETTER(VideoCaptureScreens)(ComSafeArrayAsOutParam(screens));
         if (mDisplay)
         {
-            int vrc = VINF_SUCCESS;
-            if (SUCCEEDED(rc))
-                vrc = mDisplay->i_videoCaptureEnableScreens(ComSafeArrayAsInParam(screens));
+            int vrc = mDisplay->i_videoCaptureInvalidate();
             if (RT_SUCCESS(vrc))
             {
-                if (fEnabled)
+                VIDEORECFEATURES fFeatures = mDisplay->i_videoCaptureGetEnabled();
+
+# ifdef VBOX_WITH_AUDIO_VIDEOREC
+                ComPtr<IAudioAdapter> audioAdapter;
+                rc = mMachine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam());
+                AssertComRC(rc);
+
+                Utf8Str strAudioDev = i_getAudioAdapterDeviceName(audioAdapter);
+                if (!strAudioDev.isEmpty()) /* Any audio device enabled? */
+                {
+                    for (ULONG ulLUN = 0; ulLUN < 16 /** @todo Use a define */; ulLUN++)
+                    {
+                        PPDMIBASE pBase;
+                        int rc2 = PDMR3QueryDriverOnLun(ptrVM.rawUVM(), strAudioDev.c_str(),
+                                                        0 /* iInstance */, ulLUN, "AUDIO", &pBase);
+                        if (RT_FAILURE(rc2))
+                            continue;
+
+                        if (pBase)
+                        {
+                            PPDMIAUDIOCONNECTOR pAudioCon =
+                                 (PPDMIAUDIOCONNECTOR)pBase->pfnQueryInterface(pBase, PDMIAUDIOCONNECTOR_IID);
+
+                            if (   pAudioCon
+                                && pAudioCon->pfnEnable)
+                            {
+                                rc2 = pAudioCon->pfnEnable(pAudioCon, PDMAUDIODIR_OUT, fFeatures & VIDEORECFEATURE_AUDIO);
+                                if (RT_FAILURE(rc2))
+                                    LogRel(("VideoRec: Failed to %s audio recording, rc=%Rrc\n",
+                                            fFeatures & VIDEORECFEATURE_AUDIO ? "enable" : "disable", ulLUN, rc2));
+                            }
+
+                            break; /* Driver found, no need to continue. */
+                        }
+                    }
+                }
+# endif /* VBOX_WITH_AUDIO_VIDEOREC */
+
+                if (!mDisplay->i_videoCaptureStarted())
                 {
                     vrc = mDisplay->i_videoCaptureStart();
@@ -5514 +5553 @@
                 rc = setError(E_FAIL, tr("Unable to set screens for capturing (%Rrc)"), vrc);
         }
+
         ptrVM.release();
     }
+#endif /* VBOX_WITH_VIDEOREC */
 
     /* notify console callbacks on success */

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

@@ -56 +56 @@
 # include <iprt/path.h>
 # include "VideoRec.h"
+
+# ifdef VBOX_WITH_LIBVPX
+#  include <vpx/vpx_encoder.h>
+# endif
 #endif
 
@@ -1049 +1053 @@
 
 #ifdef VBOX_WITH_VIDEOREC
-    videoCaptureScreenChanged(uScreenId);
+    i_videoCaptureScreenChanged(uScreenId);
 #endif
 
@@ -2386 +2390 @@
 }
 
-int Display::i_videoCaptureEnableScreens(ComSafeArrayIn(BOOL, aScreens))
-{
 #ifdef VBOX_WITH_VIDEOREC
-    com::SafeArray<BOOL> Screens(ComSafeArrayInArg(aScreens));
-    for (unsigned i = 0; i < Screens.size(); i++)
-    {
-        bool fChanged = maVideoRecEnabled[i] != RT_BOOL(Screens[i]);
-
-        maVideoRecEnabled[i] = RT_BOOL(Screens[i]);
+VIDEORECFEATURES Display::i_videoCaptureGetEnabled(void)
+{
+    return VideoRecGetEnabled(&mVideoRecCfg);
+}
+
+bool Display::i_videoCaptureStarted(void)
+{
+    return VideoRecIsActive(mpVideoRecCtx);
+}
+
+int Display::i_videoCaptureInvalidate(void)
+{
+    AssertPtr(mParent);
+    ComPtr<IMachine> pMachine = mParent->i_machine();
+    Assert(pMachine.isNotNull());
+
+    mVideoRecCfg.fEnabled = true;
+    mVideoRecCfg.enmDst   = VIDEORECDEST_FILE; /** @todo Make this configurable once we have more variations. */
+
+    /*
+     * Get parameters from API.
+     */
+    SafeArray<BOOL> aScreens;
+    HRESULT rc = pMachine->COMGETTER(VideoCaptureScreens)(ComSafeArrayAsOutParam(aScreens));
+    AssertComRCReturn(rc, VERR_COM_UNEXPECTED);
+    aScreens.cloneTo(mVideoRecCfg.aScreens);
+
+    rc = pMachine->COMGETTER(VideoCaptureWidth)(&mVideoRecCfg.Video.uWidth);
+    AssertComRCReturn(rc, VERR_COM_UNEXPECTED);
+    rc = pMachine->COMGETTER(VideoCaptureHeight)(&mVideoRecCfg.Video.uHeight);
+    AssertComRCReturn(rc, VERR_COM_UNEXPECTED);
+    rc = pMachine->COMGETTER(VideoCaptureRate)(&mVideoRecCfg.Video.uRate);
+    AssertComRCReturn(rc, VERR_COM_UNEXPECTED);
+    rc = pMachine->COMGETTER(VideoCaptureFPS)(&mVideoRecCfg.Video.uFPS);
+    AssertComRCReturn(rc, VERR_COM_UNEXPECTED);
+    rc = pMachine->COMGETTER(VideoCaptureFile)(&mVideoRecCfg.File.strFile);
+    AssertComRCReturn(rc, VERR_COM_UNEXPECTED);
+    rc = pMachine->COMGETTER(VideoCaptureMaxFileSize)(&mVideoRecCfg.File.uMaxSizeMB);
+    AssertComRCReturn(rc, VERR_COM_UNEXPECTED);
+    rc = pMachine->COMGETTER(VideoCaptureMaxTime)(&mVideoRecCfg.uMaxTimeS);
+    AssertComRCReturn(rc, VERR_COM_UNEXPECTED);
+    BSTR bstrOptions;
+    rc = pMachine->COMGETTER(VideoCaptureOptions)(&bstrOptions);
+    AssertComRCReturn(rc, VERR_COM_UNEXPECTED);
+
+    /*
+     * Parse options string (from API).
+     */
+    com::Utf8Str strOptions(bstrOptions);
+    size_t pos = 0;
+
+    /* By default we only enable video recording for now.
+     * Audio support is considered as being experimental. There be dragons! */
+    mVideoRecCfg.Video.fEnabled  = true;
+#ifdef VBOX_WITH_AUDIO_VIDEOREC
+    mVideoRecCfg.Audio.fEnabled  = false;
+    /* By default we use 48kHz, 16-bit, stereo for the audio track. */
+    mVideoRecCfg.Audio.uHz       = 48000;
+    mVideoRecCfg.Audio.cBits     = 16;
+    mVideoRecCfg.Audio.cChannels = 2;
+#endif
+
+    if (!mVideoRecCfg.Video.uFPS) /* Prevent division by zero. */
+        mVideoRecCfg.Video.uFPS = 30;
+
+    /*
+     * Parse options string.
+     */
+    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;
+                LogRel(("VideoRec: Only audio will be recorded\n"));
+            }
+        }
+        else if (key.compare("ac_enabled", Utf8Str::CaseInsensitive) == 0)
+        {
+#ifdef VBOX_WITH_AUDIO_VIDEOREC
+            if (value.compare("false", Utf8Str::CaseInsensitive))
+            {
+                mVideoRecCfg.Audio.fEnabled = false;
+                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)
+            {
+                mVideoRecCfg.Audio.uHz       = 22050;
+                mVideoRecCfg.Audio.cBits     = 16;
+                mVideoRecCfg.Audio.cChannels = 2;
+            }
+            else if (value.compare("high", Utf8Str::CaseInsensitive) == 0)
+            {
+                /* Stay with the default set above. */
+            }
+#endif
+        }
+        else
+            LogRel(("VideoRec: Unknown option '%s' (value '%s'), skipping\n", key.c_str(), value.c_str()));
+
+    } /* while */
+
+    /*
+     * 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)
-            videoCaptureScreenChanged(i);
-
-    }
-    return VINF_SUCCESS;
-#else
-    ComSafeArrayNoRef(aScreens);
-    return VERR_NOT_SUPPORTED;
-#endif
+            i_videoCaptureScreenChanged(i);
+
+    }
+
+    return S_OK;
 }
 
@@ -2418 +2550 @@
 int Display::i_videoCaptureSendAudio(const void *pvData, size_t cbData, uint64_t uTimestampMs)
 {
-#ifdef VBOX_WITH_AUDIO_VIDEOREC
-    if (!VideoRecIsEnabled(mpVideoRecCtx))
-        return VINF_SUCCESS;
-
-    return VideoRecSendAudioFrame(mpVideoRecCtx, pvData, cbData, uTimestampMs);
-#else
-    RT_NOREF(pvData, cbData, uTimestampMs);
-    return VERR_NOT_SUPPORTED;
-#endif
+    if (   VideoRecIsActive(mpVideoRecCtx)
+        && VideoRecGetEnabled(&mVideoRecCfg) & VIDEORECFEATURE_AUDIO)
+    {
+        return VideoRecSendAudioFrame(mpVideoRecCtx, pvData, cbData, uTimestampMs);
+    }
+
+    return VINF_SUCCESS;
 }
 
@@ -2432 +2562 @@
  * Start video capturing. Does nothing if capturing is already active.
  *
+ * @param   pVideoRecCfg        Video recording configuration to use.
  * @returns IPRT status code.
  */
 int Display::i_videoCaptureStart(void)
 {
-#ifdef VBOX_WITH_VIDEOREC
-    if (VideoRecIsEnabled(mpVideoRecCtx))
+    if (VideoRecIsActive(mpVideoRecCtx))
         return VINF_SUCCESS;
 
-    int rc = VideoRecContextCreate(mcMonitors, &mpVideoRecCtx);
+    int rc = VideoRecContextCreate(mcMonitors, &mVideoRecCfg, &mpVideoRecCtx);
     if (RT_FAILURE(rc))
     {
@@ -2446 +2576 @@
         return rc;
     }
-    ComPtr<IMachine> pMachine = mParent->i_machine();
-    com::SafeArray<BOOL> screens;
-    HRESULT hrc = pMachine->COMGETTER(VideoCaptureScreens)(ComSafeArrayAsOutParam(screens));
-    AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
-    for (unsigned i = 0; i < RT_ELEMENTS(maVideoRecEnabled); i++)
-        maVideoRecEnabled[i] = i < screens.size() && screens[i];
-    ULONG ulWidth;
-    hrc = pMachine->COMGETTER(VideoCaptureWidth)(&ulWidth);
-    AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
-    ULONG ulHeight;
-    hrc = pMachine->COMGETTER(VideoCaptureHeight)(&ulHeight);
-    AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
-    ULONG ulRate;
-    hrc = pMachine->COMGETTER(VideoCaptureRate)(&ulRate);
-    AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
-    ULONG ulFPS;
-    hrc = pMachine->COMGETTER(VideoCaptureFPS)(&ulFPS);
-    AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
-    BSTR strFile;
-    hrc = pMachine->COMGETTER(VideoCaptureFile)(&strFile);
-    AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
-    ULONG ulMaxTime;
-    hrc = pMachine->COMGETTER(VideoCaptureMaxTime)(&ulMaxTime);
-    AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
-    ULONG ulMaxSize;
-    hrc = pMachine->COMGETTER(VideoCaptureMaxFileSize)(&ulMaxSize);
-    AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
-    BSTR strOptions;
-    hrc = pMachine->COMGETTER(VideoCaptureOptions)(&strOptions);
-    AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
-
-    RTTIMESPEC ts;
-    RTTimeNow(&ts);
-    RTTIME time;
-    RTTimeExplode(&time, &ts);
+
     for (unsigned uScreen = 0; uScreen < mcMonitors; uScreen++)
     {
-        char *pszAbsPath = RTPathAbsDup(com::Utf8Str(strFile).c_str());
-        char *pszSuff = RTPathSuffix(pszAbsPath);
-        if (pszSuff)
-            pszSuff = RTStrDup(pszSuff);
-        RTPathStripSuffix(pszAbsPath);
-        if (!pszAbsPath)
-            rc = VERR_INVALID_PARAMETER;
-        if (!pszSuff)
-            pszSuff = RTStrDup(".webm");
-        char *pszName = NULL;
+        int rc2 = VideoRecStreamInit(mpVideoRecCtx, uScreen);
+        if (RT_SUCCESS(rc2))
+        {
+            i_videoCaptureScreenChanged(uScreen);
+        }
+        else
+            LogRel(("Display::VideoCaptureStart: Failed to initialize video recording context #%u (%Rrc)\n", uScreen, rc2));
+
         if (RT_SUCCESS(rc))
-        {
-            if (mcMonitors > 1)
-                rc = RTStrAPrintf(&pszName, "%s-%u%s", pszAbsPath, uScreen+1, pszSuff);
-            else
-                rc = RTStrAPrintf(&pszName, "%s%s", pszAbsPath, pszSuff);
-        }
-        if (RT_SUCCESS(rc))
-        {
-            rc = VideoRecStreamInit(mpVideoRecCtx, uScreen,
-                                    pszName, ulWidth, ulHeight,
-                                    ulRate, ulFPS, ulMaxTime,
-                                    ulMaxSize, com::Utf8Str(strOptions).c_str());
-            if (rc == VERR_ALREADY_EXISTS)
-            {
-                RTStrFree(pszName);
-                pszName = NULL;
-
-                if (mcMonitors > 1)
-                    rc = RTStrAPrintf(&pszName, "%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,
-                                      uScreen+1, pszSuff);
-                else
-                    rc = RTStrAPrintf(&pszName, "%s-%04d-%02u-%02uT%02u-%02u-%02u-%09uZ%s",
-                                      pszAbsPath, time.i32Year, time.u8Month, time.u8MonthDay,
-                                      time.u8Hour, time.u8Minute, time.u8Second, time.u32Nanosecond,
-                                      pszSuff);
-                if (RT_SUCCESS(rc))
-                    rc = VideoRecStreamInit(mpVideoRecCtx, uScreen,
-                                            pszName, ulWidth, ulHeight, ulRate,
-                                            ulFPS, ulMaxTime,
-                                            ulMaxSize, com::Utf8Str(strOptions).c_str());
-            }
-        }
-
-        if (RT_SUCCESS(rc))
-        {
-            videoCaptureScreenChanged(uScreen);
-        }
-        else
-            LogRel(("Display::VideoCaptureStart: Failed to initialize video recording context #%u, (%Rrc)\n", uScreen, rc));
-
-        RTStrFree(pszName);
-        RTStrFree(pszSuff);
-        RTStrFree(pszAbsPath);
+            rc = rc2;
     }
     return rc;
-#else /* VBOX_WITH_VIDEOREC */
-    return VERR_NOT_SUPPORTED;
-#endif
 }
 
@@ -2549 +2596 @@
  * Stop video capturing. Does nothing if video capturing is not active.
  */
-void Display::i_videoCaptureStop()
-{
-#ifdef VBOX_WITH_VIDEOREC
-    if (!VideoRecIsEnabled(mpVideoRecCtx))
+void Display::i_videoCaptureStop(void)
+{
+    if (!VideoRecIsActive(mpVideoRecCtx))
         return;
 
@@ -2560 +2606 @@
     unsigned uScreenId;
     for (uScreenId = 0; uScreenId < mcMonitors; ++uScreenId)
-        videoCaptureScreenChanged(uScreenId);
-#endif
-}
-
-#ifdef VBOX_WITH_VIDEOREC
-void Display::videoCaptureScreenChanged(unsigned uScreenId)
-{
-    if (   !VideoRecIsEnabled(mpVideoRecCtx)
+        i_videoCaptureScreenChanged(uScreenId);
+}
+
+void Display::i_videoCaptureScreenChanged(unsigned uScreenId)
+{
+    if (   !VideoRecIsActive(mpVideoRecCtx)
         || !maVideoRecEnabled[uScreenId])
     {
@@ -3289 +3333 @@
 
 #ifdef VBOX_WITH_VIDEOREC
-    if (VideoRecIsEnabled(pDisplay->mpVideoRecCtx))
+    if (   VideoRecIsActive(pDisplay->mpVideoRecCtx)
+        && VideoRecGetEnabled(&pDisplay->mVideoRecCfg) & VIDEORECFEATURE_VIDEO)
     {
         do {
@@ -4485 +4530 @@
     if (fEnabled)
     {
-        rc = pDisplay->i_videoCaptureStart();
-        fireVideoCaptureChangedEvent(pDisplay->mParent->i_getEventSource());
+        rc = pDisplay->i_videoCaptureInvalidate();
+        if (RT_SUCCESS(rc))
+        {
+            rc = pDisplay->i_videoCaptureStart();
+            fireVideoCaptureChangedEvent(pDisplay->mParent->i_getEventSource());
+        }
     }
 #endif

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

@@ -22 +22 @@
 #include <vector>
 
-#include <VBox/log.h>
 #include <iprt/asm.h>
 #include <iprt/assert.h>
 #include <iprt/critsect.h>
+#include <iprt/path.h>
 #include <iprt/semaphore.h>
 #include <iprt/thread.h>
 #include <iprt/time.h>
 
+#include <VBox/log.h>
 #include <VBox/com/VirtualBox.h>
 #include <VBox/com/com.h>
@@ -54 +55 @@
                             uint8_t *paSrc, uint32_t uSrcWidth, uint32_t uSrcHeight);
 
-int videoRecStreamLock(PVIDEORECSTREAM pStream);
-int videoRecStreamUnlock(PVIDEORECSTREAM pStream);
+static int videoRecStreamCloseFile(PVIDEORECSTREAM pStream);
+static void videoRecStreamLock(PVIDEORECSTREAM pStream);
+static void videoRecStreamUnlock(PVIDEORECSTREAM pStream);
 
 using namespace com;
@@ -114 +116 @@
             /** VPX image context. */
             vpx_image_t         RawImage;
-            /** Encoder deadline. */
-            unsigned int        uEncoderDeadline;
         } VPX;
 #endif /* VBOX_WITH_LIBVPX */
@@ -158 +158 @@
 typedef struct VIDEORECSTREAM
 {
-    /** Container context. */
-    WebMWriter         *pEBML;
+    /** Video recording context this stream is associated to. */
+    PVIDEORECCONTEXT            pCtx;
+    /** Destination where to write the stream to. */
+    VIDEORECDEST                enmDst;
+    union
+    {
+        struct
+        {
+            /** File handle to use for writing. */
+            RTFILE              hFile;
+            /** File name being used for this stream. */
+            char               *pszFile;
+            /** Pointer to WebM writer instance being used. */
+            WebMWriter         *pWEBM;
+        } File;
+    };
 #ifdef VBOX_WITH_AUDIO_VIDEOREC
     /** Track number of audio stream. */
@@ -204 +218 @@
 typedef struct VIDEORECCONTEXT
 {
+    /** Used recording configuration. */
+    VIDEORECCFG         Cfg;
     /** The current state. */
     uint32_t            enmState;
@@ -210 +226 @@
     /** Semaphore to signal the encoding worker thread. */
     RTSEMEVENT          WaitEvent;
-    /** Whether recording is enabled or not. */
+    /** Whether this conext is enabled or not. */
     bool                fEnabled;
     /** Shutdown indicator. */
@@ -216 +232 @@
     /** Worker thread. */
     RTTHREAD            Thread;
-    /** Maximal time (in ms) to record. */
-    uint64_t            uMaxTimeMs;
-    /** Maximal file size (in MB) to record. */
-    uint32_t            uMaxSizeMB;
     /** Vector of current recording stream contexts. */
     VideoRecStreams     vecStreams;
+    /** Timestamp (in ms) of when recording has been started. */
+    uint64_t            tsStartMs;
 #ifdef VBOX_WITH_AUDIO_VIDEOREC
     struct
@@ -628 +642 @@
 
                 WebMWriter::BlockData_Opus blockData = { audioFrame.abBuf, audioFrame.cbBuf, audioFrame.uTimeStampMs };
-                rc = pStream->pEBML->WriteBlock(pStream->uTrackAudio, &blockData, sizeof(blockData));
+                rc = pStream->File.pWEBM->WriteBlock(pStream->uTrackAudio, &blockData, sizeof(blockData));
                 if (RT_FAILURE(rc))
                 {
@@ -653 +667 @@
  *
  * @returns IPRT status code.
- * @param   cScreens         Number of screens to create context for.
- * @param   ppCtx            Pointer to created video recording context on success.
- */
-int VideoRecContextCreate(uint32_t cScreens, PVIDEORECCONTEXT *ppCtx)
-{
-    AssertReturn(cScreens, VERR_INVALID_PARAMETER);
-    AssertPtrReturn(ppCtx, VERR_INVALID_POINTER);
+ * @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);
 
     PVIDEORECCONTEXT pCtx = (PVIDEORECCONTEXT)RTMemAllocZ(sizeof(VIDEORECCONTEXT));
@@ -667 +683 @@
     int rc = RTCritSectInit(&pCtx->CritSect);
     if (RT_FAILURE(rc))
+    {
+        RTMemFree(pCtx);
         return rc;
+    }
 
     for (uint32_t uScreen = 0; uScreen < cScreens; uScreen++)
@@ -688 +707 @@
             pCtx->vecStreams.push_back(pStream);
 
-            pStream->pEBML = new WebMWriter();
+            pStream->File.pWEBM = new WebMWriter();
         }
         catch (std::bad_alloc)
@@ -699 +718 @@
     if (RT_SUCCESS(rc))
     {
+        pCtx->tsStartMs = RTTimeMilliTS();
         pCtx->enmState  = VIDEORECSTS_UNINITIALIZED;
         pCtx->fShutdown = false;
 
+        /* Copy the configuration to our context. */
+        pCtx->Cfg       = *pVideoRecCfg;
+
         rc = RTSemEventCreate(&pCtx->WaitEvent);
         AssertRCReturn(rc, rc);
@@ -723 +746 @@
     if (RT_FAILURE(rc))
     {
-        /* Roll back allocations on error. */
+        int rc2 = VideoRecContextDestroy(pCtx);
+        AssertRC(rc2);
+    }
+
+    return rc;
+}
+
+/**
+ * Destroys a video recording context.
+ *
+ * @param pCtx                  Video recording context to destroy.
+ */
+int VideoRecContextDestroy(PVIDEORECCONTEXT pCtx)
+{
+    if (!pCtx)
+        return VINF_SUCCESS;
+
+    /* First, disable the context. */
+    ASMAtomicWriteBool(&pCtx->fEnabled, false);
+
+    if (pCtx->enmState == VIDEORECSTS_INITIALIZED)
+    {
+        /* Set shutdown indicator. */
+        ASMAtomicWriteBool(&pCtx->fShutdown, true);
+
+        /* Signal the thread. */
+        RTSemEventSignal(pCtx->WaitEvent);
+
+        int rc = RTThreadWait(pCtx->Thread, 10 * 1000 /* 10s timeout */, NULL);
+        if (RT_FAILURE(rc))
+            return rc;
+
+        rc = RTSemEventDestroy(pCtx->WaitEvent);
+        AssertRC(rc);
+
+        pCtx->WaitEvent = NIL_RTSEMEVENT;
+    }
+
+    int rc = RTCritSectEnter(&pCtx->CritSect);
+    if (RT_SUCCESS(rc))
+    {
         VideoRecStreams::iterator it = pCtx->vecStreams.begin();
         while (it != pCtx->vecStreams.end())
@@ -729 +792 @@
             PVIDEORECSTREAM pStream = (*it);
 
-            if (pStream->pEBML)
-                delete pStream->pEBML;
-
-            it = pCtx->vecStreams.erase(it);
-
-            RTMemFree(pStream);
-            pStream = NULL;
-        }
-
-        Assert(pCtx->vecStreams.empty());
-    }
-
-    return rc;
-}
-
-/**
- * Destroys a video recording context.
- *
- * @param pCtx                  Video recording context to destroy.
- */
-int VideoRecContextDestroy(PVIDEORECCONTEXT pCtx)
-{
-    if (!pCtx)
-        return VINF_SUCCESS;
-
-    /* Set shutdown indicator. */
-    ASMAtomicWriteBool(&pCtx->fShutdown, true);
-
-    /* Signal the thread. */
-    RTSemEventSignal(pCtx->WaitEvent);
-
-    int rc = RTThreadWait(pCtx->Thread, 10 * 1000 /* 10s timeout */, NULL);
-    if (RT_FAILURE(rc))
-        return rc;
-
-    rc = RTSemEventDestroy(pCtx->WaitEvent);
-    AssertRC(rc);
-
-    pCtx->WaitEvent = NIL_RTSEMEVENT;
-
-    VideoRecStreams::iterator it = pCtx->vecStreams.begin();
-    while (it != pCtx->vecStreams.end())
-    {
-        PVIDEORECSTREAM pStream = (*it);
-
-        if (pStream->fEnabled)
-        {
-            AssertPtr(pStream->pEBML);
-            pStream->pEBML->Close();
-
-            vpx_img_free(&pStream->Video.Codec.VPX.RawImage);
-            vpx_codec_err_t rcv = vpx_codec_destroy(&pStream->Video.Codec.VPX.Ctx);
-            Assert(rcv == VPX_CODEC_OK); RT_NOREF(rcv);
+            videoRecStreamLock(pStream);
+
+            if (pStream->fEnabled)
+            {
+                switch (pStream->enmDst)
+                {
+                    case VIDEORECDEST_FILE:
+                    {
+                        if (pStream->File.pWEBM)
+                            pStream->File.pWEBM->Close();
+                        break;
+                    }
+
+                    default:
+                        AssertFailed(); /* Should never happen. */
+                        break;
+                }
+
+                vpx_img_free(&pStream->Video.Codec.VPX.RawImage);
+                vpx_codec_err_t rcv = vpx_codec_destroy(&pStream->Video.Codec.VPX.Ctx);
+                Assert(rcv == VPX_CODEC_OK); RT_NOREF(rcv);
 
 #ifdef VBOX_VIDEOREC_WITH_QUEUE
 # error "Implement me!"
 #else
-            PVIDEORECVIDEOFRAME pFrame = &pStream->Video.Frame;
-#endif
-            if (pFrame->pu8RGBBuf)
+                PVIDEORECVIDEOFRAME pFrame = &pStream->Video.Frame;
+#endif
+                if (pFrame->pu8RGBBuf)
+                {
+                    Assert(pFrame->cbRGBBuf);
+
+                    RTMemFree(pFrame->pu8RGBBuf);
+                    pFrame->pu8RGBBuf = NULL;
+                }
+
+                pFrame->cbRGBBuf = 0;
+
+                LogRel(("VideoRec: Recording screen #%u stopped\n", pStream->uScreenID));
+            }
+
+            switch (pStream->enmDst)
             {
-                Assert(pFrame->cbRGBBuf);
-
-                RTMemFree(pFrame->pu8RGBBuf);
-                pFrame->pu8RGBBuf = NULL;
+                case VIDEORECDEST_FILE:
+                {
+                    int rc2 = videoRecStreamCloseFile(pStream);
+                    AssertRC(rc2);
+
+                    if (pStream->File.pWEBM)
+                    {
+                        delete pStream->File.pWEBM;
+                        pStream->File.pWEBM = NULL;
+                    }
+                    break;
+                }
+
+                default:
+                    AssertFailed(); /* Should never happen. */
+                    break;
             }
 
-            pFrame->cbRGBBuf = 0;
-
-            LogRel(("VideoRec: Recording screen #%u stopped\n", pStream->uScreenID));
-        }
-
-        if (pStream->pEBML)
-        {
-            delete pStream->pEBML;
-            pStream->pEBML = NULL;
-        }
-
-        it = pCtx->vecStreams.erase(it);
-
-        RTCritSectDelete(&pStream->CritSect);
-
-        RTMemFree(pStream);
-        pStream = NULL;
-    }
-
-    Assert(pCtx->vecStreams.empty());
-
-    RTCritSectDelete(&pCtx->CritSect);
-
-    RTMemFree(pCtx);
-    pCtx = NULL;
-
-    return VINF_SUCCESS;
+            it = pCtx->vecStreams.erase(it);
+
+            videoRecStreamUnlock(pStream);
+
+            RTCritSectDelete(&pStream->CritSect);
+
+            RTMemFree(pStream);
+            pStream = NULL;
+        }
+
+        Assert(pCtx->vecStreams.empty());
+
+        int rc2 = RTCritSectLeave(&pCtx->CritSect);
+        AssertRC(rc2);
+
+        RTCritSectDelete(&pCtx->CritSect);
+
+        RTMemFree(pCtx);
+        pCtx = NULL;
+    }
+
+    return rc;
 }
 
@@ -853 +904 @@
  * Locks a recording stream.
  *
- * @returns IPRT status code.
  * @param   pStream             Recording stream to lock.
  */
-int videoRecStreamLock(PVIDEORECSTREAM pStream)
+static void videoRecStreamLock(PVIDEORECSTREAM pStream)
 {
     int rc = RTCritSectEnter(&pStream->CritSect);
     AssertRC(rc);
-
-    return rc;
 }
 
@@ -867 +915 @@
  * Unlocks a locked recording stream.
  *
- * @returns IPRT status code.
  * @param   pStream             Recording stream to unlock.
  */
-int videoRecStreamUnlock(PVIDEORECSTREAM pStream)
+static void videoRecStreamUnlock(PVIDEORECSTREAM pStream)
 {
     int rc = RTCritSectLeave(&pStream->CritSect);
     AssertRC(rc);
+}
+
+/**
+ * Opens a file for a given recording stream to capture to.
+ *
+ * @returns IPRT status code.
+ * @param   pStream             Recording stream to open file for.
+ * @param   pCfg                Recording configuration to use.
+ */
+int videoRecStreamOpenFile(PVIDEORECSTREAM pStream, PVIDEORECCFG pCfg)
+{
+    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
+    AssertPtrReturn(pCfg,    VERR_INVALID_POINTER);
+
+    Assert(pStream->enmDst == VIDEORECDEST_INVALID);
+    Assert(pCfg->enmDst    == VIDEORECDEST_FILE);
+
+    RTTIMESPEC ts;
+    RTTimeNow(&ts);
+
+    RTTIME time;
+    RTTimeExplode(&time, &ts);
+
+    char *pszAbsPath = RTPathAbsDup(com::Utf8Str(pCfg->File.strFile).c_str());
+    AssertPtrReturn(pszAbsPath, VERR_NO_MEMORY);
+
+    char *pszSuff    = RTPathSuffix(pszAbsPath);
+    if (pszSuff)
+        pszSuff = RTStrDup(pszSuff);
+
+    RTPathStripSuffix(pszAbsPath);
+    AssertPtrReturn(pszAbsPath, VERR_INVALID_PARAMETER);
+
+    if (!pszSuff)
+        pszSuff = RTStrDup(".webm");
+
+    char *pszFile = NULL;
+
+    int rc;
+    if (pStream->uScreenID > 1)
+        rc = RTStrAPrintf(&pszFile, "%s-%u%s", pszAbsPath, pStream->uScreenID + 1, pszSuff);
+    else
+        rc = RTStrAPrintf(&pszFile, "%s%s", pszAbsPath, pszSuff);
+
+    if (RT_SUCCESS(rc))
+    {
+        uint64_t fOpen = RTFILE_O_WRITE | RTFILE_O_DENY_WRITE;
+#ifdef DEBUG
+        fOpen |= RTFILE_O_CREATE_REPLACE;
+#else
+        /* Play safe: the file must not exist, overwriting is potentially
+         * hazardous as nothing prevents the user from picking a file name of some
+         * other important file, causing unintentional data loss. */
+        fOpen |= RTFILE_O_CREATE;
+#endif
+        RTFILE hFile;
+        rc = RTFileOpen(&hFile, pszFile, fOpen);
+        if (RT_SUCCESS(rc))
+        {
+            pStream->enmDst       = VIDEORECDEST_FILE;
+            pStream->File.hFile   = hFile;
+            pStream->File.pszFile = pszFile; /* Assign allocated string to our stream's config. */
+        }
+        else
+            RTStrFree(pszFile);
+    }
+
+    RTStrFree(pszSuff);
+    RTStrFree(pszAbsPath);
+
+    if (RT_FAILURE(rc))
+        LogRel(("VideoRec: Failed to open file for screen %RU32, rc=%Rrc\n", pStream->uScreenID, rc));
 
     return rc;
+}
+
+/**
+ * Closes a recording stream's file again.
+ *
+ * @returns IPRT status code.
+ * @param   pStream             Recording stream to close file for.
+ */
+static int videoRecStreamCloseFile(PVIDEORECSTREAM pStream)
+{
+    Assert(pStream->enmDst == VIDEORECDEST_FILE);
+
+    pStream->enmDst = VIDEORECDEST_INVALID;
+
+    AssertPtr(pStream->File.pszFile);
+
+    if (RTFileIsValid(pStream->File.hFile))
+    {
+        RTFileClose(pStream->File.hFile);
+        LogRel(("VideoRec: Closed file '%s'\n", pStream->File.pszFile));
+    }
+
+    RTStrFree(pStream->File.pszFile);
+    pStream->File.pszFile = NULL;
+
+    return VINF_SUCCESS;
 }
 
@@ -884 +1029 @@
  * @param   pCtx                Pointer to video recording context.
  * @param   uScreen             Screen number to record.
- * @param   pszFile             File to save recording to.
- * @param   uWidth              Target video resolution (width).
- * @param   uHeight             Target video resolution (height).
- * @param   uRate               Target encoding bit rate.
- * @param   uFPS                Target FPS (Frame Per Second).
- * @param   uMaxTimeS           Maximum time (in s) to record, or 0 for no time limit.
- * @param   uMaxSizeMB          Maximum file size (in MB) to record, or 0 for no limit.
- * @param   pszOptions          Additional options in "key=value" array format. Optional.
- */
-int VideoRecStreamInit(PVIDEORECCONTEXT pCtx, uint32_t uScreen, const char *pszFile,
-                       uint32_t uWidth, uint32_t uHeight, uint32_t uRate, uint32_t uFPS,
-                       uint32_t uMaxTimeS, uint32_t uMaxSizeMB, const char *pszOptions)
-{
-    AssertPtrReturn(pCtx,    VERR_INVALID_POINTER);
-    AssertPtrReturn(pszFile, VERR_INVALID_POINTER);
-    AssertReturn(uWidth,     VERR_INVALID_PARAMETER);
-    AssertReturn(uHeight,    VERR_INVALID_PARAMETER);
-    AssertReturn(uRate,      VERR_INVALID_PARAMETER);
-    AssertReturn(uFPS,       VERR_INVALID_PARAMETER);
-    /* pszOptions is optional. */
+ */
+int VideoRecStreamInit(PVIDEORECCONTEXT pCtx, uint32_t uScreen)
+{
+    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
 
     PVIDEORECSTREAM pStream = videoRecStreamGet(pCtx, uScreen);
@@ -909 +1038 @@
         return VERR_NOT_FOUND;
 
-    pCtx->uMaxTimeMs = (uMaxTimeS > 0 ? RTTimeProgramMilliTS() + uMaxTimeS * 1000 : 0);
-    pCtx->uMaxSizeMB = uMaxSizeMB;
-
-    pStream->Video.uWidth  = uWidth;
-    pStream->Video.uHeight = uHeight;
+    int rc = videoRecStreamOpenFile(pStream, &pCtx->Cfg);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    PVIDEORECCFG pCfg = &pCtx->Cfg;
+
+    pStream->pCtx          = pCtx;
+    /** @todo Make the following parameters configurable on a per-stream basis? */
+    pStream->Video.uWidth  = pCfg->Video.uWidth;
+    pStream->Video.uHeight = pCfg->Video.uHeight;
 
 #ifndef VBOX_VIDEOREC_WITH_QUEUE
@@ -933 +1067 @@
 
 #ifdef VBOX_WITH_LIBVPX
-    pVC->VPX.uEncoderDeadline = VPX_DL_REALTIME;
-
     vpx_codec_err_t rcv = vpx_codec_enc_config_default(DEFAULTCODEC, &pVC->VPX.Cfg, 0);
     if (rcv != VPX_CODEC_OK)
@@ -943 +1075 @@
 #endif
 
-    com::Utf8Str options(pszOptions);
-    size_t pos = 0;
-
-    /* By default we only enable video recording for now.
-     * Audio support is considered as being experimental. There be dragons! */
-    bool     fHasVideoTrack = true;
+    pStream->Video.uDelayMs = 1000 / pCfg->Video.uFPS;
+
+    switch (pStream->enmDst)
+    {
+        case VIDEORECDEST_FILE:
+        {
+            rc = pStream->File.pWEBM->CreateEx(pStream->File.pszFile, &pStream->File.hFile,
 #ifdef VBOX_WITH_AUDIO_VIDEOREC
-    bool     fHasAudioTrack = false;
-    /* By default we use 48kHz, 16-bit, stereo for the audio track. */
-    uint16_t uAudioHz       = 48000;
-    uint8_t  uAudioBits     = 16;
-    uint8_t  uAudioChannels = 2;
-#endif
-
-    com::Utf8Str key, value;
-    while ((pos = options.parseKeyValue(key, value, pos)) != com::Utf8Str::npos)
-    {
-        if (key.compare("vc_quality", Utf8Str::CaseInsensitive) == 0)
-        {
-            if (value.compare("realtime", Utf8Str::CaseInsensitive) == 0)
+                                               pCfg->Audio.fEnabled ? WebMWriter::AudioCodec_Opus : WebMWriter::AudioCodec_None,
+#else
+                                               WebMWriter::AudioCodec_None,
+#endif
+                                               pCfg->Video.fEnabled ? WebMWriter::VideoCodec_VP8 : WebMWriter::VideoCodec_None);
+            if (RT_FAILURE(rc))
             {
-#ifdef VBOX_WITH_LIBVPX
-                pVC->VPX.uEncoderDeadline = VPX_DL_REALTIME;
-#endif
+                LogRel(("VideoRec: Failed to create the capture output file '%s' (%Rrc)\n", pStream->File.pszFile, rc));
+                break;
             }
-            else if (value.compare("good", Utf8Str::CaseInsensitive) == 0)
+
+            const char *pszFile = pStream->File.pszFile;
+
+            if (pCfg->Video.fEnabled)
             {
-                pVC->VPX.uEncoderDeadline = 1000000 / uFPS;
+                rc = pStream->File.pWEBM->AddVideoTrack(pCfg->Video.uWidth, pCfg->Video.uHeight, pCfg->Video.uFPS,
+                                                        &pStream->uTrackVideo);
+                if (RT_FAILURE(rc))
+                {
+                    LogRel(("VideoRec: Failed to add video track to output file '%s' (%Rrc)\n", pszFile, rc));
+                    break;
+                }
+
+                LogRel(("VideoRec: Recording screen #%u with %RU32x%RU32 @ %RU32 kbps, %u FPS\n",
+                        uScreen, pCfg->Video.uWidth, pCfg->Video.uHeight, pCfg->Video.uRate, pCfg->Video.uFPS));
             }
-            else if (value.compare("best", Utf8Str::CaseInsensitive) == 0)
+
+#ifdef VBOX_WITH_AUDIO_VIDEOREC
+            if (pCfg->Audio.fEnabled)
             {
-#ifdef VBOX_WITH_LIBVPX
-                pVC->VPX.uEncoderDeadline = VPX_DL_BEST_QUALITY;
-#endif
+                rc = pStream->File.pWEBM->AddAudioTrack(pCfg->Audio.uHz, pCfg->Audio.cChannels, pCfg->Audio.cBits,
+                                                        &pStream->uTrackAudio);
+                if (RT_FAILURE(rc))
+                {
+                    LogRel(("VideoRec: Failed to add audio track to output file '%s' (%Rrc)\n", pszFile, rc));
+                    break;
+                }
+
+                LogRel(("VideoRec: Recording audio in %RU16Hz, %RU8 bit, %RU8 %s\n",
+                        pCfg->Audio.uHz, pCfg->Audio.cBits, pCfg->Audio.cChannels, pCfg->Audio.cChannels ? "channel" : "channels"));
             }
-            else
+#endif
+
+            if (   pCfg->Video.fEnabled
+#ifdef VBOX_WITH_AUDIO_VIDEOREC
+                || pCfg->Audio.fEnabled
+#endif
+               )
             {
-                LogRel(("VideoRec: Setting quality deadline to '%s'\n", value.c_str()));
-                pVC->VPX.uEncoderDeadline = value.toUInt32();
+                char szWhat[32] = { 0 };
+                if (pCfg->Video.fEnabled)
+                    RTStrCat(szWhat, sizeof(szWhat), "video");
+#ifdef VBOX_WITH_AUDIO_VIDEOREC
+                if (pCfg->Audio.fEnabled)
+                {
+                    if (pCfg->Video.fEnabled)
+                        RTStrCat(szWhat, sizeof(szWhat), " + ");
+                    RTStrCat(szWhat, sizeof(szWhat), "audio");
+                }
+#endif
+                LogRel(("VideoRec: Recording %s to '%s'\n", szWhat, pszFile));
             }
-        }
-        else if (key.compare("vc_enabled", Utf8Str::CaseInsensitive) == 0)
-        {
-#ifdef VBOX_WITH_AUDIO_VIDEOREC
-            if (value.compare("false", Utf8Str::CaseInsensitive) == 0)
-            {
-                fHasVideoTrack = false;
-                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("false", Utf8Str::CaseInsensitive))
-            {
-                fHasAudioTrack = false;
-                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)
-            {
-                uAudioHz       = 8000;
-                uAudioBits     = 16;
-                uAudioChannels = 1;
-            }
-            else if (value.startsWith("med" /* "med[ium]" */, Utf8Str::CaseInsensitive) == 0)
-            {
-                uAudioHz       = 22050;
-                uAudioBits     = 16;
-                uAudioChannels = 2;
-            }
-            else if (value.compare("high", Utf8Str::CaseInsensitive) == 0)
-            {
-                /* Stay with the default set above. */
-            }
-#endif
-        }
-        else
-            LogRel(("VideoRec: Unknown option '%s' (value '%s'), skipping\n", key.c_str(), value.c_str()));
-
-    } /* while */
-
-    uint64_t fOpen = RTFILE_O_WRITE | RTFILE_O_DENY_WRITE;
-#ifdef DEBUG
-    fOpen |= RTFILE_O_CREATE_REPLACE;
-#else
-    /* Play safe: the file must not exist, overwriting is potentially
-     * hazardous as nothing prevents the user from picking a file name of some
-     * other important file, causing unintentional data loss. */
-    fOpen |= RTFILE_O_CREATE;
-#endif
-
-    int rc = pStream->pEBML->Create(pszFile, fOpen,
-#ifdef VBOX_WITH_AUDIO_VIDEOREC
-                                    fHasAudioTrack ? WebMWriter::AudioCodec_Opus : WebMWriter::AudioCodec_None,
-#else
-                                    WebMWriter::AudioCodec_None,
-#endif
-                                    fHasVideoTrack ? WebMWriter::VideoCodec_VP8 : WebMWriter::VideoCodec_None);
+
+            break;
+        }
+
+        default:
+            AssertFailed(); /* Should never happen. */
+            rc = VERR_NOT_IMPLEMENTED;
+            break;
+    }
+
     if (RT_FAILURE(rc))
-    {
-        LogRel(("VideoRec: Failed to create the video capture output file '%s' (%Rrc)\n", pszFile, rc));
         return rc;
-    }
-
-    pStream->Video.uDelayMs = 1000 / uFPS;
-
-    if (fHasVideoTrack)
-    {
-        rc = pStream->pEBML->AddVideoTrack(uWidth, uHeight, uFPS, &pStream->uTrackVideo);
-        if (RT_FAILURE(rc))
-        {
-            LogRel(("VideoRec: Failed to add video track to output file '%s' (%Rrc)\n", pszFile, rc));
-            return rc;
-        }
-
-        LogRel(("VideoRec: Recording screen #%u with %ux%u @ %u kbps, %u FPS\n",
-                uScreen, uWidth, uHeight, uRate, uFPS));
-    }
-
-#ifdef VBOX_WITH_AUDIO_VIDEOREC
-    if (fHasAudioTrack)
-    {
-        rc = pStream->pEBML->AddAudioTrack(uAudioHz, uAudioChannels, uAudioBits, &pStream->uTrackAudio);
-        if (RT_FAILURE(rc))
-        {
-            LogRel(("VideoRec: Failed to add audio track to output file '%s' (%Rrc)\n", pszFile, rc));
-            return rc;
-        }
-
-        LogRel(("VideoRec: Recording audio in %RU16Hz, %RU8 bit, %RU8 %s\n",
-                uAudioHz, uAudioBits, uAudioChannels, uAudioChannels == 1 ? "channel" : "channels"));
-    }
-#endif
-
-    if (   fHasVideoTrack
-#ifdef VBOX_WITH_AUDIO_VIDEOREC
-        || fHasAudioTrack
-#endif
-       )
-    {
-        char szWhat[32] = { 0 };
-        if (fHasVideoTrack)
-            RTStrCat(szWhat, sizeof(szWhat), "video");
-#ifdef VBOX_WITH_AUDIO_VIDEOREC
-        if (fHasAudioTrack)
-        {
-            if (fHasVideoTrack)
-                RTStrCat(szWhat, sizeof(szWhat), " + ");
-            RTStrCat(szWhat, sizeof(szWhat), "audio");
-        }
-#endif
-        LogRel(("Recording %s to '%s'\n", szWhat, pszFile));
-    }
 
 #ifdef VBOX_WITH_LIBVPX
     /* Target bitrate in kilobits per second. */
-    pVC->VPX.Cfg.rc_target_bitrate = uRate;
+    pVC->VPX.Cfg.rc_target_bitrate = pCfg->Video.uRate;
     /* Frame width. */
-    pVC->VPX.Cfg.g_w = uWidth;
+    pVC->VPX.Cfg.g_w = pCfg->Video.uWidth;
     /* Frame height. */
-    pVC->VPX.Cfg.g_h = uHeight;
+    pVC->VPX.Cfg.g_h = pCfg->Video.uHeight;
     /* 1ms per frame. */
     pVC->VPX.Cfg.g_timebase.num = 1;
@@ -1120 +1175 @@
     if (rcv != VPX_CODEC_OK)
     {
-        LogFlow(("Failed to initialize VP8 encoder %s", vpx_codec_err_to_string(rcv)));
+        LogFlow(("Failed to initialize VP8 encoder: %s\n", vpx_codec_err_to_string(rcv)));
         return VERR_INVALID_PARAMETER;
     }
 
-    if (!vpx_img_alloc(&pVC->VPX.RawImage, VPX_IMG_FMT_I420, uWidth, uHeight, 1))
-    {
-        LogFlow(("Failed to allocate image %dx%d", uWidth, uHeight));
+    if (!vpx_img_alloc(&pVC->VPX.RawImage, VPX_IMG_FMT_I420, pCfg->Video.uWidth, pCfg->Video.uHeight, 1))
+    {
+        LogFlow(("Failed to allocate image %RU32x%RU32\n", pCfg->Video.uWidth, pCfg->Video.uHeight));
         return VERR_NO_MEMORY;
     }
@@ -1139 +1194 @@
 
 /**
- * VideoRec utility function to check if recording is enabled.
- *
- * @returns true if recording is enabled.
- * @param   pCtx                Pointer to video recording context.
- */
-bool VideoRecIsEnabled(PVIDEORECCONTEXT pCtx)
-{
-    if (!pCtx)
-        return false;
-
-    return ASMAtomicReadBool(&pCtx->fEnabled);
-}
-
-/**
- * VideoRec utility function to check if recording engine is ready to accept a new frame
- * for the given screen.
+ * Returns which recording features currently are enabled for a given configuration.
+ *
+ * @returns Enabled video recording features.
+ * @param   pCtx                Pointer to recording configuration.
+ */
+VIDEORECFEATURES VideoRecGetEnabled(PVIDEORECCFG pCfg)
+{
+    if (   !pCfg
+        || !pCfg->fEnabled)
+    {
+        return VIDEORECFEATURE_NONE;
+    }
+
+    VIDEORECFEATURES fFeatures = VIDEORECFEATURE_NONE;
+
+    if (pCfg->Video.fEnabled)
+        fFeatures |= VIDEORECFEATURE_VIDEO;
+
+    if (pCfg->Audio.fEnabled)
+        fFeatures |= VIDEORECFEATURE_AUDIO;
+
+    return fFeatures;
+}
+
+/**
+ * Checks if recording engine is ready to accept a new frame for the given screen.
  *
  * @returns true if recording engine is ready.
@@ -1184 +1249 @@
 
 /**
- * VideoRec utility function to check if a specified limit for recording
- * has been reached.
+ * Returns whether video recording for a given recording context is active or not.
+ *
+ * @returns true if active, false if not.
+ * @param   pCtx                 Pointer to video recording context.
+ */
+bool VideoRecIsActive(PVIDEORECCONTEXT pCtx)
+{
+    if (!pCtx)
+        return false;
+
+    return ASMAtomicReadBool(&pCtx->fEnabled);
+}
+
+/**
+ * Checks if a specified limit for recording has been reached.
  *
  * @returns true if any limit has been reached.
@@ -1192 +1270 @@
  * @param   tsNowMs             Current time stamp (in ms).
  */
-
 bool VideoRecIsLimitReached(PVIDEORECCONTEXT pCtx, uint32_t uScreen, uint64_t tsNowMs)
 {
@@ -1202 +1279 @@
     }
 
-    if (   pCtx->uMaxTimeMs
-        && tsNowMs >= pCtx->uMaxTimeMs)
+    const PVIDEORECCFG pCfg = &pCtx->Cfg;
+
+    if (   pCfg->uMaxTimeS
+        && tsNowMs >= pCtx->tsStartMs + (pCfg->uMaxTimeS * 1000))
     {
         return true;
     }
 
-    if (pCtx->uMaxSizeMB)
-    {
-        uint64_t sizeInMB = pStream->pEBML->GetFileSize() / (1024 * 1024);
-        if(sizeInMB >= pCtx->uMaxSizeMB)
+    if (pCfg->enmDst == VIDEORECDEST_FILE)
+    {
+
+        if (pCfg->File.uMaxSizeMB)
+        {
+            uint64_t sizeInMB = pStream->File.pWEBM->GetFileSize() / (1024 * 1024);
+            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;
-    }
-
-    /* Check for available free disk space */
-    if (   pStream->pEBML
-        && pStream->pEBML->GetAvailableSpace() < 0x100000) /**@todo r=andy WTF? Fix this. */
-    {
-        LogRel(("VideoRec: Not enough free storage space available, stopping video capture\n"));
-        return true;
+        }
     }
 
@@ -1227 +1310 @@
 
 /**
- * VideoRec utility function to encode the source image and write the encoded
- * image to target file.
+ * Encodes the source image and write the encoded image to the stream's destination.
  *
  * @returns IPRT status code.
@@ -1236 +1318 @@
 static int videoRecEncodeAndWrite(PVIDEORECSTREAM pStream, PVIDEORECVIDEOFRAME pFrame)
 {
+    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
+    AssertPtrReturn(pFrame,  VERR_INVALID_POINTER);
+
     int rc;
 
-    PVIDEORECVIDEOCODEC pVC = &pStream->Video.Codec;
-
+    AssertPtr(pStream->pCtx);
+    PVIDEORECCFG        pCfg = &pStream->pCtx->Cfg;
+    PVIDEORECVIDEOCODEC pVC  = &pStream->Video.Codec;
 #ifdef VBOX_WITH_LIBVPX
     /* Presentation Time Stamp (PTS). */
@@ -1245 +1331 @@
     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 */,
-                                           pVC->VPX.uEncoderDeadline /* Quality setting */);
+                                           pts                                    /* Time stamp */,
+                                           pStream->Video.uDelayMs                /* How long to show this frame */,
+                                           0                                      /* Flags */,
+                                           pCfg->Video.Codec.VPX.uEncoderDeadline /* Quality setting */);
     if (rcv != VPX_CODEC_OK)
     {
@@ -1268 +1354 @@
             {
                 WebMWriter::BlockData_VP8 blockData = { &pVC->VPX.Cfg, pPacket };
-                rc = pStream->pEBML->WriteBlock(pStream->uTrackVideo, &blockData, sizeof(blockData));
+                rc = pStream->File.pWEBM->WriteBlock(pStream->uTrackVideo, &blockData, sizeof(blockData));
                 break;
             }
@@ -1286 +1372 @@
 
 /**
- * VideoRec utility function to convert RGB to YUV.
+ * Converts a RGB to YUV buffer.
  *
  * @returns IPRT status code.
@@ -1365 +1451 @@
 
 /**
- * VideoRec utility function to copy a source video frame to the intermediate
- * RGB buffer. This function is executed only once per time.
+ * Copies a source video frame to the intermediate RGB buffer.
+ * This function is executed only once per time.
  *
  * @thread  EMT
@@ -1397 +1483 @@
         return VERR_NOT_FOUND;
 
-    int rc = RTCritSectEnter(&pStream->CritSect);
-    if (RT_FAILURE(rc))
-        return rc;
+    videoRecStreamLock(pStream);
+
+    int rc = VINF_SUCCESS;
 
     do
@@ -1570 +1656 @@
     } while (0);
 
-    int rc2 = RTCritSectLeave(&pStream->CritSect);
-    if (RT_SUCCESS(rc2))
-    {
-        if (   RT_SUCCESS(rc)
-            && rc != VINF_TRY_AGAIN) /* Only signal the thread if operation was successful. */
-        {
-            rc2 = RTSemEventSignal(pCtx->WaitEvent);
-        }
-    }
-
-    if (RT_SUCCESS(rc))
-        rc = rc2;
+    videoRecStreamUnlock(pStream);
+
+    if (   RT_SUCCESS(rc)
+        && rc != VINF_TRY_AGAIN) /* Only signal the thread if operation was successful. */
+    {
+        int rc2 = RTSemEventSignal(pCtx->WaitEvent);
+        AssertRC(rc2);
+    }
 
     return rc;

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

@@ -19 +19 @@
 #define ____H_VIDEOREC
 
+#include <VBox/com/array.h>
+
 struct VIDEORECCONTEXT;
 typedef struct VIDEORECCONTEXT *PVIDEORECCONTEXT;
@@ -25 +27 @@
 typedef struct VIDEORECSTREAM *PVIDEORECSTREAM;
 
-int VideoRecContextCreate(uint32_t cScreens, PVIDEORECCONTEXT *ppCtx);
+/**
+ * Enumeration for video recording destinations.
+ */
+typedef enum VIDEORECDEST
+{
+    /** Invalid destination, do not use. */
+    VIDEORECDEST_INVALID = 0,
+    /** Write to a file. */
+    VIDEORECDEST_FILE    = 1
+} VIDEORECDEST;
+
+/**
+ * Enumeration for definining a video / audio
+ * profile setting.
+ */
+typedef enum VIDEORECPROFILE
+{
+    VIDEORECPROFILE_NONE   = 0,
+    VIDEORECPROFILE_LOW,
+    VIDEORECPROFILE_MEDIUM,
+    VIDEORECPROFILE_HIGH,
+    VIDEORECPROFILE_BEST,
+    VIDEORECPROFILE_REALTIME
+} VIDEORECPROFILE;
+
+/**
+ * Structure for keeping a video recording configuration.
+ */
+typedef struct VIDEORECCFG
+{
+    /** Whether recording is enabled or not (as a whole). */
+    bool                    fEnabled;
+    /** */
+    com::SafeArray<BOOL>    aScreens;
+    /** Destination where to write the stream to. */
+    VIDEORECDEST            enmDst;
+    union
+    {
+        /**
+         * Structure for keeping recording parameters if
+         * destination is a file.
+         */
+        struct
+        {
+            BSTR            strFile;
+            /** Maximum file size (in MB) to record. */
+            uint32_t        uMaxSizeMB;
+        } File;
+    };
+
+#ifdef VBOX_WITH_AUDIO_VIDEOREC
+    /**
+     * Structure for keeping the audio recording parameters.
+     */
+    struct
+    {
+        bool                fEnabled;
+        uint16_t            uHz;
+        uint8_t             cBits;
+        uint8_t             cChannels;
+        VIDEORECPROFILE     enmProfile;
+    } Audio;
+#endif
+
+    /**
+     * Structure for keeping the video recording parameters.
+     */
+    struct
+    {
+        bool                fEnabled;
+        uint32_t            uWidth;
+        uint32_t            uHeight;
+        uint32_t            uRate;
+        uint32_t            uFPS;
+
+#ifdef VBOX_WITH_LIBVPX
+        union
+        {
+            struct
+            {
+                /** Encoder deadline. */
+                unsigned int uEncoderDeadline;
+            } VPX;
+        } Codec;
+#endif
+
+    } Video;
+    /** Maximum time (in s) to record.
+     *  Specify 0 to disable this check. */
+    uint32_t                uMaxTimeS;
+
+    VIDEORECCFG& operator=(const VIDEORECCFG &that)
+    {
+        fEnabled = that.fEnabled;
+        that.aScreens.cloneTo(aScreens);
+        enmDst   = that.enmDst;
+
+        File.strFile    = that.File.strFile;
+        File.uMaxSizeMB = that.File.uMaxSizeMB;
+#ifdef VBOX_WITH_AUDIO_VIDEOREC
+        Audio           = that.Audio;
+#endif
+        Video           = that.Video;
+        uMaxTimeS       = that.uMaxTimeS;
+        return *this;
+    }
+
+} VIDEORECCFG, *PVIDEORECCFG;
+
+/** Stores video recording features. */
+typedef uint32_t VIDEORECFEATURES;
+
+/** Video recording is disabled completely. */
+#define VIDEORECFEATURE_NONE        0
+/** Capturing video is enabled. */
+#define VIDEORECFEATURE_VIDEO       RT_BIT(0)
+/** Capturing audio is enabled. */
+#define VIDEORECFEATURE_AUDIO       RT_BIT(1)
+
+int VideoRecContextCreate(uint32_t cScreens, PVIDEORECCFG pVideoRecCfg, PVIDEORECCONTEXT *ppCtx);
 int VideoRecContextDestroy(PVIDEORECCONTEXT pCtx);
 
-int  VideoRecStreamInit(PVIDEORECCONTEXT pCtx, uint32_t uScreen, const char *pszFile,
-                        uint32_t uWidth, uint32_t uHeight, uint32_t uRate, uint32_t uFPS,
-                        uint32_t uMaxTimeS, uint32_t uMaxFileSizeMB, const char *pszOptions);
+int VideoRecStreamInit(PVIDEORECCONTEXT pCtx, uint32_t uScreen);
+int VideoRecStreamUninit(PVIDEORECCONTEXT pCtx, uint32_t uScreen);
 
-bool VideoRecIsEnabled(PVIDEORECCONTEXT pCtx);
-int  VideoRecSendAudioFrame(PVIDEORECCONTEXT pCtx, const void *pvData, size_t cbData, uint64_t uTimestampMs);
-int  VideoRecSendVideoFrame(PVIDEORECCONTEXT pCtx, uint32_t uScreen,
+VIDEORECFEATURES VideoRecGetEnabled(PVIDEORECCFG pCfg);
+
+int VideoRecSendAudioFrame(PVIDEORECCONTEXT pCtx, const void *pvData, size_t cbData, uint64_t uTimestampMs);
+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);
 bool VideoRecIsReady(PVIDEORECCONTEXT pCtx, uint32_t uScreen, uint64_t uTimeStampMs);
+bool VideoRecIsActive(PVIDEORECCONTEXT pCtx);
 bool VideoRecIsLimitReached(PVIDEORECCONTEXT pCtx, uint32_t uScreen, uint64_t tsNowMs);