Changeset 105095 in vbox

Timestamp:

Jul 2, 2024 10:06:48 AM (5 months ago)

Author:

vboxsync

Message:

Video Recording/Main: More optimizations for recording older guests which have a slightly different screen update logic. bugref:10650

Location:

trunk/src/VBox/Main

Files:

• include/ConsoleImpl.h (modified) (1 diff)
• include/DisplayImpl.h (modified) (3 diffs)
• include/Recording.h (modified) (5 diffs)
• include/RecordingInternals.h (modified) (2 diffs)
• include/RecordingStream.h (modified) (1 diff)
• src-client/ConsoleImpl.cpp (modified) (3 diffs)
• src-client/DisplayImpl.cpp (modified) (18 diffs)
• src-client/Recording.cpp (modified) (18 diffs)
• src-client/RecordingCodec.cpp (modified) (5 diffs)
• src-client/RecordingInternals.cpp (modified) (6 diffs)
• src-client/RecordingStream.cpp (modified) (16 diffs)
• src-client/RecordingUtils.cpp (modified) (7 diffs)

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

@@ -205 +205 @@
     int i_recordingStop(util::AutoWriteLock *pAutoLock = NULL);
     int i_recordingCursorShapeChange(bool fVisible, bool fAlpha, uint32_t xHot, uint32_t yHot, uint32_t uWidth, uint32_t uHeight, const uint8_t *pu8Shape, uint32_t cbShape);
+    static DECLCALLBACK(void) s_recordingOnStateChangedCallback(RecordingContext *pCtx, RECORDINGSTS enmSts, uint32_t uScreen, int vrc, void *pvUser);
 # ifdef VBOX_WITH_AUDIO_RECORDING
     AudioVideoRec *i_recordingGetAudioDrv(void) const { return mRecording.mAudioRec; }

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

@@ -46 +46 @@
 #ifdef VBOX_WITH_RECORDING
 # include "RecordingInternals.h"
+class RecordingContext;
 #endif
 
@@ -188 +189 @@
     int i_recordingStart(void);
     int i_recordingStop(void);
-    int i_recordingInvalidate(bool fForce = false);
+    int i_recordingInvalidate(void);
     int i_recordingScreenChanged(unsigned uScreenId, const DISPLAYFBINFO *pFBInfo);
-    int i_recordingScreenUpdate(unsigned uScreenId, PRECORDINGVIDEOFRAME pFrame);
+    int i_recordingScreenUpdate(unsigned uScreenId, uint8_t *pauFramebuffer, size_t cbFramebuffer, uint32_t x, uint32_t y, uint32_t w, uint32_t h, uint32_t uBytesPerLine);
+    int i_recordingScreenUpdate(unsigned uScreenId, uint32_t x, uint32_t y, uint32_t w, uint32_t h);
     int i_recordingCursorPositionChange(unsigned uScreenId, uint32_t fFlags, int32_t x, int32_t y);
 #endif
@@ -414 +416 @@
 
 #ifdef VBOX_WITH_RECORDING
-    /* Serializes access to video recording source bitmaps. */
-    RTCRITSECT           mVideoRecLock;
-    /** Array which defines which screens are being enabled for recording. */
-    bool                 maRecordingEnabled[SchemaDefs::MaxGuestMonitors];
+    /** Struct which holds information and state about (video) recording. */
+    struct Recording
+    {
+        Recording()
+            : pCtx(NULL) { }
+
+        /** Recording context. Constant across lifetime.
+         *  Might be NULL if not being used. */
+        RecordingContext * const pCtx;
+    } Recording;
 #endif
 
 #ifdef VBOX_WITH_STATISTICS
+    /** Struct for keeping STAM values. */
     struct
     {

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

@@ -71 +71 @@
 
 /**
+ * Enumeration for a recording context state.
+ */
+enum RECORDINGSTS
+{
+    /** Recording not initialized. */
+    RECORDINGSTS_UNINITIALIZED = 0,
+    /** Recording was created. */
+    RECORDINGSTS_CREATED       = 1,
+    /** Recording was started. */
+    RECORDINGSTS_STARTED       = 2,
+    /** Recording was stopped. */
+    RECORDINGSTS_STOPPED       = 3,
+    /** Limit has been reached. */
+    RECORDINGSTS_LIMIT_REACHED = 4,
+    /** Recording experienced an error. */
+    RECORDINGSTS_FAILURE       = 5,
+    /** The usual 32-bit hack. */
+    RECORDINGSTS_32BIT_HACK    = 0x7fffffff
+};
+
+/**
  * Class for managing a recording context.
  */
 class RecordingContext
 {
+    friend RecordingStream;
+
+public:
+
+    /** Recording context callback table. */
+    struct CALLBACKS
+    {
+       /**
+        * Recording state got changed. Optional.
+        *
+        * @param   pCtx                 Recording context.
+        * @param   enmSts               New status.
+        * @param   uScreen              Screen ID.
+        *                               Set to UINT32_MAX if the limit of all streams was reached.
+        * @param   vrc                  Result code of state change.
+        * @param   pvUser               User-supplied pointer. Might be NULL.
+        */
+        DECLCALLBACKMEMBER(void, pfnStateChanged, (RecordingContext *pCtx, RECORDINGSTS enmSts, uint32_t uScreen, int vrc, void *pvUser));
+
+        /** User-supplied pointer. Might be NULL. */
+        void *pvUser;
+    };
+
 public:
 
@@ -108 +152 @@
     uint64_t GetCurrentPTS(void) const;
     bool IsFeatureEnabled(RecordingFeature_T enmFeature);
+    bool IsFeatureEnabled(uint32_t uScreen, RecordingFeature_T enmFeature);
     bool IsReady(void);
-    bool IsReady(uint32_t uScreen, uint64_t msTimestamp);
     bool IsStarted(void);
     bool IsLimitReached(void);
     bool IsLimitReached(uint32_t uScreen, uint64_t msTimestamp);
     bool NeedsUpdate(uint32_t uScreen, uint64_t msTimestamp);
-
-    DECLCALLBACK(int) OnLimitReached(uint32_t uScreen, int vrc);
+    void SetCallbacks(RecordingContext::CALLBACKS *pCallbacks, void *pvUser);
 
     /** The state mouse cursor state.
@@ -138 +181 @@
     int unlock(void);
 
+    int onLimitReached(uint32_t uScreen, int vrc);
+
     static DECLCALLBACK(int) threadMain(RTTHREAD hThreadSelf, void *pvUser);
 
@@ -149 +194 @@
 
 protected:
-
-    /**
-     * Enumeration for a recording context state.
-     */
-    enum RECORDINGSTS
-    {
-        /** Context not initialized. */
-        RECORDINGSTS_UNINITIALIZED = 0,
-        /** Context was created. */
-        RECORDINGSTS_CREATED       = 1,
-        /** Context was started. */
-        RECORDINGSTS_STARTED       = 2,
-        /** The usual 32-bit hack. */
-        RECORDINGSTS_32BIT_HACK    = 0x7fffffff
-    };
 
     /** Pointer to the console object. */
@@ -171 +201 @@
     /** The current state. */
     RECORDINGSTS                 m_enmState;
+    /** Callback table. */
+    CALLBACKS                    m_Callbacks;
     /** Critical section to serialize access. */
     RTCRITSECT                   m_CritSect;

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

@@ -101 +101 @@
     /** Pixel format. */
     RECORDINGPIXELFMT enmPixelFmt;
-    /** Bytes per scan line (stride). */
+    /** Bytes per scan line (stride).
+     *  Note: Does not necessarily match \a uWidth * (\a uBPP / 8). */
     uint32_t          uBytesPerLine;
 } RECORDINGSURFACEINFO;
@@ -539 +540 @@
 PRECORDINGVIDEOFRAME RecordingVideoFrameDup(PRECORDINGVIDEOFRAME pFrame);
 void RecordingVideoFrameClear(PRECORDINGVIDEOFRAME pFrame);
-int RecordingVideoFrameBlitRawAlpha(PRECORDINGVIDEOFRAME pFrame, uint32_t uDstX, uint32_t uDstY, const uint8_t *pu8Src, size_t cbSrc, uint32_t uSrcX, uint32_t uSrcY, uint32_t uSrcWidth, uint32_t uSrcHeight, uint32_t uSrcBytesPerLine, uint8_t uSrcBPP, RECORDINGPIXELFMT enmFmt);
-int RecordingVideoFrameBlitRaw(PRECORDINGVIDEOFRAME pFrame, uint32_t uDstX, uint32_t uDstY, const uint8_t *pu8Src, size_t cbSrc, uint32_t uSrcX, uint32_t uSrcY, uint32_t uSrcWidth, uint32_t uSrcHeight, uint32_t uSrcBytesPerLine, uint8_t uSrcBPP, RECORDINGPIXELFMT enmFmt);
+int RecordingVideoFrameBlitRawAlpha(PRECORDINGVIDEOFRAME pDstFrame, uint32_t uDstX, uint32_t uDstY, const uint8_t *pu8Src, size_t cbSrc, uint32_t uSrcX, uint32_t uSrcY, uint32_t uSrcWidth, uint32_t uSrcHeight, uint32_t uSrcBytesPerLine, uint8_t uSrcBPP, RECORDINGPIXELFMT enmFmt);
+int RecordingVideoBlitRaw(uint8_t *pu8Dst, size_t cbDst, uint32_t uDstX, uint32_t uDstY, uint32_t uDstBytesPerLine, uint8_t uDstBPP, RECORDINGPIXELFMT enmDstFmt, const uint8_t *pu8Src, size_t cbSrc, uint32_t uSrcX, uint32_t uSrcY, uint32_t uSrcWidth, uint32_t uSrcHeight, uint32_t uSrcBytesPerLine, uint8_t uSrcBPP, RECORDINGPIXELFMT enmSrcFmt);
+int RecordingVideoFrameBlitRaw(PRECORDINGVIDEOFRAME pDstFrame, uint32_t uDstX, uint32_t uDstY, const uint8_t *pu8Src, size_t cbSrc, uint32_t uSrcX, uint32_t uSrcY, uint32_t uSrcWidth, uint32_t uSrcHeight, uint32_t uSrcBytesPerLine, uint8_t uSrcBPP, RECORDINGPIXELFMT enmFmt);
 int RecordingVideoFrameBlitFrame(PRECORDINGVIDEOFRAME pDstFrame, uint32_t uDstX, uint32_t uDstY, PRECORDINGVIDEOFRAME pSrcFrame, uint32_t uSrcX, uint32_t uSrcY, uint32_t uSrcWidth, uint32_t uSrcHeight);
 

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

@@ -144 +144 @@
 
     bool IsLimitReached(uint64_t msTimestamp) const;
-    bool IsReady(void) const;
+    bool IsFeatureEnabled(RecordingFeature_T enmFeature) const;
     bool NeedsUpdate(uint64_t msTimestamp) const;
 

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

@@ -7609 +7609 @@
     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 */);
+        }
+    }
 
     LogFlowFuncLeaveRC(vrc);
@@ -7623 +7633 @@
 }
 
-/**
- * Starts recording. Does nothing if recording is already active.
+/** @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.
  *
  * @returns VBox status code.
@@ -7646 +7679 @@
 
 /**
- * Stops recording. Does nothing if recording is not active.
+ * Stops recording. Does nothing if recording is not in started state.
  *
  * Note: This does *not* disable recording for a VM, in other words,

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

@@ -130 +130 @@
 #endif
 
-#ifdef VBOX_WITH_RECORDING
-    vrc = RTCritSectInit(&mVideoRecLock);
-    AssertRC(vrc);
-
-    for (unsigned i = 0; i < RT_ELEMENTS(maRecordingEnabled); i++)
-        maRecordingEnabled[i] = false;
-#endif
-
     return BaseFinalConstruct();
 }
@@ -144 +136 @@
 {
     uninit();
-
-#ifdef VBOX_WITH_RECORDING
-    if (RTCritSectIsInitialized(&mVideoRecLock))
-    {
-        RTCritSectDelete(&mVideoRecLock);
-        RT_ZERO(mVideoRecLock);
-    }
-#endif
 
     videoAccelDestroy(&mVideoAccelLegacy);
@@ -565 +549 @@
     }
 
+#ifdef VBOX_WITH_RECORDING
+    unconst(Recording.pCtx) = mParent->i_recordingGetContext();
+#endif
+
     /* Confirm a successful initialization */
     autoInitSpan.setSucceeded();
@@ -796 +784 @@
     const bool fDisabled = pFBInfo->fDisabled;
 
+    alock.release(); /* Release lock before recording code gets involved below. */
+
 #ifdef VBOX_WITH_RECORDING
     /* Recording needs to be called before releasing the display's lock below. */
     i_recordingScreenChanged(uScreenId, pFBInfo);
 #endif
-
-    alock.release();
 
     if (!pFramebuffer.isNull())
@@ -834 +822 @@
     LogRelFlowFunc(("[%d]: default format %d\n", uScreenId, pFBInfo->fDefaultFormat));
 
+    LogFlowFuncLeave();
     return VINF_SUCCESS;
 }
@@ -911 +900 @@
 
 #ifdef VBOX_WITH_RECORDING
-                RECORDINGVIDEOFRAME Frame =
-                {
-                    { (uint32_t)w, (uint32_t)h,
-                      (uint8_t )pFBInfo->u16BitsPerPixel, RECORDINGPIXELFMT_BRGA32, pFBInfo->u32LineSize },
-                    pFBInfo->pu8FramebufferVRAM + (y * pFBInfo->u32LineSize + x * (pFBInfo->u16BitsPerPixel / 8)),
-                    pFBInfo->w * pFBInfo->u32LineSize,
-                    { (uint32_t)x, (uint32_t)y }
-                };
-                i_recordingScreenUpdate(uScreenId, &Frame);
+                i_recordingScreenUpdate(uScreenId, x, y, w, h);
 #endif
             }
@@ -955 +936 @@
                             pFBInfo->updateImage.pu8Address = pAddress;
                             pFBInfo->updateImage.cbLine = ulBytesPerLine;
-#ifdef VBOX_WITH_RECORDING
-                            RECORDINGVIDEOFRAME Frame =
-                            {
-                                { (uint32_t)ulWidth, (uint32_t)ulHeight,
-                                  (uint8_t )ulBitsPerPixel, RECORDINGPIXELFMT_BRGA32, ulBytesPerLine },
-                                pAddress, ulHeight * ulBytesPerLine,
-                                { 0, 0 }
-                            };
-
-                            i_recordingScreenUpdate(uScreenId, &Frame);
-#endif
                         }
 
@@ -1006 +976 @@
                         const uint8_t *pu8Src = pbAddress + ulBytesPerLine * y + x * uBytesPerPixel;
 
-                        for (int i = y; i < y + h; ++i)
+                        for (int i = 0; i < h; ++i)
                         {
                             memcpy(pu8Dst, pu8Src, w * uBytesPerPixel);
@@ -1016 +986 @@
 
 #ifdef VBOX_WITH_RECORDING
-                        RECORDINGVIDEOFRAME Frame =
-                        {
-                            { (uint32_t)w, (uint32_t)h,
-                              (uint8_t)ulBitsPerPixel, RECORDINGPIXELFMT_BRGA32, ulBytesPerLine },
-                            pu8Dst, h * ulBytesPerLine,
-                            { (uint32_t)x, (uint32_t)y }
-                        };
-
-                        i_recordingScreenUpdate(uScreenId, &Frame);
+                        i_recordingScreenUpdate(uScreenId,
+                                                image.raw(), ulBytesPerLine * h,
+                                                x, y, w, h, ulBytesPerLine);
 #endif
                     }
@@ -1170 +1134 @@
     bool fMoveCursor = mcVRDPRefs == 0;
 #ifdef VBOX_WITH_RECORDING
-    RecordingContext *pCtx = mParent->i_recordingGetContext();
-
-    if (   pCtx
-        && pCtx->IsStarted()
+    RecordingContext *pCtx = Recording.pCtx;
+    if (   pCtx->IsStarted()
         && pCtx->IsFeatureEnabled(RecordingFeature_Video))
         fRenderCursor = fMoveCursor = false;
@@ -2157 +2119 @@
 #endif
 
-    return i_recordingInvalidate(true /* fForce */);
+    return i_recordingInvalidate();
 }
 
@@ -2179 +2141 @@
 #endif
 
-    return i_recordingInvalidate(true /* fForce */);
+    return i_recordingInvalidate();
 }
 
@@ -2186 +2148 @@
  *
  * @returns VBox status code.
- * @param   fForce              Whether to force invalidation or not. Default is @c false.
  *
- * @note    Takes the display's read lock.
+ * @note    Takes the display's write lock.
  */
-int Display::i_recordingInvalidate(bool fForce /* = false */)
-{
-    RecordingContext *pCtx = mParent->i_recordingGetContext();
-    if (!pCtx)
-        return VINF_SUCCESS;
-
+int Display::i_recordingInvalidate(void)
+{
     LogFlowFuncEnter();
 
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
     /*
@@ -2205 +2162 @@
     for (unsigned uScreen = 0; uScreen < mcMonitors; uScreen++)
     {
-        const RecordingStream *pRecordingStream = pCtx->GetStream(uScreen);
-
-        bool const fStreamEnabled = pRecordingStream->IsReady();
-        bool const fChanged       = (maRecordingEnabled[uScreen] != fStreamEnabled) || fForce;
-
-        maRecordingEnabled[uScreen] = fStreamEnabled;
-
-        if (   fStreamEnabled
-            && fChanged)
-        {
-            DISPLAYFBINFO const *pFBInfo = &maFramebuffers[uScreen];
-            /* ignore rc */ i_recordingScreenChanged(uScreen, pFBInfo);
-        }
+        DISPLAYFBINFO const *pFBInfo = &maFramebuffers[uScreen];
+        /* ignore rc */ i_recordingScreenChanged(uScreen, pFBInfo);
     }
 
@@ -2232 +2178 @@
 int Display::i_recordingScreenChanged(unsigned uScreenId, const DISPLAYFBINFO *pFBInfo)
 {
-    AssertReturn(uScreenId < mcMonitors, VERR_INVALID_PARAMETER);
-
-    RecordingContext *pCtx = mParent->i_recordingGetContext();
-
-    i_updateDeviceCursorCapabilities();
-    if (   RT_LIKELY(!maRecordingEnabled[uScreenId])
-        || !pCtx || !pCtx->IsStarted())
+    RecordingContext *pCtx = Recording.pCtx;
+
+    Log2Func(("uScreenId=%u\n", uScreenId));
+
+    if (uScreenId == 0xFFFFFFFF /* SVGA_ID_INVALID -- The old register interface is single screen only */)
+        uScreenId = VBOX_VIDEO_PRIMARY_SCREEN;
+
+    if (!pCtx->IsFeatureEnabled(uScreenId, RecordingFeature_Video))
     {
         /* Skip recording this screen. */
@@ -2244 +2191 @@
     }
 
-    LogFlowFuncEnter();
+    AssertReturn(uScreenId < mcMonitors, VERR_INVALID_PARAMETER);
+
+    RT_NOREF(pFBInfo);
+
+    /* We have to go the official way of querying the source bitmap, as this function creates it if it does not exist yet. */
+    ComPtr<IDisplaySourceBitmap> sourceBitmap;
+    HRESULT hrc = querySourceBitmap(uScreenId, sourceBitmap);
+    if (FAILED(hrc)) /* Blank, skip. */
+        return VINF_SUCCESS;
+
+    BYTE *pbAddress;
+    ULONG ulWidth;
+    ULONG ulHeight;
+    ULONG ulBitsPerPixel;
+    ULONG ulBytesPerLine;
+    BitmapFormat_T bitmapFormat = BitmapFormat_Opaque;
+    hrc = sourceBitmap->QueryBitmapInfo(&pbAddress,
+                                        &ulWidth,
+                                        &ulHeight,
+                                        &ulBitsPerPixel,
+                                        &ulBytesPerLine,
+                                        &bitmapFormat);
+    AssertComRC(hrc);
+
+    Log2Func(("pbAddress=%p, ulWidth=%RU32, ulHeight=%RU32, ulBitsPerPixel=%RU32\n",
+              pbAddress, ulWidth, ulHeight, ulBitsPerPixel));
+
+    Assert(ulWidth);
+    Assert(ulHeight);
+    Assert(ulBitsPerPixel);
+    Assert(ulBytesPerLine);
+
+    if (!pbAddress)
+    {
+        AssertFailed();
+        return VINF_SUCCESS;
+    }
+
+    i_updateDeviceCursorCapabilities();
 
     RECORDINGSURFACEINFO ScreenInfo;
-    ScreenInfo.uWidth      = pFBInfo->w;
-    ScreenInfo.uHeight     = pFBInfo->h;
-    ScreenInfo.uBPP        = (uint8_t)pFBInfo->u16BitsPerPixel;
+    ScreenInfo.uWidth      = ulWidth;
+    ScreenInfo.uHeight     = ulHeight;
+    ScreenInfo.uBPP        = ulBitsPerPixel;
     ScreenInfo.enmPixelFmt = RECORDINGPIXELFMT_BRGA32; /** @todo Does this apply everywhere? */
 
@@ -2257 +2242 @@
     if (RT_SUCCESS(vrc))
     {
-        /** @todo BUGBUG For whatever reason pFBInfo contains a wrong pFBInfo->u32LineSize
-         *        when shutting down a VM. So (re-)calculate the line size based on the framebuffer's
-         *        BPP + width parameters.
-         *
-         *        So fend off any requests here which look fishy before sending a full screen update. */
-        if (   !pFBInfo->u16BitsPerPixel
-            ||  pFBInfo->u16BitsPerPixel % 2 != 0
-            || !pFBInfo->w
-            || !pFBInfo->h
-            ||  pFBInfo->u32LineSize != pFBInfo->w * (pFBInfo->u16BitsPerPixel / 8))
-        {
-            vrc = VERR_INVALID_PARAMETER;
-        }
-        else
-        {
-            /* Make sure that we get the latest mouse pointer shape required for recording. */
-            MousePointerData pointerData;
-            mParent->i_getMouse()->i_getPointerShape(pointerData);
-            mParent->i_recordingCursorShapeChange(pointerData.fVisible, pointerData.fAlpha,
-                                                  pointerData.hotX, pointerData.hotY,
-                                                  pointerData.width, pointerData.height,
-                                                  pointerData.pu8Shape, pointerData.cbShape);
-            /* Send the full screen update. */
-            RECORDINGVIDEOFRAME Frame =
-            {
-                { (uint32_t)pFBInfo->w, (uint32_t)pFBInfo->h,
-                  (uint8_t)pFBInfo->u16BitsPerPixel, RECORDINGPIXELFMT_BRGA32, pFBInfo->u32LineSize },
-                pFBInfo->pu8FramebufferVRAM, pFBInfo->h * pFBInfo->u32LineSize,
-                { 0, 0 }
-            };
-
-            vrc = i_recordingScreenUpdate(uScreenId, &Frame);
-        }
-    }
-
-    LogFlowFuncLeaveRC(vrc);
+        /* Make sure that we get the latest mouse pointer shape required for recording. */
+        MousePointerData pointerData;
+        mParent->i_getMouse()->i_getPointerShape(pointerData);
+        mParent->i_recordingCursorShapeChange(pointerData.fVisible, pointerData.fAlpha,
+                                              pointerData.hotX, pointerData.hotY,
+                                              pointerData.width, pointerData.height,
+                                              pointerData.pu8Shape, pointerData.cbShape);
+        /* Send the full screen update. */
+        vrc = i_recordingScreenUpdate(uScreenId, pbAddress, ulHeight * ulBytesPerLine,
+                                      0, 0, ulWidth, ulHeight, ulBytesPerLine);
+    }
+
     return vrc;
 }
 
 /**
- * Called when a part of a screen got updated.
+ * Sends a screen update to the recording facility.
  *
  * @returns VBox status code.
- * @param   uScreenId           ID of screen which got updated.
- * @param   pFrame              Video frama to send.
+ * @param   uScreenId           ID of screen.
+ * @param   pauFramebuffer      Pointer to start of framebuffer.
+ * @param   cbFramebuffer       Size (in bytes) of \a pauFramebuffer.
+ * @param   x                   Absolute X starting position (in pixel) within current framebuffer.
+ * @param   y                   Absolute Y starting position (in pixel) within current framebuffer.
+ * @param   w                   Width (in pixel) of the changed area.
+ * @param   h                   Height (in pixel) of the changed area.
+ * @param   uBytesPerLine       Bytes per line of current framebuffer.
  */
-int Display::i_recordingScreenUpdate(unsigned uScreenId, PRECORDINGVIDEOFRAME pFrame)
-{
-    if (   uScreenId >= mcMonitors /* Might be SVGA_ID_INVALID. */
-        || !maRecordingEnabled[uScreenId])
+int Display::i_recordingScreenUpdate(unsigned uScreenId, uint8_t *pauFramebuffer, size_t cbFramebuffer,
+                                     uint32_t x, uint32_t y, uint32_t w, uint32_t h, uint32_t uBytesPerLine)
+{
+    RT_NOREF(cbFramebuffer);
+
+    RecordingContext *pCtx = Recording.pCtx;
+
+    Log2Func(("uScreenId=%u, pauFramebuffer=%p, cbFramebuffer=%zu, x=%RU32, y=%RU32, w=%RU32, h=%RU32, uBytesPerLine=%RU32\n",
+              uScreenId, pauFramebuffer, cbFramebuffer, x, y, w, h, uBytesPerLine));
+
+    if (uScreenId == 0xFFFFFFFF /* SVGA_ID_INVALID -- The old register interface is single screen only */)
+        uScreenId = VBOX_VIDEO_PRIMARY_SCREEN;
+
+    if (!pCtx->IsFeatureEnabled(uScreenId, RecordingFeature_Video))
         return VINF_SUCCESS;
 
-    RecordingContext *pCtx = mParent->i_recordingGetContext();
-    if (!pCtx)
-        return VINF_SUCCESS;
-
-    /* If the recording context has reached the configured recording
-     * limit, disable recording. */
-    if (pCtx->IsLimitReached())
-    {
-        mParent->i_onRecordingChange(FALSE /* Disable */);
-        return VINF_SUCCESS;
-    }
+#ifdef VBOX_STRICT /* Skipped in release build for speed reasons. */
+    AssertPtrReturn(pauFramebuffer, VERR_INVALID_POINTER);
+    AssertReturn   (cbFramebuffer,  VERR_INVALID_PARAMETER);
+    AssertReturn   (uBytesPerLine,  VERR_INVALID_PARAMETER);
+    AssertReturn   (w,              VERR_INVALID_PARAMETER);
+    AssertReturn   (h,              VERR_INVALID_PARAMETER);
+#endif
 
     uint64_t const tsNowMs = pCtx->GetCurrentPTS();
 
-    int vrc = VINF_NO_CHANGE;
-
-    if (   pCtx->IsStarted()
-        && pCtx->IsFeatureEnabled(RecordingFeature_Video))
-    {
-        STAM_PROFILE_START(&Stats.Monitor[uScreenId].Recording.profileRecording, a);
-
-        vrc = pCtx->SendVideoFrame(uScreenId, pFrame, tsNowMs);
-
-        STAM_PROFILE_STOP(&Stats.Monitor[uScreenId].Recording.profileRecording, a);
-    }
+    STAM_PROFILE_START(&Stats.Monitor[uScreenId].Recording.profileRecording, a);
+
+    uint8_t const uBytesPerPixel = 4;
+    size_t  const offFrame = (y * uBytesPerLine) + (x * uBytesPerPixel);
+    size_t  const cbFrame  = w * h * uBytesPerPixel;
+
+    RECORDINGVIDEOFRAME Frame =
+    {
+        { w, h, 32 /* BPP */, RECORDINGPIXELFMT_BRGA32, uBytesPerLine },
+        pauFramebuffer + offFrame, cbFrame,
+        { x, y }
+    };
+
+#if 0
+    RecordingUtilsDbgDumpImageData(pauFramebuffer + offFrame, cbFramebuffer,
+                                   "/tmp/recording", "display-screen-update", w, h, uBytesPerLine, 32 /* BPP */);
+#endif
+
+    int vrc = pCtx->SendVideoFrame(uScreenId, &Frame, tsNowMs);
+
+    STAM_PROFILE_STOP(&Stats.Monitor[uScreenId].Recording.profileRecording, a);
 
     return vrc;
+}
+
+/**
+ * Sends a screen upate to the recording facility using the current framebuffer.
+ *
+ * @returns VBox status code.
+ * @param   uScreenId           ID of screen.
+ * @param   x                   Absolute X starting position (in pixel) within current framebuffer.
+ * @param   y                   Absolute Y starting position (in pixel) within current framebuffer.
+ * @param   w                   Width (in pixel) of the changed area.
+ * @param   h                   Height (in pixel) of the changed area.
+ */
+int Display::i_recordingScreenUpdate(unsigned uScreenId, uint32_t x, uint32_t y, uint32_t w, uint32_t h)
+{
+    BYTE *pbAddress;
+    ULONG ulWidth;
+    ULONG ulHeight;
+    ULONG ulBitsPerPixel;
+    ULONG ulBytesPerLine;
+
+    if (uScreenId == VBOX_VIDEO_PRIMARY_SCREEN) /* Take a shortcut for the primary screen. */
+    {
+        pbAddress      = mpDrv->IConnector.pbData;
+        ulWidth        = mpDrv->IConnector.cx;
+        ulHeight       = mpDrv->IConnector.cy;
+        ulBitsPerPixel = mpDrv->IConnector.cBits;
+        ulBytesPerLine = mpDrv->IConnector.cbScanline;
+    }
+    else
+    {
+        BitmapFormat_T bitmapFormat = BitmapFormat_Opaque;
+        maFramebuffers[uScreenId].pSourceBitmap->QueryBitmapInfo(&pbAddress,
+                                                                 &ulWidth,
+                                                                 &ulHeight,
+                                                                 &ulBitsPerPixel,
+                                                                 &ulBytesPerLine,
+                                                                 &bitmapFormat);
+    }
+
+    Log2Func(("uScreenId=%u, pbAddress=%p, ulWidth=%RU32, ulHeight=%RU32, ulBitsPerPixel=%RU32\n",
+              uScreenId, pbAddress, ulWidth, ulHeight, ulBitsPerPixel));
+
+    AssertPtr(pbAddress);
+    Assert(ulWidth);
+    Assert(ulHeight);
+    Assert(ulBitsPerPixel);
+    Assert(ulBytesPerLine);
+
+    return i_recordingScreenUpdate(uScreenId,
+                                   pbAddress, ulHeight * ulBytesPerLine,
+                                   x, y, w, h, ulBytesPerLine);
 }
 
@@ -2353 +2387 @@
     RT_NOREF(fFlags);
 
-    if (   uScreenId >= mcMonitors /* Might be SVGA_ID_INVALID. */
-        || !maRecordingEnabled[uScreenId])
+    RecordingContext *pCtx = Recording.pCtx;
+
+    Log2Func(("uScreenId=%u, fFlags=%#x, x=%RI32, y=%RI32\n", uScreenId, fFlags, x, y));
+
+    if (uScreenId == 0xFFFFFFFF /* SVGA_ID_INVALID -- The old register interface is single screen only */)
+        uScreenId = VBOX_VIDEO_PRIMARY_SCREEN;
+
+    if (!pCtx->IsFeatureEnabled(uScreenId, RecordingFeature_Video))
         return VINF_SUCCESS;
 
-    RecordingContext *pCtx = mParent->i_recordingGetContext();
-    if (!pCtx)
-        return VINF_SUCCESS;
-
-    /* If the recording context has reached the configured recording
-     * limit, disable recording. */
-    if (pCtx->IsLimitReached())
-    {
-        mParent->i_onRecordingChange(FALSE /* Disable */);
-        return VINF_SUCCESS;
-    }
-
-    if (   pCtx->IsStarted()
-        && pCtx->IsFeatureEnabled(RecordingFeature_Video))
-    {
-        return pCtx->SendCursorPositionChange(uScreenId, x, y, pCtx->GetCurrentPTS());
-    }
-
-    return VINF_SUCCESS;
+    return pCtx->SendCursorPositionChange(uScreenId, x, y, pCtx->GetCurrentPTS());
 }
 #endif /* VBOX_WITH_RECORDING */

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

@@ -137 +137 @@
         vrc = RecordingVideoFrameBlitRaw(&m_Shape, 0, 0, &pu8Shape[offShape], cbShape - offShape, 0, 0, uWidth, uHeight, uWidth * 4 /* BPP */, uBPP,
                                          m_Shape.Info.enmPixelFmt);
-#ifdef DEBUG_andy_disabled
+#if 0
     RecordingUtilsDbgDumpVideoFrameEx(&m_Shape, "/tmp/recording", "cursor-update");
 #endif
@@ -530 +530 @@
 
     m_pConsole = ptrConsole;
+    RT_ZERO(m_Callbacks);
 
     settings::RecordingScreenSettingsMap::const_iterator itScreen = m_Settings.mapScreens.begin();
@@ -537 +538 @@
         try
         {
-            pStream = new RecordingStream(this, itScreen->first /* Screen ID */, itScreen->second);
-            m_vecStreams.push_back(pStream);
             if (itScreen->second.fEnabled)
+            {
+                pStream = new RecordingStream(this, itScreen->first /* Screen ID */, itScreen->second);
+                m_vecStreams.push_back(pStream);
                 m_cStreamsEnabled++;
-            LogFlowFunc(("pStream=%p\n", pStream));
+                LogFlowFunc(("pStream=%p\n", pStream));
+            }
         }
         catch (std::bad_alloc &)
@@ -565 +568 @@
         vrc = RTSemEventCreate(&m_WaitEvent);
         AssertRCReturn(vrc, vrc);
+
+        RT_ZERO(m_Callbacks);
     }
 
@@ -571 +576 @@
 
     return vrc;
+}
+
+/**
+ * Sets the callback table for a recording context.
+ *
+ * @param   pCallbacks          Callback table to set.
+ * @param   pvUser              User-supplied pointer.
+ */
+void RecordingContext::SetCallbacks(RecordingContext::CALLBACKS *pCallbacks, void *pvUser)
+{
+    lock();
+
+    memcpy(&m_Callbacks, pCallbacks, sizeof(RecordingContext::CALLBACKS));
+    m_Callbacks.pvUser = pvUser;
+
+    unlock();
 }
 
@@ -857 +878 @@
 
 /**
- * Returns if this recording context is ready to accept new recording data for a given screen.
- *
- * @returns @c true if the specified screen is ready, @c false if not.
+ * Returns if a feature for a given stream is enabled or not.
+ *
+ * @returns @c true if the specified feature is enabled (running), @c false if not.
  * @param   uScreen             Screen ID.
- * @param   msTimestamp         Timestamp (PTS, in ms). Currently not being used.
- */
-bool RecordingContext::IsReady(uint32_t uScreen, uint64_t msTimestamp)
-{
-    RT_NOREF(msTimestamp);
-
+ * @param   enmFeature          Feature of stream to check for.
+ *
+ * @note    Implies that the stream is enabled (i.e. active).
+ */
+bool RecordingContext::IsFeatureEnabled(uint32_t uScreen, RecordingFeature_T enmFeature)
+{
     lock();
 
     bool fIsReady = false;
 
-    if (m_enmState != RECORDINGSTS_STARTED)
+    if (m_enmState == RECORDINGSTS_STARTED)
     {
         const RecordingStream *pStream = getStreamInternal(uScreen);
         if (pStream)
-            fIsReady = pStream->IsReady();
+            fIsReady = pStream->IsFeatureEnabled(enmFeature);
 
         /* Note: Do not check for other constraints like the video FPS rate here,
@@ -890 +911 @@
  * Returns whether a given recording context has been started or not.
  *
- * @returns true if active, false if not.
+ * @returns @c true if started, @c false if not.
  */
 bool RecordingContext::IsStarted(void)
@@ -906 +927 @@
  * Checks if a specified limit for recording has been reached.
  *
- * @returns true if any limit has been reached.
+ * @returns @c true if any limit has been reached, @c false if not.
  */
 bool RecordingContext::IsLimitReached(void)
@@ -924 +945 @@
  * Checks if a specified limit for recording has been reached.
  *
- * @returns true if any limit has been reached.
+ * @returns @c true if any limit has been reached, @c false if not.
  * @param   uScreen             Screen ID.
  * @param   msTimestamp         Timestamp (PTS, in ms) to check for.
@@ -982 +1003 @@
 }
 
-DECLCALLBACK(int) RecordingContext::OnLimitReached(uint32_t uScreen, int vrc)
-{
-    RT_NOREF(uScreen, vrc);
+/**
+ * Gets called by a stream if its limit has been reached.
+ *
+ * @returns VBox status code.
+ * @param   uScreen             The stream's ID (Screen ID).
+ * @param   vrc                 Result code of the limit operation.
+ */
+DECLCALLBACK(int) RecordingContext::onLimitReached(uint32_t uScreen, int vrc)
+{
     LogFlowThisFunc(("Stream %RU32 has reached its limit (%Rrc)\n", uScreen, vrc));
 
@@ -990 +1017 @@
 
     Assert(m_cStreamsEnabled);
-    m_cStreamsEnabled--;
+    if (m_cStreamsEnabled)
+        m_cStreamsEnabled--;
+
+    bool const fAllDisabled = m_cStreamsEnabled == 0;
 
     LogFlowThisFunc(("cStreamsEnabled=%RU16\n", m_cStreamsEnabled));
 
-    unlock();
+    unlock(); /* Leave the lock before invoking callbacks. */
+
+    if (m_Callbacks.pfnStateChanged)
+        m_Callbacks.pfnStateChanged(this, RECORDINGSTS_LIMIT_REACHED,
+                                    fAllDisabled ? UINT32_MAX : uScreen, vrc, m_Callbacks.pvUser);
 
     return VINF_SUCCESS;
@@ -1032 +1066 @@
     AssertPtrReturn(pFrame, VERR_INVALID_POINTER);
 
-    LogFlowFunc(("uScreen=%RU32, offX=%RU32, offY=%RU32, w=%RU32, h=%RU32, msTimestamp=%RU64\n",
-                 uScreen, pFrame->Pos.x, pFrame->Pos.y, pFrame->Info.uWidth, pFrame->Info.uHeight, msTimestamp));
+    LogFlowFunc(("uScreen=%RU32, offX=%RU32, offY=%RU32, w=%RU32, h=%RU32 (%zu bytes), msTimestamp=%RU64\n",
+                 uScreen, pFrame->Pos.x, pFrame->Pos.y, pFrame->Info.uWidth, pFrame->Info.uHeight,
+                 pFrame->Info.uHeight * pFrame->Info.uWidth * (pFrame->Info.uBPP / 8), msTimestamp));
 
     if (!pFrame->pau8Buf) /* Empty / invalid frame, skip. */
@@ -1039 +1074 @@
 
     /* Sanity. */
+    AssertReturn(pFrame->Info.uBPP, VERR_INVALID_PARAMETER);
+    AssertReturn(pFrame->cbBuf, VERR_INVALID_PARAMETER);
     AssertReturn(pFrame->Info.uWidth  * pFrame->Info.uHeight * (pFrame->Info.uBPP / 8) <= pFrame->cbBuf, VERR_INVALID_PARAMETER);
-    AssertReturn(pFrame->Info.uHeight * pFrame->Info.uBytesPerLine <= pFrame->cbBuf, VERR_INVALID_PARAMETER);
 
     lock();
@@ -1048 +1084 @@
     {
         unlock();
-
-        AssertFailed();
-        return VERR_NOT_FOUND;
-    }
+        return VINF_SUCCESS;
+    }
+
+    unlock();
 
     int vrc = pStream->SendVideoFrame(pFrame, msTimestamp);
-
-    unlock();
-
-    if (   RT_SUCCESS(vrc)
-        && vrc != VINF_RECORDING_THROTTLED) /* Only signal the thread if operation was successful. */
-    {
+    if (vrc == VINF_SUCCESS) /* Might be VINF_RECORDING_THROTTLED or VINF_RECORDING_LIMIT_REACHED. */
         threadNotify();
-    }
 
     return vrc;
@@ -1083 +1113 @@
         return VINF_SUCCESS;
 
-    if (uScreen == 0xFFFFFFFF /* SVGA_ID_INVALID */)
-        uScreen = 0;
-
     int vrc = m_Cursor.Move(x, y);
     if (RT_SUCCESS(vrc))
@@ -1095 +1122 @@
         {
             unlock();
-
-            AssertFailed();
-            return VERR_NOT_FOUND;
+            return VINF_SUCCESS;
         }
 
+        unlock();
+
         vrc = pStream->SendCursorPos(0 /* idCursor */, &m_Cursor.m_Shape.Pos, msTimestamp);
-
-        unlock();
-
-        if (   RT_SUCCESS(vrc)
-            && vrc != VINF_RECORDING_THROTTLED) /* Only signal the thread if operation was successful. */
-        {
+        if (vrc == VINF_SUCCESS) /* Might be VINF_RECORDING_THROTTLED or VINF_RECORDING_LIMIT_REACHED. */
             threadNotify();
-        }
     }
 
@@ -1160 +1181 @@
     unlock();
 
-    if (RT_SUCCESS(vrc))
+    if (vrc == VINF_SUCCESS) /* Might be VINF_RECORDING_THROTTLED or VINF_RECORDING_LIMIT_REACHED. */
         threadNotify();
 
@@ -1182 +1203 @@
     {
         unlock();
-
-        AssertFailed();
-        return VERR_NOT_FOUND;
-    }
+        return VINF_SUCCESS;
+    }
+
+    unlock();
 
     int const vrc = pStream->SendScreenChange(pInfo, msTimestamp);
 
-    unlock();
-
     return vrc;
 }

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

@@ -374 +374 @@
      * - if available (through mouse integration via Guest Additions): the guest's mouse cursor via a (software) overlay
      *
-     * So composing is done the folowing way:
+     * So composing is done the following way:
      *
      *  - always store the plain framebuffer updates in our back buffer first
@@ -388 +388 @@
             PRECORDINGVIDEOFRAME pSrc = &pFrame->u.Video;
 
-            vrc = RecordingVideoFrameBlitFrame(pFront, pSrc->Pos.x, pSrc->Pos.y,
-                                               pSrc, 0 /* uSrcX */, 0 /* uSrcY */, pSrc->Info.uWidth, pSrc->Info.uHeight);
+            vrc = RecordingVideoBlitRaw(pFront->pau8Buf, pFront->cbBuf, pSrc->Pos.x, pSrc->Pos.y,
+                                        pFront->Info.uBytesPerLine, pFront->Info.uBPP, pFront->Info.enmPixelFmt,
+                                        pSrc->pau8Buf, pSrc->cbBuf, 0 /* uSrcX */, 0 /* uSrcY */, pSrc->Info.uWidth, pSrc->Info.uHeight,
+                                        pSrc->Info.uBytesPerLine, pSrc->Info.uBPP, pSrc->Info.enmPixelFmt);
 #if 0
             RecordingUtilsDbgDumpVideoFrameEx(pFront, "/tmp/recording", "encode-front");
-            RecordingUtilsDbgDumpVideoFrameEx(pSrc, "/tmp/recording", "encode-src");
+            RecordingUtilsDbgDumpImageData(pSrc->pau8Buf, pSrc->cbBuf,
+                                           "/tmp/recording", "encode-src",
+                                           pSrc->Info.uWidth, pSrc->Info.uHeight, pSrc->Info.uBytesPerLine, pSrc->Info.uBPP);
 #endif
             vrc = RecordingVideoFrameBlitFrame(pBack, pSrc->Pos.x, pSrc->Pos.y,
@@ -499 +503 @@
               pCodec->Parms.u.Video.Scaling.u.Crop.m_iOriginX, pCodec->Parms.u.Video.Scaling.u.Crop.m_iOriginY));
 
-    int32_t sx_b = sx; /* X origin within the source frame. */
-    int32_t sy_b = sy; /* Y origin within the source frame. */
-    int32_t sw_b = sw; /* Width of the source frame (starting at X origin). */
-    int32_t sh_b = sh; /* Height of the source frame (starting at Y origin). */
-    int32_t dx_b = dx; /* X destination of the source frame within the destination frame. */
-    int32_t dy_b = dy; /* Y destination of the source frame within the destination frame. */
-
-    RT_NOREF(sx_b);
-    RT_NOREF(sy_b);
-    RT_NOREF(sw_b);
-    RT_NOREF(sh_b);
-    RT_NOREF(dx_b);
-    RT_NOREF(dy_b);
-
     vrc = RecordingUtilsCoordsCropCenter(&pCodec->Parms, &sx, &sy, &sw, &sh, &dx, &dy);
     if (vrc == VINF_SUCCESS) /* vrc might be VWRN_RECORDING_ENCODING_SKIPPED to skip encoding. */
@@ -546 +536 @@
 static DECLCALLBACK(int) recordingCodecVPXScreenChange(PRECORDINGCODEC pCodec, PRECORDINGSURFACEINFO pInfo)
 {
-    LogRel2(("Recording: Codec got screen change notification (%RU16x%RU16, %RU8 BPP)\n",
-             pInfo->uWidth, pInfo->uHeight, pInfo->uBPP));
-
-    /* Fend-off bogus reports. */
-    if (   !pInfo->uWidth
-        || !pInfo->uHeight)
-        return VERR_INVALID_PARAMETER;
-
-     /** @todo BUGBUG Not sure why we sometimes get 0 BPP for a display change from Main.
-      *               For now we ASSUME 32 BPP. */
-    if (!pInfo->uBPP)
-        pInfo->uBPP = 32;
-
     /* The VPX encoder only understands even frame sizes. */
     if (   (pInfo->uWidth  % 2) != 0
@@ -1206 +1183 @@
 int recordingCodecScreenChange(PRECORDINGCODEC pCodec, PRECORDINGSURFACEINFO pInfo)
 {
+    LogRel2(("Recording: Codec got screen change notification (%RU16x%RU16, %RU8 BPP)\n",
+             pInfo->uWidth, pInfo->uHeight, pInfo->uBPP));
+
     if (!pCodec->Ops.pfnScreenChange)
         return VINF_SUCCESS;
+
+    /* Fend-off bogus reports. */
+    if (   !pInfo->uWidth
+        || !pInfo->uHeight)
+        return VERR_INVALID_PARAMETER;
+    AssertReturn(pInfo->uBPP % 8 == 0, VERR_INVALID_PARAMETER);
 
     return pCodec->Ops.pfnScreenChange(pCodec, pInfo);

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

@@ -248 +248 @@
  * @param   enmSrcFmt           Pixel format of source data. Must match \a pFrame.
  */
-DECLINLINE(int) recordingVideoFrameBlitRaw(uint8_t *pu8Dst, size_t cbDst, uint32_t uDstX, uint32_t uDstY,
-                                           uint32_t uDstBytesPerLine, uint8_t uDstBPP, RECORDINGPIXELFMT enmDstFmt,
-                                           const uint8_t *pu8Src, size_t cbSrc, uint32_t uSrcX, uint32_t uSrcY, uint32_t uSrcWidth, uint32_t uSrcHeight,
-                                           uint32_t uSrcBytesPerLine, uint8_t uSrcBPP, RECORDINGPIXELFMT enmSrcFmt)
+DECLINLINE(int) recordingVideoBlitRaw(uint8_t *pu8Dst, size_t cbDst, uint32_t uDstX, uint32_t uDstY,
+                                      uint32_t uDstBytesPerLine, uint8_t uDstBPP, RECORDINGPIXELFMT enmDstFmt,
+                                      const uint8_t *pu8Src, size_t cbSrc, uint32_t uSrcX, uint32_t uSrcY, uint32_t uSrcWidth, uint32_t uSrcHeight,
+                                      uint32_t uSrcBytesPerLine, uint8_t uSrcBPP, RECORDINGPIXELFMT enmSrcFmt)
 {
     RT_NOREF(enmDstFmt, enmSrcFmt);
@@ -275 +275 @@
 
     return VINF_SUCCESS;
+}
+
+int RecordingVideoBlitRaw(uint8_t *pu8Dst, size_t cbDst, uint32_t uDstX, uint32_t uDstY,
+                          uint32_t uDstBytesPerLine, uint8_t uDstBPP, RECORDINGPIXELFMT enmDstFmt,
+                          const uint8_t *pu8Src, size_t cbSrc, uint32_t uSrcX, uint32_t uSrcY, uint32_t uSrcWidth, uint32_t uSrcHeight,
+                          uint32_t uSrcBytesPerLine, uint8_t uSrcBPP, RECORDINGPIXELFMT enmSrcFmt)
+{
+    return recordingVideoBlitRaw(pu8Dst, cbDst, uDstX, uDstY, uDstBytesPerLine,uDstBPP, enmDstFmt,
+                                 pu8Src, cbSrc, uSrcX, uSrcY, uSrcWidth, uSrcHeight,uSrcBytesPerLine, uSrcBPP, enmSrcFmt);
 }
 
@@ -366 +375 @@
                                uint32_t uSrcBytesPerLine, uint8_t uSrcBPP, RECORDINGPIXELFMT enmFmt)
 {
-    return recordingVideoFrameBlitRaw(/* Destination */
-                                      pDstFrame->pau8Buf, pDstFrame->cbBuf, uDstX, uDstY,
-                                      pDstFrame->Info.uBytesPerLine, pDstFrame->Info.uBPP, pDstFrame->Info.enmPixelFmt,
-                                      /* Source */
-                                      pu8Src, cbSrc, uSrcX, uSrcY, uSrcWidth, uSrcHeight, uSrcBytesPerLine, uSrcBPP, enmFmt);
+    return recordingVideoBlitRaw(/* Destination */
+                                pDstFrame->pau8Buf, pDstFrame->cbBuf, uDstX, uDstY,
+                                pDstFrame->Info.uBytesPerLine, pDstFrame->Info.uBPP, pDstFrame->Info.enmPixelFmt,
+                                /* Source */
+                                pu8Src, cbSrc, uSrcX, uSrcY, uSrcWidth, uSrcHeight, uSrcBytesPerLine, uSrcBPP, enmFmt);
 }
 
@@ -377 +386 @@
  *
  * @returns VBox status code.
- * @param   pFrame              Destination frame.
+ * @param   pDstFrame           Destination frame.
  * @param   uDstX               X destination (in pixel) within destination frame.
  * @param   uDstY               Y destination (in pixel) within destination frame.
@@ -390 +399 @@
  * @param   enmFmt              Pixel format of source data. Must match \a pFrame.
  */
-int RecordingVideoFrameBlitRawAlpha(PRECORDINGVIDEOFRAME pFrame, uint32_t uDstX, uint32_t uDstY,
+int RecordingVideoFrameBlitRawAlpha(PRECORDINGVIDEOFRAME pDstFrame, uint32_t uDstX, uint32_t uDstY,
                                     const uint8_t *pu8Src, size_t cbSrc, uint32_t uSrcX, uint32_t uSrcY, uint32_t uSrcWidth, uint32_t uSrcHeight,
                                     uint32_t uSrcBytesPerLine, uint8_t uSrcBPP, RECORDINGPIXELFMT enmFmt)
 {
-    return recordingVideoFrameBlitRawAlpha(pFrame, uDstX, uDstY,
+    return recordingVideoFrameBlitRawAlpha(pDstFrame, uDstX, uDstY,
                                            pu8Src, cbSrc, uSrcX, uSrcY, uSrcWidth, uSrcHeight, uSrcBytesPerLine, uSrcBPP, enmFmt);
 }
@@ -416 +425 @@
                                  PRECORDINGVIDEOFRAME pSrcFrame, uint32_t uSrcX, uint32_t uSrcY, uint32_t uSrcWidth, uint32_t uSrcHeight)
 {
-    return recordingVideoFrameBlitRaw(/* Dest */
-                                      pDstFrame->pau8Buf, pDstFrame->cbBuf, uDstX, uDstY,
-                                      pDstFrame->Info.uBytesPerLine, pDstFrame->Info.uBPP, pDstFrame->Info.enmPixelFmt,
-                                      /* Source */
-                                      pSrcFrame->pau8Buf, pSrcFrame->cbBuf, uSrcX, uSrcY, uSrcWidth, uSrcHeight,
-                                      pSrcFrame->Info.uBytesPerLine, pSrcFrame->Info.uBPP, pSrcFrame->Info.enmPixelFmt);
+    return recordingVideoBlitRaw(/* Dest */
+                                 pDstFrame->pau8Buf, pDstFrame->cbBuf, uDstX, uDstY,
+                                 pDstFrame->Info.uBytesPerLine, pDstFrame->Info.uBPP, pDstFrame->Info.enmPixelFmt,
+                                 /* Source */
+                                 pSrcFrame->pau8Buf, pSrcFrame->cbBuf, uSrcX, uSrcY, uSrcWidth, uSrcHeight,
+                                 pSrcFrame->Info.uBytesPerLine, pSrcFrame->Info.uBPP, pSrcFrame->Info.enmPixelFmt);
 }
 

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

@@ -148 +148 @@
 
     if (   m_ScreenSettings.ulMaxTimeS
-        && msTimestamp >= m_tsStartMs + (m_ScreenSettings.ulMaxTimeS * RT_MS_1SEC))
+        && msTimestamp >= m_ScreenSettings.ulMaxTimeS * RT_MS_1SEC)
     {
         LogRel(("Recording: Time limit for stream #%RU16 has been reached (%RU32s)\n",
@@ -185 +185 @@
  *
  * @returns VBox status code.
+ * @retval  VINF_RECORDING_LIMIT_REACHED if the stream's recording limit has been reached.
  * @param   msTimestamp         Timestamp (PTS, in ms).
+ *
+ * @note    Caller must *not* have the stream's lock (callbacks involved).
  */
 int RecordingStream::iterateInternal(uint64_t msTimestamp)
 {
+    AssertReturn(!RTCritSectIsOwner(&m_CritSect), VERR_WRONG_ORDER);
+
     if (!m_fEnabled)
         return VINF_SUCCESS;
@@ -209 +214 @@
             m_fEnabled = false;
 
-            int vrc2 = m_pCtx->OnLimitReached(m_uScreenID, VINF_SUCCESS /* vrc */);
+            int vrc2 = m_pCtx->onLimitReached(m_uScreenID, VINF_SUCCESS /* vrc */);
             AssertRC(vrc2);
             break;
@@ -230 +235 @@
 bool RecordingStream::IsLimitReached(uint64_t msTimestamp) const
 {
-    if (!IsReady())
+    if (!m_fEnabled)
         return true;
 
@@ -237 +242 @@
 
 /**
- * Returns whether a recording stream is ready (e.g. enabled and active) or not.
+ * Returns whether a feature for a recording stream is enabled or not.
  *
  * @returns @c true if ready, @c false if not.
- */
-bool RecordingStream::IsReady(void) const
-{
-    return m_fEnabled;
+ * @param   enmFeature          Feature of stream to check enabled status for.
+ */
+bool RecordingStream::IsFeatureEnabled(RecordingFeature_T enmFeature) const
+{
+    return m_fEnabled && m_ScreenSettings.isFeatureEnabled(enmFeature);
 }
 
@@ -392 +398 @@
  *
  * @returns VBox status code.
+ * @retval  VINF_RECORDING_LIMIT_REACHED if the stream's recording limit has been reached.
  * @param   rcWait              Result of the encoding thread's wait operation.
  *                              Can be used for figuring out if the encoder has to perform some
@@ -401 +408 @@
 int RecordingStream::ThreadMain(int rcWait, RecordingBlockMap &commonBlocks)
 {
-    Log3Func(("rcWait=%Rrc\n", rcWait));
+    Log3Func(("uScreenID=%RU16, rcWait=%Rrc\n", m_uScreenID, rcWait));
+
+    uint64_t const msTimestamp = m_pCtx->GetCurrentPTS();
 
     /* No new data arrived within time? Feed the encoder with the last frame we built.
@@ -410 +419 @@
         && m_ScreenSettings.isFeatureEnabled(RecordingFeature_Video))
     {
-        return recordingCodecEncodeCurrent(&m_CodecVideo, m_pCtx->GetCurrentPTS());
+        return recordingCodecEncodeCurrent(&m_CodecVideo, msTimestamp);
     }
 
@@ -528 +537 @@
     AssertPtrReturn(pPos, VERR_INVALID_POINTER);
 
-    lock();
-
     int vrc = iterateInternal(msTimestamp);
     if (vrc != VINF_SUCCESS) /* Can return VINF_RECORDING_LIMIT_REACHED. */
-    {
-        unlock();
         return vrc;
-    }
 
     PRECORDINGFRAME pFrame = (PRECORDINGFRAME)RTMemAlloc(sizeof(RECORDINGFRAME));
@@ -544 +548 @@
     pFrame->u.Cursor.Pos = *pPos;
 
+    lock();
+
     vrc = addFrame(pFrame, msTimestamp);
 
@@ -568 +574 @@
     AssertPtrReturn(m_pCtx, VERR_WRONG_ORDER);
 
-    lock();
-
     int vrc = iterateInternal(msTimestamp);
     if (vrc != VINF_SUCCESS) /* Can return VINF_RECORDING_LIMIT_REACHED. */
-    {
-        unlock();
         return vrc;
-    }
 
     PRECORDINGFRAME pFrame = (PRECORDINGFRAME)RTMemAlloc(sizeof(RECORDINGFRAME));
@@ -589 +590 @@
     pFrame->msTimestamp = msTimestamp;
 
+    lock();
+
     vrc = addFrame(pFrame, msTimestamp);
+
+    unlock();
 
     if (RT_FAILURE(vrc))
@@ -596 +601 @@
         RecordingFrameFree(pFrame);
     }
-
-    unlock();
 
     LogFlowFuncLeaveRC(vrc);
@@ -620 +623 @@
     AssertPtrReturn(m_pCtx, VERR_WRONG_ORDER);
 
-    lock();
-
     int vrc = iterateInternal(msTimestamp);
     if (vrc != VINF_SUCCESS) /* Can return VINF_RECORDING_LIMIT_REACHED. */
-    {
-        unlock();
         return vrc;
-    }
 
     PRECORDINGFRAME pFrame = (PRECORDINGFRAME)RTMemAlloc(sizeof(RECORDINGFRAME));
@@ -633 +631 @@
 
     pFrame->u.Video = *pVideoFrame;
+
     /* Make a deep copy of the pixel data. */
-    pFrame->u.Video.pau8Buf = (uint8_t *)RTMemDup(pVideoFrame->pau8Buf, pVideoFrame->cbBuf);
+    pFrame->u.Video.pau8Buf = (uint8_t *)RTMemAlloc(pVideoFrame->cbBuf);
     AssertPtrReturnStmt(pFrame->u.Video.pau8Buf, RTMemFree(pFrame), VERR_NO_MEMORY);
-    pFrame->u.Video.cbBuf   = pVideoFrame->cbBuf;
+    size_t       offDst            = 0;
+    size_t       offSrc            = 0;
+    size_t const cbDstBytesPerLine = pVideoFrame->Info.uWidth * (pVideoFrame->Info.uBPP / 8);
+    for (uint32_t h = 0; h < pFrame->u.Video.Info.uHeight; h++)
+    {
+        memcpy(pFrame->u.Video.pau8Buf + offDst, pVideoFrame->pau8Buf + offSrc, cbDstBytesPerLine);
+        offDst += cbDstBytesPerLine;
+        offSrc += pVideoFrame->Info.uBytesPerLine;
+    }
+    pFrame->u.Video.Info.uBytesPerLine = cbDstBytesPerLine;
 
     pFrame->enmType     = RECORDINGFRAME_TYPE_VIDEO;
     pFrame->msTimestamp = msTimestamp;
 
+    lock();
+
     vrc = addFrame(pFrame, msTimestamp);
+
+    unlock();
 
     if (RT_FAILURE(vrc))
@@ -648 +660 @@
         RecordingFrameFree(pFrame);
     }
-
-    unlock();
 
     LogFlowFuncLeaveRC(vrc);

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

@@ -42 +42 @@
 #endif
 
+#define LOG_GROUP LOG_GROUP_RECORDING
 #include <VBox/log.h>
 
@@ -370 +371 @@
  * @returns VBox status code.
  * @param   pu8RGBBuf           Pointer to actual RGB image data.
+ *                              Must point right to the beginning of the pixel data (offset, if any).
  * @param   cbRGBBuf            Size (in bytes) of \a pu8RGBBuf.
  * @param   pszPath             Absolute path to dump file to. Must exist.
@@ -383 +385 @@
                                    uint32_t uWidth, uint32_t uHeight, uint32_t uBytesPerLine, uint8_t uBPP)
 {
-    RT_NOREF(cbRGBBuf);
-
     const uint8_t  uBytesPerPixel = uBPP / 8 /* Bits */;
     const size_t   cbData         = uWidth * uHeight * uBytesPerPixel;
@@ -390 +390 @@
     if (!cbData) /* No data to write? Bail out early. */
         return VINF_SUCCESS;
+
+    AssertReturn(cbData <= cbRGBBuf, VERR_INVALID_PARAMETER);
+
+    Log3Func(("pu8RGBBuf=%p, cbRGBBuf=%zu, uWidth=%RU32, uHeight=%RU32, uBytesPerLine=%RU32, uBPP=%RU8\n",
+              pu8RGBBuf, cbRGBBuf, uWidth, uHeight, uBytesPerLine, uBPP));
 
     BMPFILEHDR fileHdr;
@@ -409 +414 @@
     coreHdr.uYPelsPerMeter = 5000;
 
-    static uint64_t s_iCount = 0;
+    static uint64_t s_cRecordingUtilsBmpsDumped = 0;
 
     /* Hardcoded path for now. */
@@ -421 +426 @@
 
     char szFileName[RTPATH_MAX];
-    if (RTStrPrintf2(szFileName, sizeof(szFileName), "%s/RecDump-%04RU64-%s-w%RU16h%RU16.bmp",
-                     pszPath ? pszPath : szPath, s_iCount, pszWhat ? pszWhat : "Frame", uWidth, uHeight) <= 0)
+    if (RTStrPrintf2(szFileName, sizeof(szFileName), "%s/RecDump-%04RU64-%s-w%RU32h%RU32bpp%RU8.bmp",
+                     pszPath ? pszPath : szPath, s_cRecordingUtilsBmpsDumped, pszWhat ? pszWhat : "Frame", uWidth, uHeight, uBPP) <= 0)
         return VERR_BUFFER_OVERFLOW;
 
-    s_iCount++;
+    s_cRecordingUtilsBmpsDumped++;
 
     RTFILE fh;
@@ -436 +441 @@
 
         /* Bitmaps (DIBs) are stored upside-down (thanks, OS/2), so work from the bottom up. */
-        size_t offSrc = cbRGBBuf - uBytesPerLine;
+        size_t offSrc = uBytesPerLine * (uHeight - 1);
+        Assert(offSrc <= cbRGBBuf);
 
         /* Do the copy. */
-        for (unsigned int i = 0; i < uHeight; i++)
-        {
-            RTFileWrite(fh, pu8RGBBuf + offSrc, uBytesPerLine, NULL);
+        while (offSrc)
+        {
+            LogFunc(("offSrc=%zu\n", offSrc));
+            vrc = RTFileWrite(fh, pu8RGBBuf + offSrc, uWidth * uBytesPerPixel, NULL);
+            AssertRCBreak(vrc);
+            Assert(offSrc >= uBytesPerLine);
             offSrc -= uBytesPerLine;
-        }
-
-        RTFileClose(fh);
+
+        }
+
+        int vrc2 = RTFileClose(fh);
+        if (RT_SUCCESS(vrc))
+            vrc = vrc2;
     }