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

Timestamp:

Nov 15, 2018 4:12:07 PM (6 years ago)

Author:

vboxsync

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

126645

Message:

Recording/Main: Implemented better support for recording limits (also now configurable per screen).

Location:

trunk/src/VBox/Main/src-client

Files:

• ConsoleImpl.cpp (modified) (8 diffs)
• DisplayImpl.cpp (modified) (2 diffs)
• Recording.cpp (modified) (8 diffs)
• RecordingStream.cpp (modified) (7 diffs)
• SessionImpl.cpp (modified) (1 diff)

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

@@ -5641 +5641 @@
             LogRel(("Recording: %s\n", fEnable ? "Enabling" : "Disabling"));
 
-            pDisplay->i_recordingInvalidate();
-
             if (fEnable)
             {
@@ -5661 +5659 @@
                         && Recording.mpCtx->IsReady()) /* Any video recording (audio and/or video) feature enabled? */
                     {
-                        vrc = i_recordingStart();
+                        vrc = pDisplay->i_recordingInvalidate();
+                        if (RT_SUCCESS(vrc))
+                            vrc = i_recordingStart(pAutoLock);
                     }
                 }
+
+                if (RT_FAILURE(vrc))
+                    LogRel(("Recording: Failed to enable with %Rrc\n", vrc));
             }
             else
             {
-                i_recordingStop();
+                i_recordingStop(pAutoLock);
 # ifdef VBOX_WITH_AUDIO_RECORDING
-                Recording.mAudioRec->doDetachDriverViaEmt(mpUVM, pAutoLock);
+                if (Recording.mAudioRec)
+                    Recording.mAudioRec->doDetachDriverViaEmt(mpUVM, pAutoLock);
 # endif
                 i_recordingDestroy();
@@ -5685 +5689 @@
 #endif /* VBOX_WITH_RECORDING */
 
-HRESULT Console::i_onRecordingChange()
+/**
+ * Called by IInternalSessionControl::OnRecordingChange().
+ */
+HRESULT Console::i_onRecordingChange(BOOL fEnabled)
 {
     AutoCaller autoCaller(this);
@@ -5698 +5705 @@
     if (ptrVM.isOk())
     {
-        ComPtr<IRecordingSettings> recordingSettings;
-        rc = mMachine->COMGETTER(RecordingSettings)(recordingSettings.asOutParam());
-        AssertComRCReturnRC(rc);
-
-        BOOL fEnabled;
-        rc = recordingSettings->COMGETTER(Enabled)(&fEnabled);
-        AssertComRCReturnRC(rc);
+        LogFlowThisFunc(("fEnabled=%RTbool\n", RT_BOOL(fEnabled)));
 
         int vrc = i_recordingEnable(fEnabled, &alock);
@@ -6974 +6975 @@
     AssertReturn(Recording.mpCtx == NULL, VERR_WRONG_ORDER);
 
-    int rc = VINF_SUCCESS;
-
-    try
-    {
-        Recording.mpCtx = new RecordingContext(this);
-    }
-    catch (std::bad_alloc &)
-    {
-        return VERR_NO_MEMORY;
-    }
-    catch (int &rc2)
-    {
-        return rc2;
-    }
-
-    settings::RecordingSettings Settings;
-    rc = i_recordingGetSettings(Settings);
+    settings::RecordingSettings recordingSettings;
+    int rc = i_recordingGetSettings(recordingSettings);
     if (RT_SUCCESS(rc))
     {
-        AssertPtr(Recording.mpCtx);
-        rc = Recording.mpCtx->Create(Settings);
+        try
+        {
+            Recording.mpCtx = new RecordingContext(this /* pConsole */, recordingSettings);
+        }
+        catch (std::bad_alloc &)
+        {
+            return VERR_NO_MEMORY;
+        }
+        catch (int &rc2)
+        {
+            return rc2;
+        }
     }
 
@@ -7020 +7016 @@
  * @returns IPRT status code.
  */
-int Console::i_recordingStart(void)
-{
+int Console::i_recordingStart(util::AutoWriteLock *pAutoLock /* = NULL */)
+{
+    RT_NOREF(pAutoLock);
     AssertPtrReturn(Recording.mpCtx, VERR_WRONG_ORDER);
 
@@ -7043 +7040 @@
  * Stops recording. Does nothing if recording is not active.
  */
-int Console::i_recordingStop(void)
+int Console::i_recordingStop(util::AutoWriteLock *pAutoLock /* = NULL */)
 {
     if (   !Recording.mpCtx
@@ -7058 +7055 @@
             mDisplay->i_recordingScreenChanged(uScreen);
 
+        if (pAutoLock)
+            pAutoLock->release();
+
         ComPtr<IRecordingSettings> pRecordSettings;
         HRESULT hrc = mMachine->COMGETTER(RecordingSettings)(pRecordSettings.asOutParam());
         ComAssertComRC(hrc);
-        hrc = pRecordSettings->COMSETTER(Enabled)(false);
+        hrc = pRecordSettings->COMSETTER(Enabled)(FALSE);
         ComAssertComRC(hrc);
+
+        if (pAutoLock)
+            pAutoLock->acquire();
     }
 

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

@@ -3432 +3432 @@
 # endif /* VBOX_WITH_HGCM && VBOX_WITH_CROGL */
 
+            /* If the recording context has reached the configured recording
+             * limit, disable recording. */
+            if (pCtx->IsLimitReached())
+            {
+                pDisplay->mParent->i_onRecordingChange(FALSE /* Disable */);
+                break;
+            }
+
             uint64_t tsNowMs = RTTimeProgramMilliTS();
             for (uScreenId = 0; uScreenId < pDisplay->mcMonitors; uScreenId++)
@@ -3437 +3445 @@
                 if (!pDisplay->maRecordingEnabled[uScreenId])
                     continue;
-
-                if (pCtx->IsLimitReached(uScreenId, tsNowMs))
-                {
-                    pDisplay->mParent->i_recordingStop();
-                    break;
-                }
 
                 DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[uScreenId];

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

@@ -90 +90 @@
 
 
-RecordingContext::RecordingContext(Console *a_pConsole)
-    : pConsole(a_pConsole)
-    , enmState(RECORDINGSTS_UNINITIALIZED)
-    , cStreamsEnabled(0) { }
-
 RecordingContext::RecordingContext(Console *a_pConsole, const settings::RecordingSettings &a_Settings)
     : pConsole(a_pConsole)
@@ -373 +368 @@
 }
 
+int RecordingContext::lock(void)
+{
+    int rc = RTCritSectEnter(&this->CritSect);
+    AssertRC(rc);
+    return rc;
+}
+
+int RecordingContext::unlock(void)
+{
+    int rc = RTCritSectLeave(&this->CritSect);
+    AssertRC(rc);
+    return rc;
+}
+
 /**
  * Retrieves a specific recording stream of a recording context.
@@ -440 +449 @@
  * @param   enmFeature          Recording feature to check for.
  */
-bool RecordingContext::IsFeatureEnabled(RecordingFeature_T enmFeature) const
-{
+bool RecordingContext::IsFeatureEnabled(RecordingFeature_T enmFeature)
+{
+    lock();
+
     RecordingStreams::const_iterator itStream = this->vecStreams.begin();
     while (itStream != this->vecStreams.end())
     {
         if ((*itStream)->GetConfig().isFeatureEnabled(enmFeature))
+        {
+            unlock();
             return true;
+        }
         ++itStream;
     }
+
+    unlock();
 
     return false;
@@ -470 +486 @@
  * @param   uTimeStampMs        Current time stamp (in ms). Currently not being used.
  */
-bool RecordingContext::IsReady(uint32_t uScreen, uint64_t uTimeStampMs) const
+bool RecordingContext::IsReady(uint32_t uScreen, uint64_t uTimeStampMs)
 {
     RT_NOREF(uTimeStampMs);
 
+    lock();
+
+    bool fIsReady = false;
+
     if (this->enmState != RECORDINGSTS_STARTED)
-        return false;
-
-    bool fIsReady = false;
-
-    const RecordingStream *pStream = GetStream(uScreen);
-    if (pStream)
-        fIsReady = pStream->IsReady();
-
-    /* Note: Do not check for other constraints like the video FPS rate here,
-     *       as this check then also would affect other (non-FPS related) stuff
-     *       like audio data. */
+    {
+        const RecordingStream *pStream = GetStream(uScreen);
+        if (pStream)
+            fIsReady = pStream->IsReady();
+
+        /* Note: Do not check for other constraints like the video FPS rate here,
+         *       as this check then also would affect other (non-FPS related) stuff
+         *       like audio data. */
+    }
+
+    unlock();
 
     return fIsReady;
@@ -495 +515 @@
  * @returns true if active, false if not.
  */
-bool RecordingContext::IsStarted(void) const
-{
-    return (this->enmState == RECORDINGSTS_STARTED);
+bool RecordingContext::IsStarted(void)
+{
+    lock();
+
+    const bool fIsStarted = this->enmState == RECORDINGSTS_STARTED;
+
+    unlock();
+
+    return fIsStarted;
+}
+
+/**
+ * Checks if a specified limit for recording has been reached.
+ *
+ * @returns true if any limit has been reached.
+ */
+bool RecordingContext::IsLimitReached(void)
+{
+    lock();
+
+    LogFlowThisFunc(("cStreamsEnabled=%RU16\n", this->cStreamsEnabled));
+
+    const bool fLimitReached = this->cStreamsEnabled == 0;
+
+    unlock();
+
+    return fLimitReached;
 }
 
@@ -505 +549 @@
  * @returns true if any limit has been reached.
  * @param   uScreen             Screen ID.
- * @param   tsNowMs             Current time stamp (in ms).
- */
-bool RecordingContext::IsLimitReached(uint32_t uScreen, uint64_t tsNowMs) const
-{
-    const RecordingStream *pStream = GetStream(uScreen);
+ * @param   uTimeStampMs        Timestamp (in ms) to check for.
+ */
+bool RecordingContext::IsLimitReached(uint32_t uScreen, uint64_t uTimeStampMs)
+{
+    lock();
+
+    bool fLimitReached = false;
+
+    const RecordingStream *pStream = getStreamInternal(uScreen);
     if (   !pStream
-        || pStream->IsLimitReached(tsNowMs))
-    {
-        return true;
-    }
-
-    return false;
+        || pStream->IsLimitReached(uTimeStampMs))
+    {
+        fLimitReached = true;
+    }
+
+    unlock();
+
+    return fLimitReached;
+}
+
+DECLCALLBACK(int) RecordingContext::OnLimitReached(uint32_t uScreen, int rc)
+{
+    RT_NOREF(uScreen);
+    LogFlowThisFunc(("Stream %RU32 has reached its limit (%Rrc)\n", uScreen, rc));
+
+    lock();
+
+    Assert(this->cStreamsEnabled);
+    this->cStreamsEnabled--;
+
+    LogFlowThisFunc(("cStreamsEnabled=%RU16\n", cStreamsEnabled));
+
+    unlock();
+
+    return VINF_SUCCESS;
 }
 
@@ -629 +696 @@
         AssertRC(rc);
 
+        AssertFailed();
         return VERR_NOT_FOUND;
     }
@@ -638 +706 @@
 
     if (   RT_SUCCESS(rc)
-        && rc != VINF_TRY_AGAIN) /* Only signal the thread if operation was successful. */
+        && rc != VINF_RECORDING_THROTTLED) /* Only signal the thread if operation was successful. */
     {
         threadNotify();

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

@@ -263 +263 @@
 
 /**
- * Checks if a specified limit for a recording stream has been reached.
+ * Checks if a specified limit for a recording stream has been reached, internal version.
  *
  * @returns true if any limit has been reached.
- * @param   tsNowMs             Current time stamp (in ms).
- */
-bool RecordingStream::IsLimitReached(uint64_t tsNowMs) const
-{
-    if (!IsReady())
-        return true;
+ * @param   uTimeStampMs        Timestamp (in ms) to check for.
+ */
+bool RecordingStream::isLimitReachedInternal(uint64_t uTimeStampMs) const
+{
+    LogFlowThisFunc(("uTimeStampMs=%RU64, ulMaxTimeS=%RU32, tsStartMs=%RU64\n",
+                     uTimeStampMs, this->ScreenSettings.ulMaxTimeS, this->tsStartMs));
 
     if (   this->ScreenSettings.ulMaxTimeS
-        && tsNowMs >= this->tsStartMs + (this->ScreenSettings.ulMaxTimeS * RT_MS_1SEC))
+        && uTimeStampMs >= this->tsStartMs + (this->ScreenSettings.ulMaxTimeS * RT_MS_1SEC))
     {
         LogRel(("Recording: Time limit for stream #%RU16 has been reached (%RU32s)\n",
@@ -304 +304 @@
 
     return false;
+}
+
+/**
+ * Internal iteration main loop.
+ * Does housekeeping and recording context notification.
+ *
+ * @returns IPRT status code.
+ * @param   uTimeStampMs        Current timestamp (in ms).
+ */
+int RecordingStream::iterateInternal(uint64_t uTimeStampMs)
+{
+    if (!this->fEnabled)
+        return VINF_SUCCESS;
+
+    int rc;
+
+    if (isLimitReachedInternal(uTimeStampMs))
+    {
+        rc = VINF_RECORDING_LIMIT_REACHED;
+    }
+    else
+        rc = VINF_SUCCESS;
+
+    AssertPtr(this->pCtx);
+
+    switch (rc)
+    {
+        case VINF_RECORDING_LIMIT_REACHED:
+        {
+            this->fEnabled = false;
+
+            int rc2 = this->pCtx->OnLimitReached(this->uScreenID, VINF_SUCCESS /* rc */);
+            AssertRC(rc2);
+            break;
+        }
+
+        default:
+            break;
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/**
+ * Checks if a specified limit for a recording stream has been reached.
+ *
+ * @returns true if any limit has been reached.
+ * @param   uTimeStampMs        Timestamp (in ms) to check for.
+ */
+bool RecordingStream::IsLimitReached(uint64_t uTimeStampMs) const
+{
+    if (!IsReady())
+        return true;
+
+    return isLimitReachedInternal(uTimeStampMs);
 }
 
@@ -449 +505 @@
  * Sends a raw (e.g. not yet encoded) video frame to the recording stream.
  *
- * @returns IPRT status code.
+ * @returns IPRT status code. Will return VINF_RECORDING_LIMIT_REACHED if the stream's recording
+ *          limit has been reached or VINF_RECORDING_THROTTLED if the frame is too early for the current
+ *          FPS setting.
  * @param   x                   Upper left (X) coordinate where the video frame starts.
  * @param   y                   Upper left (Y) coordinate where the video frame starts.
@@ -465 +523 @@
     lock();
 
+    LogFlowFunc(("uTimeStampMs=%RU64\n", uTimeStampMs));
+
     PRECORDINGVIDEOFRAME pFrame = NULL;
 
-    int rc = VINF_SUCCESS;
+    int rc = iterateInternal(uTimeStampMs);
+    if (rc != VINF_SUCCESS) /* Can return VINF_RECORDING_LIMIT_REACHED. */
+    {
+        unlock();
+        return rc;
+    }
 
     do
     {
-        if (!this->fEnabled)
-        {
-            rc = VINF_TRY_AGAIN; /* Not (yet) enabled. */
-            break;
-        }
-
         if (uTimeStampMs < this->Video.uLastTimeStampMs + this->Video.uDelayMs)
         {
-            rc = VINF_TRY_AGAIN; /* Respect maximum frames per second. */
+            rc = VINF_RECORDING_THROTTLED; /* Respect maximum frames per second. */
             break;
         }
@@ -710 +769 @@
         return rc;
 
-    const settings::RecordingScreenSettings *pSettings = &this->ScreenSettings;
+    settings::RecordingScreenSettings *pSettings = &this->ScreenSettings;
 
     rc = RTCritSectInit(&this->CritSect);
@@ -823 +882 @@
         this->enmState  = RECORDINGSTREAMSTATE_INITIALIZED;
         this->fEnabled  = true;
-        this->tsStartMs = RTTimeMilliTS();
+        this->tsStartMs = RTTimeProgramMilliTS();
     }
     else
@@ -846 +905 @@
     int rc = VINF_SUCCESS;
 
-    if (this->fEnabled)
-    {
-        switch (this->ScreenSettings.enmDest)
-        {
-            case RecordingDestination_File:
-            {
-                if (this->File.pWEBM)
-                    rc = this->File.pWEBM->Close();
-                break;
-            }
-
-            default:
-                AssertFailed(); /* Should never happen. */
-                break;
-        }
-
-        this->Blocks.Clear();
-
-        LogRel(("Recording: Recording screen #%u stopped\n", this->uScreenID));
-    }
+    switch (this->ScreenSettings.enmDest)
+    {
+        case RecordingDestination_File:
+        {
+            if (this->File.pWEBM)
+                rc = this->File.pWEBM->Close();
+            break;
+        }
+
+        default:
+            AssertFailed(); /* Should never happen. */
+            break;
+    }
+
+    this->Blocks.Clear();
+
+    LogRel(("Recording: Recording screen #%u stopped\n", this->uScreenID));
 
     if (RT_FAILURE(rc))

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

@@ -725 +725 @@
 }
 
-HRESULT Session::onRecordingChange()
-{
-    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();
+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);
 #else
     return S_OK;