static void vrdpReportCachedBitmap (PVBOXDISPDEV pDev,
SURFOBJ *psoSrc,
const VRDPBCHASH *phash)
{
BOOL bRc;
VRDEORDERCACHEDBITMAP order;
Assert(sizeof (*phash) == sizeof (order.hash));
memcpy (order.hash, phash, sizeof (*phash));
bRc = vrdpReportOrder (pDev, &order, sizeof (order), VRDE_ORDER_CACHED_BITMAP);
if (bRc)
{
int bytesPerPixel = format2BytesPerPixel(psoSrc);
uint8_t *pu8Bits = (uint8_t *)psoSrc->pvScan0;
int32_t lDelta = psoSrc->lDelta;
uint32_t cWidth = psoSrc->sizlBitmap.cx;
uint32_t cHeight = psoSrc->sizlBitmap.cy;
Assert(cWidth != 0 && cHeight != 0 && bytesPerPixel != 0);
vrdpWriteBits (pDev, pu8Bits, lDelta, 0, 0, cWidth, cHeight, bytesPerPixel);
}
}
void vrdpReportDirtyRect(PVBOXDISPDEV pDev, RECTL *prcl)
{
SURFOBJ *pso = pDev->surface.psoBitmap;
/* This is a Bitmap Update Fallback operation. It takes bits from VRAM
* and inserts them in the pipeline. These bits are not cached.
*/
uint8_t *pu8Bits;
int32_t lDelta;
uint32_t cWidth;
uint32_t cHeight;
BOOL bRc = FALSE;
int bytesPerPixel = format2BytesPerPixel(pso);
RECTL rclCopy = *prcl;
vrdpAdjustRect (pso, &rclCopy);
pu8Bits = (uint8_t *)pso->pvScan0 +
pso->lDelta * rclCopy.top +
bytesPerPixel * rclCopy.left;
lDelta = pso->lDelta;
cWidth = rclCopy.right - rclCopy.left;
cHeight = rclCopy.bottom - rclCopy.top;
if (cWidth == 0 || cHeight == 0)
{
return;
}
if (bytesPerPixel > 0)
{
bRc = vrdpWriteHdr(pDev, VRDP_MAKE_OP(VRDE_ORDER_DIRTY_RECT));
if (bRc)
{
bRc = vrdpWriteBits(pDev, pu8Bits, lDelta, rclCopy.left, rclCopy.top, cWidth, cHeight, bytesPerPixel);
}
}
if (!bRc)
{
WARN(("failed!!! %d,%d %dx%d, bpp = %d\n",
rclCopy.left, rclCopy.top, cWidth, cHeight, bytesPerPixel));
}
}
void vrdpDrvSaveScreenBits(SURFOBJ *pso, ULONG iMode, ULONG_PTR ident, RECTL *prcl)
{
PVBOXDISPDEV pDev = (PVBOXDISPDEV)pso->dhpdev;
switch (iMode)
{
case SS_SAVE:
{
VRDEORDERSAVESCREEN order;
order.pt1.x = (int16_t)prcl->left;
order.pt1.y = (int16_t)prcl->top;
order.pt2.x = (int16_t)prcl->right;
order.pt2.y = (int16_t)prcl->bottom;
order.ident = (uint8_t)ident;
order.restore = 0;
vrdpReportOrderGeneric(pDev, NULL, &order, sizeof (order), VRDE_ORDER_SAVESCREEN);
} break;
case SS_RESTORE:
{
VRDEORDERSAVESCREEN order;
order.pt1.x = (int16_t)prcl->left;
order.pt1.y = (int16_t)prcl->top;
order.pt2.x = (int16_t)prcl->right;
order.pt2.y = (int16_t)prcl->bottom;
order.ident = (uint8_t)ident;
order.restore = 1;
if (vrdpReportOrderGeneric(pDev, NULL, &order, sizeof (order), VRDE_ORDER_SAVESCREEN))
{
uint8_t *pu8Bits;
int32_t lDelta;
uint32_t w;
uint32_t h;
int cbPixel;
pso = getSurfObj(pso);
cbPixel = format2BytesPerPixel(pso);
pu8Bits = (uint8_t *)pso->pvScan0 +
pso->lDelta * prcl->top +
cbPixel * prcl->left;
lDelta = pso->lDelta;
w = prcl->right - prcl->left;
h = prcl->bottom - prcl->top;
vrdpWriteBits(pDev, pu8Bits, lDelta, prcl->left, prcl->top, w, h, cbPixel);
}
} break;
default:
WARN(("Invalid mode %d!!!", iMode));
}
}
BOOL vrdpDrvRealizeBrush(BRUSHOBJ *pbo, SURFOBJ *psoTarget, SURFOBJ *psoPattern, SURFOBJ *psoMask,
XLATEOBJ *pxlo, ULONG iHatch)
{
BOOL bRc = FALSE;
LOGF(("psoMask = %p, iHatch = %d", psoMask, iHatch));
VBoxDispDumpPSO(psoPattern, "psoPattern");
if (psoPattern
&& psoPattern->sizlBitmap.cx == 8
&& psoPattern->sizlBitmap.cy == 8
&& psoPattern->iBitmapFormat == 1
)
{
uint32_t cbBrush = sizeof (VRDPBRUSH);
VRDPBRUSH *pBrush = (VRDPBRUSH *)BRUSHOBJ_pvAllocRbrush (pbo, cbBrush);
LOG(("pattern pBrush = %p, size = %d", pBrush, cbBrush));
if (pBrush)
{
int i;
uint8_t *pu8Bits = (uint8_t *)psoPattern->pvScan0;
for (i = 0; i < 8; i++)
{
pBrush->u.pat.au8Pattern[i] = *pu8Bits;
pu8Bits += psoPattern->lDelta;
}
/* Obtain RGB values for the brush fore and background colors:
* "should translate color zero through the XLATEOBJ to get the foreground color for the brush."
*/
pBrush->u.pat.rgbFG = vrdpColor2RGB (psoTarget, pxlo->pulXlate[0]);
pBrush->u.pat.rgbBG = vrdpColor2RGB (psoTarget, pxlo->pulXlate[1]);
pBrush->fPattern = TRUE;
bRc = TRUE;
}
}
#if 0
else if (psoPattern)
{
/* Color brushes and brushes >8x8 are cached and MEMBLT order generated. */
uint32_t cbBrush = sizeof (VRDPBRUSH) +
psoTarget->sizlBitmap.cx * sizeof (uint32_t) * psoTarget->sizlBitmap.cy;
??? target
VRDPBRUSH *pBrush = (VRDPBRUSH *)BRUSHOBJ_pvAllocRbrush (pbo, cbBrush);
LOG(("bitmap pBrush = %p, size = %d", pBrush, cbBrush));
if (pBrush)
{
/* Byte per pattern pixel. */
uint32_t cbSrcBPP = format2BytesPerPixel(psoPattern);
/* Source bits scanline pointer. */
uint8_t *pu8BitsSrcScanLine = (uint8_t *)psoPattern->pvScan0;
/* Target RGB pixel pointer. */
uint32_t *pu32BitsDst = &pBrush->u.bitmap.au32Bits[0];
int y;
for (y = 0; y < psoTarget->sizlBitmap.cy; y++, pu8BitsSrcScanLine += psoPattern->lDelta)
{
uint8_t *pu8BitsSrc = pu8BitsSrcScanLine;
int x;
for (x = 0; x < psoTarget->sizlBitmap.cx; x++, pu8BitsSrc += cbSrcBPP)
{
uint32_t color = 0;
memcpy (&color, pu8BitsSrc, cbSrcBPP);
if (pxlo)
{
color = XLATEOBJ_iXlate (pxlo, color);
}
*pu32BitsDst++ = vrdpColor2RGB (psoTarget, color);
/* LOG(("%08X", pu32BitsDst[-1])); */
}
}
pBrush->u.bitmap.w = (uint16_t)psoTarget->sizlBitmap.cx;
pBrush->u.bitmap.h = (uint16_t)psoTarget->sizlBitmap.cy;
pBrush->fPattern = FALSE;
bRc = TRUE;
}
}
static BOOL ssbCopy(SSB *pSSB, SURFOBJ *pso, RECTL *prcl, BOOL bToScreen)
{
BYTE *pSrc;
BYTE *pDst;
LONG lDeltaSrc;
LONG lDeltaDst;
ULONG cWidth;
ULONG cHeight;
int cbPixel = format2BytesPerPixel(pso);
LOGF(("pSSB = %p, pso = %p, prcl = %p, bToScreen = %d", pSSB, pso, prcl, bToScreen));
if (cbPixel == 0)
{
WARN(("unsupported pixel format!!!"));
return FALSE;
}
cWidth = prcl->right - prcl->left;
cHeight = prcl->bottom - prcl->top;
if (bToScreen)
{
if (pSSB->pBuffer == NULL)
{
WARN(("source buffer is NULL!!!"));
return FALSE;
}
pSrc = pSSB->pBuffer;
lDeltaSrc = cWidth * cbPixel;
pDst = (BYTE *)pso->pvScan0 +
pso->lDelta * prcl->top +
cbPixel * prcl->left;
lDeltaDst = pso->lDelta;
}
else
{
if (pSSB->pBuffer != NULL)
{
WARN(("source buffer is not NULL!!!"));
return FALSE;
}
pSSB->pBuffer = (BYTE *)EngAllocMem (0, cWidth * cHeight * cbPixel, MEM_ALLOC_TAG);
if (pSSB->pBuffer == NULL)
{
WARN(("Failed to allocate buffer!!!"));
return FALSE;
}
pDst = pSSB->pBuffer;
lDeltaDst = cWidth * cbPixel;
pSrc = (BYTE *)pso->pvScan0 +
pso->lDelta * prcl->top +
cbPixel * prcl->left;
lDeltaSrc = pso->lDelta;
}
LOG(("cHeight = %d, pDst = %p, pSrc = %p, lDeltaSrc = %d, lDeltaDst = %d",
cHeight, pDst, pSrc, lDeltaSrc, lDeltaDst));
while (cHeight--)
{
memcpy (pDst, pSrc, cWidth * cbPixel);
pDst += lDeltaDst;
pSrc += lDeltaSrc;
}
LOGF(("completed."));
return TRUE;
}
