/**
* Function description
* Recalculate client desktop size and update to rdpSettings
*
* @return TRUE if width/height changed.
*/
static INLINE BOOL shadow_client_recalc_desktop_size(rdpShadowClient* client)
{
int width, height;
rdpShadowServer* server = client->server;
rdpSettings* settings = client->context.settings;
RECTANGLE_16 viewport = {0, 0, server->surface->width, server->surface->height};
if (server->shareSubRect)
{
rectangles_intersection(&viewport, &(server->subRect), &viewport);
}
width = viewport.right - viewport.left;
height = viewport.bottom - viewport.top;
if (settings->DesktopWidth != (UINT32)width || settings->DesktopHeight != (UINT32)height)
{
settings->DesktopWidth = width;
settings->DesktopHeight = height;
return TRUE;
}
return FALSE;
}
UINT xf_OutputExpose(xfContext* xfc, UINT32 x, UINT32 y,
UINT32 width, UINT32 height)
{
UINT16 count;
UINT32 index;
UINT status = ERROR_INTERNAL_ERROR;
xfGfxSurface* surface;
RECTANGLE_16 invalidRect;
RECTANGLE_16 surfaceRect;
RECTANGLE_16 intersection;
UINT16* pSurfaceIds = NULL;
RdpgfxClientContext* context = xfc->context.gdi->gfx;
invalidRect.left = x;
invalidRect.top = y;
invalidRect.right = x + width;
invalidRect.bottom = y + height;
status = context->GetSurfaceIds(context, &pSurfaceIds, &count);
if (status != CHANNEL_RC_OK)
goto fail;
EnterCriticalSection(&context->mux);
for (index = 0; index < count; index++)
{
surface = (xfGfxSurface*) context->GetSurfaceData(context, pSurfaceIds[index]);
if (!surface || !surface->gdi.outputMapped)
continue;
surfaceRect.left = surface->gdi.outputOriginX;
surfaceRect.top = surface->gdi.outputOriginY;
surfaceRect.right = surface->gdi.outputOriginX + surface->gdi.width;
surfaceRect.bottom = surface->gdi.outputOriginY + surface->gdi.height;
if (rectangles_intersection(&invalidRect, &surfaceRect, &intersection))
{
/* Invalid rects are specified relative to surface origin */
intersection.left -= surfaceRect.left;
intersection.top -= surfaceRect.top;
intersection.right -= surfaceRect.left;
intersection.bottom -= surfaceRect.top;
region16_union_rect(&surface->gdi.invalidRegion,
&surface->gdi.invalidRegion,
&intersection);
}
}
free(pSurfaceIds);
LeaveCriticalSection(&context->mux);
IFCALLRET(context->UpdateSurfaces, status, context);
if (status != CHANNEL_RC_OK)
goto fail;
fail:
return status;
}
static INLINE void shadow_client_calc_desktop_size(rdpShadowServer* server, int* pWidth, int* pHeight)
{
RECTANGLE_16 viewport = {0, 0, server->screen->width, server->screen->height};
if (server->shareSubRect)
{
rectangles_intersection(&viewport, &(server->subRect), &viewport);
}
(*pWidth) = viewport.right - viewport.left;
(*pHeight) = viewport.bottom - viewport.top;
}
int xf_OutputExpose(xfContext* xfc, int x, int y, int width, int height)
{
UINT16 count;
int index;
int status = 1;
xfGfxSurface* surface;
RECTANGLE_16 invalidRect;
RECTANGLE_16 surfaceRect;
RECTANGLE_16 intersection;
UINT16* pSurfaceIds = NULL;
RdpgfxClientContext* context = xfc->gfx;
invalidRect.left = x;
invalidRect.top = y;
invalidRect.right = x + width;
invalidRect.bottom = y + height;
context->GetSurfaceIds(context, &pSurfaceIds, &count);
for (index = 0; index < count; index++)
{
surface = (xfGfxSurface*) context->GetSurfaceData(context, pSurfaceIds[index]);
if (!surface || !surface->outputMapped)
continue;
surfaceRect.left = surface->outputOriginX;
surfaceRect.top = surface->outputOriginY;
surfaceRect.right = surface->outputOriginX + surface->width;
surfaceRect.bottom = surface->outputOriginY + surface->height;
if (rectangles_intersection(&invalidRect, &surfaceRect, &intersection))
{
/* Invalid rects are specified relative to surface origin */
intersection.left -= surfaceRect.left;
intersection.top -= surfaceRect.top;
intersection.right -= surfaceRect.left;
intersection.bottom -= surfaceRect.top;
region16_union_rect(&surface->invalidRegion, &surface->invalidRegion, &intersection);
}
}
free(pSurfaceIds);
if (xf_UpdateSurfaces(xfc) < 0)
status = -1;
return status;
}
BOOL region16_intersect_rect(REGION16 *dst, const REGION16 *src, const RECTANGLE_16 *rect)
{
REGION16_DATA *newItems;
const RECTANGLE_16 *srcPtr, *endPtr, *srcExtents;
RECTANGLE_16 *dstPtr;
int nbRects, usedRects;
RECTANGLE_16 common, newExtents;
assert(src);
assert(src->data);
srcPtr = region16_rects(src, &nbRects);
if (!nbRects)
{
region16_clear(dst);
return TRUE;
}
srcExtents = region16_extents(src);
if (nbRects == 1)
{
BOOL intersects = rectangles_intersection(srcExtents, rect, &common);
region16_clear(dst);
if (intersects)
return region16_union_rect(dst, dst, &common);
return TRUE;
}
newItems = allocateRegion(nbRects);
if (!newItems)
return FALSE;
dstPtr = (RECTANGLE_16*) (&newItems[1]);
usedRects = 0;
ZeroMemory(&newExtents, sizeof(newExtents));
/* accumulate intersecting rectangles, the final region16_simplify_bands() will
* do all the bad job to recreate correct rectangles
*/
for (endPtr = srcPtr + nbRects; (srcPtr < endPtr) && (rect->bottom > srcPtr->top); srcPtr++)
{
if (rectangles_intersection(srcPtr, rect, &common))
{
*dstPtr = common;
usedRects++;
dstPtr++;
newExtents.top = MIN(common.top, newExtents.top);
newExtents.left = MIN(common.left, newExtents.left);
newExtents.bottom = MAX(common.bottom, newExtents.bottom);
newExtents.right = MAX(common.right, newExtents.right);
}
}
newItems->nbRects = usedRects;
newItems->size = sizeof(REGION16_DATA) + (usedRects * sizeof(RECTANGLE_16));
if (dst->data->size)
free(dst->data);
dst->data = realloc(newItems, newItems->size);
if (!dst->data)
{
free(newItems);
return FALSE;
}
dst->extents = newExtents;
return region16_simplify_bands(dst);
}
BOOL rectangles_intersects(const RECTANGLE_16 *r1, const RECTANGLE_16 *r2)
{
RECTANGLE_16 tmp;
return rectangles_intersection(r1, r2, &tmp);
}
int test_progressive_decode(PROGRESSIVE_CONTEXT* progressive, EGFX_SAMPLE_FILE files[4], EGFX_SAMPLE_FILE bitmaps[4], int quarter, int count)
{
int cnt;
int pass;
int size;
int index;
int status;
int nXSrc, nYSrc;
int nXDst, nYDst;
int nWidth, nHeight;
RECTANGLE_16 tileRect;
RECTANGLE_16 updateRect;
RECTANGLE_16 clippingRect;
RFX_PROGRESSIVE_TILE* tile;
PROGRESSIVE_BLOCK_REGION* region;
clippingRect.left = 0;
clippingRect.top = 0;
clippingRect.right = g_Width;
clippingRect.bottom = g_Height;
for (pass = 0; pass < count; pass++)
{
status = progressive_decompress(progressive, files[pass].buffer, files[pass].size,
&g_DstData, PIXEL_FORMAT_XRGB32, g_DstStep, 0, 0, g_Width, g_Height, 0);
printf("ProgressiveDecompress: status: %d pass: %d\n", status, pass + 1);
region = &(progressive->region);
switch (quarter)
{
case 0:
clippingRect.left = 0;
clippingRect.top = 0;
clippingRect.right = g_Width / 2;
clippingRect.bottom = g_Height /2;
break;
case 1:
clippingRect.left = g_Width / 2;
clippingRect.top = g_Height / 2;
clippingRect.right = g_Width;
clippingRect.bottom = g_Height;
break;
case 2:
clippingRect.left = 0;
clippingRect.top = g_Height / 2;
clippingRect.right = g_Width / 2;
clippingRect.bottom = g_Height;
break;
case 3:
clippingRect.left = g_Width / 2;
clippingRect.top = 0;
clippingRect.right = g_Width;
clippingRect.bottom = g_Height / 2;
break;
}
for (index = 0; index < region->numTiles; index++)
{
tile = region->tiles[index];
tileRect.left = tile->x;
tileRect.top = tile->y;
tileRect.right = tile->x + tile->width;
tileRect.bottom = tile->y + tile->height;
rectangles_intersection(&tileRect, &clippingRect, &updateRect);
nXDst = updateRect.left;
nYDst = updateRect.top;
nWidth = updateRect.right - updateRect.left;
nHeight = updateRect.bottom - updateRect.top;
if ((nWidth <= 0) || (nHeight <= 0))
continue;
nXSrc = nXDst - tile->x;
nYSrc = nYDst - tile->y;
freerdp_image_copy(g_DstData, PIXEL_FORMAT_XRGB32, g_DstStep,
nXDst, nYDst, nWidth, nHeight, tile->data,
PIXEL_FORMAT_XRGB32, 64 * 4, nXSrc, nYSrc);
}
size = bitmaps[pass].size;
cnt = test_memcmp_count(g_DstData, bitmaps[pass].buffer, size, 1);
if (cnt)
{
float rate = ((float) cnt) / ((float) size) * 100.0f;
printf("Progressive RemoteFX decompression failure\n");
printf("Actual, Expected (%d/%d = %.3f%%):\n", cnt, size, rate);
}
//WLog_Image(progressive->log, WLOG_TRACE, g_DstData, g_Width, g_Height, 32);
}
return 1;
}
