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

Timestamp:

Jul 11, 2024 7:49:37 AM (5 months ago)

Author:

vboxsync

Message:

Recording: Implemented support for a dedicated progress object, which is exposed to API clients. This can be used for better tracking the recording progress as well as for error reporting. The RecordingSettings API also now has a dedicated start() method to start recording, as well as support for attaching to an already ongoing recording by retrieving the progress object at a later time. Adapted FE/Qt (draft, see @todos), FE/VBoxManage and the Validation Kit testdriver to the new APIs. VBoxManage also can attach to an ongoing recording now. The recording progress object also will have multiple operations to get the recording progress for convenience. bugref:10718

Location:

trunk/src/VBox/Main/src-client

Files:

• ConsoleImpl.cpp (modified) (8 diffs)
• Recording.cpp (modified) (23 diffs)
• RecordingStream.cpp (modified) (1 diff)
• SessionImpl.cpp (modified) (1 diff)

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

@@ -6094 +6094 @@
  *
  * @returns VBox status code.
- * @retval  VERR_NO_CHANGE if the recording state has not been changed.
+ * @retval  VINF_NO_CHANGE if the recording state has not been changed.
  * @param   fEnable             Whether to enable or disable the recording.
  * @param   pAutoLock           Pointer to auto write lock to use for attaching/detaching required driver(s) at runtime.
- */
-int Console::i_recordingEnable(BOOL fEnable, util::AutoWriteLock *pAutoLock)
+ * @param   pProgress           Progress object to use. Optional and can be NULL.
+ */
+int Console::i_recordingEnable(BOOL fEnable, util::AutoWriteLock *pAutoLock, ComPtr<IProgress> &pProgress)
 {
     AssertPtrReturn(pAutoLock, VERR_INVALID_POINTER);
 
+    bool const fIsEnabled = mRecording.mCtx.IsStarted();
+
+    if (RT_BOOL(fEnable) == fIsEnabled) /* No change? Bail out. */
+        return VINF_NO_CHANGE;
+
     int vrc = VINF_SUCCESS;
 
     Display *pDisplay = i_getDisplay();
-    if (pDisplay)
-    {
-        bool const fIsEnabled = mRecording.mCtx.IsStarted();
-
-        if (RT_BOOL(fEnable) != fIsEnabled)
-        {
-            LogRel(("Recording: %s\n", fEnable ? "Enabling" : "Disabling"));
-
-            SafeVMPtrQuiet ptrVM(this);
-            if (ptrVM.isOk())
+    AssertPtrReturn(pDisplay, VERR_INVALID_POINTER);
+
+    LogRel(("Recording: %s\n", fEnable ? "Enabling" : "Disabling"));
+
+    SafeVMPtrQuiet ptrVM(this);
+    if (ptrVM.isOk())
+    {
+        if (fEnable)
+        {
+            vrc = i_recordingCreate(pProgress);
+            if (RT_SUCCESS(vrc))
             {
-                if (fEnable)
+# ifdef VBOX_WITH_AUDIO_RECORDING
+                /* Attach the video recording audio driver if required. */
+                if (   mRecording.mCtx.IsFeatureEnabled(RecordingFeature_Audio)
+                    && mRecording.mAudioRec)
                 {
-                    vrc = i_recordingCreate();
+                    vrc = mRecording.mAudioRec->applyConfiguration(mRecording.mCtx.GetConfig());
                     if (RT_SUCCESS(vrc))
-                    {
-# ifdef VBOX_WITH_AUDIO_RECORDING
-                        /* Attach the video recording audio driver if required. */
-                        if (   mRecording.mCtx.IsFeatureEnabled(RecordingFeature_Audio)
-                            && mRecording.mAudioRec)
-                        {
-                            vrc = mRecording.mAudioRec->applyConfiguration(mRecording.mCtx.GetConfig());
-                            if (RT_SUCCESS(vrc))
-                                vrc = mRecording.mAudioRec->doAttachDriverViaEmt(ptrVM.rawUVM(), ptrVM.vtable(), pAutoLock);
-
-                            if (RT_FAILURE(vrc))
-                                setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Attaching to audio recording driver failed (%Rrc) -- please consult log file for details"), vrc);
-                        }
+                        vrc = mRecording.mAudioRec->doAttachDriverViaEmt(ptrVM.rawUVM(), ptrVM.vtable(), pAutoLock);
+
+                    if (RT_FAILURE(vrc))
+                        mRecording.mCtx.SetError(vrc, Utf8StrFmt(tr("Attaching audio recording driver failed (%Rrc)"), vrc));
+                }
 # endif
-                        if (   RT_SUCCESS(vrc)
-                            && mRecording.mCtx.IsReady()) /* Any video recording (audio and/or video) feature enabled? */
-                        {
-                            vrc = i_recordingStart(pAutoLock);
-                            if (RT_FAILURE(vrc))
-                                setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Recording start failed (%Rrc) -- please consult log file for details"), vrc);
-                        }
-                    }
-                    else
-                        setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Recording initialization failed (%Rrc) -- please consult log file for details"), vrc);
-
-                    if (RT_FAILURE(vrc))
-                        LogRel(("Recording: Failed to enable with %Rrc\n", vrc));
-                }
-                else
+                if (   RT_SUCCESS(vrc)
+                    && mRecording.mCtx.IsReady()) /* Any video recording (audio and/or video) feature enabled? */
                 {
-                    vrc = i_recordingStop(pAutoLock);
-                    if (RT_SUCCESS(vrc))
-                    {
-# ifdef VBOX_WITH_AUDIO_RECORDING
-                        if (mRecording.mAudioRec)
-                            mRecording.mAudioRec->doDetachDriverViaEmt(ptrVM.rawUVM(), ptrVM.vtable(), pAutoLock);
-# endif
-                        i_recordingDestroy();
-                    }
-                    else
-                       setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Recording stop failed (%Rrc) -- please consult log file for details"), vrc);
+                    vrc = i_recordingStart(pAutoLock);
                 }
             }
-            else
-                vrc = VERR_VM_INVALID_VM_STATE;
 
             if (RT_FAILURE(vrc))
-                LogRel(("Recording: %s failed with %Rrc\n", fEnable ? "Enabling" : "Disabling", vrc));
-        }
-        else /* Should not happen. */
-        {
-            vrc = VERR_NO_CHANGE;
-            setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Recording already %s"), fIsEnabled ? tr("enabled") : tr("disabled"));
-        }
-    }
+                LogRel(("Recording: Failed to enable with %Rrc\n", vrc));
+        }
+        else /* Disable */
+        {
+            vrc = i_recordingStop(pAutoLock);
+            if (RT_SUCCESS(vrc))
+            {
+# ifdef VBOX_WITH_AUDIO_RECORDING
+                if (mRecording.mAudioRec)
+                {
+                    vrc = mRecording.mAudioRec->doDetachDriverViaEmt(ptrVM.rawUVM(), ptrVM.vtable(), pAutoLock);
+                    if (RT_FAILURE(vrc))
+                        mRecording.mCtx.SetError(vrc, Utf8StrFmt(tr("Detaching audio recording driver failed (%Rrc) -- please consult log file for details"), vrc));
+                }
+# endif
+                i_recordingDestroy();
+            }
+        }
+    }
+    else
+        vrc = VERR_VM_INVALID_VM_STATE;
+
+    if (RT_FAILURE(vrc))
+        LogRel(("Recording: %s failed with %Rrc\n", fEnable ? "Enabling" : "Disabling", vrc));
 
     return vrc;
@@ -6181 +6174 @@
 
 /**
- * Called by IInternalSessionControl::OnRecordingChange().
- */
-HRESULT Console::i_onRecordingChange(BOOL fEnabled)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.hrc());
+ * Called by IInternalSessionControl::OnRecordingStateChange().
+ */
+HRESULT Console::i_onRecordingStateChange(BOOL aEnable, ComPtr<IProgress> &aProgress)
+{
+#ifdef VBOX_WITH_RECORDING
+    HRESULT hrc = S_OK;
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    HRESULT hrc = S_OK;
-#ifdef VBOX_WITH_RECORDING
+    LogRel2(("Recording: State changed (%s)\n", aEnable ? "enabled" : "disabled"));
+
     /* Don't trigger recording changes if the VM isn't running. */
     SafeVMPtrQuiet ptrVM(this);
     if (ptrVM.isOk())
     {
-        LogFlowThisFunc(("fEnabled=%RTbool\n", RT_BOOL(fEnabled)));
-
-        int vrc = i_recordingEnable(fEnabled, &alock);
-        if (RT_SUCCESS(vrc))
-        {
-            alock.release();
-            ::FireRecordingChangedEvent(mEventSource);
-        }
-        else /* Error set via ErrorInfo within i_recordingEnable() already. */
-            hrc = VBOX_E_IPRT_ERROR;
+        ComPtr<IVirtualBoxErrorInfo> pErrorInfo;
+
+        int vrc = i_recordingEnable(aEnable, &alock, aProgress);
+        if (RT_FAILURE(vrc))
+        {
+            /* If available, get the error information from the progress object and fire it via the event below. */
+            if (aProgress.isNotNull())
+            {
+                hrc = aProgress->COMGETTER(ErrorInfo(pErrorInfo.asOutParam()));
+                AssertComRCReturn(hrc, hrc);
+            }
+        }
+
+        alock.release(); /* Release lock before firing event. */
+
+        if (vrc != VINF_NO_CHANGE)
+            ::FireRecordingStateChangedEvent(mEventSource, aEnable, pErrorInfo);
+
+        if (RT_FAILURE(vrc))
+            hrc = VBOX_E_RECORDING_ERROR;
+
         ptrVM.release();
     }
+
+    return hrc;
 #else
-    RT_NOREF(fEnabled);
+    RT_NOREF(aEnabled, aProgress);
+    ReturnComNotImplemented();
 #endif /* VBOX_WITH_RECORDING */
-    return hrc;
+}
+
+/**
+ * Called by IInternalSessionControl::OnRecordingScreenStateChange().
+ */
+HRESULT Console::i_onRecordingScreenStateChange(BOOL aEnable, ULONG aScreen)
+{
+    RT_NOREF(aEnable, aScreen);
+    ReturnComNotImplemented();
 }
 
@@ -7604 +7619 @@
  * @returns VBox status code.
  */
-int Console::i_recordingCreate(void)
+int Console::i_recordingCreate(ComPtr<IProgress> &pProgress)
 {
     settings::RecordingSettings recordingSettings;
     int vrc = i_recordingGetSettings(recordingSettings);
     if (RT_SUCCESS(vrc))
-    {
-        vrc = mRecording.mCtx.Create(this, recordingSettings);
-        if (RT_SUCCESS(vrc))
-        {
-            RecordingContext::CALLBACKS Callbacks;
-            RT_ZERO(Callbacks);
-            Callbacks.pfnStateChanged = Console::s_recordingOnStateChangedCallback;
-
-            mRecording.mCtx.SetCallbacks(&Callbacks, this /* pvUser */);
-        }
-    }
+        vrc = mRecording.mCtx.Create(this, recordingSettings, pProgress);
+
+    if (RT_FAILURE(vrc))
+        setErrorBoth(VBOX_E_RECORDING_ERROR, vrc, tr("Recording initialization failed (%Rrc) -- please consult log file for details"), vrc);
 
     LogFlowFuncLeaveRC(vrc);
@@ -7633 +7641 @@
 }
 
-/** @copydoc RecordingContext::CALLBACKS::pfnStateChanged */
-DECLCALLBACK(void) Console::s_recordingOnStateChangedCallback(RecordingContext *pCtx,
-                                                              RECORDINGSTS enmSts, uint32_t uScreen, int vrc, void *pvUser)
-{
-    RT_NOREF(pCtx, vrc);
-
-    Console *pThis = (Console *)pvUser;
-    AssertPtrReturnVoid(pThis);
-
-    switch (enmSts)
-    {
-        case RECORDINGSTS_LIMIT_REACHED:
-        {
-            if (uScreen == UINT32_MAX) /* Limit for all screens reached? Disable recording. */
-                pThis->i_onRecordingChange(FALSE /* Disable */);
-            break;
-        }
-
-        default:
-            break;
-    }
-}
-
 /**
  * Starts recording. Does nothing if recording is already started.
@@ -7667 +7652 @@
     if (mRecording.mCtx.IsStarted())
         return VINF_SUCCESS;
-
-    LogRel(("Recording: Starting ...\n"));
 
     int vrc = mRecording.mCtx.Start();
@@ -7674 +7657 @@
         vrc = mDisplay->i_recordingStart();
 
+    if (RT_FAILURE(vrc))
+        mRecording.mCtx.SetError(vrc, Utf8StrFmt(tr("Recording start failed (%Rrc)"), vrc).c_str());
+
     LogFlowFuncLeaveRC(vrc);
     return vrc;
@@ -7688 +7674 @@
     if (!mRecording.mCtx.IsStarted())
         return VINF_SUCCESS;
-
-    LogRel(("Recording: Stopping ...\n"));
 
     int vrc = mRecording.mCtx.Stop();
     if (RT_SUCCESS(vrc))
         vrc = mDisplay->i_recordingStop();
+
+    if (RT_FAILURE(vrc))
+        setErrorBoth(VBOX_E_RECORDING_ERROR, vrc, tr("Recording stop failed (%Rrc)"), vrc);
 
     LogFlowFuncLeaveRC(vrc);
@@ -11394 +11381 @@
                 pConsole->i_consoleVRDPServer()->EnableConnections();
 
+                /* Release the lock before a lengthy operation. */
+                alock.release();
+
 #ifdef VBOX_WITH_RECORDING
                 /*
-                 * Enable recording if configured.
+                 * Start recording if configured.
                  */
+                ComPtr<IRecordingSettings> pRecordingSettings;
+                hrc = pConsole->mMachine->COMGETTER(RecordingSettings)(pRecordingSettings.asOutParam());
+                AssertComRCBreak(hrc, RT_NOTHING);
+
                 BOOL fRecordingEnabled = FALSE;
-                {
-                    ComPtr<IRecordingSettings> ptrRecordingSettings;
-                    hrc = pConsole->mMachine->COMGETTER(RecordingSettings)(ptrRecordingSettings.asOutParam());
-                    AssertComRCBreak(hrc, RT_NOTHING);
-
-                    hrc = ptrRecordingSettings->COMGETTER(Enabled)(&fRecordingEnabled);
-                    AssertComRCBreak(hrc, RT_NOTHING);
-                }
+                hrc = pRecordingSettings->COMGETTER(Enabled)(&fRecordingEnabled);
+                AssertComRCBreak(hrc, RT_NOTHING);
+
                 if (fRecordingEnabled)
                 {
-                    vrc = pConsole->i_recordingEnable(fRecordingEnabled, &alock);
-                    if (RT_SUCCESS(vrc))
-                        ::FireRecordingChangedEvent(pConsole->mEventSource);
-                    else
+                    ComPtr<IProgress> pProgress;
+                    hrc = pRecordingSettings->Start(pProgress.asOutParam());
+                    if (FAILED(hrc))
                     {
-                        LogRel(("Recording: Failed with %Rrc on VM power up\n", vrc));
-                        vrc = VINF_SUCCESS; /* do not fail with broken recording */
+                        com::ErrorInfoKeeper eik;
+                        ComPtr<IVirtualBoxErrorInfo> pErrorInfo = eik.takeError();
+                        Bstr strMsg;
+                        hrc = pErrorInfo->COMGETTER(Text)(strMsg.asOutParam());
+                        AssertComRCBreak(hrc, RT_NOTHING);
+                        LONG lRc;
+                        hrc = pErrorInfo->COMGETTER(ResultCode)(&lRc);
+                        AssertComRCBreak(hrc, RT_NOTHING);
+
+                        LogRel(("Recording: Failed to start on VM power up: %ls (%Rrc)\n",
+                                strMsg.raw(), lRc));
                     }
                 }
 #endif
-
-                /* release the lock before a lengthy operation */
-                alock.release();
-
                 /*
                  * Capture USB devices.

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

@@ -50 +50 @@
 #include <iprt/time.h>
 
+#include <iprt/cpp/utils.h>
+
 #include <VBox/err.h>
 #include <VBox/com/VirtualBox.h>
@@ -59 +61 @@
 #include "RecordingUtils.h"
 #include "WebMWriter.h"
+#include "VirtualBoxErrorInfoImpl.h"
 
 using namespace com;
@@ -188 +191 @@
 }
 
-/**
- * Recording context constructor.
- *
- * @param   ptrConsole          Pointer to console object this context is bound to (weak pointer).
- * @param   Settings            Reference to recording settings to use for creation.
- *
- * @note    Will throw vrc when unable to create.
- */
-RecordingContext::RecordingContext(Console *ptrConsole, const settings::RecordingSettings &Settings)
-    : m_pConsole(NULL)
-    , m_enmState(RECORDINGSTS_UNINITIALIZED)
-    , m_cStreamsEnabled(0)
-{
-    int vrc = RTCritSectInit(&m_CritSect);
-    if (RT_FAILURE(vrc))
-        throw vrc;
-
-    vrc = RecordingContext::createInternal(ptrConsole, Settings);
-    if (RT_FAILURE(vrc))
-        throw vrc;
-}
-
 RecordingContext::~RecordingContext(void)
 {
@@ -219 +200 @@
 
 /**
+ * Returns whether the recording progress object has been canceled or not.
+ *
+ * @returns \c true if canceled, or \c false if not.
+ */
+bool RecordingContext::progressIsCanceled(void) const
+{
+    if (m_pProgress.isNull())
+        return true;
+
+    BOOL fCanceled;
+    HRESULT const hrc = m_pProgress->COMGETTER(Canceled(&fCanceled));
+    AssertComRC(hrc);
+    return RT_BOOL(fCanceled);
+}
+
+/**
+ * Returns whether the recording progress object has been completed or not.
+ *
+ * @returns \c true if completed, or \c false if not.
+ */
+bool RecordingContext::progressIsCompleted(void) const
+{
+    if (m_pProgress.isNull())
+        return true;
+
+    BOOL fCompleted;
+    HRESULT const hrc = m_pProgress->COMGETTER(Completed(&fCompleted));
+    AssertComRC(hrc);
+    return RT_BOOL(fCompleted);
+}
+
+/**
+ * Creates a progress object based on the given recording settings.
+ *
+ * @returns VBox status code.
+ * @param   Settings            Recording settings to use for creation.
+ * @param   pProgress           Where to return the created progress object on success.
+ */
+int RecordingContext::progressCreate(const settings::RecordingSettings &Settings, ComObjPtr<Progress> &pProgress)
+{
+    /* Determine the number of operations the recording progress has.
+     * We use the maximum time (in s) of each screen as the overall progress indicator.
+     * If one screen is configured to be recorded indefinitely (until manually stopped),
+     * the operation count gets reset to 1. */
+    ULONG cOperations;
+    settings::RecordingScreenSettingsMap::const_iterator itScreen = Settings.mapScreens.begin();
+    while (itScreen != Settings.mapScreens.end())
+    {
+        settings::RecordingScreenSettings const &screenSettings = itScreen->second;
+        if (screenSettings.ulMaxTimeS == 0)
+        {
+            cOperations = 1; /* Screen will be recorded indefinitely, reset operation count and bail out.  */
+            break;
+        }
+        else
+            cOperations = RT_MAX(cOperations, screenSettings.ulMaxTimeS);
+        ++itScreen;
+    }
+
+    HRESULT hrc = pProgress.createObject();
+    if (SUCCEEDED(hrc))
+    {
+        hrc = pProgress->init(m_pConsole, Utf8Str("Recording"),
+                              TRUE /* aCancelable */, cOperations, cOperations /* ulTotalOperationsWeight */,
+                              Utf8Str("Starting"), 1 /* ulFirstOperationWeight */);
+        if (SUCCEEDED(hrc))
+            pProgress->i_setCancelCallback(RecordingContext::s_progressCancelCallback, this /* pvUser */);
+    }
+
+    return SUCCEEDED(hrc) ? VINF_SUCCESS : VERR_COM_UNEXPECTED;
+}
+
+/**
+ * Sets the current progress based on the operation.
+ *
+ * @returns VBox status code.
+ * @param   uOp                 Operation index to set (zero-based).
+ * @param   strDesc             Description of the operation.
+ */
+int RecordingContext::progressSet(uint32_t uOp, const Bstr &strDesc)
+{
+    if (m_pProgress.isNull())
+        return VINF_SUCCESS;
+
+    if (   uOp     == m_ulCurOp /* No change? */
+        || uOp + 1  > m_cOps    /* Done? */
+        || m_cOps == 1)         /* Indefinitely recording until canceled? Skip. */
+        return VINF_SUCCESS;
+
+    Assert(uOp > m_ulCurOp);
+
+    ComPtr<IInternalProgressControl> pProgressControl(m_pProgress);
+    AssertReturn(!!pProgressControl, VERR_COM_UNEXPECTED);
+
+    /* hrc ignored */ pProgressControl->SetNextOperation(strDesc.raw(), 1 /* Weight */);
+    /* Might be E_FAIL if already canceled. */
+
+    m_ulCurOp = uOp;
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Sets the current progress based on a timestamp (PTS).
+ *
+ * @returns VBox status code.
+ * @param   msTimestamp         Timestamp to use (absolute, PTS).
+ */
+int RecordingContext::progressSet(uint64_t msTimestamp)
+{
+    /* Run until stopped / canceled? */
+    if (m_cOps == 1)
+        return VINF_SUCCESS;
+
+    ULONG const nextOp = (ULONG)msTimestamp / RT_MS_1SEC; /* Each operation equals 1s (same weight). */
+    if (nextOp <= m_ulCurOp) /* If next operation still is the current operation, bail out early. */
+        return VINF_SUCCESS;
+
+    /* Format the recording time as a human-readable time (HH:MM:SS) and set it as current progress operation text. */
+    char  szDesc[32];
+    szDesc[0] = '\0';
+    char *psz = szDesc;
+    RTTIMESPEC TimeSpec;
+    RTTIME Time;
+    RTTimeExplode(&Time, RTTimeSpecSetMilli(&TimeSpec, msTimestamp));
+    psz += RTStrFormatNumber(psz, Time.u8Hour,   10, 2, 0, RTSTR_F_ZEROPAD);
+    *psz++ = ':';
+    psz += RTStrFormatNumber(psz, Time.u8Minute, 10, 2, 0, RTSTR_F_ZEROPAD);
+    *psz++ = ':';
+    psz += RTStrFormatNumber(psz, Time.u8Second, 10, 2, 0, RTSTR_F_ZEROPAD);
+
+    /* All operations have the same weight. */
+    uint8_t const uPercent = (100 * nextOp + m_cOps / 2) / m_cOps;
+
+    LogRel2(("Recording: Progress %s (%RU32 / %RU32) -- %RU8%%\n", szDesc, nextOp, m_cOps, uPercent));
+
+    psz += RTStrPrintf2(psz, psz - szDesc, " (%RU8%%)", uPercent);
+
+    return progressSet(nextOp, Bstr(szDesc));
+}
+
+/**
+ * Notifies the progress object about completion.
+ *
+ * @returns VBox status code.
+ * @param   hrc                 Completion result to set.
+ * @param   pErrorInfo          Error info to set in case \a hrc indicates an error. Optional and can be NULL.
+ */
+int RecordingContext::progressNotifyComplete(HRESULT hrc /* = S_OK */, IVirtualBoxErrorInfo *pErrorInfo /* = NULL */)
+{
+    if (m_pProgress.isNull())
+        return VINF_SUCCESS;
+
+    BOOL fCompleted;
+    HRESULT hrc2 = m_pProgress->COMGETTER(Completed)(&fCompleted);
+    AssertComRC(hrc2);
+
+    if (!fCompleted)
+    {
+        ComPtr<IInternalProgressControl> pProgressControl(m_pProgress);
+        AssertReturn(!!pProgressControl, VERR_COM_UNEXPECTED);
+
+        pProgressControl->NotifyComplete(hrc, pErrorInfo);
+    }
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Reports an error condition to the recording context.
+ *
+ * @returns VBox status code.
+ * @param   rc                  Error code to set.
+ * @param   strText             Error description to set.
+ */
+int RecordingContext::SetError(int rc, const com::Utf8Str &strText)
+{
+    lock();
+
+    if (   m_pProgress.isNull()
+        || !m_pConsole)
+    {
+        unlock();
+        return VINF_SUCCESS;
+    }
+
+    ComObjPtr<VirtualBoxErrorInfo> pErrorInfo;
+    HRESULT hrc = pErrorInfo.createObject();
+    AssertComRC(hrc);
+    hrc = pErrorInfo->initEx(VBOX_E_RECORDING_ERROR, (LONG)rc,
+                             m_pConsole->getStaticClassIID(), m_pConsole->getStaticComponentName(), strText);
+    AssertComRC(hrc);
+
+    unlock();
+
+    LogRel(("Recording: An error occurred: %s (%Rrc)\n", strText.c_str(), rc));
+
+    hrc = m_pProgress->NotifyComplete(VBOX_E_RECORDING_ERROR, pErrorInfo);
+    AssertComRC(hrc);
+
+    return VINF_SUCCESS;
+}
+
+/**
  * Worker thread for all streams of a recording context.
- *
- * For video frames, this also does the RGB/YUV conversion and encoding.
  */
 DECLCALLBACK(int) RecordingContext::threadMain(RTTHREAD hThreadSelf, void *pvUser)
@@ -236 +419 @@
         int vrcWait = RTSemEventWait(pThis->m_WaitEvent, RT_MS_1SEC);
 
+        if (ASMAtomicReadBool(&pThis->m_fShutdown))
+        {
+            LogRel2(("Recording: Thread is shutting down ...\n"));
+            break;
+        }
+
         Log2Func(("Processing %zu streams (wait = %Rrc)\n", pThis->m_vecStreams.size(), vrcWait));
 
+        uint64_t const msTimestamp = pThis->GetCurrentPTS();
+
+        /* Set the overall progress. */
+        int vrc = pThis->progressSet(msTimestamp);
+        AssertRC(vrc);
+
         /* Process common raw blocks (data which not has been encoded yet). */
-        int vrc = pThis->processCommonData(pThis->m_mapBlocksRaw, 100 /* ms timeout */);
+        vrc = pThis->processCommonData(pThis->m_mapBlocksRaw, 100 /* ms timeout */);
 
         /** @todo r=andy This is inefficient -- as we already wake up this thread
@@ -250 +445 @@
 
             /* Hand-in common encoded blocks. */
-            vrc = pStream->ThreadMain(vrcWait, pThis->m_mapBlocksEncoded);
+            vrc = pStream->ThreadMain(vrcWait, msTimestamp, pThis->m_mapBlocksEncoded);
             if (RT_FAILURE(vrc))
             {
@@ -264 +459 @@
 
         /* Keep going in case of errors. */
-
-        if (ASMAtomicReadBool(&pThis->m_fShutdown))
-        {
-            LogFunc(("Thread is shutting down ...\n"));
-            break;
-        }
 
     } /* for */
@@ -468 +657 @@
  */
 /* static */
-DECLCALLBACK(int) RecordingContext::audioCodecWriteDataCallback(PRECORDINGCODEC pCodec, const void *pvData, size_t cbData,
+DECLCALLBACK(int) RecordingContext::s_audioCodecWriteDataCallback(PRECORDINGCODEC pCodec, const void *pvData, size_t cbData,
                                                                 uint64_t msAbsPTS, uint32_t uFlags, void *pvUser)
 {
@@ -493 +682 @@
     RECORDINGCODECCALLBACKS Callbacks;
     Callbacks.pvUser       = this;
-    Callbacks.pfnWriteData = RecordingContext::audioCodecWriteDataCallback;
+    Callbacks.pfnWriteData = RecordingContext::s_audioCodecWriteDataCallback;
 
     int vrc = recordingCodecCreateAudio(&m_CodecAudio, enmCodec);
@@ -504 +693 @@
 
 /**
+ * Progress canceled callback.
+ *
+ * @param   pvUser              User-supplied pointer. Points to the RecordingContext instance.
+ */
+/* static */
+DECLCALLBACK(void) RecordingContext::s_progressCancelCallback(void *pvUser)
+{
+    RecordingContext *pThis = (RecordingContext *)pvUser;
+
+    LogRel(("Recording: Canceled\n"));
+
+    if (pThis->m_pConsole)
+    {
+        ComPtr<IProgress> pProgressIgnored;
+        pThis->m_pConsole->i_onRecordingStateChange(FALSE /* Disable */, pProgressIgnored);
+    }
+}
+
+/** @copydoc RecordingContext::CALLBACKS::pfnStateChanged */
+DECLCALLBACK(void) RecordingContext::s_recordingStateChangedCallback(RecordingContext *pCtx,
+                                                                     RECORDINGSTS enmSts, uint32_t uScreen, int vrc, void *pvUser)
+{
+    RT_NOREF(vrc, pvUser);
+
+    Log2Func(("enmSts=%0x, uScreen=%RU32, vrc=%Rrc\n", enmSts, uScreen, vrc));
+
+    switch (enmSts)
+    {
+        case RECORDINGSTS_LIMIT_REACHED:
+        {
+            if (uScreen == UINT32_MAX) /* Limit for all screens reached? Disable recording. */
+            {
+                ComPtr<IProgress> pProgressIgnored;
+                pCtx->m_pConsole->i_onRecordingStateChange(FALSE /* Disable */, pProgressIgnored);
+
+                pCtx->lock();
+
+                /* Make sure to complete the progress object (if not already done so). */
+                pCtx->progressNotifyComplete(S_OK);
+
+                pCtx->unlock();
+            }
+            else if (pCtx->m_pConsole)
+                pCtx->m_pConsole->i_onRecordingScreenStateChange(FALSE /* Disable */, uScreen);
+            break;
+        }
+
+        default:
+            break;
+    }
+}
+
+/**
  * Creates a recording context.
  *
@@ -509 +751 @@
  * @param   ptrConsole          Pointer to console object this context is bound to (weak pointer).
  * @param   Settings            Reference to recording settings to use for creation.
- */
-int RecordingContext::createInternal(Console *ptrConsole, const settings::RecordingSettings &Settings)
-{
-    int vrc = VINF_SUCCESS;
-
+ * @param   pProgress           Progress object returned on success.
+ */
+int RecordingContext::createInternal(Console *ptrConsole, const settings::RecordingSettings &Settings,
+                                     ComPtr<IProgress> &pProgress)
+{
     /* Copy the settings to our context. */
     m_Settings = Settings;
@@ -524 +766 @@
     settings::RecordingScreenSettings const &screen0Settings = itScreen0->second;
 
-    vrc = this->audioInit(screen0Settings);
+    int vrc = this->audioInit(screen0Settings);
     if (RT_FAILURE(vrc))
         return vrc;
@@ -560 +802 @@
     }
 
+    ComObjPtr<Progress> pThisProgress;
+    vrc = progressCreate(m_Settings, pThisProgress);
     if (RT_SUCCESS(vrc))
     {
-        m_tsStartMs = 0;
-        m_enmState  = RECORDINGSTS_CREATED;
-        m_fShutdown = false;
-
         vrc = RTSemEventCreate(&m_WaitEvent);
         AssertRCReturn(vrc, vrc);
 
-        RT_ZERO(m_Callbacks);
+        RecordingContext::CALLBACKS Callbacks;
+        RT_ZERO(Callbacks);
+        Callbacks.pfnStateChanged = RecordingContext::s_recordingStateChangedCallback;
+
+        SetCallbacks(&Callbacks, this /* pvUser */);
+
+        reset();
+
+        unconst(m_pProgress) = pThisProgress;
+        pThisProgress.queryInterfaceTo(pProgress.asOutParam());
     }
 
@@ -595 +844 @@
 
 /**
+ * Resets a recording context.
+ */
+void RecordingContext::reset(void)
+{
+    m_tsStartMs       = 0;
+    m_enmState        = RECORDINGSTS_CREATED;
+    m_fShutdown       = false;
+    m_cStreamsEnabled = 0;
+
+    unconst(m_pProgress).setNull();
+}
+
+/**
  * Starts a recording context by creating its worker thread.
  *
@@ -606 +868 @@
     Assert(m_enmState == RECORDINGSTS_CREATED);
 
+    LogRel2(("Recording: Starting ...\n"));
+
     m_tsStartMs = RTTimeMilliTS();
+
+    m_ulCurOp = 0;
+    if (m_pProgress.isNotNull())
+    {
+        HRESULT hrc = m_pProgress->COMGETTER(OperationCount)(&m_cOps);
+        AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
+    }
 
     int vrc = RTThreadCreate(&m_Thread, RecordingContext::threadMain, (void *)this, 0,
@@ -620 +891 @@
     }
     else
-        Log(("Recording: Failed to start (%Rrc)\n", vrc));
+        LogRel(("Recording: Failed to start (%Rrc)\n", vrc));
 
     return vrc;
@@ -635 +906 @@
         return VINF_SUCCESS;
 
-    LogThisFunc(("Shutting down thread ...\n"));
+    LogRel2(("Recording: Stopping ...\n"));
 
     /* Set shutdown indicator. */
@@ -649 +920 @@
     if (RT_SUCCESS(vrc))
     {
+        if (m_pProgress.isNotNull())
+            progressNotifyComplete();
+
         LogRel(("Recording: Stopped\n"));
-        m_tsStartMs = 0;
-        m_enmState  = RECORDINGSTS_CREATED;
+
+        reset();
     }
     else
-        Log(("Recording: Failed to stop (%Rrc)\n", vrc));
+        LogRel(("Recording: Failed to stop (%Rrc)\n", vrc));
 
     unlock();
@@ -705 +979 @@
     m_enmState = RECORDINGSTS_UNINITIALIZED;
 
+    unconst(m_pProgress).setNull();
+
     unlock();
 }
@@ -791 +1067 @@
  * @param   ptrConsole          Pointer to console object this context is bound to (weak pointer).
  * @param   Settings            Reference to recording settings to use for creation.
- */
-int RecordingContext::Create(Console *ptrConsole, const settings::RecordingSettings &Settings)
-{
-    return createInternal(ptrConsole, Settings);
+ * @param   pProgress           Progress object returned on success.
+ */
+int RecordingContext::Create(Console *ptrConsole, const settings::RecordingSettings &Settings, ComPtr<IProgress> &pProgress)
+{
+    return createInternal(ptrConsole, Settings, pProgress);
 }
 
@@ -1012 +1289 @@
 int RecordingContext::onLimitReached(uint32_t uScreen, int vrc)
 {
-    LogFlowThisFunc(("Stream %RU32 has reached its limit (%Rrc)\n", uScreen, vrc));
-
-    lock();
-
-    Assert(m_cStreamsEnabled);
+    lock();
+
+    LogRel2(("Recording: Active streams: %RU16\n", m_cStreamsEnabled));
+
     if (m_cStreamsEnabled)
         m_cStreamsEnabled--;
@@ -1022 +1298 @@
     bool const fAllDisabled = m_cStreamsEnabled == 0;
 
-    LogFlowThisFunc(("cStreamsEnabled=%RU16\n", m_cStreamsEnabled));
+    if (fAllDisabled)
+        LogRel(("Recording: All set limits have been reached\n"));
+    else
+        LogRel(("Recording: Set limit for screen #%RU32 has been reached\n", uScreen));
 
     unlock(); /* Leave the lock before invoking callbacks. */
@@ -1176 +1455 @@
             vrc = vrc2;
 
+        /* Bail out as soon as possible when the shutdown flag is set. */
+        if (ASMAtomicReadBool(&m_fShutdown))
+            break;
+
         ++it;
     }

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

@@ -402 +402 @@
  *                              Can be used for figuring out if the encoder has to perform some
  *                              worked based on that result.
+ * @param   msTimestamp         Timestamp to use for PTS calculation (absolute).
  * @param   commonBlocks        Common blocks multiplexed to all recording streams.
  *
  * @note    Runs in encoding thread.
  */
-int RecordingStream::ThreadMain(int rcWait, RecordingBlockMap &commonBlocks)
-{
-    Log3Func(("uScreenID=%RU16, rcWait=%Rrc\n", m_uScreenID, rcWait));
-
-    uint64_t const msTimestamp = m_pCtx->GetCurrentPTS();
+int RecordingStream::ThreadMain(int rcWait, uint64_t msTimestamp, RecordingBlockMap &commonBlocks)
+{
+    Log3Func(("uScreenID=%RU16, msTimestamp=%RU64, rcWait=%Rrc\n", m_uScreenID, msTimestamp, rcWait));
 
     /* No new data arrived within time? Feed the encoder with the last frame we built.

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

@@ -773 +773 @@
 }
 
-HRESULT Session::onRecordingChange(BOOL aEnable)
-{
-    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_onRecordingChange(aEnable);
+HRESULT Session::onRecordingStateChange(BOOL aEnable, ComPtr<IProgress> &aProgress)
+{
+    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_onRecordingStateChange(aEnable, aProgress);
+#else
+    RT_NOREF(aEnable);
+    return S_OK;
+#endif
+}
+
+HRESULT Session::onRecordingScreenStateChange(BOOL aEnable, ULONG aScreen)
+{
+    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_onRecordingScreenStateChange(aEnable, aScreen);
 #else
     RT_NOREF(aEnable);