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

Timestamp:

Jun 24, 2024 5:43:00 PM (7 months ago)

Author:

vboxsync

Message:

Video Recording: Big revamp to improve overall performance. We now don't rely on the periodic display refresh callback anymore to render the entire framebuffer but now rely on delta updates ("dirty rectangles"). Also, we now only encode new frames when an area has changed. This also needed cursor position + change change notifications, as we render the cursor on the host side if mouse integration is enabled (requires 7.1 Guest Additions as of now). Optimized the BGRA32->YUV IV420 color space conversion as well as the overall amount of pixel data shuffled forth and back. Added a new testcase for the cropping/centering code. bugref:10650

Location:

trunk/src/VBox/Main/src-client

Files:

• ConsoleImpl.cpp (modified) (3 diffs)
• DisplayImpl.cpp (modified) (17 diffs)
• DrvAudioRec.cpp (modified) (3 diffs)
• MouseImpl.cpp (modified) (2 diffs)
• Recording.cpp (modified) (17 diffs)
• RecordingCodec.cpp (modified) (26 diffs)
• RecordingInternals.cpp (modified) (4 diffs)
• RecordingStream.cpp (modified) (14 diffs)
• RecordingUtils.cpp (modified) (7 diffs)

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

@@ -7666 +7666 @@
 }
 
+/**
+ * Sends a cursor shape change to the recording context.
+ *
+ * @returns VBox status code.
+ * @param   fVisible            Whether the mouse cursor actually is visible or not.
+ * @param   fAlpha              Whether the pixel data contains alpha channel information or not.
+ * @param   xHot                X hot position (in pixel) of the new cursor.
+ * @param   yHot                Y hot position (in pixel) of the new cursor.
+ * @param   uWidth              Width (in pixel) of the new cursor.
+ * @param   uHeight             Height (in pixel) of the new cursor.
+ * @param   pu8Shape            Pixel data of the new cursor.
+ * @param   cbShape             Size of \a pu8Shape (in bytes).
+ */
+int Console::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)
+{
+    if (!mRecording.mCtx.IsStarted())
+        return VINF_SUCCESS;
+
+    return mRecording.mCtx.SendCursorShapeChange(fVisible, fAlpha, xHot, yHot, uWidth, uHeight, pu8Shape, cbShape,
+                                                 mRecording.mCtx.GetCurrentPTS());
+}
 #endif /* VBOX_WITH_RECORDING */
 
@@ -7795 +7816 @@
 
     if (!mMouse.isNull())
-       mMouse->updateMousePointerShape(fVisible, fAlpha, xHot, yHot, width, height, pu8Shape, cbShape);
+       mMouse->i_updatePointerShape(fVisible, fAlpha, xHot, yHot, width, height, pu8Shape, cbShape);
 
     com::SafeArray<BYTE> shape(cbShape);
@@ -7801 +7822 @@
         memcpy(shape.raw(), pu8Shape, cbShape);
     ::FireMousePointerShapeChangedEvent(mEventSource, fVisible, fAlpha, xHot, yHot, width, height, ComSafeArrayAsInParam(shape));
+
+#ifdef VBOX_WITH_RECORDING
+    i_recordingCursorShapeChange(fVisible, fAlpha, xHot, yHot, width, height, pu8Shape, cbShape);
+#endif
 
 #if 0

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

@@ -34 +34 @@
 #include "ConsoleVRDPServer.h"
 #include "GuestImpl.h"
+#include "MouseImpl.h"
 #include "VMMDev.h"
 
@@ -61 +62 @@
 # include <iprt/path.h>
 # include "Recording.h"
+# include "RecordingUtils.h"
 
 # include <VBox/vmm/pdmapi.h>
@@ -590 +592 @@
         maFramebuffers[uScreenId].updateImage.cbLine = 0;
         maFramebuffers[uScreenId].pFramebuffer.setNull();
-#ifdef VBOX_WITH_RECORDING
-        maFramebuffers[uScreenId].Recording.pSourceBitmap.setNull();
-#endif
     }
 
@@ -797 +796 @@
     const bool fDisabled = pFBInfo->fDisabled;
 
+#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())
     {
-        HRESULT hr = pFramebuffer->NotifyChange(uScreenId, 0, 0, w, h); /** @todo origin */
-        LogFunc(("NotifyChange hr %08X\n", hr));
-        NOREF(hr);
+        HRESULT hrc = pFramebuffer->NotifyChange(uScreenId, 0, 0, w, h); /** @todo origin */
+        LogFunc(("NotifyChange hr %08X\n", hrc));
+        RT_NOREF(hrc);
     }
 
@@ -828 +832 @@
         i_handleSetVisibleRegion(mcRectVisibleRegion, mpRectVisibleRegion);
 
-#ifdef VBOX_WITH_RECORDING
-    i_recordingScreenChanged(uScreenId);
-#endif
-
     LogRelFlowFunc(("[%d]: default format %d\n", uScreenId, pFBInfo->fDefaultFormat));
 
@@ -909 +909 @@
             {
                 pFramebuffer->NotifyUpdate(x, y, w, h);
+
+#ifdef VBOX_WITH_RECORDING
+                RECORDINGVIDEOFRAME Frame =
+                {
+                    (uint16_t)w, (uint16_t)h,
+                    (uint8_t )pFBInfo->u16BitsPerPixel, RECORDINGPIXELFMT_BRGA32, pFBInfo->u32LineSize,
+                    pFBInfo->pu8FramebufferVRAM + (y * pFBInfo->u32LineSize + x * (pFBInfo->u16BitsPerPixel / 8)),
+                    pFBInfo->w * pFBInfo->u32LineSize,
+                    (uint16_t)x, (uint16_t)y
+                };
+                i_recordingScreenUpdate(uScreenId, &Frame);
+#endif
             }
         }
@@ -943 +955 @@
                             pFBInfo->updateImage.pu8Address = pAddress;
                             pFBInfo->updateImage.cbLine = ulBytesPerLine;
+#ifdef VBOX_WITH_RECORDING
+                            RECORDINGVIDEOFRAME Frame =
+                            {
+                                (uint16_t)ulWidth, (uint16_t)ulHeight,
+                                (uint8_t )ulBitsPerPixel, RECORDINGPIXELFMT_BRGA32, ulBytesPerLine,
+                                pAddress, ulHeight * ulBytesPerLine,
+                                0, 0
+                            };
+
+                            i_recordingScreenUpdate(uScreenId, &Frame);
+#endif
                         }
 
@@ -972 +995 @@
                     i_checkCoordBounds(&x, &y, &w, &h, ulWidth, ulHeight);
 
-                    if (w != 0 && h != 0)
+                    if (   w != 0
+                        && h != 0)
                     {
-                        const size_t cbData = w * h * 4;
+                        unsigned const uBytesPerPixel = ulBitsPerPixel / 8;
+
+                        const size_t cbData = w * h * uBytesPerPixel;
                         com::SafeArray<BYTE> image(cbData);
 
                         uint8_t *pu8Dst = image.raw();
-                        const uint8_t *pu8Src = pbAddress + ulBytesPerLine * y + x * 4;
-
-                        int i;
-                        for (i = y; i < y + h; ++i)
+                        const uint8_t *pu8Src = pbAddress + ulBytesPerLine * y + x * uBytesPerPixel;
+
+                        for (int i = y; i < y + h; ++i)
                         {
-                            memcpy(pu8Dst, pu8Src, w * 4);
-                            pu8Dst += w * 4;
+                            memcpy(pu8Dst, pu8Src, w * uBytesPerPixel);
+                            pu8Dst += w * uBytesPerPixel;
                             pu8Src += ulBytesPerLine;
                         }
 
                         pFramebuffer->NotifyUpdateImage(x, y, w, h, ComSafeArrayAsInParam(image));
+
+#ifdef VBOX_WITH_RECORDING
+                        RECORDINGVIDEOFRAME Frame =
+                        {
+                            (uint16_t)w, (uint16_t)h,
+                            (uint8_t)ulBitsPerPixel, RECORDINGPIXELFMT_BRGA32, ulBytesPerLine,
+                            pu8Dst, h * ulBytesPerLine,
+                            (uint16_t)x, (uint16_t)y
+                        };
+
+                        i_recordingScreenUpdate(uScreenId, &Frame);
+#endif
                     }
                 }
@@ -1128 +1165 @@
 /** Updates the device's view of the host cursor handling capabilities.
  *  Calls into mpDrv->pUpPort. */
-void Display::i_UpdateDeviceCursorCapabilities(void)
+void Display::i_updateDeviceCursorCapabilities(void)
 {
     bool fRenderCursor = true;
@@ -1172 +1209 @@
     alock.release();  /* Release before calling up for lock order reasons. */
     mfHostCursorCapabilities = fHostCursorCapabilities;
-    i_UpdateDeviceCursorCapabilities();
+    i_updateDeviceCursorCapabilities();
     return S_OK;
 }
@@ -1419 +1456 @@
 
     i_VideoAccelVRDP(fConnect, c);
-    i_UpdateDeviceCursorCapabilities();
+    i_updateDeviceCursorCapabilities();
 }
 
@@ -2150 +2187 @@
  * @returns VBox status code.
  * @param   fForce              Whether to force invalidation or not. Default is @c false.
+ *
+ * @note    Takes the display's read lock.
  */
 int Display::i_recordingInvalidate(bool fForce /* = false */)
@@ -2156 +2195 @@
     if (!pCtx)
         return VINF_SUCCESS;
+
+    LogFlowFuncEnter();
+
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
     /*
@@ -2169 +2212 @@
         maRecordingEnabled[uScreen] = fStreamEnabled;
 
-        if (fChanged && uScreen < mcMonitors)
-            i_recordingScreenChanged(uScreen);
+        if (   fStreamEnabled
+            && fChanged)
+        {
+            DISPLAYFBINFO const *pFBInfo = &maFramebuffers[uScreen];
+            /* ignore rc */ i_recordingScreenChanged(uScreen, pFBInfo);
+        }
     }
 
@@ -2179 +2226 @@
  * Called when the recording state of a screen got changed.
  *
+ * @returns VBox status code.
  * @param   uScreenId           ID of screen for which the recording state got changed.
+ * @param   pFBInfo             Frame buffer information to use.
  */
-void Display::i_recordingScreenChanged(unsigned uScreenId)
-{
+int Display::i_recordingScreenChanged(unsigned uScreenId, const DISPLAYFBINFO *pFBInfo)
+{
+    AssertReturn(uScreenId < mcMonitors, VERR_INVALID_PARAMETER);
+
     RecordingContext *pCtx = mParent->i_recordingGetContext();
 
-    i_UpdateDeviceCursorCapabilities();
+    i_updateDeviceCursorCapabilities();
     if (   RT_LIKELY(!maRecordingEnabled[uScreenId])
         || !pCtx || !pCtx->IsStarted())
     {
         /* Skip recording this screen. */
-        return;
-    }
-
-    /* Get a new source bitmap which will be used by video recording code. */
-    ComPtr<IDisplaySourceBitmap> pSourceBitmap;
-    QuerySourceBitmap(uScreenId, pSourceBitmap.asOutParam());
-
-    int vrc2 = RTCritSectEnter(&mVideoRecLock);
-    if (RT_SUCCESS(vrc2))
-    {
-        maFramebuffers[uScreenId].Recording.pSourceBitmap = pSourceBitmap;
-
-        vrc2 = RTCritSectLeave(&mVideoRecLock);
-        AssertRC(vrc2);
-    }
+        return VINF_SUCCESS;
+    }
+
+    LogFlowFuncEnter();
+
+    RECORDINGSURFACEINFO ScreenInfo;
+    ScreenInfo.uWidth      = pFBInfo->w;
+    ScreenInfo.uHeight     = pFBInfo->h;
+    ScreenInfo.uBPP        = (uint8_t)pFBInfo->u16BitsPerPixel;
+    ScreenInfo.enmPixelFmt = RECORDINGPIXELFMT_BRGA32; /** @todo Does this apply everywhere? */
+
+    uint64_t const tsNowMs = pCtx->GetCurrentPTS();
+
+    int vrc = pCtx->SendScreenChange(uScreenId, &ScreenInfo, tsNowMs);
+    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 =
+            {
+                (uint16_t)pFBInfo->w, (uint16_t)pFBInfo->h,
+                (uint8_t)pFBInfo->u16BitsPerPixel, RECORDINGPIXELFMT_BRGA32, pFBInfo->u32LineSize, //pFBInfo->w * (pFBInfo->u16BitsPerPixel / 8),
+                pFBInfo->pu8FramebufferVRAM, pFBInfo->h * pFBInfo->u32LineSize, 0, 0
+            };
+
+            vrc = i_recordingScreenUpdate(uScreenId, &Frame);
+        }
+    }
+
+    LogFlowFuncLeaveRC(vrc);
+    return vrc;
+}
+
+/**
+ * Called when a part of a screen got updated.
+ *
+ * @returns VBox status code.
+ * @param   uScreenId           ID of screen which got updated.
+ * @param   pFrame              Video frama to send.
+ */
+int Display::i_recordingScreenUpdate(unsigned uScreenId, PRECORDINGVIDEOFRAME pFrame)
+{
+    if (!maRecordingEnabled[uScreenId])
+        return VINF_NO_CHANGE;
+
+    AssertPtr(mParent);
+    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;
+    }
+
+    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);
+    }
+
+    return vrc;
+}
+
+/**
+ * Called when the mouse cursor position has changed within the guest.
+ *
+ * @returns VBox status code.
+ * @param   uScreenId           ID of screen.
+ * @param   fFlags              Position flags. Not used yet.
+ * @param   x                   X position of the mouse cursor (within guest).
+ * @param   y                   Y position of the mouse cursor (within guest).
+ *
+ * @note    Requires Guest Additions installed + mouse integration enabled.
+ */
+int Display::i_recordingCursorPositionChange(unsigned uScreenId, uint32_t fFlags, int32_t x, int32_t y)
+{
+    RT_NOREF(fFlags);
+
+#if 0 /** @todo For whatever reason we always report SVGA_ID_INVALID here. Needs investigation. */
+    if (   uScreenId > mcMonitors /* Might be SVGA_ID_INVALID. */
+        || !maRecordingEnabled[uScreenId])
+        return VINF_SUCCESS;
+#endif
+
+    AssertPtr(mParent);
+    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;
 }
 #endif /* VBOX_WITH_RECORDING */
@@ -3024 +3197 @@
         }
     }
-
-#ifdef VBOX_WITH_RECORDING
-    AssertPtr(pDisplay->mParent);
-    RecordingContext *pCtx = pDisplay->mParent->i_recordingGetContext();
-
-    if (   pCtx
-        && pCtx->IsStarted()
-        && pCtx->IsFeatureEnabled(RecordingFeature_Video))
-    {
-        do
-        {
-            /* If the recording context has reached the configured recording
-             * limit, disable recording. */
-            if (pCtx->IsLimitReached())
-            {
-                pDisplay->mParent->i_onRecordingChange(FALSE /* Disable */);
-                break;
-            }
-
-            STAM_PROFILE_START(&pDisplay->Stats.Recording.profileRecording, b);
-
-            uint64_t tsNowMs = RTTimeProgramMilliTS();
-            for (uScreenId = 0; uScreenId < pDisplay->mcMonitors; uScreenId++)
-            {
-                if (!pDisplay->maRecordingEnabled[uScreenId])
-                    continue;
-
-                if (!pCtx->NeedsUpdate(uScreenId, tsNowMs))
-                    continue;
-
-                STAM_PROFILE_START(&pDisplay->Stats.Monitor[uScreenId].Recording.profileRecording, c);
-
-                DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[uScreenId];
-                if (!pFBInfo->fDisabled)
-                {
-                    ComPtr<IDisplaySourceBitmap> pSourceBitmap;
-                    int vrc2 = RTCritSectEnter(&pDisplay->mVideoRecLock);
-                    if (RT_SUCCESS(vrc2))
-                    {
-                        pSourceBitmap = pFBInfo->Recording.pSourceBitmap;
-                        RTCritSectLeave(&pDisplay->mVideoRecLock);
-                    }
-
-                    if (!pSourceBitmap.isNull())
-                    {
-                        BYTE *pbAddress = NULL;
-                        ULONG ulWidth = 0;
-                        ULONG ulHeight = 0;
-                        ULONG ulBitsPerPixel = 0;
-                        ULONG ulBytesPerLine = 0;
-                        BitmapFormat_T bitmapFormat = BitmapFormat_Opaque;
-                        HRESULT hrc = pSourceBitmap->QueryBitmapInfo(&pbAddress,
-                                                                     &ulWidth,
-                                                                     &ulHeight,
-                                                                     &ulBitsPerPixel,
-                                                                     &ulBytesPerLine,
-                                                                     &bitmapFormat);
-                        if (SUCCEEDED(hrc) && pbAddress)
-                            vrc = pCtx->SendVideoFrame(uScreenId, 0, 0, BitmapFormat_BGR,
-                                                       ulBitsPerPixel, ulBytesPerLine, ulWidth, ulHeight,
-                                                       pbAddress, tsNowMs);
-                        else
-                            vrc = VERR_NOT_SUPPORTED;
-
-                        pSourceBitmap.setNull();
-                    }
-                    else
-                        vrc = VERR_NOT_SUPPORTED;
-
-                    if (vrc == VINF_TRY_AGAIN)
-                        break;
-                }
-
-                STAM_PROFILE_STOP(&pDisplay->Stats.Monitor[uScreenId].Recording.profileRecording, c);
-            }
-
-            STAM_PROFILE_STOP(&pDisplay->Stats.Recording.profileRecording, b);
-
-        } while (0);
-    }
-#endif /* VBOX_WITH_RECORDING */
 
     STAM_PROFILE_STOP(&pDisplay->Stats.profileDisplayRefreshCallback, a);
@@ -3693 +3785 @@
     }
     ::FireCursorPositionChangedEvent(pThis->mParent->i_getEventSource(), RT_BOOL(fFlags & VBVA_CURSOR_VALID_DATA), x, y);
+
+# ifdef VBOX_WITH_RECORDING
+    pThis->i_recordingCursorPositionChange(aScreenId, fFlags, x, y);
+# endif
 }
 

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

@@ -318 +318 @@
             /* Make sure to let the driver backend know that we need the audio data in
              * a specific sampling rate the codec is optimized for. */
-            pCfgAcq->Props = pCodec->Parms.Audio.PCMProps;
+            pCfgAcq->Props = pCodec->Parms.u.Audio.PCMProps;
 
             /* Every codec frame marks a period for now. Optimize this later. */
@@ -491 +491 @@
                                                        const void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten)
 {
-    RT_NOREF(pInterface);
-    PAVRECSTREAM pStreamAV = (PAVRECSTREAM)pStream;
+    PDRVAUDIORECORDING pThis = RT_FROM_CPP_MEMBER(pInterface, DRVAUDIORECORDING, IHostAudio);
+    PAVRECSTREAM pStreamAV   = (PAVRECSTREAM)pStream;
     AssertPtrReturn(pStreamAV, VERR_INVALID_POINTER);
     if (cbBuf)
@@ -561 +561 @@
             if (cbSrc == cbFrame) /* Only send full codec frames. */
             {
-                vrc = pRecStream->SendAudioFrame(pStreamAV->pvSrcBuf, cbSrc, RTTimeProgramMilliTS());
+                AssertPtr(pThis->pRecCtx);
+                vrc = pRecStream->SendAudioFrame(pStreamAV->pvSrcBuf, cbSrc, pThis->pRecCtx->GetCurrentPTS());
                 if (RT_FAILURE(vrc))
                     break;

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

@@ -323 +323 @@
 }
 
-void Mouse::updateMousePointerShape(bool fVisible, bool fAlpha,
-                                    uint32_t hotX, uint32_t hotY,
-                                    uint32_t width, uint32_t height,
-                                    const uint8_t *pu8Shape, uint32_t cbShape)
+/**
+ * Updates the pointer shape data.
+ *
+ * @returns VBox status code.
+ * @param   fVisible            Whether the mouse cursor actually is visible or not.
+ * @param   fAlpha              Whether the pixel data contains an alpha mask or not.
+ * @param   uHotX               X hot position (in pixel) of the new cursor.
+ * @param   uHotY               Y hot position (in pixel) of the new cursor.
+ * @param   uWidth              Width (in pixel) of the new cursor.
+ * @param   uHeight             Height (in pixel) of the new cursor.
+ * @param   pu8Shape            Pixel data of the new cursor.
+ * @param   cbShape             Size of \a pu8Shape (in bytes).
+ *
+ * @note    Takes the write lock.
+ */
+int Mouse::i_updatePointerShape(bool fVisible, bool fAlpha,
+                                uint32_t uHotX, uint32_t uHotY,
+                                uint32_t uWidth, uint32_t uHeight,
+                                const uint8_t *pu8Shape, uint32_t cbShape)
 {
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    RTMemFree(mPointerData.pu8Shape);
-    mPointerData.pu8Shape = NULL;
-    mPointerData.cbShape = 0;
-
-    mPointerData.fVisible = fVisible;
-    mPointerData.fAlpha   = fAlpha;
-    mPointerData.hotX     = hotX;
-    mPointerData.hotY     = hotY;
-    mPointerData.width    = width;
-    mPointerData.height   = height;
-    if (cbShape)
-    {
-        mPointerData.pu8Shape = (uint8_t *)RTMemDup(pu8Shape, cbShape);
-        if (mPointerData.pu8Shape)
-        {
-            mPointerData.cbShape = cbShape;
-        }
-    }
-
-    mPointerShape.setNull();
+    mPointerData.Destroy(); /* Destroy old data first. */
+
+    int vrc = mPointerData.Init(fVisible, fAlpha, uHotX, uHotY, uWidth, uHeight, pu8Shape, cbShape);
+    if (RT_SUCCESS(vrc))
+    {
+        mPointerShape.setNull();
+    }
+
+    return vrc;
 }
 
@@ -1124 +1128 @@
 {
     return RT_BOOL(mfVMMDevGuestCaps & VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR);
+}
+
+
+/**
+ * Returns the current mouse pointer data.
+ *
+ * @returns VBox status code.
+ * @param   aData               Where to return the current mouse pointer data.
+ */
+int Mouse::i_getPointerShape(MousePointerData &aData)
+{
+    AutoReadLock aLock(this COMMA_LOCKVAL_SRC_POS);
+
+    return aData.Init(mPointerData);
 }
 

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

@@ -68 +68 @@
 
 
+
+RecordingCursorState::RecordingCursorState()
+    : m_fFlags(VBOX_RECORDING_CURSOR_F_NONE)
+{
+    m_Shape.Pos.x = UINT16_MAX;
+    m_Shape.Pos.y = UINT16_MAX;
+
+    RT_ZERO(m_Shape);
+}
+
+RecordingCursorState::~RecordingCursorState()
+{
+    Destroy();
+}
+
+/**
+ * Destroys a cursor state.
+ */
+void RecordingCursorState::Destroy(void)
+{
+    RecordingVideoFrameDestroy(&m_Shape);
+}
+
+/**
+ * Creates or updates the cursor shape.
+ *
+ * @returns VBox status code.
+ * @param   fAlpha              Whether the pixel data contains alpha channel information or not.
+ * @param   uWidth              Width (in pixel) of new cursor shape.
+ * @param   uHeight             Height (in pixel) of new cursor shape.
+ * @param   pu8Shape            Pixel data of new cursor shape.
+ * @param   cbShape             Bytes of \a pu8Shape.
+ */
+int RecordingCursorState::CreateOrUpdate(bool fAlpha, uint32_t uWidth, uint32_t uHeight, const uint8_t *pu8Shape, size_t cbShape)
+{
+    int vrc;
+
+    uint32_t fFlags = RECORDINGVIDEOFRAME_F_VISIBLE;
+
+    const uint8_t uBPP = 32; /* Seems to be fixed. */
+
+    uint32_t offShape;
+    if (fAlpha)
+    {
+        /* Calculate the offset to the actual pixel data. */
+        offShape = (uWidth + 7) / 8 * uHeight; /* size of the AND mask */
+        offShape = (offShape + 3) & ~3;
+        AssertReturn(offShape <= cbShape, VERR_INVALID_PARAMETER);
+        fFlags |= RECORDINGVIDEOFRAME_F_BLIT_ALPHA;
+    }
+    else
+        offShape = 0;
+
+    /* Cursor shape size has become bigger? Reallocate. */
+    if (cbShape > m_Shape.cbBuf)
+    {
+        RecordingVideoFrameDestroy(&m_Shape);
+        vrc = RecordingVideoFrameInit(&m_Shape, fFlags, uWidth, uHeight, 0 /* posX */, 0 /* posY */,
+                                      uBPP, RECORDINGPIXELFMT_BRGA32);
+    }
+    else /* Otherwise just zero out first. */
+    {
+        RecordingVideoFrameClear(&m_Shape);
+        vrc = VINF_SUCCESS;
+    }
+
+    if (RT_SUCCESS(vrc))
+        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
+    RecordingUtilsDbgDumpVideoFrameEx(&m_Shape, "/tmp/recording", "cursor-update");
+#endif
+
+    return vrc;
+}
+
+/**
+ * Moves (sets) the cursor to a new position.
+ *
+ * @returns VBox status code.
+ * @retval  VERR_NO_CHANGE if the cursor wasn't moved (set).
+ * @param   iX                  New X position to set.
+ * @param   iY                  New Y position to set.
+ */
+int RecordingCursorState::Move(int32_t iX, int32_t iY)
+{
+    /* No relative coordinates here. */
+    if (   iX < 0
+        || iY < 0)
+        return VERR_NO_CHANGE;
+
+    if (   m_Shape.Pos.x == (uint32_t)iX
+        && m_Shape.Pos.y == (uint32_t)iY)
+        return VERR_NO_CHANGE;
+
+    m_Shape.Pos.x = (uint16_t)iX;
+    m_Shape.Pos.y = (uint16_t)iY;
+
+    return VINF_SUCCESS;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
 /**
  * Recording context constructor.
@@ -129 +234 @@
     for (;;)
     {
-        int vrc = RTSemEventWait(pThis->m_WaitEvent, RT_INDEFINITE_WAIT);
-        AssertRCBreak(vrc);
-
-        Log2Func(("Processing %zu streams\n", pThis->m_vecStreams.size()));
+        int vrcWait = RTSemEventWait(pThis->m_WaitEvent, RT_MS_1SEC);
+
+        Log2Func(("Processing %zu streams (wait = %Rrc)\n", pThis->m_vecStreams.size(), vrcWait));
 
         /* Process common raw blocks (data which not has been encoded yet). */
-        vrc = pThis->processCommonData(pThis->m_mapBlocksRaw, 100 /* ms timeout */);
+        int vrc = pThis->processCommonData(pThis->m_mapBlocksRaw, 100 /* ms timeout */);
 
         /** @todo r=andy This is inefficient -- as we already wake up this thread
@@ -146 +250 @@
 
             /* Hand-in common encoded blocks. */
-            vrc = pStream->Process(pThis->m_mapBlocksEncoded);
+            vrc = pStream->ThreadMain(vrcWait, pThis->m_mapBlocksEncoded);
             if (RT_FAILURE(vrc))
             {
@@ -207 +311 @@
         {
             RecordingBlock *pBlockCommon = (RecordingBlock *)(*itBlock);
-            switch (pBlockCommon->enmType)
+            PRECORDINGFRAME pFrame = (PRECORDINGFRAME)pBlockCommon->pvData;
+            AssertPtr(pFrame);
+            switch (pFrame->enmType)
             {
 #ifdef VBOX_WITH_AUDIO_RECORDING
-                case RECORDINGBLOCKTYPE_AUDIO:
+                case RECORDINGFRAME_TYPE_AUDIO:
                 {
-                    PRECORDINGAUDIOFRAME pAudioFrame = (PRECORDINGAUDIOFRAME)pBlockCommon->pvData;
-
-                    RECORDINGFRAME Frame;
-                    Frame.msTimestamp = pBlockCommon->msTimestamp;
-                    Frame.Audio.pvBuf = pAudioFrame->pvBuf;
-                    Frame.Audio.cbBuf = pAudioFrame->cbBuf;
-
-                    vrc = recordingCodecEncode(&m_CodecAudio, &Frame, NULL, NULL);
+                    vrc = recordingCodecEncodeFrame(&m_CodecAudio, pFrame, pFrame->msTimestamp, NULL /* pvUser */);
                     break;
                 }
 #endif /* VBOX_WITH_AUDIO_RECORDING */
-                default:
-                    /* Skip unknown stuff. */
-                    break;
+
+            default:
+                /* Skip unknown stuff. */
+                break;
             }
 
@@ -278 +378 @@
                  pCodec, cbData, msTimestamp, uFlags));
 
-    /** @todo Optimize this! Three allocations in here! */
-
-    RECORDINGBLOCKTYPE const enmType = pCodec->Parms.enmType == RECORDINGCODECTYPE_AUDIO
-                                     ? RECORDINGBLOCKTYPE_AUDIO : RECORDINGBLOCKTYPE_UNKNOWN;
-
-    AssertReturn(enmType != RECORDINGBLOCKTYPE_UNKNOWN, VERR_NOT_SUPPORTED);
-
-    RecordingBlock *pBlock = new RecordingBlock();
+    RECORDINGFRAME_TYPE const enmType = pCodec->Parms.enmType == RECORDINGCODECTYPE_AUDIO
+                                      ? RECORDINGFRAME_TYPE_AUDIO : RECORDINGFRAME_TYPE_INVALID;
+
+    AssertReturn(enmType != RECORDINGFRAME_TYPE_INVALID, VERR_NOT_SUPPORTED);
+
+    PRECORDINGFRAME pFrame = NULL;
 
     switch (enmType)
     {
-        case RECORDINGBLOCKTYPE_AUDIO:
-        {
-            PRECORDINGAUDIOFRAME pFrame = (PRECORDINGAUDIOFRAME)RTMemAlloc(sizeof(RECORDINGAUDIOFRAME));
+        case RECORDINGFRAME_TYPE_AUDIO:
+        {
+            pFrame = (PRECORDINGFRAME)RTMemAlloc(sizeof(RECORDINGFRAME));
             AssertPtrReturn(pFrame, VERR_NO_MEMORY);
-
-            pFrame->pvBuf = (uint8_t *)RTMemAlloc(cbData);
-            AssertPtrReturn(pFrame->pvBuf, VERR_NO_MEMORY);
-            pFrame->cbBuf = cbData;
-
-            memcpy(pFrame->pvBuf, pvData, cbData);
-
-            pBlock->enmType     = enmType;
-            pBlock->pvData      = pFrame;
-            pBlock->cbData      = sizeof(RECORDINGAUDIOFRAME) + cbData;
-            pBlock->cRefs       = m_cStreamsEnabled;
-            pBlock->msTimestamp = msTimestamp;
-            pBlock->uFlags      = uFlags;
-
+            pFrame->enmType     = RECORDINGFRAME_TYPE_AUDIO;
+            pFrame->msTimestamp = msTimestamp;
+
+            PRECORDINGAUDIOFRAME pAudioFrame = &pFrame->u.Audio;
+            pAudioFrame->pvBuf = (uint8_t *)RTMemDup(pvData, cbData);
+            AssertPtrReturn(pAudioFrame->pvBuf, VERR_NO_MEMORY);
+            pAudioFrame->cbBuf = cbData;
             break;
         }
@@ -319 +410 @@
     int vrc;
 
+    RecordingBlock *pBlock = NULL;
     try
     {
+        pBlock = new RecordingBlock();
+
+        pBlock->pvData      = pFrame;
+        pBlock->cbData      = sizeof(RECORDINGFRAME);
+        pBlock->cRefs       = m_cStreamsEnabled;
+        pBlock->msTimestamp = msTimestamp;
+        pBlock->uFlags      = uFlags;
+
         RecordingBlockMap::iterator itBlocks = mapCommon.find(msTimestamp);
         if (itBlocks == mapCommon.end())
@@ -334 +434 @@
         vrc = VINF_SUCCESS;
     }
-    catch (const std::exception &ex)
-    {
-        RT_NOREF(ex);
+    catch (const std::exception &)
+    {
         vrc = VERR_NO_MEMORY;
     }
@@ -343 +442 @@
 
     if (RT_SUCCESS(vrc))
+    {
         vrc = threadNotify();
+    }
+    else
+    {
+        if (pBlock)
+            delete pBlock;
+        RecordingFrameFree(pFrame);
+    }
 
     return vrc;
@@ -448 +555 @@
     if (RT_SUCCESS(vrc))
     {
-        m_tsStartMs = RTTimeMilliTS();
+        m_tsStartMs = 0;
         m_enmState  = RECORDINGSTS_CREATED;
         m_fShutdown = false;
@@ -474 +581 @@
     Assert(m_enmState == RECORDINGSTS_CREATED);
 
+    m_tsStartMs = RTTimeMilliTS();
+
     int vrc = RTThreadCreate(&m_Thread, RecordingContext::threadMain, (void *)this, 0,
                              RTTHREADTYPE_MAIN_WORKER, RTTHREADFLAGS_WAITABLE, "Record");
@@ -483 +592 @@
     {
         LogRel(("Recording: Started\n"));
-        m_enmState = RECORDINGSTS_STARTED;
+        m_enmState  = RECORDINGSTS_STARTED;
     }
     else
@@ -516 +625 @@
     {
         LogRel(("Recording: Stopped\n"));
-        m_enmState = RECORDINGSTS_CREATED;
+        m_tsStartMs = 0;
+        m_enmState  = RECORDINGSTS_CREATED;
     }
     else
@@ -689 +799 @@
 
 /**
+ * Returns the current PTS (presentation time stamp) for a recording context.
+ *
+ * @returns Current PTS.
+ */
+uint64_t RecordingContext::GetCurrentPTS(void) const
+{
+    return RTTimeMilliTS() - m_tsStartMs;
+}
+
+/**
  * Returns if a specific recoding feature is enabled for at least one of the attached
  * recording streams or not.
@@ -829 +949 @@
  * @param   msTimestamp         Timestamp (PTS, in ms).
  */
-bool RecordingContext::NeedsUpdate( uint32_t uScreen, uint64_t msTimestamp)
+bool RecordingContext::NeedsUpdate(uint32_t uScreen, uint64_t msTimestamp)
 {
     lock();
@@ -900 +1020 @@
  *
  * @returns VBox status code.
- * @param   uScreen            Screen number to send video frame to.
- * @param   x                  Starting x coordinate of the video frame.
- * @param   y                  Starting y coordinate of the video frame.
- * @param   uPixelFormat       Pixel format.
- * @param   uBPP               Bits Per Pixel (BPP).
- * @param   uBytesPerLine      Bytes per scanline.
- * @param   uSrcWidth          Width of the video frame.
- * @param   uSrcHeight         Height of the video frame.
- * @param   puSrcData          Pointer to video frame data.
- * @param   msTimestamp        Timestamp (PTS, in ms).
- */
-int RecordingContext::SendVideoFrame(uint32_t uScreen, uint32_t x, uint32_t y,
-                                     uint32_t uPixelFormat, uint32_t uBPP, uint32_t uBytesPerLine,
-                                     uint32_t uSrcWidth, uint32_t uSrcHeight, uint8_t *puSrcData,
-                                     uint64_t msTimestamp)
-{
-    AssertReturn(uSrcWidth,  VERR_INVALID_PARAMETER);
-    AssertReturn(uSrcHeight, VERR_INVALID_PARAMETER);
-    AssertReturn(puSrcData,  VERR_INVALID_POINTER);
+ * @param   uScreen             Screen number to send video frame to.
+ * @param   pFrame              Video frame to send.
+ * @param   msTimestamp         Timestamp (PTS, in ms).
+ */
+int RecordingContext::SendVideoFrame(uint32_t uScreen, PRECORDINGVIDEOFRAME pFrame, uint64_t msTimestamp)
+{
+    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));
+
+    if (!pFrame->pau8Buf) /* Empty / invalid frame, skip. */
+        return VINF_SUCCESS;
+
+    /* Sanity. */
+    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();
@@ -931 +1049 @@
     }
 
-    int vrc = pStream->SendVideoFrame(x, y, uPixelFormat, uBPP, uBytesPerLine, uSrcWidth, uSrcHeight, puSrcData, msTimestamp);
+    int vrc = pStream->SendVideoFrame(pFrame, msTimestamp);
 
     unlock();
@@ -944 +1062 @@
 }
 
+/**
+ * Sends a cursor position change to the recording context.
+ *
+ * @returns VBox status code.
+ * @param   uScreen            Screen number.
+ * @param   x                  X location within the guest.
+ * @param   y                  Y location within the guest.
+ * @param   msTimestamp        Timestamp (PTS, in ms).
+ */
+int RecordingContext::SendCursorPositionChange(uint32_t uScreen, int32_t x, int32_t y, uint64_t msTimestamp)
+{
+    LogFlowFunc(("uScreen=%RU32, x=%RU32, y=%RU32\n", uScreen, x, y));
+
+    /* If no cursor shape is set yet, skip any cursor position changes. */
+    if (!m_Cursor.m_Shape.pau8Buf)
+        return VINF_SUCCESS;
+
+    if (uScreen == 0xFFFFFFFF /* SVGA_ID_INVALID */)
+        uScreen = 0;
+
+    int vrc = m_Cursor.Move(x, y);
+    if (RT_SUCCESS(vrc))
+    {
+        lock();
+
+        RecordingStream *pStream = getStreamInternal(uScreen);
+        if (!pStream)
+        {
+            unlock();
+
+            AssertFailed();
+            return VERR_NOT_FOUND;
+        }
+
+        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. */
+        {
+            threadNotify();
+        }
+    }
+
+    return vrc;
+}
+
+/**
+ * Sends a cursor shape change to the recording context.
+ *
+ * @returns VBox status code.
+ * @param   fVisible            Whether the mouse cursor actually is visible or not.
+ * @param   fAlpha              Whether the pixel data contains alpha channel information or not.
+ * @param   xHot                X hot position (in pixel) of the new cursor.
+ * @param   yHot                Y hot position (in pixel) of the new cursor.
+ * @param   uWidth              Width (in pixel) of the new cursor.
+ * @param   uHeight             Height (in pixel) of the new cursor.
+ * @param   pu8Shape            Pixel data of the new cursor. Must be 32 BPP RGBA for now.
+ * @param   cbShape             Size of \a pu8Shape (in bytes).
+ * @param   msTimestamp         Timestamp (PTS, in ms).
+ */
+int RecordingContext::SendCursorShapeChange(bool fVisible, bool fAlpha, uint32_t xHot, uint32_t yHot,
+                                            uint32_t uWidth, uint32_t uHeight, const uint8_t *pu8Shape, size_t cbShape,
+                                            uint64_t msTimestamp)
+{
+    RT_NOREF(fAlpha, xHot, yHot);
+
+    LogFlowFunc(("fVisible=%RTbool, fAlpha=%RTbool, uWidth=%RU32, uHeight=%RU32\n", fVisible, fAlpha, uWidth, uHeight));
+
+    if (   !pu8Shape /* Might be NULL on saved state load. */
+        || !fVisible)
+        return VINF_SUCCESS;
+
+    AssertReturn(cbShape, VERR_INVALID_PARAMETER);
+
+    lock();
+
+    int vrc = m_Cursor.CreateOrUpdate(fAlpha, uWidth, uHeight, pu8Shape, cbShape);
+
+    RecordingStreams::iterator it = m_vecStreams.begin();
+    while (it != m_vecStreams.end())
+    {
+        RecordingStream *pStream = (*it);
+
+        int vrc2 = pStream->SendCursorShape(0 /* idCursor */, &m_Cursor.m_Shape, msTimestamp);
+        if (RT_SUCCESS(vrc))
+            vrc = vrc2;
+
+        ++it;
+    }
+
+    unlock();
+
+    if (RT_SUCCESS(vrc))
+        threadNotify();
+
+    return vrc;
+}
+
+/**
+ * Sends a screen change to a recording stream.
+ *
+ * @returns VBox status code.
+ * @param   uScreen             Screen number.
+ * @param   pInfo               Recording screen info to use.
+ * @param   msTimestamp         Timestamp (PTS, in ms).
+ */
+int RecordingContext::SendScreenChange(uint32_t uScreen, PRECORDINGSURFACEINFO pInfo, uint64_t msTimestamp)
+{
+    lock();
+
+    RecordingStream *pStream = getStreamInternal(uScreen);
+    if (!pStream)
+    {
+        unlock();
+
+        AssertFailed();
+        return VERR_NOT_FOUND;
+    }
+
+    int const vrc = pStream->SendScreenChange(pInfo, msTimestamp);
+
+    unlock();
+
+    return vrc;
+}
+

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

@@ -66 +66 @@
 #include <VBox/vmm/pdmaudioinline.h>
 
+#include "Recording.h"
 #include "RecordingInternals.h"
 #include "RecordingUtils.h"
@@ -72 +73 @@
 #include <math.h>
 
+#include <iprt/formats/bmp.h>
+
+
+/*********************************************************************************************************************************
+*   Prototypes                                                                                                                   *
+*********************************************************************************************************************************/
+static int recordingCodecVPXEncodeWorker(PRECORDINGCODEC pCodec, vpx_image_t *pImage, uint64_t msTimestamp);
+
+
+/*********************************************************************************************************************************
+*   Generic inline functions                                                                                                     *
+*********************************************************************************************************************************/
+
+DECLINLINE(void) recordingCodecLock(PRECORDINGCODEC pCodec)
+{
+    int vrc2 = RTCritSectEnter(&pCodec->CritSect);
+    AssertRC(vrc2);
+}
+
+DECLINLINE(void) recordingCodecUnlock(PRECORDINGCODEC pCodec)
+{
+    int vrc2 = RTCritSectLeave(&pCodec->CritSect);
+    AssertRC(vrc2);
+}
+
 
 /*********************************************************************************************************************************
@@ -78 +104 @@
 
 #ifdef VBOX_WITH_LIBVPX
+/** Prototypes. */
+static DECLCALLBACK(int) recordingCodecVPXScreenChange(PRECORDINGCODEC pCodec, PRECORDINGSURFACEINFO pInfo);
+
+/**
+ * Clears (zeros) the VPX planes.
+ */
+DECLINLINE(void) recordingCodecVPXClearPlanes(PRECORDINGCODEC pCodec)
+{
+    size_t const cbYPlane  = pCodec->Parms.u.Video.uWidth * pCodec->Parms.u.Video.uHeight;
+    memset(pCodec->Video.VPX.RawImage.planes[VPX_PLANE_Y], 0, cbYPlane);
+    size_t const cbUVPlane = (pCodec->Parms.u.Video.uWidth / 2) * (pCodec->Parms.u.Video.uHeight / 2);
+    memset(pCodec->Video.VPX.RawImage.planes[VPX_PLANE_U], 128, cbUVPlane);
+    memset(pCodec->Video.VPX.RawImage.planes[VPX_PLANE_V], 128, cbUVPlane);
+}
+
 /** @copydoc RECORDINGCODECOPS::pfnInit */
 static DECLCALLBACK(int) recordingCodecVPXInit(PRECORDINGCODEC pCodec)
 {
-    pCodec->cbScratch = _4K;
-    pCodec->pvScratch = RTMemAlloc(pCodec->cbScratch);
-    AssertPtrReturn(pCodec->pvScratch, VERR_NO_MEMORY);
-
-    pCodec->Parms.csFrame  = 0;
-    pCodec->Parms.cbFrame  = pCodec->Parms.Video.uWidth * pCodec->Parms.Video.uHeight * 4 /* 32-bit */;
-    pCodec->Parms.msFrame  = 1; /* 1ms per frame. */
+    const unsigned uBPP = 32;
+
+    pCodec->Parms.csFrame = 0;
+    pCodec->Parms.cbFrame = pCodec->Parms.u.Video.uWidth * pCodec->Parms.u.Video.uHeight * (uBPP / 8);
+    pCodec->Parms.msFrame = 1; /* 1ms per frame. */
 
 # ifdef VBOX_WITH_LIBVPX_VP9
@@ -106 +145 @@
     pVPX->Cfg.rc_target_bitrate = pCodec->Parms.uBitrate;
     /* Frame width. */
-    pVPX->Cfg.g_w = pCodec->Parms.Video.uWidth;
+    pVPX->Cfg.g_w = pCodec->Parms.u.Video.uWidth;
     /* Frame height. */
-    pVPX->Cfg.g_h = pCodec->Parms.Video.uHeight;
+    pVPX->Cfg.g_h = pCodec->Parms.u.Video.uHeight;
     /* ms per frame. */
     pVPX->Cfg.g_timebase.num = pCodec->Parms.msFrame;
@@ -124 +163 @@
 
     if (!vpx_img_alloc(&pVPX->RawImage, VPX_IMG_FMT_I420,
-                       pCodec->Parms.Video.uWidth, pCodec->Parms.Video.uHeight, 1))
-    {
-        LogRel(("Recording: Failed to allocate image %RU32x%RU32\n", pCodec->Parms.Video.uWidth, pCodec->Parms.Video.uHeight));
+                       pCodec->Parms.u.Video.uWidth, pCodec->Parms.u.Video.uHeight, 1))
+    {
+        LogRel(("Recording: Failed to allocate image %RU32x%RU32\n", pCodec->Parms.u.Video.uWidth, pCodec->Parms.u.Video.uHeight));
         return VERR_RECORDING_CODEC_INIT_FAILED;
     }
 
-    /* Save a pointer to the first raw YUV plane. */
-    pVPX->pu8YuvBuf = pVPX->RawImage.planes[0];
-
-    return VINF_SUCCESS;
+    /* Save a pointer to the Y (Luminance) plane. */
+    pVPX->pu8YuvBuf = pVPX->RawImage.planes[VPX_PLANE_Y];
+
+    /* Initialize front + back buffers. */
+    RT_ZERO(pCodec->Video.VPX.Front);
+    RT_ZERO(pCodec->Video.VPX.Back);
+
+    pCodec->Video.VPX.pCursorShape = NULL;
+
+    RECORDINGSURFACEINFO ScreenInfo;
+    ScreenInfo.uWidth      = pCodec->Parms.u.Video.uWidth;
+    ScreenInfo.uHeight     = pCodec->Parms.u.Video.uHeight;
+    ScreenInfo.uBPP        = uBPP;
+    ScreenInfo.enmPixelFmt = RECORDINGPIXELFMT_BRGA32;
+
+    RT_ZERO(pCodec->Video.VPX.PosCursorOld);
+
+    int vrc = recordingCodecVPXScreenChange(pCodec, &ScreenInfo);
+    if (RT_FAILURE(vrc))
+        LogRel(("Recording: Failed to initialize codec: %Rrc\n", vrc));
+
+    return vrc;
 }
 
@@ -147 +204 @@
     Assert(rcv == VPX_CODEC_OK); RT_NOREF(rcv);
 
+    RecordingVideoFrameDestroy(&pCodec->Video.VPX.Front);
+    RecordingVideoFrameDestroy(&pCodec->Video.VPX.Back);
+
+    RecordingVideoFrameFree(pCodec->Video.VPX.pCursorShape);
+    pCodec->Video.VPX.pCursorShape = NULL;
+
     return VINF_SUCCESS;
+}
+
+/** @copydoc RECORDINGCODECOPS::pfnFinalize */
+static DECLCALLBACK(int) recordingCodecVPXFinalize(PRECORDINGCODEC pCodec)
+{
+    recordingCodecLock(pCodec);
+
+    int vrc = recordingCodecVPXEncodeWorker(pCodec, NULL /* pImage */, pCodec->State.tsLastWrittenMs + 1);
+
+    recordingCodecUnlock(pCodec);
+
+    return vrc;
 }
 
@@ -165 +240 @@
             else if (value.compare("good", com::Utf8Str::CaseInsensitive) == 0)
             {
-                AssertStmt(pCodec->Parms.Video.uFPS, pCodec->Parms.Video.uFPS = 25);
-                pVPX->uEncoderDeadline = 1000000 / pCodec->Parms.Video.uFPS;
+                AssertStmt(pCodec->Parms.u.Video.uFPS, pCodec->Parms.u.Video.uFPS = 25);
+                pVPX->uEncoderDeadline = 1000000 / pCodec->Parms.u.Video.uFPS;
             }
             else if (value.compare("best", com::Utf8Str::CaseInsensitive) == 0)
@@ -180 +255 @@
 }
 
-/** @copydoc RECORDINGCODECOPS::pfnEncode */
-static DECLCALLBACK(int) recordingCodecVPXEncode(PRECORDINGCODEC pCodec, PRECORDINGFRAME pFrame,
-                                                 size_t *pcEncoded, size_t *pcbEncoded)
-{
-    RT_NOREF(pcEncoded, pcbEncoded);
-
-    AssertPtrReturn(pFrame, VERR_INVALID_POINTER);
-
-    PRECORDINGVIDEOFRAME pVideoFrame = pFrame->VideoPtr;
-
-    int vrc = RecordingUtilsRGBToYUV(pVideoFrame->enmPixelFmt,
-                                     /* Destination */
-                                     pCodec->Video.VPX.pu8YuvBuf, pVideoFrame->uWidth, pVideoFrame->uHeight,
-                                     /* Source */
-                                     pVideoFrame->pu8RGBBuf, pCodec->Parms.Video.uWidth, pCodec->Parms.Video.uHeight);
-    AssertRCReturn(vrc, vrc);
+/**
+ * Worker for encoding the last composed image.
+ *
+ * @returns VBox status code.
+ * @param   pCodec              Pointer to codec instance.
+ * @param   pImage              VPX image to encode.
+ *                              Set to NULL to signal the encoder that it has to finish up stuff when ending encoding.
+ * @param   msTimestamp         Timestamp (PTS) to use for encoding.
+ *
+ * @note    Caller must take encoder lock.
+ */
+static int recordingCodecVPXEncodeWorker(PRECORDINGCODEC pCodec, vpx_image_t *pImage, uint64_t msTimestamp)
+{
+    int vrc;
 
     PRECORDINGCODECVPX pVPX = &pCodec->Video.VPX;
 
     /* Presentation TimeStamp (PTS). */
-    vpx_codec_pts_t pts = pFrame->msTimestamp;
-    vpx_codec_err_t rcv = vpx_codec_encode(&pVPX->Ctx,
-                                           &pVPX->RawImage,
-                                           pts                          /* Timestamp */,
-                                           pCodec->Parms.Video.uDelayMs /* How long to show this frame */,
-                                           0                            /* Flags */,
-                                           pVPX->uEncoderDeadline       /* Quality setting */);
+    vpx_codec_pts_t const pts = msTimestamp;
+    vpx_codec_err_t const rcv = vpx_codec_encode(&pVPX->Ctx,
+                                                 pImage,
+                                                 pts                            /* Timestamp */,
+                                                 pCodec->Parms.u.Video.uDelayMs /* How long to show this frame */,
+                                                 0                              /* Flags */,
+                                                 pVPX->uEncoderDeadline         /* Quality setting */);
     if (rcv != VPX_CODEC_OK)
     {
@@ -221 +294 @@
     {
         const vpx_codec_cx_pkt_t *pPkt = vpx_codec_get_cx_data(&pVPX->Ctx, &iter);
-        if (!pPkt)
+        if (!pPkt) /* End of list */
             break;
 
@@ -240 +313 @@
                     fFlags |= RECORDINGCODEC_ENC_F_BLOCK_IS_INVISIBLE;
 
+                Log3Func(("msTimestamp=%RU64, fFlags=%#x\n", msTimestamp, fFlags));
+
                 vrc = pCodec->Callbacks.pfnWriteData(pCodec, pPkt->data.frame.buf, pPkt->data.frame.sz,
                                                      tsAbsPTSMs, fFlags, pCodec->Callbacks.pvUser);
@@ -254 +329 @@
     return vrc;
 }
+
+/** @copydoc RECORDINGCODECOPS::pfnEncode */
+static DECLCALLBACK(int) recordingCodecVPXEncode(PRECORDINGCODEC pCodec, PRECORDINGFRAME pFrame,
+                                                 uint64_t msTimestamp, void *pvUser)
+{
+    recordingCodecLock(pCodec);
+
+    int vrc;
+
+    /* If no frame is given, encode the last composed frame again with the given timestamp. */
+    if (pFrame == NULL)
+    {
+        vrc = recordingCodecVPXEncodeWorker(pCodec, &pCodec->Video.VPX.RawImage, msTimestamp);
+        recordingCodecUnlock(pCodec);
+        return vrc;
+    }
+
+    RecordingContext *pCtx = (RecordingContext *)pvUser;
+    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
+
+    Assert(pFrame->msTimestamp == msTimestamp);
+
+    /* Note: We get BGRA 32 input here. */
+    PRECORDINGVIDEOFRAME pFront = &pCodec->Video.VPX.Front;
+    PRECORDINGVIDEOFRAME pBack  = &pCodec->Video.VPX.Back;
+
+    int32_t sx = 0; /* X origin within the source frame. */
+    int32_t sy = 0; /* Y origin within the source frame. */
+    int32_t sw = 0; /* Width of the source frame (starting at X origin). */
+    int32_t sh = 0; /* Height of the source frame (starting at Y origin). */
+    int32_t dx = 0; /* X destination of the source frame within the destination frame. */
+    int32_t dy = 0; /* Y destination of the source frame within the destination frame. */
+
+    /*
+     * Note!
+     *
+     * We don't implement any rendering graph or some such here, as we only have two things to render here, namely:
+     *
+     * - the actual framebuffer updates
+     * - if available (through mouse integration via Guest Additions): the guest's mouse cursor via a (software) overlay
+     *
+     * So composing is done the folowing way:
+     *
+     *  - always store the plain framebuffer updates in our back buffer first
+     *  - copy the framebuffer updates to our front buffer
+     *  - restore the area of the old mouse cursor position by copying frame buffer area data from back -> front buffer
+     *  - apply the mouse cursor updates to our front buffer
+     */
+
+    switch (pFrame->enmType)
+    {
+        case RECORDINGFRAME_TYPE_VIDEO:
+        {
+            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);
+#if 0
+            RecordingUtilsDbgDumpVideoFrameEx(pFront, "/tmp/recording", "encode-front");
+            RecordingUtilsDbgDumpVideoFrameEx(pSrc, "/tmp/recording", "encode-src");
+#endif
+            vrc = RecordingVideoFrameBlitFrame(pBack, pSrc->Pos.x, pSrc->Pos.y,
+                                               pSrc,  0 /* uSrcX */, 0 /* uSrcY */, pSrc->Info.uWidth, pSrc->Info.uHeight);
+            pFront = pBack;
+
+            sw = pSrc->Info.uWidth;
+            sh = pSrc->Info.uHeight;
+            sx = pSrc->Pos.x;
+            sy = pSrc->Pos.y;
+
+            Log3Func(("RECORDINGFRAME_TYPE_VIDEO: sx=%d, sy=%d, sw=%d, sh=%d\n", sx, sy, sw, sh));
+
+            dx = pSrc->Pos.x;
+            dy = pSrc->Pos.y;
+            break;
+        }
+
+        case RECORDINGFRAME_TYPE_CURSOR_SHAPE:
+        {
+            pCodec->Video.VPX.pCursorShape = RecordingVideoFrameDup(&pFrame->u.CursorShape);
+            AssertPtr(pCodec->Video.VPX.pCursorShape);
+
+            RT_FALL_THROUGH(); /* Re-render cursor with new shape below. */
+        }
+
+        case RECORDINGFRAME_TYPE_CURSOR_POS:
+        {
+            const PRECORDINGVIDEOFRAME pCursor = pCodec->Video.VPX.pCursorShape;
+            if (!pCursor) /* No cursor shape set yet. */
+                break;
+
+            PRECORDINGPOS pPosOld = &pCodec->Video.VPX.PosCursorOld;
+            PRECORDINGPOS pPosNew = pFrame->enmType == RECORDINGFRAME_TYPE_CURSOR_POS
+                                  ? &pFrame->u.Cursor.Pos
+                                  : pPosOld;
+
+            Log3Func(("RECORDINGFRAME_TYPE_CURSOR_POS: x=%d, y=%d, oldx=%d, oldy=%d, w=%d, h=%d\n",
+                      pPosNew->x, pPosNew->y,
+                      pPosOld->x, pPosOld->y, pCursor->Info.uWidth, pCursor->Info.uHeight));
+
+            /* Calculate the merged area between the old and the new (current) cursor position
+             * so that we update everything to not create any ghosting. */
+            sx = RT_MIN(pPosNew->x, pPosOld->x);
+            sy = RT_MIN(pPosNew->y, pPosOld->y);
+            sw = (  pPosNew->x > pPosOld->x
+                  ? pPosNew->x - pPosOld->x
+                  : pPosOld->x - pPosNew->x) + pCursor->Info.uWidth;
+            sh = (  pPosNew->y > pPosOld->y
+                  ? pPosNew->y - pPosOld->y
+                  : pPosOld->y - pPosNew->y) + pCursor->Info.uHeight;
+
+            /* Limit the width / height to blit to the front buffer's size. */
+            if (sx + sw >= (int32_t)pFront->Info.uWidth)
+                sw = pFront->Info.uWidth - sx;
+            if (sy + sh >= (int32_t)pFront->Info.uHeight)
+                sh = pFront->Info.uHeight - sy;
+
+            /* Save current cursor position for next iteration. */
+            *pPosOld = *pPosNew;
+
+            dx = sx;
+            dy = sy;
+
+            Log3Func(("RECORDINGFRAME_TYPE_CURSOR_POS: sx=%d, sy=%d, sw=%d, sh=%d\n", sx, sy, sw, sh));
+
+            /* Nothing to encode? Bail out. */
+            if (             sw <= 0
+                ||           sh <= 0
+                || (uint32_t)sx >  pBack->Info.uWidth
+                || (uint32_t)sy >  pBack->Info.uHeight)
+                break;
+
+            /* Restore background of front buffer first. */
+            vrc = RecordingVideoFrameBlitFrame(pFront, dx, dy,
+                                               pBack,  sx, sy, sw, sh);
+
+            /* Blit mouse cursor to front buffer. */
+            if (RT_SUCCESS(vrc))
+                vrc = RecordingVideoFrameBlitRawAlpha(pFront, pPosNew->x, pPosNew->y,
+                                                      pCursor->pau8Buf, pCursor->cbBuf,
+                                                      0 /* uSrcX */, 0 /* uSrcY */, pCursor->Info.uWidth, pCursor->Info.uHeight,
+                                                      pCursor->Info.uBytesPerLine, pCursor->Info.uBPP, pCursor->Info.enmPixelFmt);
+#if 0
+            RecordingUtilsDbgDumpVideoFrameEx(pFront, "/tmp/recording", "cursor-alpha-front");
+#endif
+            break;
+        }
+
+        default:
+            AssertFailed();
+            break;
+
+    }
+
+    /* Nothing to encode? Bail out. */
+    if (   sw == 0
+        || sh == 0)
+    {
+        recordingCodecUnlock(pCodec);
+        return VINF_SUCCESS;
+    }
+
+    Log3Func(("Encoding video parameters: %RU16x%RU16 (%RU8 FPS), originX=%RI32, originY=%RI32\n",
+              pCodec->Parms.u.Video.uWidth, pCodec->Parms.u.Video.uHeight, pCodec->Parms.u.Video.uFPS,
+              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. */
+    {
+        Log3Func(("Encoding source %RI32,%RI32 (%RI32x%RI32) to %RI32,%RI32 (%zu bytes)\n",
+                  sx, sy, sw, sh, dx, dy, sw * sh * (pFront->Info.uBPP / 8)));
+#ifdef DEBUG
+        AssertReturn(sw      <= (int32_t)pFront->Info.uWidth,  VERR_INVALID_PARAMETER);
+        AssertReturn(sh      <= (int32_t)pFront->Info.uHeight, VERR_INVALID_PARAMETER);
+        AssertReturn(sx + sw <= (int32_t)pFront->Info.uWidth , VERR_INVALID_PARAMETER);
+        AssertReturn(sy + sh <= (int32_t)pFront->Info.uHeight, VERR_INVALID_PARAMETER);
+#endif
+
+#if 0
+        RecordingUtilsDbgDumpImageData(&pFront->pau8Buf[(sy * pFront->Info.uBytesPerLine) + (sx * (pFront->Info.uBPP / 8))], pFront->cbBuf,
+                                       "/tmp/recording", "cropped", sw, sh, pFront->Info.uBytesPerLine, pFront->Info.uBPP);
+#endif
+        /* Blit (and convert from BGRA 32) the changed parts of the front buffer to the YUV 420 surface of the codec. */
+        RecordingUtilsConvBGRA32ToYUVI420Ex(/* Destination */
+                                            pCodec->Video.VPX.pu8YuvBuf, dx, dy, pCodec->Parms.u.Video.uWidth, pCodec->Parms.u.Video.uHeight,
+                                            /* Source */
+                                            pFront->pau8Buf, sx, sy, sw, sh, pFront->Info.uBytesPerLine, pFront->Info.uBPP);
+
+        vrc = recordingCodecVPXEncodeWorker(pCodec, &pCodec->Video.VPX.RawImage, msTimestamp);
+    }
+
+    recordingCodecUnlock(pCodec);
+
+    return vrc;
+}
+
+/** @copydoc RECORDINGCODECOPS::pfnScreenChange */
+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
+        || (pInfo->uHeight % 2) != 0)
+        return VERR_INVALID_PARAMETER;
+
+    PRECORDINGCODECVPX pVPX = &pCodec->Video.VPX;
+
+    recordingCodecLock(pCodec);
+
+    /* Tear down old stuff. */
+    RecordingVideoFrameDestroy(&pVPX->Front);
+    RecordingVideoFrameDestroy(&pVPX->Back);
+
+    /* Initialize front + back buffers. */
+    int vrc = RecordingVideoFrameInit(&pVPX->Front, RECORDINGVIDEOFRAME_F_VISIBLE,
+                                      pInfo->uWidth, pInfo->uHeight, 0, 0,
+                                      pInfo->uBPP, pInfo->enmPixelFmt);
+    if (RT_SUCCESS(vrc))
+        vrc = RecordingVideoFrameInit(&pVPX->Back, RECORDINGVIDEOFRAME_F_VISIBLE,
+                                      pInfo->uWidth, pInfo->uHeight, 0, 0,
+                                      pInfo->uBPP, pInfo->enmPixelFmt);
+    if (RT_SUCCESS(vrc))
+    {
+        RecordingVideoFrameClear(&pVPX->Front);
+        RecordingVideoFrameClear(&pVPX->Back);
+
+        recordingCodecVPXClearPlanes(pCodec);
+
+        /* Calculate the X/Y origins for cropping / centering.
+         * This is needed as the codec's video output size not necessarily matches the VM's frame buffer size. */
+        pCodec->Parms.u.Video.Scaling.u.Crop.m_iOriginX = int32_t(pCodec->Parms.u.Video.uWidth  - pInfo->uWidth) / 2;
+        pCodec->Parms.u.Video.Scaling.u.Crop.m_iOriginY = int32_t(pCodec->Parms.u.Video.uHeight - pInfo->uHeight) / 2;
+    }
+
+    recordingCodecUnlock(pCodec);
+
+    if (RT_FAILURE(vrc))
+        LogRel(("Recording: Codec error handling screen change notification: %Rrc\n", vrc));
+
+    return vrc;
+
+}
 #endif /* VBOX_WITH_LIBVPX */
 
@@ -269 +612 @@
     AssertPtrReturn(pCodec->pvScratch, VERR_NO_MEMORY);
 
-    const PPDMAUDIOPCMPROPS pPCMProps = &pCodec->Parms.Audio.PCMProps;
+    const PPDMAUDIOPCMPROPS pPCMProps = &pCodec->Parms.u.Audio.PCMProps;
 
     /** @todo BUGBUG When left out this call, vorbis_block_init() does not find oggpack_writeinit and all goes belly up ... */
@@ -336 +679 @@
 /** @copydoc RECORDINGCODECOPS::pfnEncode */
 static DECLCALLBACK(int) recordingCodecVorbisEncode(PRECORDINGCODEC pCodec,
-                                                    const PRECORDINGFRAME pFrame, size_t *pcEncoded, size_t *pcbEncoded)
-{
-    const PPDMAUDIOPCMPROPS pPCMProps = &pCodec->Parms.Audio.PCMProps;
+                                                    const PRECORDINGFRAME pFrame, uint64_t msTimestamp, void *pvUser)
+{
+    RT_NOREF(msTimestamp, pvUser);
+
+    const PPDMAUDIOPCMPROPS pPCMProps = &pCodec->Parms.u.Audio.PCMProps;
 
     Assert      (pCodec->Parms.cbFrame);
-    AssertReturn(pFrame->Audio.cbBuf % pCodec->Parms.cbFrame == 0, VERR_INVALID_PARAMETER);
-    Assert      (pFrame->Audio.cbBuf);
-    AssertReturn(pFrame->Audio.cbBuf % PDMAudioPropsFrameSize(pPCMProps) == 0, VERR_INVALID_PARAMETER);
-    AssertReturn(pCodec->cbScratch >= pFrame->Audio.cbBuf, VERR_INVALID_PARAMETER);
+    AssertReturn(pFrame->u.Audio.cbBuf % pCodec->Parms.cbFrame == 0, VERR_INVALID_PARAMETER);
+    Assert      (pFrame->u.Audio.cbBuf);
+    AssertReturn(pFrame->u.Audio.cbBuf % PDMAudioPropsFrameSize(pPCMProps) == 0, VERR_INVALID_PARAMETER);
+    AssertReturn(pCodec->cbScratch >= pFrame->u.Audio.cbBuf, VERR_INVALID_PARAMETER);
 
     int vrc = VINF_SUCCESS;
 
     int const cbFrame = PDMAudioPropsFrameSize(pPCMProps);
-    int const cFrames = (int)(pFrame->Audio.cbBuf / cbFrame);
+    int const cFrames = (int)(pFrame->u.Audio.cbBuf / cbFrame);
 
     /* Write non-interleaved frames. */
     float  **buffer = vorbis_analysis_buffer(&pCodec->Audio.Vorbis.dsp_state, cFrames);
-    int16_t *puSrc  = (int16_t *)pFrame->Audio.pvBuf; RT_NOREF(puSrc);
+    int16_t *puSrc  = (int16_t *)pFrame->u.Audio.pvBuf; RT_NOREF(puSrc);
 
     /* Convert samples into floating point. */
@@ -375 +720 @@
         return VERR_RECORDING_ENCODING_FAILED;
     }
-
-    if (pcEncoded)
-        *pcEncoded = 0;
-    if (pcbEncoded)
-        *pcbEncoded = 0;
 
     size_t cBlocksEncoded = 0;
@@ -439 +779 @@
     }
 
-    if (pcbEncoded)
-        *pcbEncoded = 0;
-    if (pcEncoded)
-        *pcEncoded  = 0;
-
     if (RT_FAILURE(vrc))
         LogRel(("Recording: Encoding Vorbis audio data failed, vrc=%Rrc\n", vrc));
 
     Log3Func(("cbSrc=%zu, cbDst=%zu, cEncoded=%zu, cbEncoded=%zu, vrc=%Rrc\n",
-              pFrame->Audio.cbBuf, pCodec->cbScratch, cBlocksEncoded, cBytesEncoded, vrc));
-
-    return vrc;
-}
-
+              pFrame->u.Audio.cbBuf, pCodec->cbScratch, cBlocksEncoded, cBytesEncoded, vrc));
+
+    return vrc;
+}
+
+/** @copydoc RECORDINGCODECOPS::pfnFinalize */
 static DECLCALLBACK(int) recordingCodecVorbisFinalize(PRECORDINGCODEC pCodec)
 {
@@ -488 +824 @@
     LogRel(("Recording: Initializing audio codec '%s'\n", strCodec.c_str()));
 
-    const PPDMAUDIOPCMPROPS pPCMProps = &pCodec->Parms.Audio.PCMProps;
+    const PPDMAUDIOPCMPROPS pPCMProps = &pCodec->Parms.u.Audio.PCMProps;
 
     PDMAudioPropsInit(pPCMProps,
@@ -546 +882 @@
     LogRel(("Recording: Initializing video codec '%s'\n", strTemp.c_str()));
 
-    pCodec->Parms.uBitrate       = Settings.Video.ulRate;
-    pCodec->Parms.Video.uFPS     = Settings.Video.ulFPS;
-    pCodec->Parms.Video.uWidth   = Settings.Video.ulWidth;
-    pCodec->Parms.Video.uHeight  = Settings.Video.ulHeight;
-    pCodec->Parms.Video.uDelayMs = RT_MS_1SEC / pCodec->Parms.Video.uFPS;
+    pCodec->Parms.uBitrate         = Settings.Video.ulRate;
+    pCodec->Parms.u.Video.uFPS     = Settings.Video.ulFPS;
+    pCodec->Parms.u.Video.uWidth   = Settings.Video.ulWidth;
+    pCodec->Parms.u.Video.uHeight  = Settings.Video.ulHeight;
+    pCodec->Parms.u.Video.uDelayMs = RT_MS_1SEC / pCodec->Parms.u.Video.uFPS;
 
     if (pCallbacks)
@@ -556 +892 @@
 
     AssertReturn(pCodec->Parms.uBitrate, VERR_INVALID_PARAMETER);        /* Bitrate must be set. */
-    AssertStmt(pCodec->Parms.Video.uFPS, pCodec->Parms.Video.uFPS = 25); /* Prevent division by zero. */
-
-    AssertReturn(pCodec->Parms.Video.uHeight, VERR_INVALID_PARAMETER);
-    AssertReturn(pCodec->Parms.Video.uWidth, VERR_INVALID_PARAMETER);
-    AssertReturn(pCodec->Parms.Video.uDelayMs, VERR_INVALID_PARAMETER);
+    AssertStmt(pCodec->Parms.u.Video.uFPS, pCodec->Parms.u.Video.uFPS = 25); /* Prevent division by zero. */
+
+    AssertReturn(pCodec->Parms.u.Video.uHeight, VERR_INVALID_PARAMETER);
+    AssertReturn(pCodec->Parms.u.Video.uWidth, VERR_INVALID_PARAMETER);
+    AssertReturn(pCodec->Parms.u.Video.uDelayMs, VERR_INVALID_PARAMETER);
 
     int vrc = VINF_SUCCESS;
@@ -602 +938 @@
             if (value.compare("low", com::Utf8Str::CaseInsensitive) == 0)
             {
-                PDMAudioPropsInit(&pCodec->Parms.Audio.PCMProps, 16, true /* fSigned */, 1 /* Channels */, 8000 /* Hz */);
+                PDMAudioPropsInit(&pCodec->Parms.u.Audio.PCMProps, 16, true /* fSigned */, 1 /* Channels */, 8000 /* Hz */);
             }
             else if (value.startsWith("med" /* "med[ium]" */, com::Utf8Str::CaseInsensitive) == 0)
@@ -610 +946 @@
             else if (value.compare("high", com::Utf8Str::CaseInsensitive) == 0)
             {
-                PDMAudioPropsInit(&pCodec->Parms.Audio.PCMProps, 16, true /* fSigned */, 2 /* Channels */, 48000 /* Hz */);
+                PDMAudioPropsInit(&pCodec->Parms.u.Audio.PCMProps, 16, true /* fSigned */, 2 /* Channels */, 48000 /* Hz */);
             }
         }
@@ -625 +961 @@
 {
     pCodec->State.tsLastWrittenMs = 0;
-
     pCodec->State.cEncErrors = 0;
-#ifdef VBOX_WITH_STATISTICS
-    pCodec->STAM.cEncBlocks  = 0;
-    pCodec->STAM.msEncTotal  = 0;
-#endif
 }
 
@@ -708 +1039 @@
             pCodec->Ops.pfnInit         = recordingCodecVPXInit;
             pCodec->Ops.pfnDestroy      = recordingCodecVPXDestroy;
+            pCodec->Ops.pfnFinalize     = recordingCodecVPXFinalize;
             pCodec->Ops.pfnParseOptions = recordingCodecVPXParseOptions;
             pCodec->Ops.pfnEncode       = recordingCodecVPXEncode;
+            pCodec->Ops.pfnScreenChange = recordingCodecVPXScreenChange;
 
             vrc = VINF_SUCCESS;
@@ -740 +1073 @@
 int recordingCodecInit(const PRECORDINGCODEC pCodec, const PRECORDINGCODECCALLBACKS pCallbacks, const settings::RecordingScreenSettings &Settings)
 {
+    int vrc = RTCritSectInit(&pCodec->CritSect);
+    AssertRCReturn(vrc, vrc);
+
+    pCodec->cbScratch = 0;
+    pCodec->pvScratch = NULL;
+
     recordingCodecReset(pCodec);
 
-    int vrc;
     if (pCodec->Parms.enmType == RECORDINGCODECTYPE_AUDIO)
         vrc = recordingCodecInitAudio(pCodec, pCallbacks, Settings);
@@ -811 +1149 @@
         pCodec->Parms.enmType       = RECORDINGCODECTYPE_INVALID;
         pCodec->Parms.enmVideoCodec = RecordingVideoCodec_None;
-    }
-
-    return vrc;
-}
-
-/**
- * Feeds the codec encoder with data to encode.
+
+        int vrc2 = RTCritSectDelete(&pCodec->CritSect);
+        AssertRC(vrc2);
+    }
+
+    return vrc;
+}
+
+/**
+ * Feeds the codec encoder with frame data to encode.
  *
  * @returns VBox status code.
  * @param   pCodec              Codec to use.
  * @param   pFrame              Pointer to frame data to encode.
- * @param   pcEncoded           Where to return the number of encoded blocks in \a pvDst on success. Optional.
- * @param   pcbEncoded          Where to return the number of encoded bytes in \a pvDst on success. Optional.
- */
-int recordingCodecEncode(PRECORDINGCODEC pCodec,
-                         const PRECORDINGFRAME pFrame, size_t *pcEncoded, size_t *pcbEncoded)
+ * @param   msTimestamp         Timestamp (PTS) to use for encoding.
+ * @param   pvUser              User data pointer. Optional and can be NULL.
+ */
+int recordingCodecEncodeFrame(PRECORDINGCODEC pCodec, const PRECORDINGFRAME pFrame, uint64_t msTimestamp, void *pvUser)
 {
     AssertPtrReturn(pCodec->Ops.pfnEncode, VERR_NOT_SUPPORTED);
 
-    size_t cEncoded, cbEncoded;
-    int vrc = pCodec->Ops.pfnEncode(pCodec, pFrame, &cEncoded, &cbEncoded);
+    int vrc = pCodec->Ops.pfnEncode(pCodec, pFrame, msTimestamp, pvUser);
     if (RT_SUCCESS(vrc))
-    {
         pCodec->State.tsLastWrittenMs = pFrame->msTimestamp;
 
-#ifdef VBOX_WITH_STATISTICS
-        pCodec->STAM.cEncBlocks += cEncoded;
-        pCodec->STAM.msEncTotal += pCodec->Parms.msFrame * cEncoded;
-#endif
-        if (pcEncoded)
-            *pcEncoded = cEncoded;
-        if (pcbEncoded)
-            *pcbEncoded = cbEncoded;
-    }
-
-    return vrc;
+    return vrc;
+}
+
+/**
+ * Feeds the codec encoder with the current composed image.
+ *
+ * @returns VBox status code.
+ * @param   pCodec              Codec to use.
+ * @param   msTimestamp         Timestamp (PTS) to use for encoding.
+ */
+int recordingCodecEncodeCurrent(PRECORDINGCODEC pCodec, uint64_t msTimestamp)
+{
+    int vrc = pCodec->Ops.pfnEncode(pCodec, NULL /* pFrame */, msTimestamp, NULL /* pvUser */);
+    if (RT_SUCCESS(vrc))
+        pCodec->State.tsLastWrittenMs = msTimestamp;
+
+    return vrc;
+}
+
+/**
+ * Lets the codec know that a screen change has happened.
+ *
+ * @returns VBox status code.
+ * @param   pCodec              Codec to use.
+ * @param   pInfo               Screen info to send.
+ */
+int recordingCodecScreenChange(PRECORDINGCODEC pCodec, PRECORDINGSURFACEINFO pInfo)
+{
+    if (!pCodec->Ops.pfnScreenChange)
+        return VINF_SUCCESS;
+
+    return pCodec->Ops.pfnScreenChange(pCodec, pInfo);
 }
 
@@ -885 +1244 @@
 {
     Log3Func(("%RU64 -- tsLastWrittenMs=%RU64 + uDelayMs=%RU32\n",
-              msTimestamp, pCodec->State.tsLastWrittenMs,pCodec->Parms.Video.uDelayMs));
-
-    if (msTimestamp < pCodec->State.tsLastWrittenMs + pCodec->Parms.Video.uDelayMs)
+              msTimestamp, pCodec->State.tsLastWrittenMs,pCodec->Parms.u.Video.uDelayMs));
+
+    if (msTimestamp < pCodec->State.tsLastWrittenMs + pCodec->Parms.u.Video.uDelayMs)
         return 0; /* Too early for writing (respect set FPS). */
 
@@ -894 +1253 @@
     return pCodec->Parms.cbFrame;
 }
+

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

@@ -27 +27 @@
 
 #include "RecordingInternals.h"
+#include "RecordingUtils.h"
 
 #include <iprt/assert.h>
 #include <iprt/mem.h>
 
-#ifdef VBOX_WITH_AUDIO_RECORDING
-
-/**
- * Initializes a recording frame.
- *
+#ifdef DEBUG
+# include <math.h>
+# include <iprt/file.h>
+# include <iprt/formats/bmp.h>
+#endif
+
+#include "../src-client/Remotery.h"
+
+
+/*********************************************************************************************************************************
+*   Prototypes                                                                                                                   *
+*********************************************************************************************************************************/
+DECLINLINE(int) recordingVideoFrameInit(PRECORDINGVIDEOFRAME pFrame, uint32_t fFlags, uint32_t uWidth, uint32_t uHeight, uint32_t uPosX, uint32_t uPosY,
+                                        uint8_t uBPP, RECORDINGPIXELFMT enmFmt);
+
+
+/**
+ * Allocates an empty video frame, inline version.
+ *
+ * @returns Allocated video frame on success, or NULL on failure.
+ */
+DECLINLINE(PRECORDINGVIDEOFRAME) recordingVideoFrameAlloc(void)
+{
+    return (PRECORDINGVIDEOFRAME)RTMemAlloc(sizeof(RECORDINGVIDEOFRAME));
+}
+
+/**
+ * Allocates an empty video frame.
+ *
+ * @returns Allocated video frame on success, or NULL on failure.
+ */
+PRECORDINGVIDEOFRAME RecordingVideoFrameAlloc(void)
+{
+    PRECORDINGVIDEOFRAME pFrame = recordingVideoFrameAlloc();
+    AssertPtrReturn(pFrame, NULL);
+    RT_BZERO(pFrame, sizeof(RECORDINGVIDEOFRAME));
+    return pFrame;
+}
+
+/**
+ * Returns an allocated video frame from given image data.
+ *
+ * @returns Allocated video frame on success, or NULL on failure.
+ * @param   pvData              Pointer to image data to use.
+ * @param   x                   X location hint (in pixel) to use for allocated frame.
+ *                              This is *not* the offset within \a pvData!
+ * @param   y                   X location hint (in pixel) to use for allocated frame.
+ *                              This is *not* the offset within \a pvData!
+ * @param   w                   Width (in pixel) of \a pvData image data.
+ * @param   h                   Height (in pixel) of \a pvData image data.
+ * @param   uBPP                Bits per pixel) of \a pvData image data.
+ * @param   enmFmt              Pixel format of \a pvData image data.
+ */
+PRECORDINGVIDEOFRAME RecordingVideoFrameAllocEx(const void *pvData, uint32_t x, uint32_t y, uint32_t w, uint32_t h,
+                                                uint8_t uBPP, RECORDINGPIXELFMT enmFmt)
+{
+    PRECORDINGVIDEOFRAME pFrame = recordingVideoFrameAlloc();
+    AssertPtrReturn(pFrame, NULL);
+    int rc = recordingVideoFrameInit(pFrame, RECORDINGVIDEOFRAME_F_VISIBLE, w, h, x, y, uBPP, enmFmt);
+    AssertRCReturn(rc, NULL);
+    memcpy(pFrame->pau8Buf, pvData, pFrame->cbBuf);
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Frees a recording video frame.
+ *
+ * @param   pFrame              Pointer to video frame to free. The pointer will be invalid after return.
+ */
+void RecordingVideoFrameFree(PRECORDINGVIDEOFRAME pFrame)
+{
+    if (!pFrame)
+        return;
+
+    RecordingVideoFrameDestroy(pFrame);
+
+    RTMemFree(pFrame);
+}
+
+/**
+ * Initializes a recording frame, inline version.
+ *
+ * @returns VBox status code.
  * @param   pFrame              Pointer to video frame to initialize.
- * @param   w                   Width (in pixel) of video frame.
- * @param   h                   Height (in pixel) of video frame.
+ * @param   fFlags              Flags of type RECORDINGVIDEOFRAME_F_XXX.
+ * @param   uWidth              Width (in pixel) of video frame.
+ * @param   uHeight             Height (in pixel) of video frame.
+ * @param   uPosX               X positioning hint.
+ * @param   uPosY               Y positioning hint.
  * @param   uBPP                Bits per pixel (BPP).
- * @param   enmPixelFmt         Pixel format to use.
- */
-int RecordingVideoFrameInit(PRECORDINGVIDEOFRAME pFrame, int w, int h, uint8_t uBPP, RECORDINGPIXELFMT enmPixelFmt)
-{
+ * @param   enmFmt              Pixel format to use.
+ */
+DECLINLINE(int) recordingVideoFrameInit(PRECORDINGVIDEOFRAME pFrame, uint32_t fFlags, uint32_t uWidth, uint32_t uHeight,
+                                        uint32_t uPosX, uint32_t uPosY, uint8_t uBPP, RECORDINGPIXELFMT enmFmt)
+{
+    AssertPtrReturn(pFrame, VERR_INVALID_POINTER);
+    AssertReturn(uWidth, VERR_INVALID_PARAMETER);
+    AssertReturn(uHeight, VERR_INVALID_PARAMETER);
+    AssertReturn(uBPP && uBPP % 8 == 0, VERR_INVALID_PARAMETER);
+
     /* Calculate bytes per pixel and set pixel format. */
     const unsigned uBytesPerPixel = uBPP / 8;
-    const   size_t cbRGBBuf       = w * h * uBytesPerPixel;
+
+    /* Calculate bytes per pixel and set pixel format. */
+    const size_t cbRGBBuf = uWidth * uHeight * uBytesPerPixel;
     AssertReturn(cbRGBBuf, VERR_INVALID_PARAMETER);
 
-    pFrame->pu8RGBBuf = (uint8_t *)RTMemAlloc(cbRGBBuf);
-    AssertPtrReturn(pFrame->pu8RGBBuf, VERR_NO_MEMORY);
-    pFrame->cbRGBBuf    = cbRGBBuf;
-
-    pFrame->uX            = 0;
-    pFrame->uY            = 0;
-    pFrame->uWidth        = w;
-    pFrame->uHeight       = h;
-    pFrame->enmPixelFmt   = enmPixelFmt;
-    pFrame->uBPP          = uBPP;
-    pFrame->uBytesPerLine = w * uBytesPerPixel;
+    pFrame->pau8Buf = (uint8_t *)RTMemAlloc(cbRGBBuf);
+    AssertPtrReturn(pFrame->pau8Buf, VERR_NO_MEMORY);
+    pFrame->cbBuf  = cbRGBBuf;
+
+    pFrame->fFlags             = fFlags;
+    pFrame->Info.uWidth        = uWidth;
+    pFrame->Info.uHeight       = uHeight;
+    pFrame->Info.uBPP          = uBPP;
+    pFrame->Info.enmPixelFmt   = enmFmt;
+    pFrame->Info.uBytesPerLine = uWidth * uBytesPerPixel;
+    pFrame->Pos.x              = uPosX;
+    pFrame->Pos.y              = uPosY;
 
     return VINF_SUCCESS;
@@ -65 +157 @@
 
 /**
+ * Initializes a recording frame.
+ *
+ * @param   pFrame              Pointer to video frame to initialize.
+ * @param   fFlags              Flags of type RECORDINGVIDEOFRAME_F_XXX.
+ * @param   uWidth              Width (in pixel) of video frame.
+ * @param   uHeight             Height (in pixel) of video frame.
+ * @param   uPosX               X positioning hint.
+ * @param   uPosY               Y positioning hint.
+ * @param   uBPP                Bits per pixel (BPP).
+ * @param   enmFmt              Pixel format to use.
+ */
+int RecordingVideoFrameInit(PRECORDINGVIDEOFRAME pFrame, uint32_t fFlags, uint32_t uWidth, uint32_t uHeight, uint32_t uPosX, uint32_t uPosY,
+                            uint8_t uBPP, RECORDINGPIXELFMT enmFmt)
+{
+    return recordingVideoFrameInit(pFrame, fFlags, uWidth, uHeight, uPosX, uPosY, uBPP, enmFmt);
+}
+
+/**
+ * Destroys a recording video frame.
+ *
+ * @param   pFrame              Pointer to video frame to destroy.
+ */
+void RecordingVideoFrameDestroy(PRECORDINGVIDEOFRAME pFrame)
+{
+    if (!pFrame)
+        return;
+
+    if (pFrame->pau8Buf)
+    {
+        Assert(pFrame->cbBuf);
+        RTMemFree(pFrame->pau8Buf);
+        pFrame->pau8Buf = NULL;
+        pFrame->cbBuf  = 0;
+    }
+}
+
+/**
+ * Duplicates a video frame.
+ *
+ * @returns Pointer to duplicated frame on success, or NULL on failure.
+ * @param   pFrame              Video frame to duplicate.
+ */
+PRECORDINGVIDEOFRAME RecordingVideoFrameDup(PRECORDINGVIDEOFRAME pFrame)
+{
+    PRECORDINGVIDEOFRAME pFrameDup = (PRECORDINGVIDEOFRAME)RTMemDup(pFrame, sizeof(RECORDINGVIDEOFRAME));
+    AssertPtrReturn(pFrameDup, NULL);
+    pFrameDup->pau8Buf = (uint8_t *)RTMemDup(pFrame->pau8Buf, pFrame->cbBuf);
+    AssertPtrReturnStmt(pFrameDup, RTMemFree(pFrameDup), NULL);
+
+    return pFrameDup;
+}
+
+/**
+ * Clears the content of a video recording frame, inlined version.
+ *
+ * @param   pFrame              Video recording frame to clear content for.
+ */
+DECLINLINE(void) recordingVideoFrameClear(PRECORDINGVIDEOFRAME pFrame)
+{
+    RT_BZERO(pFrame->pau8Buf, pFrame->cbBuf);
+}
+
+/**
+ * Clears the content of a video recording frame.
+ *
+ * @param   pFrame              Video recording frame to clear content for.
+ */
+void RecordingVideoFrameClear(PRECORDINGVIDEOFRAME pFrame)
+{
+    recordingVideoFrameClear(pFrame);
+}
+
+/**
+ * Simple blitting function for raw image data, inlined version.
+ *
+ * @returns VBox status code.
+ * @param   pFrame              Destination frame.
+ * @param   uDstX               X destination (in pixel) within destination frame.
+ * @param   uDstY               Y destination (in pixel) within destination frame.
+ * @param   uDstBytesPerLine    Bytes per line in destination buffer.
+ * @param   uDstBPP             BPP of destination buffer.
+ * @param   enmDstFmt           Pixel format of source data. Must match \a pFrame.
+ * @param   pu8Src              Source data to blit. Must be in the same pixel format as \a pFrame.
+ * @param   cbSrc               Size (in bytes) of \a pu8Src.
+ * @param   uSrcX               X start (in pixel) within source data.
+ * @param   uSrcY               Y start (in pixel) within source data.
+ * @param   uSrcWidth           Width (in pixel) to blit from source data.
+ * @param   uSrcHeight          Height (in pixel) to blit from data.
+ * @param   uSrcBytesPerLine    Bytes per line in source data.
+ * @param   uSrcBPP             BPP of source data. Must match \a pFrame.
+ * @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)
+{
+    RT_NOREF(enmDstFmt, enmSrcFmt);
+
+    uint8_t const uDstBytesPerPixel = uDstBPP / 8;
+    uint8_t const uSrcBytesPerPixel = uSrcBPP / 8;
+
+    size_t offSrc = RT_MIN(uSrcY * uSrcBytesPerLine + uSrcX * uSrcBytesPerPixel, cbSrc);
+    size_t offDst = RT_MIN(uDstY * uDstBytesPerLine + uDstX * uDstBytesPerPixel, cbDst);
+
+    for (uint32_t y = 0; y < uSrcHeight; y++)
+    {
+        size_t const cbToCopy = RT_MIN(cbDst - offDst,
+                                       RT_MIN(uSrcWidth * uSrcBytesPerPixel, cbSrc - offSrc));
+        if (!cbToCopy)
+            break;
+        memcpy(pu8Dst + offDst, (const uint8_t *)pu8Src + offSrc, cbToCopy);
+        offDst = RT_MIN(offDst + uDstBytesPerLine, cbDst);
+        Assert(offDst <= cbDst);
+        offSrc = RT_MIN(offSrc + uSrcBytesPerLine, cbSrc);
+        Assert(offSrc <= cbSrc);
+    }
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Simple blitting function for raw image data with alpha channel, inlined version.
+ *
+ * @returns VBox status code.
+ * @param   pFrame              Destination frame.
+ * @param   uDstX               X destination (in pixel) within destination frame.
+ * @param   uDstY               Y destination (in pixel) within destination frame.
+ * @param   pu8Src              Source data to blit. Must be in the same pixel format as \a pFrame.
+ * @param   cbSrc               Size (in bytes) of \a pu8Src.
+ * @param   uSrcX               X start (in pixel) within source data.
+ * @param   uSrcY               Y start (in pixel) within source data.
+ * @param   uSrcWidth           Width (in pixel) to blit from source data.
+ * @param   uSrcHeight          Height (in pixel) to blit from data.
+ * @param   uSrcBytesPerLine    Bytes per line in source data.
+ * @param   uSrcBPP             BPP of source data. Must match \a pFrame.
+ * @param   enmFmt              Pixel format of source data. Must match \a pFrame.
+ */
+DECLINLINE(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)
+{
+    AssertReturn(pFrame->Info.enmPixelFmt == enmFmt, VERR_NOT_SUPPORTED);
+    AssertReturn(pFrame->Info.uBPP == uSrcBPP, VERR_NOT_SUPPORTED);
+
+    RT_NOREF(uDstX, uDstY, cbSrc, uSrcX, uSrcY, uSrcBytesPerLine);
+    uint8_t const uDstBytesPerPixel = pFrame->Info.uBPP / 8;
+    uint8_t const uSrcBytesPerPixel = uSrcBPP / 8;
+
+    for (uint32_t y = 0; y < uSrcHeight; y++)
+    {
+        size_t offSrc = RT_MIN((uSrcY + y) * uSrcBytesPerLine + uSrcX * uSrcBytesPerPixel, cbSrc);
+        size_t offDst = RT_MIN((uDstY + y) * pFrame->Info.uBytesPerLine + uDstX * uDstBytesPerPixel, pFrame->cbBuf);
+
+        for (uint32_t x = 0; x < uSrcWidth; x++)
+        {
+            /* BGRA */
+            int const idx_b = 0;
+            int const idx_g = 1;
+            int const idx_r = 2;
+            int const idx_a = 3;
+
+            unsigned int const alpha = pu8Src[offSrc + idx_a] + 1;
+            unsigned int const inv_alpha = 256 - pu8Src[offSrc + idx_a];
+            if (pu8Src[offSrc + idx_a])
+            {
+                pFrame->pau8Buf[offDst + idx_r] = (unsigned char)((alpha * pu8Src[offSrc + idx_r] + inv_alpha * pFrame->pau8Buf[offDst + idx_r]) >> 8);
+                pFrame->pau8Buf[offDst + idx_g] = (unsigned char)((alpha * pu8Src[offSrc + idx_g] + inv_alpha * pFrame->pau8Buf[offDst + idx_g]) >> 8);
+                pFrame->pau8Buf[offDst + idx_b] = (unsigned char)((alpha * pu8Src[offSrc + idx_b] + inv_alpha * pFrame->pau8Buf[offDst + idx_b]) >> 8);
+                pFrame->pau8Buf[offDst + idx_a] = 0xff;
+            }
+
+            offSrc = RT_MIN(offSrc + uSrcBytesPerPixel, cbSrc);
+            if (offSrc >= cbSrc)
+                break;
+            offDst = RT_MIN(offDst + uDstBytesPerPixel, pFrame->cbBuf);
+            if (offDst >= pFrame->cbBuf)
+                break;
+        }
+    }
+
+#if 0
+    RecordingUtilsDbgDumpImageData(pu8Src, cbSrc, "/tmp", "cursor-src", uSrcWidth, uSrcHeight, uSrcBytesPerLine, 32);
+    RecordingUtilsDbgDumpVideoFrameEx(pFrame, "/tmp", "cursor-dst");
+#endif
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Simple blitting function for raw image data.
+ *
+ * @returns VBox status code.
+ * @param   pDstFrame           Destination frame.
+ * @param   uDstX               X destination (in pixel) within destination frame.
+ * @param   uDstY               Y destination (in pixel) within destination frame.
+ * @param   pu8Src              Source data to blit. Must be in the same pixel format as \a pFrame.
+ * @param   cbSrc               Size (in bytes) of \a pu8Src.
+ * @param   uSrcX               X start (in pixel) within source data.
+ * @param   uSrcY               Y start (in pixel) within source data.
+ * @param   uSrcWidth           Width (in pixel) to blit from source data.
+ * @param   uSrcHeight          Height (in pixel) to blit from data.
+ * @param   uSrcBytesPerLine    Bytes per line in source data.
+ * @param   uSrcBPP             BPP of source data. Must match \a pFrame.
+ * @param   enmFmt              Pixel format of source data. Must match \a pFrame.
+ */
+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)
+{
+    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);
+}
+
+/**
+ * Simple blitting function for raw image data with alpha channel.
+ *
+ * @returns VBox status code.
+ * @param   pFrame              Destination frame.
+ * @param   uDstX               X destination (in pixel) within destination frame.
+ * @param   uDstY               Y destination (in pixel) within destination frame.
+ * @param   pu8Src              Source data to blit. Must be in the same pixel format as \a pFrame.
+ * @param   cbSrc               Size (in bytes) of \a pu8Src.
+ * @param   uSrcX               X start (in pixel) within source data.
+ * @param   uSrcY               Y start (in pixel) within source data.
+ * @param   uSrcWidth           Width (in pixel) to blit from source data.
+ * @param   uSrcHeight          Height (in pixel) to blit from data.
+ * @param   uSrcBytesPerLine    Bytes per line in source data.
+ * @param   uSrcBPP             BPP of source data. Must match \a pFrame.
+ * @param   enmFmt              Pixel format of source data. Must match \a 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)
+{
+    return recordingVideoFrameBlitRawAlpha(pFrame, uDstX, uDstY,
+                                           pu8Src, cbSrc, uSrcX, uSrcY, uSrcWidth, uSrcHeight, uSrcBytesPerLine, uSrcBPP, enmFmt);
+}
+
+/**
+ * Simple blitting function for video frames.
+ *
+ * @returns VBox status code.
+ * @param   pDstFrame           Destination frame.
+ * @param   uDstX               X destination (in pixel) within destination frame.
+ * @param   uDstY               Y destination (in pixel) within destination frame.
+ * @param   pSrcFrame           Source frame.
+ * @param   uSrcX               X start (in pixel) within source frame.
+ * @param   uSrcY               Y start (in pixel) within source frame.
+ * @param   uSrcWidth           Width (in pixel) to blit from source frame.
+ * @param   uSrcHeight          Height (in pixel) to blit from frame.
+ *
+ * @note    Does NOT check for limits, so use with care!
+ */
+int RecordingVideoFrameBlitFrame(PRECORDINGVIDEOFRAME pDstFrame, uint32_t uDstX, uint32_t uDstY,
+                                 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);
+}
+
+#ifdef VBOX_WITH_AUDIO_RECORDING
+/**
  * Destroys a recording audio frame.
  *
  * @param   pFrame              Pointer to audio frame to destroy.
  */
-static void recordingAudioFrameDestroy(PRECORDINGAUDIOFRAME pFrame)
-{
+DECLINLINE(void) recordingAudioFrameDestroy(PRECORDINGAUDIOFRAME pFrame)
+{
+    if (!pFrame)
+        return;
+
     if (pFrame->pvBuf)
     {
         Assert(pFrame->cbBuf);
         RTMemFree(pFrame->pvBuf);
+        pFrame->pvBuf = NULL;
         pFrame->cbBuf = 0;
     }
@@ -94 +460 @@
     pFrame = NULL;
 }
-
 #endif /* VBOX_WITH_AUDIO_RECORDING */
 
 /**
- * Destroys a recording video frame.
- *
- * @param   pFrame              Pointer to video frame to destroy.
- */
-void RecordingVideoFrameDestroy(PRECORDINGVIDEOFRAME pFrame)
-{
-    if (pFrame->pu8RGBBuf)
-    {
-        Assert(pFrame->cbRGBBuf);
-        RTMemFree(pFrame->pu8RGBBuf);
-        pFrame->cbRGBBuf = 0;
-    }
-}
-
-/**
- * Frees a recording video frame.
- *
- * @param   pFrame              Pointer to video frame to free. The pointer will be invalid after return.
- */
-void RecordingVideoFrameFree(PRECORDINGVIDEOFRAME pFrame)
-{
-    if (!pFrame)
-        return;
-
-    RecordingVideoFrameDestroy(pFrame);
-
-    RTMemFree(pFrame);
-}
-
-/**
  * Frees a recording frame.
  *
- * @param   pFrame              Pointer to recording frame to free. The pointer will be invalid after return.
+ * @param   pFrame              Pointer to recording frame to free.
+ *                              The pointer will be invalid after return.
  */
 void RecordingFrameFree(PRECORDINGFRAME pFrame)
@@ -141 +477 @@
 #ifdef VBOX_WITH_AUDIO_RECORDING
         case RECORDINGFRAME_TYPE_AUDIO:
-            recordingAudioFrameDestroy(&pFrame->Audio);
+            recordingAudioFrameDestroy(&pFrame->u.Audio);
             break;
 #endif
         case RECORDINGFRAME_TYPE_VIDEO:
-            RecordingVideoFrameDestroy(&pFrame->Video);
+            RecordingVideoFrameDestroy(&pFrame->u.Video);
             break;
 
+        case RECORDINGFRAME_TYPE_CURSOR_SHAPE:
+            RecordingVideoFrameDestroy(&pFrame->u.CursorShape);
+            break;
+
         default:
-            AssertFailed();
+            /* Nothing to do here. */
             break;
     }

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

@@ -259 +259 @@
 /**
  * Processes a recording stream.
+ *
  * This function takes care of the actual encoding and writing of a certain stream.
  * As this can be very CPU intensive, this function usually is called from a separate thread.
  *
  * @returns VBox status code.
- * @param   mapBlocksCommon     Map of common block to process for this stream.
+ * @param   streamBlocks        Block set of stream to process.
+ * @param   commonBlocks        Block set of common blocks to process for this stream.
  *
  * @note    Runs in recording thread.
  */
-int RecordingStream::Process(RecordingBlockMap &mapBlocksCommon)
+int RecordingStream::process(const RecordingBlockSet &streamBlocks, RecordingBlockMap &commonBlocks)
 {
     LogFlowFuncEnter();
@@ -281 +283 @@
     int vrc = VINF_SUCCESS;
 
-    RecordingBlockMap::iterator itStreamBlocks = m_Blocks.Map.begin();
-    while (itStreamBlocks != m_Blocks.Map.end())
-    {
-        uint64_t const   msTimestamp = itStreamBlocks->first;
-        RecordingBlocks *pBlocks     = itStreamBlocks->second;
+    RecordingBlockMap::const_iterator itStreamBlock = streamBlocks.Map.begin();
+    while (itStreamBlock != streamBlocks.Map.end())
+    {
+        uint64_t const   msTimestamp = itStreamBlock->first; RT_NOREF(msTimestamp);
+        RecordingBlocks *pBlocks     = itStreamBlock->second;
 
         AssertPtr(pBlocks);
 
-        while (!pBlocks->List.empty())
+        RecordingBlockList::const_iterator itBlockInList = pBlocks->List.cbegin();
+        while (itBlockInList != pBlocks->List.cend())
         {
-            RecordingBlock *pBlock = pBlocks->List.front();
-            AssertPtr(pBlock);
-
-            switch (pBlock->enmType)
-            {
-                case RECORDINGBLOCKTYPE_VIDEO:
-                {
-                    RECORDINGFRAME Frame;
-                    Frame.VideoPtr    = (PRECORDINGVIDEOFRAME)pBlock->pvData;
-                    Frame.msTimestamp = msTimestamp;
-
-                    int vrc2 = recordingCodecEncode(&m_CodecVideo, &Frame, NULL, NULL);
+            PRECORDINGFRAME pFrame = (PRECORDINGFRAME)(*itBlockInList)->pvData;
+            AssertPtr(pFrame);
+            Assert(pFrame->msTimestamp == msTimestamp);
+
+            switch (pFrame->enmType)
+            {
+                case RECORDINGFRAME_TYPE_VIDEO:
+                    RT_FALL_THROUGH();
+                case RECORDINGFRAME_TYPE_CURSOR_SHAPE:
+                    RT_FALL_THROUGH();
+                case RECORDINGFRAME_TYPE_CURSOR_POS:
+                {
+                    int vrc2 = recordingCodecEncodeFrame(&m_CodecVideo, pFrame, pFrame->msTimestamp, m_pCtx /* pvUser */);
                     AssertRC(vrc2);
                     if (RT_SUCCESS(vrc))
                         vrc = vrc2;
-
                     break;
                 }
 
+                case RECORDINGFRAME_TYPE_SCREEN_CHANGE:
+                {
+                    /* ignore rc */ recordingCodecScreenChange(&m_CodecVideo, &pFrame->u.ScreenInfo);
+                    break;
+                }
+
                 default:
-                    /* Note: Audio data already is encoded. */
                     break;
             }
 
-            pBlocks->List.pop_front();
-            delete pBlock;
+            ++itBlockInList;
         }
 
-        Assert(pBlocks->List.empty());
-        delete pBlocks;
-
-        m_Blocks.Map.erase(itStreamBlocks);
-        itStreamBlocks = m_Blocks.Map.begin();
+        ++itStreamBlock;
     }
 
@@ -332 +335 @@
         /* As each (enabled) screen has to get the same audio data, look for common (audio) data which needs to be
          * written to the screen's assigned recording stream. */
-        RecordingBlockMap::iterator itCommonBlocks = mapBlocksCommon.begin();
-        while (itCommonBlocks != mapBlocksCommon.end())
+        RecordingBlockMap::const_iterator itBlockMap = commonBlocks.begin();
+        while (itBlockMap != commonBlocks.end())
         {
-            RecordingBlockList::iterator itBlock = itCommonBlocks->second->List.begin();
-            while (itBlock != itCommonBlocks->second->List.end())
-            {
-                RecordingBlock *pBlockCommon = (RecordingBlock *)(*itBlock);
-                switch (pBlockCommon->enmType)
-                {
-                    case RECORDINGBLOCKTYPE_AUDIO:
-                    {
-                        PRECORDINGAUDIOFRAME pAudioFrame = (PRECORDINGAUDIOFRAME)pBlockCommon->pvData;
-                        AssertPtr(pAudioFrame);
-                        AssertPtr(pAudioFrame->pvBuf);
-                        Assert(pAudioFrame->cbBuf);
-
-                        AssertPtr(this->File.m_pWEBM);
-                        int vrc2 = this->File.m_pWEBM->WriteBlock(m_uTrackAudio, pAudioFrame->pvBuf, pAudioFrame->cbBuf, pBlockCommon->msTimestamp, pBlockCommon->uFlags);
-                        AssertRC(vrc2);
-                        if (RT_SUCCESS(vrc))
-                            vrc = vrc2;
-                        break;
-                    }
-
-                    default:
-                        AssertFailed();
-                        break;
-                }
-
-                Assert(pBlockCommon->cRefs);
-                pBlockCommon->cRefs--;
-                if (pBlockCommon->cRefs == 0)
-                {
-                    itCommonBlocks->second->List.erase(itBlock);
-                    delete pBlockCommon;
-                    itBlock = itCommonBlocks->second->List.begin();
+            RecordingBlockList &blockList = itBlockMap->second->List;
+
+            RecordingBlockList::iterator itBlockList = blockList.begin();
+            while (itBlockList != blockList.end())
+            {
+                RecordingBlock *pBlock = (RecordingBlock *)(*itBlockList);
+
+                PRECORDINGFRAME      pFrame      = (PRECORDINGFRAME)pBlock->pvData;
+                Assert(pFrame->enmType == RECORDINGFRAME_TYPE_AUDIO);
+                PRECORDINGAUDIOFRAME pAudioFrame = &pFrame->u.Audio;
+
+                int vrc2 = this->File.m_pWEBM->WriteBlock(m_uTrackAudio, pAudioFrame->pvBuf, pAudioFrame->cbBuf, pBlock->msTimestamp, pBlock->uFlags);
+                if (RT_SUCCESS(vrc))
+                    vrc = vrc2;
+
+                Log3Func(("RECORDINGFRAME_TYPE_AUDIO: %zu bytes -> %Rrc\n", pAudioFrame->cbBuf, vrc2));
+
+                Assert(pBlock->cRefs);
+                pBlock->cRefs--;
+                if (pBlock->cRefs == 0)
+                {
+                    blockList.erase(itBlockList);
+                    delete pBlock;
+                    itBlockList = blockList.begin();
                 }
                 else
-                    ++itBlock;
-            }
-
-            /* If no entries are left over in the block map, remove it altogether. */
-            if (itCommonBlocks->second->List.empty())
-            {
-                delete itCommonBlocks->second;
-                mapBlocksCommon.erase(itCommonBlocks);
-                itCommonBlocks = mapBlocksCommon.begin();
+                    ++itBlockList;
+            }
+
+            /* If no entries are left over in the block list, remove it altogether. */
+            if (blockList.empty())
+            {
+                delete itBlockMap->second;
+                commonBlocks.erase(itBlockMap);
+                itBlockMap = commonBlocks.begin();
             }
             else
-                ++itCommonBlocks;
-
-            LogFunc(("Common blocks: %zu\n", mapBlocksCommon.size()));
+                ++itBlockMap;
         }
     }
 #else
-    RT_NOREF(mapBlocksCommon);
+    RT_NOREF(commonBlocks);
 #endif /* VBOX_WITH_AUDIO_RECORDING */
 
@@ -393 +385 @@
 
     LogFlowFuncLeaveRC(vrc);
+    return vrc;
+}
+
+/**
+ * The stream's main routine called from the encoding thread.
+ *
+ * @returns VBox status code.
+ * @param   rcWait              Result of the encoding thread's wait operation.
+ *                              Can be used for figuring out if the encoder has to perform some
+ *                              worked based on that result.
+ * @param   commonBlocks        Common blocks multiplexed to all recording streams.
+ *
+ * @note    Runs in encoding thread.
+ */
+int RecordingStream::ThreadMain(int rcWait, RecordingBlockMap &commonBlocks)
+{
+    Log3Func(("rcWait=%Rrc\n", rcWait));
+
+    /* No new data arrived within time? Feed the encoder with the last frame we built.
+     *
+     * This is necessary in order to render a video which has a consistent time line,
+     * as we only encode data when something has changed ("dirty areas"). */
+    if (   rcWait == VERR_TIMEOUT
+        && m_ScreenSettings.isFeatureEnabled(RecordingFeature_Video))
+    {
+        return recordingCodecEncodeCurrent(&m_CodecVideo, m_pCtx->GetCurrentPTS());
+    }
+
+    int vrc = process(m_Blocks, commonBlocks);
+
+    /*
+     * Housekeeping.
+     *
+     * Here we delete all processed stream blocks of this stream.
+     * The common blocks will be deleted by the recording context (which owns those).
+     */
+    lock();
+
+    RecordingBlockMap::iterator itStreamBlocks = m_Blocks.Map.begin();
+    while (itStreamBlocks != m_Blocks.Map.end())
+    {
+        RecordingBlocks *pBlocks = itStreamBlocks->second;
+        AssertPtr(pBlocks);
+        pBlocks->Clear();
+        Assert(pBlocks->List.empty());
+        delete pBlocks;
+
+        m_Blocks.Map.erase(itStreamBlocks);
+        itStreamBlocks = m_Blocks.Map.begin();
+    }
+    Assert(m_Blocks.Map.empty());
+
+    unlock();
+
+    return vrc;
+}
+
+/**
+ * Adds a recording frame to be fed to the encoder.
+ *
+ * @returns VBox status code.
+ * @param   pFrame              Recording frame to add.
+ *                              Ownership of the frame will be transferred to the encoder on success then.
+ *                              Must be free'd by the caller on failure.
+ * @param   msTimestamp         Timestamp (PTS, in ms).
+ *
+ * @note    Caller needs to take the stream's lock.
+ */
+int RecordingStream::addFrame(PRECORDINGFRAME pFrame, uint64_t msTimestamp)
+{
+    int vrc;
+
+    Assert(pFrame->msTimestamp == msTimestamp); /* Sanity. */
+
+    try
+    {
+        RecordingBlock *pBlock = new RecordingBlock();
+
+        pBlock->pvData = pFrame;
+        pBlock->cbData = sizeof(RECORDINGFRAME);
+
+        try
+        {
+            RecordingBlocks *pRecordingBlocks;
+            RecordingBlockMap::const_iterator it = m_Blocks.Map.find(msTimestamp);
+            if (it == m_Blocks.Map.end())
+            {
+                pRecordingBlocks = new RecordingBlocks();
+                pRecordingBlocks->List.push_back(pBlock);
+                m_Blocks.Map.insert(std::make_pair(msTimestamp, pRecordingBlocks));
+            }
+            else
+            {
+                pRecordingBlocks = it->second;
+                pRecordingBlocks->List.push_back(pBlock);
+            }
+
+            vrc = VINF_SUCCESS;
+        }
+        catch (const std::exception &)
+        {
+            delete pBlock;
+            vrc = VERR_NO_MEMORY;
+        }
+    }
+    catch (const std::exception &)
+    {
+        vrc = VERR_NO_MEMORY;
+    }
+
     return vrc;
 }
@@ -407 +509 @@
 {
     AssertPtrReturn(m_pCtx, VERR_WRONG_ORDER);
-    AssertReturn(NeedsUpdate(msTimestamp), VINF_RECORDING_THROTTLED); /* We ASSUME that the caller checked that first. */
-
-    Log3Func(("cbData=%zu, msTimestamp=%RU64\n", cbData, msTimestamp));
 
     /* As audio data is common across all streams, re-route this to the recording context, where
@@ -417 +516 @@
 
 /**
+ * Sends a cursor position change to the recording stream.
+ *
+ * @returns VBox status code.
+ * @param   idCursor            Cursor ID. Currently unused and always set to 0.
+ * @param   pPos                Cursor information to send.
+ * @param   msTimestamp         Timestamp (PTS, in ms).
+ */
+int RecordingStream::SendCursorPos(uint8_t idCursor, PRECORDINGPOS pPos, uint64_t msTimestamp)
+{
+    RT_NOREF(idCursor);
+    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));
+    AssertPtrReturn(pFrame, VERR_NO_MEMORY);
+    pFrame->enmType     = RECORDINGFRAME_TYPE_CURSOR_POS;
+    pFrame->msTimestamp = msTimestamp;
+
+    pFrame->u.Cursor.Pos = *pPos;
+
+    vrc = addFrame(pFrame, msTimestamp);
+
+    unlock();
+
+    return vrc;
+}
+
+/**
+ * Sends a cursor shape change to the recording stream.
+ *
+ * @returns VBox status code.
+ * @param   idCursor            Cursor ID. Currently unused and always set to 0.
+ * @param   pShape              Cursor shape to send.
+ * @param   msTimestamp         Timestamp (PTS, in ms).
+ *
+ * @note    Keep it as simple as possible, as this function might run on EMT.
+ * @thread  EMT
+ */
+int RecordingStream::SendCursorShape(uint8_t idCursor, PRECORDINGVIDEOFRAME pShape, uint64_t msTimestamp)
+{
+    RT_NOREF(idCursor);
+    AssertPtrReturn(pShape, VERR_INVALID_POINTER);
+    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));
+    AssertPtrReturn(pFrame, VERR_NO_MEMORY);
+
+    pFrame->u.Video = *pShape;
+    /* Make a deep copy of the pixel data. */
+    pFrame->u.Video.pau8Buf = (uint8_t *)RTMemDup(pShape->pau8Buf, pShape->cbBuf);
+    AssertPtrReturnStmt(pFrame->u.Video.pau8Buf, RTMemFree(pFrame), VERR_NO_MEMORY);
+    pFrame->u.Video.cbBuf   = pShape->cbBuf;
+
+    pFrame->enmType     = RECORDINGFRAME_TYPE_CURSOR_SHAPE;
+    pFrame->msTimestamp = msTimestamp;
+
+    vrc = addFrame(pFrame, msTimestamp);
+
+    if (RT_FAILURE(vrc))
+    {
+        RecordingVideoFrameDestroy(&pFrame->u.Video);
+        RecordingFrameFree(pFrame);
+    }
+
+    unlock();
+
+    LogFlowFuncLeaveRC(vrc);
+    return vrc;
+}
+
+/**
  * Sends a raw (e.g. not yet encoded) video frame to the recording stream.
  *
@@ -422 +609 @@
  * @retval  VINF_RECORDING_LIMIT_REACHED if the stream's recording limit has been reached.
  * @retval  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.
- * @param   uPixelFormat        Pixel format of the video frame.
- * @param   uBPP                Bits per pixel (BPP) of the video frame.
- * @param   uBytesPerLine       Bytes per line  of the video frame.
- * @param   uSrcWidth           Width (in pixels) of the video frame.
- * @param   uSrcHeight          Height (in pixels) of the video frame.
- * @param   puSrcData           Actual pixel data of the video frame.
+ * @param   pVideoFrame         Video frame to send.
  * @param   msTimestamp         Timestamp (PTS, in ms).
- */
-int RecordingStream::SendVideoFrame(uint32_t x, uint32_t y, uint32_t uPixelFormat, uint32_t uBPP, uint32_t uBytesPerLine,
-                                    uint32_t uSrcWidth, uint32_t uSrcHeight, uint8_t *puSrcData, uint64_t msTimestamp)
-{
+ *
+ * @note    Keep it as simple as possible, as this function might run on EMT.
+ * @thread  EMT
+ */
+int RecordingStream::SendVideoFrame(PRECORDINGVIDEOFRAME pVideoFrame, uint64_t msTimestamp)
+{
+    AssertPtrReturn(pVideoFrame, VERR_INVALID_POINTER);
     AssertPtrReturn(m_pCtx, VERR_WRONG_ORDER);
 
-    if (RT_UNLIKELY(!NeedsUpdate(msTimestamp)))
-        return VINF_RECORDING_THROTTLED;
-
     lock();
-
-    Log3Func(("[%RU32 %RU32 %RU32 %RU32] msTimestamp=%RU64\n", x , y, uSrcWidth, uSrcHeight, msTimestamp));
-
-    PRECORDINGVIDEOFRAME pFrame = NULL;
 
     int vrc = iterateInternal(msTimestamp);
@@ -453 +629 @@
     }
 
-    do
-    {
-        int xDiff = ((int)m_ScreenSettings.Video.ulWidth - (int)uSrcWidth) / 2;
-        uint32_t w = uSrcWidth;
-        if ((int)w + xDiff + (int)x <= 0)  /* Nothing visible. */
-        {
-            vrc = VERR_INVALID_PARAMETER;
-            break;
-        }
-
-        uint32_t destX;
-        if ((int)x < -xDiff)
-        {
-            w += xDiff + x;
-            x = -xDiff;
-            destX = 0;
-        }
-        else
-            destX = x + xDiff;
-
-        uint32_t h = uSrcHeight;
-        int yDiff = ((int)m_ScreenSettings.Video.ulHeight - (int)uSrcHeight) / 2;
-        if ((int)h + yDiff + (int)y <= 0)  /* Nothing visible. */
-        {
-            vrc = VERR_INVALID_PARAMETER;
-            break;
-        }
-
-        uint32_t destY;
-        if ((int)y < -yDiff)
-        {
-            h += yDiff + (int)y;
-            y = -yDiff;
-            destY = 0;
-        }
-        else
-            destY = y + yDiff;
-
-        if (   destX > m_ScreenSettings.Video.ulWidth
-            || destY > m_ScreenSettings.Video.ulHeight)
-        {
-            vrc = VERR_INVALID_PARAMETER;  /* Nothing visible. */
-            break;
-        }
-
-        if (destX + w > m_ScreenSettings.Video.ulWidth)
-            w = m_ScreenSettings.Video.ulWidth - destX;
-
-        if (destY + h > m_ScreenSettings.Video.ulHeight)
-            h = m_ScreenSettings.Video.ulHeight - destY;
-
-        pFrame = (PRECORDINGVIDEOFRAME)RTMemAllocZ(sizeof(RECORDINGVIDEOFRAME));
-        AssertBreakStmt(pFrame, vrc = VERR_NO_MEMORY);
-
-        /* Calculate bytes per pixel and set pixel format. */
-        const unsigned uBytesPerPixel = uBPP / 8;
-        if (uPixelFormat == BitmapFormat_BGR)
-        {
-            switch (uBPP)
-            {
-                case 32:
-                    pFrame->enmPixelFmt = RECORDINGPIXELFMT_RGB32;
-                    break;
-                case 24:
-                    pFrame->enmPixelFmt = RECORDINGPIXELFMT_RGB24;
-                    break;
-                case 16:
-                    pFrame->enmPixelFmt = RECORDINGPIXELFMT_RGB565;
-                    break;
-                default:
-                    AssertMsgFailedBreakStmt(("Unknown color depth (%RU32)\n", uBPP), vrc = VERR_NOT_SUPPORTED);
-                    break;
-            }
-        }
-        else
-            AssertMsgFailedBreakStmt(("Unknown pixel format (%RU32)\n", uPixelFormat), vrc = VERR_NOT_SUPPORTED);
-
-        const size_t cbRGBBuf =   m_ScreenSettings.Video.ulWidth
-                                * m_ScreenSettings.Video.ulHeight
-                                * uBytesPerPixel;
-        AssertBreakStmt(cbRGBBuf, vrc = VERR_INVALID_PARAMETER);
-
-        pFrame->pu8RGBBuf = (uint8_t *)RTMemAlloc(cbRGBBuf);
-        AssertBreakStmt(pFrame->pu8RGBBuf, vrc = VERR_NO_MEMORY);
-        pFrame->cbRGBBuf  = cbRGBBuf;
-        pFrame->uWidth    = uSrcWidth;
-        pFrame->uHeight   = uSrcHeight;
-
-        /* If the current video frame is smaller than video resolution we're going to encode,
-         * clear the frame beforehand to prevent artifacts. */
-        if (   uSrcWidth  < m_ScreenSettings.Video.ulWidth
-            || uSrcHeight < m_ScreenSettings.Video.ulHeight)
-        {
-            RT_BZERO(pFrame->pu8RGBBuf, pFrame->cbRGBBuf);
-        }
-
-        /* Calculate start offset in source and destination buffers. */
-        uint32_t offSrc = y * uBytesPerLine + x * uBytesPerPixel;
-        uint32_t offDst = (destY * m_ScreenSettings.Video.ulWidth + destX) * uBytesPerPixel;
-
-#ifdef VBOX_RECORDING_DUMP
-        BMPFILEHDR fileHdr;
-        RT_ZERO(fileHdr);
-
-        BMPWIN3XINFOHDR coreHdr;
-        RT_ZERO(coreHdr);
-
-        fileHdr.uType       = BMP_HDR_MAGIC;
-        fileHdr.cbFileSize = (uint32_t)(sizeof(BMPFILEHDR) + sizeof(BMPWIN3XINFOHDR) + (w * h * uBytesPerPixel));
-        fileHdr.offBits    = (uint32_t)(sizeof(BMPFILEHDR) + sizeof(BMPWIN3XINFOHDR));
-
-        coreHdr.cbSize         = sizeof(BMPWIN3XINFOHDR);
-        coreHdr.uWidth         = w;
-        coreHdr.uHeight        = h;
-        coreHdr.cPlanes        = 1;
-        coreHdr.cBits          = uBPP;
-        coreHdr.uXPelsPerMeter = 5000;
-        coreHdr.uYPelsPerMeter = 5000;
-
-        char szFileName[RTPATH_MAX];
-        RTStrPrintf2(szFileName, sizeof(szFileName), "/tmp/VideoRecFrame-%RU32.bmp", m_uScreenID);
-
-        RTFILE fh;
-        int vrc2 = RTFileOpen(&fh, szFileName,
-                              RTFILE_O_CREATE_REPLACE | RTFILE_O_WRITE | RTFILE_O_DENY_NONE);
-        if (RT_SUCCESS(vrc2))
-        {
-            RTFileWrite(fh, &fileHdr,    sizeof(fileHdr),    NULL);
-            RTFileWrite(fh, &coreHdr, sizeof(coreHdr), NULL);
-        }
-#endif
-        Assert(pFrame->cbRGBBuf >= w * h * uBytesPerPixel);
-
-        /* Do the copy. */
-        for (unsigned int i = 0; i < h; i++)
-        {
-            /* Overflow check. */
-            Assert(offSrc + w * uBytesPerPixel <= uSrcHeight * uBytesPerLine);
-            Assert(offDst + w * uBytesPerPixel <= m_ScreenSettings.Video.ulHeight * m_ScreenSettings.Video.ulWidth * uBytesPerPixel);
-
-            memcpy(pFrame->pu8RGBBuf + offDst, puSrcData + offSrc, w * uBytesPerPixel);
-
-#ifdef VBOX_RECORDING_DUMP
-            if (RT_SUCCESS(rc2))
-                RTFileWrite(fh, pFrame->pu8RGBBuf + offDst, w * uBytesPerPixel, NULL);
-#endif
-            offSrc += uBytesPerLine;
-            offDst += m_ScreenSettings.Video.ulWidth * uBytesPerPixel;
-        }
-
-#ifdef VBOX_RECORDING_DUMP
-        if (RT_SUCCESS(vrc2))
-            RTFileClose(fh);
-#endif
-
-    } while (0);
-
-    if (vrc == VINF_SUCCESS) /* Note: Also could be VINF_TRY_AGAIN. */
-    {
-        RecordingBlock *pBlock = new RecordingBlock();
-        if (pBlock)
-        {
-            AssertPtr(pFrame);
-
-            pBlock->enmType = RECORDINGBLOCKTYPE_VIDEO;
-            pBlock->pvData  = pFrame;
-            pBlock->cbData  = sizeof(RECORDINGVIDEOFRAME) + pFrame->cbRGBBuf;
-
-            try
-            {
-                RecordingBlocks *pRecordingBlocks = new RecordingBlocks();
-                pRecordingBlocks->List.push_back(pBlock);
-
-                Assert(m_Blocks.Map.find(msTimestamp) == m_Blocks.Map.end());
-                m_Blocks.Map.insert(std::make_pair(msTimestamp, pRecordingBlocks));
-            }
-            catch (const std::exception &ex)
-            {
-                RT_NOREF(ex);
-
-                delete pBlock;
-                vrc = VERR_NO_MEMORY;
-            }
-        }
-        else
-            vrc = VERR_NO_MEMORY;
-    }
+    PRECORDINGFRAME pFrame = (PRECORDINGFRAME)RTMemAlloc(sizeof(RECORDINGFRAME));
+    AssertPtrReturn(pFrame, VERR_NO_MEMORY);
+
+    pFrame->u.Video = *pVideoFrame;
+    /* Make a deep copy of the pixel data. */
+    pFrame->u.Video.pau8Buf = (uint8_t *)RTMemDup(pVideoFrame->pau8Buf, pVideoFrame->cbBuf);
+    AssertPtrReturnStmt(pFrame->u.Video.pau8Buf, RTMemFree(pFrame), VERR_NO_MEMORY);
+    pFrame->u.Video.cbBuf   = pVideoFrame->cbBuf;
+
+    pFrame->enmType     = RECORDINGFRAME_TYPE_VIDEO;
+    pFrame->msTimestamp = msTimestamp;
+
+    vrc = addFrame(pFrame, msTimestamp);
 
     if (RT_FAILURE(vrc))
-        RecordingVideoFrameFree(pFrame);
+    {
+        RecordingVideoFrameDestroy(&pFrame->u.Video);
+        RecordingFrameFree(pFrame);
+    }
+
+    unlock();
+
+    LogFlowFuncLeaveRC(vrc);
+    return vrc;
+}
+
+/**
+ * Sends a screen size change to a recording stream.
+ *
+ * @returns VBox status code.
+ * @param   pInfo               Recording screen info to use.
+ * @param   msTimestamp         Timestamp (PTS, in ms).
+ * @param   fForce              Set to \c true to force a change, otherwise to \c false.
+ */
+int RecordingStream::SendScreenChange(PRECORDINGSURFACEINFO pInfo, uint64_t msTimestamp, bool fForce /* = false */)
+{
+    AssertPtrReturn(pInfo, VERR_INVALID_POINTER);
+
+    if (   !pInfo->uWidth
+        || !pInfo->uHeight)
+        return VINF_SUCCESS;
+
+    RT_NOREF(fForce);
+
+    LogRel(("Recording: Size of screen #%RU32 changed to %RU32x%RU32 (%RU8 BPP)\n",
+            m_uScreenID, pInfo->uWidth, pInfo->uHeight, pInfo->uBPP));
+
+    lock();
+
+    PRECORDINGFRAME pFrame = (PRECORDINGFRAME)RTMemAlloc(sizeof(RECORDINGFRAME));
+    AssertPtrReturn(pFrame, VERR_NO_MEMORY);
+    pFrame->enmType      = RECORDINGFRAME_TYPE_SCREEN_CHANGE;
+    pFrame->msTimestamp  = msTimestamp;
+
+    pFrame->u.ScreenInfo = *pInfo;
+
+    int vrc = addFrame(pFrame, msTimestamp);
 
     unlock();
@@ -795 +838 @@
         m_enmState  = RECORDINGSTREAMSTATE_INITIALIZED;
         m_fEnabled  = true;
-        m_tsStartMs = RTTimeProgramMilliTS();
+        m_tsStartMs = RTTimeMilliTS();
 
         return VINF_SUCCESS;
@@ -817 +860 @@
 {
     int vrc = VINF_SUCCESS;
+
+    /* ignore rc */ recordingCodecFinalize(&m_CodecVideo);
 
     switch (m_ScreenSettings.enmDest)
@@ -918 +963 @@
 
     if (m_ScreenSettings.isFeatureEnabled(RecordingFeature_Video))
-    {
-        vrc = recordingCodecFinalize(&m_CodecVideo);
-        if (RT_SUCCESS(vrc))
-            vrc = recordingCodecDestroy(&m_CodecVideo);
-    }
+        vrc = recordingCodecDestroy(&m_CodecVideo);
 
     if (RT_SUCCESS(vrc))
@@ -953 +994 @@
 
     WebMWriter::WebMBlockFlags blockFlags = VBOX_WEBM_BLOCK_FLAG_NONE;
-    if (RT_LIKELY(uFlags != RECORDINGCODEC_ENC_F_NONE))
+    if (RT_LIKELY(uFlags == RECORDINGCODEC_ENC_F_NONE))
     {
         /* All set. */
@@ -966 +1007 @@
 
     return this->File.m_pWEBM->WriteBlock(  pCodec->Parms.enmType == RECORDINGCODECTYPE_AUDIO
-                                        ? m_uTrackAudio : m_uTrackVideo,
-                                        pvData, cbData, msAbsPTS, blockFlags);
+                                          ? m_uTrackAudio : m_uTrackVideo,
+                                          pvData, cbData, msAbsPTS, blockFlags);
 }
 
@@ -1012 +1053 @@
     Callbacks.pfnWriteData = RecordingStream::codecWriteDataCallback;
 
-    int vrc = recordingCodecCreateVideo(pCodec, screenSettings.Video.enmCodec);
+    RECORDINGSURFACEINFO ScreenInfo;
+    ScreenInfo.uWidth  = screenSettings.Video.ulWidth;
+    ScreenInfo.uHeight = screenSettings.Video.ulHeight;
+    ScreenInfo.uBPP    = 32; /* We always start with 32 bit. */
+
+    int vrc = SendScreenChange(&ScreenInfo, true /* fForce */);
     if (RT_SUCCESS(vrc))
-        vrc = recordingCodecInit(pCodec, &Callbacks, screenSettings);
+    {
+        vrc = recordingCodecCreateVideo(pCodec, screenSettings.Video.enmCodec);
+        if (RT_SUCCESS(vrc))
+            vrc = recordingCodecInit(pCodec, &Callbacks, screenSettings);
+    }
 
     if (RT_FAILURE(vrc))

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

@@ -42 +42 @@
 #endif
 
+#include <VBox/log.h>
+
 
 /**
@@ -60 +62 @@
     RT_NOREF(aDstWidth, aDstHeight);
 
-    AssertReturn(!(aSrcWidth & 1),  false);
-    AssertReturn(!(aSrcHeight & 1), false);
-
-    bool fRc = true;
-    T iter1(aSrcWidth, aSrcHeight, aSrcBuf);
-    T iter2 = iter1;
-    iter2.skip(aSrcWidth);
-    unsigned cPixels = aSrcWidth * aSrcHeight;
-    unsigned offY = 0;
-    unsigned offU = cPixels;
-    unsigned offV = cPixels + cPixels / 4;
-    unsigned const cyHalf = aSrcHeight / 2;
-    unsigned const cxHalf = aSrcWidth  / 2;
-    for (unsigned i = 0; i < cyHalf && fRc; ++i)
-    {
-        for (unsigned j = 0; j < cxHalf; ++j)
-        {
-            unsigned red, green, blue;
-            fRc = iter1.getRGB(&red, &green, &blue);
-            AssertReturn(fRc, false);
-            aDstBuf[offY] = ((66 * red + 129 * green + 25 * blue + 128) >> 8) + 16;
-            unsigned u = (((-38 * red - 74 * green + 112 * blue + 128) >> 8) + 128) / 4;
-            unsigned v = (((112 * red - 94 * green -  18 * blue + 128) >> 8) + 128) / 4;
-
-            fRc = iter1.getRGB(&red, &green, &blue);
-            AssertReturn(fRc, false);
-            aDstBuf[offY + 1] = ((66 * red + 129 * green + 25 * blue + 128) >> 8) + 16;
-            u += (((-38 * red - 74 * green + 112 * blue + 128) >> 8) + 128) / 4;
-            v += (((112 * red - 94 * green -  18 * blue + 128) >> 8) + 128) / 4;
-
-            fRc = iter2.getRGB(&red, &green, &blue);
-            AssertReturn(fRc, false);
-            aDstBuf[offY + aSrcWidth] = ((66 * red + 129 * green + 25 * blue + 128) >> 8) + 16;
-            u += (((-38 * red - 74 * green + 112 * blue + 128) >> 8) + 128) / 4;
-            v += (((112 * red - 94 * green -  18 * blue + 128) >> 8) + 128) / 4;
-
-            fRc = iter2.getRGB(&red, &green, &blue);
-            AssertReturn(fRc, false);
-            aDstBuf[offY + aSrcWidth + 1] = ((66 * red + 129 * green + 25 * blue + 128) >> 8) + 16;
-            u += (((-38 * red - 74 * green + 112 * blue + 128) >> 8) + 128) / 4;
-            v += (((112 * red - 94 * green -  18 * blue + 128) >> 8) + 128) / 4;
-
-            aDstBuf[offU] = u;
-            aDstBuf[offV] = v;
-            offY += 2;
-            ++offU;
-            ++offV;
-        }
-
-        iter1.skip(aSrcWidth);
-        iter2.skip(aSrcWidth);
-        offY += aSrcWidth;
+    size_t image_size = aSrcWidth * aSrcHeight;
+    size_t upos = image_size;
+    size_t vpos = upos + upos / 4;
+    size_t i = 0;
+
+#define CALC_Y(r, g, b) \
+    ((66 * r + 129 * g + 25 * b) >> 8) + 16
+#define CALC_U(r, g, b) \
+    ((-38 * r + -74 * g + 112 * b) >> 8) + 128
+#define CALC_V(r, g, b) \
+    ((112 * r + -94 * g + -18 * b) >> 8) + 128
+
+    for (size_t line = 0; line < aSrcHeight; ++line)
+    {
+        if ((line % 2) == 0)
+        {
+            for (size_t x = 0; x < aSrcWidth; x += 2)
+            {
+                uint8_t b = aSrcBuf[4 * i];
+                uint8_t g = aSrcBuf[4 * i + 1];
+                uint8_t r = aSrcBuf[4 * i + 2];
+
+                aDstBuf[i++] = CALC_Y(r, g, b);
+
+                aDstBuf[upos++] = CALC_U(r, g, b);
+                aDstBuf[vpos++] = CALC_V(r, g, b);
+
+                b = aSrcBuf[4 * i];
+                g = aSrcBuf[4 * i + 1];
+                r = aSrcBuf[4 * i + 2];
+
+                aDstBuf[i++] = CALC_Y(r, g, b);
+            }
+        }
+        else
+        {
+            for (size_t x = 0; x < aSrcWidth; x++)
+            {
+                uint8_t b = aSrcBuf[4 * i];
+                uint8_t g = aSrcBuf[4 * i + 1];
+                uint8_t r = aSrcBuf[4 * i + 2];
+
+                aDstBuf[i++] = CALC_Y(r, g, b);
+            }
+        }
     }
 
@@ -152 +147 @@
 
 /**
- * Converts a RGB to YUV buffer.
- *
- * @returns IPRT status code.
- * @param   enmPixelFormat      Pixel format to use for conversion.
+ * Converts an entire RGB BGRA32 buffer to a YUV I420 buffer.
+ *
  * @param   paDst               Pointer to destination buffer.
- * @param   uDstWidth           Width (X, in pixels) of destination buffer.
- * @param   uDstHeight          Height (Y, in pixels) of destination buffer.
+ * @param   uDstWidth           Width (X, in pixel) of destination buffer.
+ * @param   uDstHeight          Height (Y, in pixel) of destination buffer.
  * @param   paSrc               Pointer to source buffer.
- * @param   uSrcWidth           Width (X, in pixels) of source buffer.
- * @param   uSrcHeight          Height (Y, in pixels) of source buffer.
- */
-int RecordingUtilsRGBToYUV(RECORDINGPIXELFMT enmPixelFormat,
-                           uint8_t *paDst, uint32_t uDstWidth, uint32_t uDstHeight,
-                           uint8_t *paSrc, uint32_t uSrcWidth, uint32_t uSrcHeight)
-{
-    switch (enmPixelFormat)
-    {
-        case RECORDINGPIXELFMT_RGB32:
-            if (!recordingUtilsColorConvWriteYUV420p<ColorConvBGRA32Iter>(paDst, uDstWidth, uDstHeight,
-                                                                          paSrc, uSrcWidth, uSrcHeight))
-                return VERR_INVALID_PARAMETER;
-            break;
-        case RECORDINGPIXELFMT_RGB24:
-            if (!recordingUtilsColorConvWriteYUV420p<ColorConvBGR24Iter>(paDst, uDstWidth, uDstHeight,
-                                                                         paSrc, uSrcWidth, uSrcHeight))
-                return VERR_INVALID_PARAMETER;
-            break;
-        case RECORDINGPIXELFMT_RGB565:
-            if (!recordingUtilsColorConvWriteYUV420p<ColorConvBGR565Iter>(paDst, uDstWidth, uDstHeight,
-                                                                          paSrc, uSrcWidth, uSrcHeight))
-                return VERR_INVALID_PARAMETER;
-            break;
-        default:
-            AssertFailed();
-            return VERR_NOT_SUPPORTED;
-    }
-    return VINF_SUCCESS;
+ * @param   uSrcWidth           Width (X, in pixel) of source buffer.
+ * @param   uSrcHeight          Height (Y, in pixel) of source buffer.
+ */
+void RecordingUtilsConvBGRA32ToYUVI420(uint8_t *paDst, uint32_t uDstWidth, uint32_t uDstHeight,
+                                       uint8_t *paSrc, uint32_t uSrcWidth, uint32_t uSrcHeight)
+{
+    RT_NOREF(uDstWidth, uDstHeight);
+
+    size_t const image_size = uSrcWidth * uSrcHeight;
+    size_t upos = image_size;
+    size_t vpos = upos + upos / 4;
+    size_t i = 0;
+
+#define CALC_Y(r, g, b) \
+    ((66 * r + 129 * g + 25 * b) >> 8) + 16
+#define CALC_U(r, g, b) \
+    ((-38 * r + -74 * g + 112 * b) >> 8) + 128
+#define CALC_V(r, g, b) \
+    ((112 * r + -94 * g + -18 * b) >> 8) + 128
+
+    for (size_t y = 0; y < uSrcHeight; y++)
+    {
+        if ((y % 2) == 0)
+        {
+            for (size_t x = 0; x < uSrcWidth; x += 2)
+            {
+                uint8_t b = paSrc[4 * i];
+                uint8_t g = paSrc[4 * i + 1];
+                uint8_t r = paSrc[4 * i + 2];
+
+                paDst[i++] = CALC_Y(r, g, b);
+
+                paDst[upos++] = CALC_U(r, g, b);
+                paDst[vpos++] = CALC_V(r, g, b);
+
+                b = paSrc[4 * i];
+                g = paSrc[4 * i + 1];
+                r = paSrc[4 * i + 2];
+
+                paDst[i++] = CALC_Y(r, g, b);
+            }
+        }
+        else
+        {
+            for (size_t x = 0; x < uSrcWidth; x++)
+            {
+                uint8_t const b = paSrc[4 * i];
+                uint8_t const g = paSrc[4 * i + 1];
+                uint8_t const r = paSrc[4 * i + 2];
+
+                paDst[i++] = CALC_Y(r, g, b);
+            }
+        }
+    }
+
+#undef CALC_Y
+#undef CALC_U
+#undef CALC_V
+}
+
+/**
+ * Converts a part of a RGB BGRA32 buffer to a YUV I420 buffer.
+ *
+ * @param   paDst               Pointer to destination buffer.
+ * @param   uDstX               X destination position (in pixel).
+ * @param   uDstY               Y destination position (in pixel).
+ * @param   uDstWidth           Width (X, in pixel) of destination buffer.
+ * @param   uDstHeight          Height (Y, in pixel) of destination buffer.
+ * @param   paSrc               Pointer to source buffer.
+ * @param   uSrcX               X source position (in pixel).
+ * @param   uSrcY               Y source position (in pixel).
+ * @param   uSrcWidth           Width (X, in pixel) of source buffer.
+ * @param   uSrcHeight          Height (Y, in pixel) of source buffer.
+ * @param   uSrcStride          Stride (in bytes) of source buffer.
+ * @param   uSrcBPP             Bits per pixel of source buffer.
+ */
+void RecordingUtilsConvBGRA32ToYUVI420Ex(uint8_t *paDst, uint32_t uDstX, uint32_t uDstY, uint32_t uDstWidth, uint32_t uDstHeight,
+                                         uint8_t *paSrc, uint32_t uSrcX, uint32_t uSrcY, uint32_t uSrcWidth, uint32_t uSrcHeight,
+                                         uint32_t uSrcStride, uint8_t uSrcBPP)
+{
+    Assert(uDstX < uDstWidth);
+    Assert(uDstX + uSrcWidth <= uDstWidth);
+    Assert(uDstY < uDstHeight);
+    Assert(uDstY + uSrcHeight <= uDstHeight);
+    Assert(uSrcBPP % 8 == 0);
+
+    RT_NOREF(uSrcHeight, uDstHeight);
+
+#define CALC_Y(r, g, b) \
+    (66 * r + 129 * g + 25 * b) >> 8
+#define CALC_U(r, g, b) \
+    ((-38 * r + -74 * g + 112 * b) >> 8) + 128
+#define CALC_V(r, g, b) \
+    ((112 * r + -94 * g + -18 * b) >> 8) + 128
+
+    uint32_t uDstXCur = uDstX;
+
+    const unsigned uSrcBytesPerPixel = uSrcBPP / 8;
+
+    size_t offSrc = (uSrcY * uSrcStride) + (uSrcX * uSrcBytesPerPixel);
+
+    for (size_t y = 0; y < uSrcHeight; y++)
+    {
+        for (size_t x = 0; x < uSrcWidth; x++)
+        {
+            size_t const offBGR = offSrc + (x * uSrcBytesPerPixel);
+
+            uint8_t const b = paSrc[offBGR];
+            uint8_t const g = paSrc[offBGR + 1];
+            uint8_t const r = paSrc[offBGR + 2];
+
+            size_t const offY  = uDstY * uDstWidth + uDstXCur;
+            size_t const offUV = (uDstY / 2) * (uDstWidth / 2) + (uDstXCur / 2) + uDstWidth * uDstHeight;
+
+            paDst[offY]                               = CALC_Y(r, g, b);
+            paDst[offUV]                              = CALC_U(r, g, b);
+            paDst[offUV + uDstWidth * uDstHeight / 4] = CALC_V(r, g, b);
+
+            uDstXCur++;
+        }
+
+        offSrc += uSrcStride;
+
+        uDstXCur = uDstX;
+        uDstY++;
+    }
+
+#undef CALC_Y
+#undef CALC_U
+#undef CALC_V
+}
+
+/**
+ * Crops (centers) or centers coordinates of a given source.
+ *
+ * @returns VBox status code.
+ * @retval  VWRN_RECORDING_ENCODING_SKIPPED if the source is not visible.
+ * @param   pCodecParms         Video codec parameters to use for cropping / centering.
+ * @param   sx                  Input / output: X location (in pixel) of the source.
+ * @param   sy                  Input / output: Y location (in pixel) of the source.
+ * @param   sw                  Input / output: Width (in pixel) of the source.
+ * @param   sh                  Input / output: Height (in pixel) of the source.
+ * @param   dx                  Input / output: X location (in pixel) of the destination.
+ * @param   dy                  Input / output: Y location (in pixel) of the destination.
+ *
+ * @note    Used when no other scaling algorithm is being selected / available. See testcase.
+ */
+int RecordingUtilsCoordsCropCenter(PRECORDINGCODECPARMS pCodecParms,
+                                   int32_t *sx, int32_t *sy, int32_t *sw, int32_t *sh, int32_t *dx, int32_t *dy)
+{
+    int vrc = VINF_SUCCESS;
+
+    Log3Func(("Original: sx=%RI32 sy=%RI32 sw=%RI32 sh=%RI32 dx=%RI32 dy=%RI32\n",
+              *sx, *sy, *sw, *sh, *dx, *dy));
+
+    /*
+     * Do centered cropping or centering.
+     */
+
+    int32_t const uOriginX = (int32_t)pCodecParms->u.Video.Scaling.u.Crop.m_iOriginX;
+    int32_t const uOriginY = (int32_t)pCodecParms->u.Video.Scaling.u.Crop.m_iOriginY;
+
+    /* Apply cropping / centering values. */
+    *dx += uOriginX;
+    *dy += uOriginY;
+
+    if (*dx < 0)
+    {
+        *dx  = 0;
+        *sx += RT_ABS(uOriginX);
+        *sw -= RT_ABS(uOriginX);
+    }
+
+    if (*dy < 0)
+    {
+        *dy  = 0;
+        *sy += RT_ABS(uOriginY);
+        *sh -= RT_ABS(uOriginY);
+    }
+
+    Log3Func(("Crop0: sx=%RI32 sy=%RI32 sw=%RI32 sh=%RI32 dx=%RI32 dy=%RI32\n",
+              *sx, *sy, *sw, *sh, *dx, *dy));
+
+    if (*sw > (int32_t)pCodecParms->u.Video.uWidth)
+        *sw = (int32_t)pCodecParms->u.Video.uWidth;
+
+    if (*sh > (int32_t)pCodecParms->u.Video.uHeight)
+        *sh = pCodecParms->u.Video.uHeight;
+
+    if (*dx + *sw >= (int32_t)pCodecParms->u.Video.uWidth)
+        *sw = pCodecParms->u.Video.uWidth - *dx;
+
+    if (*dy + *sh >= (int32_t)pCodecParms->u.Video.uHeight)
+        *sh = pCodecParms->u.Video.uHeight - *dy;
+
+    if (   *dx + *sw < 1
+        || *dy + *sh < 1
+        || *dx > (int32_t)pCodecParms->u.Video.uWidth
+        || *dy > (int32_t)pCodecParms->u.Video.uHeight
+        || *sw < 1
+        || *sh < 1)
+    {
+        vrc = VWRN_RECORDING_ENCODING_SKIPPED; /* Not visible, skip encoding. */
+    }
+
+    Log3Func(("Crop1: sx=%RI32 sy=%RI32 sw=%RI32 sh=%RI32 dx=%RI32 dy=%RI32 -> vrc=%Rrc\n",
+              *sx, *sy, *sw, *sh, *dx, *dy, vrc));
+
+    return vrc;
 }
 
 #ifdef DEBUG
 /**
- * Dumps a video recording frame to a bitmap (BMP) file, extended version.
+ * Dumps image data to a bitmap (BMP) file.
  *
  * @returns VBox status code.
- * @param   pu8RGBBuf           Pointer to actual RGB frame data.
+ * @param   pu8RGBBuf           Pointer to actual RGB image data.
  * @param   cbRGBBuf            Size (in bytes) of \a pu8RGBBuf.
  * @param   pszPath             Absolute path to dump file to. Must exist.
- *                              Specify NULL to use the system's temp directory.
- *                              Existing frame files will be overwritten.
- * @param   pszPrefx            Naming prefix to use. Optional and can be NULL.
+ *                              Specify NULL to use the system's temp directory as output directory.
+ *                              Existing files will be overwritten.
+ * @param   pszWhat             Hint of what to dump. Optional and can be NULL.
  * @param   uWidth              Width (in pixel) to write.
  * @param   uHeight             Height (in pixel) to write.
+ * @param   uBytsPerLine        Bytes per line.
  * @param   uBPP                Bits in pixel.
  */
-int RecordingUtilsDbgDumpFrameEx(const uint8_t *pu8RGBBuf, size_t cbRGBBuf, const char *pszPath, const char *pszPrefx,
-                                 uint16_t uWidth, uint32_t uHeight, uint8_t uBPP)
+int RecordingUtilsDbgDumpImageData(const uint8_t *pu8RGBBuf, size_t cbRGBBuf, const char *pszPath, const char *pszWhat,
+                                   uint32_t uWidth, uint32_t uHeight, uint32_t uBytesPerLine, uint8_t uBPP)
 {
     RT_NOREF(cbRGBBuf);
@@ -228 +402 @@
 
     coreHdr.cbSize         = sizeof(BMPWIN3XINFOHDR);
-    coreHdr.uWidth         = uWidth ;
+    coreHdr.uWidth         = uWidth;
     coreHdr.uHeight        = uHeight;
     coreHdr.cPlanes        = 1;
@@ -237 +411 @@
     static uint64_t s_iCount = 0;
 
+    /* Hardcoded path for now. */
     char szPath[RTPATH_MAX];
     if (!pszPath)
-        RTPathTemp(szPath, sizeof(szPath));
+    {
+        int rc2 = RTPathTemp(szPath, sizeof(szPath));
+        if (RT_FAILURE(rc2))
+            return rc2;
+    }
 
     char szFileName[RTPATH_MAX];
     if (RTStrPrintf2(szFileName, sizeof(szFileName), "%s/RecDump-%04RU64-%s-w%RU16h%RU16.bmp",
-                     pszPath ? pszPath : szPath, s_iCount, pszPrefx ? pszPrefx : "Frame", uWidth, uHeight) <= 0)
-    {
+                     pszPath ? pszPath : szPath, s_iCount, pszWhat ? pszWhat : "Frame", uWidth, uHeight) <= 0)
         return VERR_BUFFER_OVERFLOW;
-    }
 
     s_iCount++;
@@ -259 +436 @@
 
         /* Bitmaps (DIBs) are stored upside-down (thanks, OS/2), so work from the bottom up. */
-        uint32_t offSrc = (uHeight * uWidth * uBytesPerPixel) - uWidth * uBytesPerPixel;
+        uint32_t offSrc = cbRGBBuf - uBytesPerLine;
 
         /* Do the copy. */
         for (unsigned int i = 0; i < uHeight; i++)
         {
-            RTFileWrite(fh, pu8RGBBuf + offSrc, uWidth * uBytesPerPixel, NULL);
-            offSrc -= uWidth * uBytesPerPixel;
+            RTFileWrite(fh, pu8RGBBuf + offSrc, uBytesPerLine, NULL);
+            offSrc -= uBytesPerLine;
         }
 
@@ -275 +452 @@
 
 /**
- * Dumps a video recording frame to a bitmap (BMP) file.
+ * Dumps a video recording frame to a bitmap (BMP) file, extended version.
  *
  * @returns VBox status code.
  * @param   pFrame              Video frame to dump.
- */
-int RecordingUtilsDbgDumpFrame(const PRECORDINGFRAME pFrame)
-{
-    AssertReturn(pFrame->enmType == RECORDINGFRAME_TYPE_VIDEO, VERR_INVALID_PARAMETER);
-    return RecordingUtilsDbgDumpFrameEx(pFrame->Video.pu8RGBBuf, pFrame->Video.cbRGBBuf,
-                                        NULL /*  Use temp directory */, NULL /* pszPrefix */,
-                                        pFrame->Video.uWidth, pFrame->Video.uHeight, pFrame->Video.uBPP);
+ * @param   pszPath             Output directory.
+ * @param   pszWhat             Hint of what to dump. Optional and can be NULL.
+ */
+int RecordingUtilsDbgDumpVideoFrameEx(const PRECORDINGVIDEOFRAME pFrame, const char *pszPath, const char *pszWhat)
+{
+    return RecordingUtilsDbgDumpImageData(pFrame->pau8Buf, pFrame->cbBuf,
+                                          pszPath, pszWhat,
+                                          pFrame->Info.uWidth, pFrame->Info.uHeight, pFrame->Info.uBytesPerLine, pFrame->Info.uBPP);
+}
+
+/**
+ * Dumps a video recording frame to a bitmap (BMP) file.
+ *
+ * @returns VBox status code.
+ * @param   pFrame              Video frame to dump.
+ * @param   pszWhat             Hint of what to dump. Optional and can be NULL.
+ */
+int RecordingUtilsDbgDumpVideoFrame(const PRECORDINGVIDEOFRAME pFrame, const char *pszWhat)
+{
+    return RecordingUtilsDbgDumpVideoFrameEx(pFrame, NULL /* Use temp directory */, pszWhat);
 }
 #endif /* DEBUG */