Index: /trunk/src/VBox/GuestHost/OpenGL/include/cr_blitter.h
===================================================================
--- /trunk/src/VBox/GuestHost/OpenGL/include/cr_blitter.h	(revision 50411)
+++ /trunk/src/VBox/GuestHost/OpenGL/include/cr_blitter.h	(revision 50412)
@@ -220,5 +220,5 @@
     /*dtor*/
     PFNCRTEXDATA_RELEASED pfnTextureReleased;
-    struct CR_TEXDATA *pStretchedCache;
+    struct CR_TEXDATA *pScaledCache;
 } CR_TEXDATA, *PCR_TEXDATA;
 
@@ -281,9 +281,9 @@
 VBOXBLITTERDECL(int) CrTdBltDataAcquire(PCR_TEXDATA pTex, GLenum enmFormat, bool fInverted, const CR_BLITTER_IMG**ppImg);
 
-VBOXBLITTERDECL(int) CrTdBltDataAcquireStretched(PCR_TEXDATA pTex, GLenum enmFormat, bool fInverted, uint32_t width, uint32_t height, const CR_BLITTER_IMG**ppImg);
-
-VBOXBLITTERDECL(int) CrTdBltDataReleaseStretched(PCR_TEXDATA pTex, const CR_BLITTER_IMG *pImg);
-
-VBOXBLITTERDECL(void) CrTdBltStretchCacheMoveTo(PCR_TEXDATA pTex, PCR_TEXDATA pDstTex);
+VBOXBLITTERDECL(int) CrTdBltDataAcquireScaled(PCR_TEXDATA pTex, GLenum enmFormat, bool fInverted, uint32_t width, uint32_t height, const CR_BLITTER_IMG**ppImg);
+
+VBOXBLITTERDECL(int) CrTdBltDataReleaseScaled(PCR_TEXDATA pTex, const CR_BLITTER_IMG *pImg);
+
+VBOXBLITTERDECL(void) CrTdBltScaleCacheMoveTo(PCR_TEXDATA pTex, PCR_TEXDATA pDstTex);
 
 /* release the texture data, the data remains cached in the CR_TEXDATA object until it is discarded with CrTdBltDataFree or CrTdBltDataCleanup */
Index: /trunk/src/VBox/GuestHost/OpenGL/include/cr_vreg.h
===================================================================
--- /trunk/src/VBox/GuestHost/OpenGL/include/cr_vreg.h	(revision 50411)
+++ /trunk/src/VBox/GuestHost/OpenGL/include/cr_vreg.h	(revision 50412)
@@ -51,16 +51,16 @@
 #define CR_FLOAT_RCAST(_t, _v) ((_t)((float)(_v) + 0.5))
 
-DECLINLINE(void) VBoxRectStretch(PRTRECT pRect, float xStretch, float yStretch)
-{
-    pRect->xLeft = CR_FLOAT_RCAST(int32_t, pRect->xLeft * xStretch);
-    pRect->yTop = CR_FLOAT_RCAST(int32_t, pRect->yTop * yStretch);
-    pRect->xRight = CR_FLOAT_RCAST(int32_t, pRect->xRight * xStretch);
-    pRect->yBottom = CR_FLOAT_RCAST(int32_t, pRect->yBottom * yStretch);
-}
-
-DECLINLINE(void) VBoxRectStretched(const RTRECT *pRect, float xStretch, float yStretch, PRTRECT pResult)
+DECLINLINE(void) VBoxRectScale(PRTRECT pRect, float xScale, float yScale)
+{
+    pRect->xLeft = CR_FLOAT_RCAST(int32_t, pRect->xLeft * xScale);
+    pRect->yTop = CR_FLOAT_RCAST(int32_t, pRect->yTop * yScale);
+    pRect->xRight = CR_FLOAT_RCAST(int32_t, pRect->xRight * xScale);
+    pRect->yBottom = CR_FLOAT_RCAST(int32_t, pRect->yBottom * yScale);
+}
+
+DECLINLINE(void) VBoxRectScaled(const RTRECT *pRect, float xScale, float yScale, PRTRECT pResult)
 {
     *pResult = *pRect;
-    VBoxRectStretch(pResult, xStretch, yStretch);
+    VBoxRectScale(pResult, xScale, yScale);
 }
 #endif
Index: /trunk/src/VBox/GuestHost/OpenGL/util/blitter.cpp
===================================================================
--- /trunk/src/VBox/GuestHost/OpenGL/util/blitter.cpp	(revision 50411)
+++ /trunk/src/VBox/GuestHost/OpenGL/util/blitter.cpp	(revision 50412)
@@ -1317,6 +1317,6 @@
     crTdBltImgFree(pTex);
 
-    if (pTex->pStretchedCache)
-        CrTdBltDataFreeNe(pTex->pStretchedCache);
+    if (pTex->pScaledCache)
+        CrTdBltDataFreeNe(pTex->pScaledCache);
 }
 
@@ -1340,6 +1340,6 @@
     crTdBltImgRelease(pTex);
 
-    if (pTex->pStretchedCache)
-        CrTdBltDataInvalidateNe(pTex->pStretchedCache);
+    if (pTex->pScaledCache)
+        CrTdBltDataInvalidateNe(pTex->pScaledCache);
 }
 
@@ -1372,9 +1372,9 @@
 static void crTdBltSdCleanupCacheNe(PCR_TEXDATA pTex)
 {
-    if (pTex->pStretchedCache)
-    {
-        CrTdBltDataCleanupNe(pTex->pStretchedCache);
-        CrTdRelease(pTex->pStretchedCache);
-        pTex->pStretchedCache = NULL;
+    if (pTex->pScaledCache)
+    {
+        CrTdBltDataCleanupNe(pTex->pScaledCache);
+        CrTdRelease(pTex->pScaledCache);
+        pTex->pScaledCache = NULL;
     }
 }
@@ -1540,14 +1540,14 @@
 }
 
-static int ctTdBltSdCreate(PCR_BLITTER pBlitter, uint32_t width, uint32_t height, GLenum enmTarget, PCR_TEXDATA *ppStretchedCache)
-{
-    PCR_TEXDATA pStretchedCache;
+static int ctTdBltSdCreate(PCR_BLITTER pBlitter, uint32_t width, uint32_t height, GLenum enmTarget, PCR_TEXDATA *ppScaledCache)
+{
+    PCR_TEXDATA pScaledCache;
 
     Assert(CrBltIsEntered(pBlitter));
 
-    *ppStretchedCache = NULL;
-
-    pStretchedCache = (PCR_TEXDATA)RTMemAlloc(sizeof (*pStretchedCache));
-    if (!pStretchedCache)
+    *ppScaledCache = NULL;
+
+    pScaledCache = (PCR_TEXDATA)RTMemAlloc(sizeof (*pScaledCache));
+    if (!pScaledCache)
     {
         WARN(("RTMemAlloc failed"));
@@ -1563,26 +1563,26 @@
     {
         WARN(("Tex create failed"));
-        RTMemFree(pStretchedCache);
+        RTMemFree(pScaledCache);
         return VERR_GENERAL_FAILURE;
     }
 
-    CrTdInit(pStretchedCache, &Tex, pBlitter, ctTdBltSdReleased);
-
-    *ppStretchedCache = pStretchedCache;
-
-    return VINF_SUCCESS;
-}
-
-static int ctTdBltSdGet(PCR_TEXDATA pTex, uint32_t width, uint32_t height, PCR_TEXDATA *ppStretchedCache)
+    CrTdInit(pScaledCache, &Tex, pBlitter, ctTdBltSdReleased);
+
+    *ppScaledCache = pScaledCache;
+
+    return VINF_SUCCESS;
+}
+
+static int ctTdBltSdGet(PCR_TEXDATA pTex, uint32_t width, uint32_t height, PCR_TEXDATA *ppScaledCache)
 {
     Assert(pTex->Flags.Entered);
 
-    PCR_TEXDATA pStretchedCache;
-
-    *ppStretchedCache = NULL;
-
-    if (!pTex->pStretchedCache)
-    {
-        int rc = ctTdBltSdCreate(pTex->pBlitter, width, height, pTex->Tex.target, &pStretchedCache);
+    PCR_TEXDATA pScaledCache;
+
+    *ppScaledCache = NULL;
+
+    if (!pTex->pScaledCache)
+    {
+        int rc = ctTdBltSdCreate(pTex->pBlitter, width, height, pTex->Tex.target, &pScaledCache);
         if (!RT_SUCCESS(rc))
         {
@@ -1591,17 +1591,17 @@
         }
 
-        pTex->pStretchedCache = pStretchedCache;
+        pTex->pScaledCache = pScaledCache;
     }
     else
     {
-        int cmp = pTex->pStretchedCache->Tex.width - width;
+        int cmp = pTex->pScaledCache->Tex.width - width;
         if (cmp <= 0)
-            cmp = pTex->pStretchedCache->Tex.height - height;
+            cmp = pTex->pScaledCache->Tex.height - height;
 
         if (!cmp)
-            pStretchedCache = pTex->pStretchedCache;
+            pScaledCache = pTex->pScaledCache;
         else if (cmp < 0) /* current cache is "less" than the requested */
         {
-            int rc = ctTdBltSdCreate(pTex->pBlitter, width, height, pTex->Tex.target, &pStretchedCache);
+            int rc = ctTdBltSdCreate(pTex->pBlitter, width, height, pTex->Tex.target, &pScaledCache);
             if (!RT_SUCCESS(rc))
             {
@@ -1610,10 +1610,10 @@
             }
 
-            pStretchedCache->pStretchedCache = pTex->pStretchedCache;
-            pTex->pStretchedCache = pStretchedCache;
+            pScaledCache->pScaledCache = pTex->pScaledCache;
+            pTex->pScaledCache = pScaledCache;
         }
         else /* cmp > 0 */
         {
-            int rc = ctTdBltSdGet(pTex->pStretchedCache, width, height, &pStretchedCache);
+            int rc = ctTdBltSdGet(pTex->pScaledCache, width, height, &pScaledCache);
             if (!RT_SUCCESS(rc))
             {
@@ -1624,5 +1624,5 @@
     }
 
-    Assert(pStretchedCache);
+    Assert(pScaledCache);
 
 #if 0
@@ -1639,20 +1639,20 @@
         }
 
-        pTex->pBlitter->pDispatch->DeleteTextures(1, &pTex->pStretchedCache->Tex.hwid);
-
-        crTdResize(pTex->pStretchedCache, &Tex);
+        pTex->pBlitter->pDispatch->DeleteTextures(1, &pTex->pScaledCache->Tex.hwid);
+
+        crTdResize(pTex->pScaledCache, &Tex);
     }
 #endif
 
-    *ppStretchedCache = pStretchedCache;
-    return VINF_SUCCESS;
-}
-
-static int ctTdBltSdGetUpdated(PCR_TEXDATA pTex, uint32_t width, uint32_t height, PCR_TEXDATA *ppStretchedCache)
-{
-    PCR_TEXDATA pStretchedCache;
-
-    *ppStretchedCache = NULL;
-    int rc = ctTdBltSdGet(pTex, width, height, &pStretchedCache);
+    *ppScaledCache = pScaledCache;
+    return VINF_SUCCESS;
+}
+
+static int ctTdBltSdGetUpdated(PCR_TEXDATA pTex, uint32_t width, uint32_t height, PCR_TEXDATA *ppScaledCache)
+{
+    PCR_TEXDATA pScaledCache;
+
+    *ppScaledCache = NULL;
+    int rc = ctTdBltSdGet(pTex, width, height, &pScaledCache);
     if (!RT_SUCCESS(rc))
     {
@@ -1661,8 +1661,8 @@
     }
 
-    Assert(width == pStretchedCache->Tex.width);
-    Assert(height == pStretchedCache->Tex.height);
-
-    if (!pStretchedCache->Flags.DataValid)
+    Assert(width == pScaledCache->Tex.width);
+    Assert(height == pScaledCache->Tex.height);
+
+    if (!pScaledCache->Flags.DataValid)
     {
         RTRECT SrcRect, DstRect;
@@ -1678,13 +1678,13 @@
         DstRect.yBottom = height;
 
-        CrBltBlitTexTex(pTex->pBlitter, &pTex->Tex, &SrcRect, &pStretchedCache->Tex, &DstRect, 1, 0);
-    }
-
-    *ppStretchedCache = pStretchedCache;
-
-    return VINF_SUCCESS;
-}
-
-VBOXBLITTERDECL(int) CrTdBltDataAcquireStretched(PCR_TEXDATA pTex, GLenum enmFormat, bool fInverted, uint32_t width, uint32_t height, const CR_BLITTER_IMG**ppImg)
+        CrBltBlitTexTex(pTex->pBlitter, &pTex->Tex, &SrcRect, &pScaledCache->Tex, &DstRect, 1, 0);
+    }
+
+    *ppScaledCache = pScaledCache;
+
+    return VINF_SUCCESS;
+}
+
+VBOXBLITTERDECL(int) CrTdBltDataAcquireScaled(PCR_TEXDATA pTex, GLenum enmFormat, bool fInverted, uint32_t width, uint32_t height, const CR_BLITTER_IMG**ppImg)
 {
     if (pTex->Tex.width == width && pTex->Tex.height == height)
@@ -1697,7 +1697,7 @@
     }
 
-    PCR_TEXDATA pStretchedCache;
-
-    int rc = ctTdBltSdGetUpdated(pTex, width, height, &pStretchedCache);
+    PCR_TEXDATA pScaledCache;
+
+    int rc = ctTdBltSdGetUpdated(pTex, width, height, &pScaledCache);
     if (!RT_SUCCESS(rc))
     {
@@ -1706,5 +1706,5 @@
     }
 
-    rc = CrTdBltEnter(pStretchedCache);
+    rc = CrTdBltEnter(pScaledCache);
     if (!RT_SUCCESS(rc))
     {
@@ -1713,9 +1713,9 @@
     }
 
-    rc = CrTdBltDataAcquire(pStretchedCache, enmFormat, fInverted, ppImg);
+    rc = CrTdBltDataAcquire(pScaledCache, enmFormat, fInverted, ppImg);
     if (!RT_SUCCESS(rc))
     {
         WARN(("CrTdBltDataAcquire failed rc %d", rc));
-        CrTdBltLeave(pTex->pStretchedCache);
+        CrTdBltLeave(pTex->pScaledCache);
         return rc;
     }
@@ -1724,8 +1724,8 @@
 }
 
-VBOXBLITTERDECL(int) CrTdBltDataReleaseStretched(PCR_TEXDATA pTex, const CR_BLITTER_IMG *pImg)
-{
-    PCR_TEXDATA pStretchedCache = RT_FROM_MEMBER(pImg, CR_TEXDATA, Img);
-    int rc = CrTdBltDataRelease(pStretchedCache);
+VBOXBLITTERDECL(int) CrTdBltDataReleaseScaled(PCR_TEXDATA pTex, const CR_BLITTER_IMG *pImg)
+{
+    PCR_TEXDATA pScaledCache = RT_FROM_MEMBER(pImg, CR_TEXDATA, Img);
+    int rc = CrTdBltDataRelease(pScaledCache);
     if (!RT_SUCCESS(rc))
     {
@@ -1734,18 +1734,18 @@
     }
 
-    if (pStretchedCache != pTex)
-        CrTdBltLeave(pStretchedCache);
-
-    return VINF_SUCCESS;
-}
-
-VBOXBLITTERDECL(void) CrTdBltStretchCacheMoveTo(PCR_TEXDATA pTex, PCR_TEXDATA pDstTex)
-{
-    if (!pTex->pStretchedCache)
+    if (pScaledCache != pTex)
+        CrTdBltLeave(pScaledCache);
+
+    return VINF_SUCCESS;
+}
+
+VBOXBLITTERDECL(void) CrTdBltScaleCacheMoveTo(PCR_TEXDATA pTex, PCR_TEXDATA pDstTex)
+{
+    if (!pTex->pScaledCache)
         return;
 
     crTdBltSdCleanupCacheNe(pDstTex);
 
-    pDstTex->pStretchedCache = pTex->pStretchedCache;
-    pTex->pStretchedCache = NULL;
-}
+    pDstTex->pScaledCache = pTex->pScaledCache;
+    pTex->pScaledCache = NULL;
+}
Index: /trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_presenter.cpp
===================================================================
--- /trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_presenter.cpp	(revision 50411)
+++ /trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_presenter.cpp	(revision 50412)
@@ -262,5 +262,5 @@
 }
 
-static void crFbBltImgStretched(const CR_BLITTER_IMG *pSrc, const RTPOINT *pSrcDataPoint, bool fSrcInvert, const RTRECT *pCopyRect, const RTPOINT *pDstDataPoint, float strX, float strY, CR_BLITTER_IMG *pDst)
+static void crFbBltImgScaled(const CR_BLITTER_IMG *pSrc, const RTPOINT *pSrcDataPoint, bool fSrcInvert, const RTRECT *pCopyRect, const RTPOINT *pDstDataPoint, float strX, float strY, CR_BLITTER_IMG *pDst)
 {
     int32_t srcX = pCopyRect->xLeft - pSrcDataPoint->x;
@@ -271,15 +271,44 @@
     Assert(srcY < pSrc->height);
 
-    int32_t dstX = CR_FLOAT_RCAST(int32_t, strX * (pCopyRect->xLeft - pDstDataPoint->x));
-    int32_t dstY = CR_FLOAT_RCAST(int32_t, strY * (pCopyRect->yTop - pDstDataPoint->y));
+    RTPOINT ScaledDtsDataPoint;
+    RTRECT ScaledCopyRect;
+
+    VBoxRectScaled(pCopyRect, strX, strY, &ScaledCopyRect);
+    ScaledDtsDataPoint.x = CR_FLOAT_RCAST(int32_t, strX * pDstDataPoint->x);
+    ScaledDtsDataPoint.y = CR_FLOAT_RCAST(int32_t, strY * pDstDataPoint->y);
+
+    int32_t dstX = ScaledCopyRect.xLeft - ScaledDtsDataPoint.x;
+    int32_t dstY = ScaledCopyRect.yTop - ScaledDtsDataPoint.y;
     Assert(dstX >= 0);
     Assert(dstY >= 0);
 
+    int32_t ScaledDstWidth = ScaledCopyRect.xRight - ScaledCopyRect.xLeft;
+    int32_t delta = (int32_t)pDst->width - dstX - ScaledDstWidth;
+    if (delta < 0)
+        ScaledDstWidth += delta;
+
+    if (ScaledDstWidth <= 0)
+    {
+        WARN(("dst width (%d) <= 0", ScaledDstWidth));
+        return;
+    }
+
+    int32_t ScaledDstHeight = ScaledCopyRect.yBottom - ScaledCopyRect.yTop;
+    delta = (int32_t)pDst->height - dstY - ScaledDstHeight;
+    if (delta < 0)
+        ScaledDstHeight += delta;
+
+    if (ScaledDstHeight <= 0)
+    {
+        WARN(("dst height (%d) <= 0", ScaledDstHeight));
+        return;
+    }
+
     uint8_t *pu8Src = ((uint8_t*)pSrc->pvData) + pSrc->pitch * (!fSrcInvert ? srcY : pSrc->height - srcY - 1) + srcX * 4;
     uint8_t *pu8Dst = ((uint8_t*)pDst->pvData) + pDst->pitch * dstY + dstX * 4;
 
     CrBmpScale32(pu8Dst, pDst->pitch,
-                        CR_FLOAT_RCAST(int32_t, strX * (pCopyRect->xRight - pCopyRect->xLeft)),
-                        CR_FLOAT_RCAST(int32_t, strY * (pCopyRect->yBottom - pCopyRect->yTop)),
+                        ScaledDstWidth,
+                        ScaledDstHeight,
                         pu8Src,
                         fSrcInvert ? -pSrc->pitch : pSrc->pitch,
@@ -312,5 +341,5 @@
     PCR_BLITTER pEnteredBlitter = NULL;
     uint32_t width = 0, height = 0;
-    RTPOINT StretchedEntryPoint = {0};
+    RTPOINT ScaledEntryPoint = {0};
 
     VBOXVR_SCR_COMPOSITOR_CONST_ITERATOR Iter;
@@ -319,7 +348,7 @@
     float strY = ((float)pImg->height) / (pSrcRect->yBottom - pSrcRect->yTop);
 
-    RTPOINT StretchedSrcPoint;
-    StretchedSrcPoint.x = CR_FLOAT_RCAST(int32_t, strX * SrcPoint.x);
-    StretchedSrcPoint.y = CR_FLOAT_RCAST(int32_t, strY * SrcPoint.y);
+    RTPOINT ScaledSrcPoint;
+    ScaledSrcPoint.x = CR_FLOAT_RCAST(int32_t, strX * SrcPoint.x);
+    ScaledSrcPoint.y = CR_FLOAT_RCAST(int32_t, strY * SrcPoint.y);
 
     RTPOINT ZeroPoint = {0, 0};
@@ -366,5 +395,5 @@
                     continue;
 
-                VBoxRectStretch(&Intersection, strX, strY);
+                VBoxRectScale(&Intersection, strX, strY);
                 if (VBoxRectIsZero(&Intersection))
                     continue;
@@ -422,9 +451,9 @@
                     width = CR_FLOAT_RCAST(uint32_t, strX * pVrTex->width);
                     height = CR_FLOAT_RCAST(uint32_t, strY * pVrTex->height);
-                    StretchedEntryPoint.x = CR_FLOAT_RCAST(int32_t, strX * CrVrScrCompositorEntryRectGet(pEntry)->xLeft);
-                    StretchedEntryPoint.y = CR_FLOAT_RCAST(int32_t, strY * CrVrScrCompositorEntryRectGet(pEntry)->yTop);
+                    ScaledEntryPoint.x = CR_FLOAT_RCAST(int32_t, strX * CrVrScrCompositorEntryRectGet(pEntry)->xLeft);
+                    ScaledEntryPoint.y = CR_FLOAT_RCAST(int32_t, strY * CrVrScrCompositorEntryRectGet(pEntry)->yTop);
                 }
 
-                rc = CrTdBltDataAcquireStretched(pTex, GL_BGRA, false, width, height, &pSrcImg);
+                rc = CrTdBltDataAcquireScaled(pTex, GL_BGRA, false, width, height, &pSrcImg);
                 if (!RT_SUCCESS(rc))
                 {
@@ -435,7 +464,7 @@
                 bool fInvert = !(CrVrScrCompositorEntryFlagsGet(pEntry) & CRBLT_F_INVERT_SRC_YCOORDS);
 
-                crFbBltImg(pSrcImg, &StretchedEntryPoint, fInvert, &Intersection, &StretchedSrcPoint, pImg);
-
-                CrTdBltDataReleaseStretched(pTex, pSrcImg);
+                crFbBltImg(pSrcImg, &ScaledEntryPoint, fInvert, &Intersection, &ScaledSrcPoint, pImg);
+
+                CrTdBltDataReleaseScaled(pTex, pSrcImg);
             }
         }
@@ -481,5 +510,5 @@
         CR_BLITTER_IMG FbImg;
 
-        bool fStretch = fbWidth != stretchedWidth || fbHeight != stretchedHeight;
+        bool fScale = fbWidth != stretchedWidth || fbHeight != stretchedHeight;
 
         crFbImgFromFb(hFb, &FbImg);
@@ -496,8 +525,8 @@
                     continue;
 
-                if (!fStretch)
+                if (!fScale)
                     crFbBltImg(&FbImg, &ZeroPoint, false, &Intersection, &SrcPoint, pImg);
                 else
-                    crFbBltImgStretched(&FbImg, &ZeroPoint, false, &Intersection, &SrcPoint, strX, strY, pImg);
+                    crFbBltImgScaled(&FbImg, &ZeroPoint, false, &Intersection, &SrcPoint, strX, strY, pImg);
             }
         }
@@ -517,5 +546,5 @@
 }
 
-static int crFbBltGetContentsStretchCPU(HCR_FRAMEBUFFER hFb, const RTRECT *pSrcRect, uint32_t cRects, const RTRECT *pRects, CR_BLITTER_IMG *pImg)
+static int crFbBltGetContentsScaleCPU(HCR_FRAMEBUFFER hFb, const RTRECT *pSrcRect, uint32_t cRects, const RTRECT *pRects, CR_BLITTER_IMG *pImg)
 {
     uint32_t srcWidth = pSrcRect->xRight - pSrcRect->xLeft;
@@ -568,5 +597,5 @@
     }
 
-    return crFbBltGetContentsStretchCPU(hFb, pSrcRect, cRects, pRects, pImg);
+    return crFbBltGetContentsScaleCPU(hFb, pSrcRect, cRects, pRects, pImg);
 }
 
@@ -871,5 +900,5 @@
         CR_TEXDATA *pReplacingTex = CrVrScrCompositorEntryTexGet(&pFbReplacingEntry->Entry);
 
-        CrTdBltStretchCacheMoveTo(pTex, pReplacingTex);
+        CrTdBltScaleCacheMoveTo(pTex, pReplacingTex);
 
         if (pFb->pDisplay)
Index: /trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_cocoa_helper.m
===================================================================
--- /trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_cocoa_helper.m	(revision 50411)
+++ /trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_cocoa_helper.m	(revision 50412)
@@ -1498,5 +1498,5 @@
                             VBoxRectTranslate(&DstRect, -RestrictDstRect.xLeft, -RestrictDstRect.yTop);
                             
-                            VBoxRectStretch(&DstRect, m_FBOThumbScaleX, m_FBOThumbScaleY);
+                            VBoxRectScale(&DstRect, m_FBOThumbScaleX, m_FBOThumbScaleY);
                     
                             if (VBoxRectIsZero(&DstRect))