mirror of https://github.com/FreeRDP/FreeRDP
445 lines
11 KiB
C
445 lines
11 KiB
C
/**
|
|
* FreeRDP: A Remote Desktop Protocol Implementation
|
|
* Graphical Objects
|
|
*
|
|
* Copyright 2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
|
|
* Copyright 2016 Armin Novak <armin.novak@thincast.com>
|
|
* Copyright 2016 Thincast Technologies GmbH
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <winpr/crt.h>
|
|
|
|
#include <freerdp/log.h>
|
|
#include <freerdp/gdi/dc.h>
|
|
#include <freerdp/gdi/shape.h>
|
|
#include <freerdp/gdi/region.h>
|
|
#include <freerdp/gdi/bitmap.h>
|
|
|
|
#include "clipping.h"
|
|
#include "drawing.h"
|
|
#include "brush.h"
|
|
#include "graphics.h"
|
|
|
|
#define TAG FREERDP_TAG("gdi")
|
|
/* Bitmap Class */
|
|
|
|
HGDI_BITMAP gdi_create_bitmap(rdpGdi* gdi, UINT32 nWidth, UINT32 nHeight,
|
|
UINT32 SrcFormat, BYTE* data)
|
|
{
|
|
UINT32 nSrcStep;
|
|
UINT32 nDstStep;
|
|
BYTE* pSrcData;
|
|
BYTE* pDstData;
|
|
HGDI_BITMAP bitmap;
|
|
|
|
if (!gdi)
|
|
return NULL;
|
|
|
|
nDstStep = nWidth * GetBytesPerPixel(gdi->dstFormat);
|
|
pDstData = _aligned_malloc(nHeight * nDstStep, 16);
|
|
|
|
if (!pDstData)
|
|
return NULL;
|
|
|
|
pSrcData = data;
|
|
nSrcStep = nWidth * GetBytesPerPixel(SrcFormat);
|
|
|
|
if (!freerdp_image_copy(pDstData, gdi->dstFormat, nDstStep, 0, 0,
|
|
nWidth, nHeight, pSrcData, SrcFormat, nSrcStep, 0, 0,
|
|
&gdi->palette, FREERDP_FLIP_NONE))
|
|
{
|
|
_aligned_free(pDstData);
|
|
return NULL;
|
|
}
|
|
|
|
bitmap = gdi_CreateBitmap(nWidth, nHeight, gdi->dstFormat, pDstData);
|
|
return bitmap;
|
|
}
|
|
|
|
static BOOL gdi_Bitmap_New(rdpContext* context, rdpBitmap* bitmap)
|
|
{
|
|
gdiBitmap* gdi_bitmap;
|
|
rdpGdi* gdi = context->gdi;
|
|
gdi_bitmap = (gdiBitmap*) bitmap;
|
|
gdi_bitmap->hdc = gdi_CreateCompatibleDC(gdi->hdc);
|
|
|
|
if (!gdi_bitmap->hdc)
|
|
return FALSE;
|
|
|
|
if (!bitmap->data)
|
|
gdi_bitmap->bitmap = gdi_CreateCompatibleBitmap(
|
|
gdi->hdc, bitmap->width,
|
|
bitmap->height);
|
|
else
|
|
{
|
|
UINT32 format = bitmap->format;
|
|
gdi_bitmap->bitmap = gdi_create_bitmap(gdi, bitmap->width,
|
|
bitmap->height,
|
|
format, bitmap->data);
|
|
}
|
|
|
|
if (!gdi_bitmap->bitmap)
|
|
{
|
|
gdi_DeleteDC(gdi_bitmap->hdc);
|
|
return FALSE;
|
|
}
|
|
|
|
gdi_bitmap->hdc->format = gdi_bitmap->bitmap->format;
|
|
gdi_SelectObject(gdi_bitmap->hdc, (HGDIOBJECT) gdi_bitmap->bitmap);
|
|
gdi_bitmap->org_bitmap = NULL;
|
|
return TRUE;
|
|
}
|
|
|
|
static void gdi_Bitmap_Free(rdpContext* context, rdpBitmap* bitmap)
|
|
{
|
|
gdiBitmap* gdi_bitmap = (gdiBitmap*) bitmap;
|
|
|
|
if (gdi_bitmap)
|
|
{
|
|
if (gdi_bitmap->hdc)
|
|
gdi_SelectObject(gdi_bitmap->hdc, (HGDIOBJECT) gdi_bitmap->org_bitmap);
|
|
|
|
gdi_DeleteObject((HGDIOBJECT) gdi_bitmap->bitmap);
|
|
gdi_DeleteDC(gdi_bitmap->hdc);
|
|
_aligned_free(bitmap->data);
|
|
}
|
|
|
|
free(bitmap);
|
|
}
|
|
|
|
static BOOL gdi_Bitmap_Paint(rdpContext* context, rdpBitmap* bitmap)
|
|
{
|
|
gdiBitmap* gdi_bitmap = (gdiBitmap*) bitmap;
|
|
UINT32 width = bitmap->right - bitmap->left + 1;
|
|
UINT32 height = bitmap->bottom - bitmap->top + 1;
|
|
return gdi_BitBlt(context->gdi->primary->hdc,
|
|
bitmap->left, bitmap->top,
|
|
width, height, gdi_bitmap->hdc,
|
|
0, 0, GDI_SRCCOPY, &context->gdi->palette);
|
|
}
|
|
|
|
static BOOL gdi_Bitmap_Decompress(rdpContext* context, rdpBitmap* bitmap,
|
|
const BYTE* pSrcData, UINT32 DstWidth, UINT32 DstHeight,
|
|
UINT32 bpp, UINT32 length, BOOL compressed,
|
|
UINT32 codecId)
|
|
{
|
|
UINT32 SrcSize = length;
|
|
rdpGdi* gdi = context->gdi;
|
|
UINT32 size = DstWidth * DstHeight;
|
|
bitmap->compressed = FALSE;
|
|
bitmap->format = gdi->dstFormat;
|
|
|
|
if ((GetBytesPerPixel(bitmap->format) == 0) ||
|
|
(DstWidth == 0) || (DstHeight == 0) || (DstWidth > UINT32_MAX / DstHeight) ||
|
|
(size > (UINT32_MAX / GetBytesPerPixel(bitmap->format))))
|
|
return FALSE;
|
|
|
|
size *= GetBytesPerPixel(bitmap->format);
|
|
bitmap->length = size;
|
|
bitmap->data = (BYTE*) _aligned_malloc(bitmap->length, 16);
|
|
|
|
if (!bitmap->data)
|
|
return FALSE;
|
|
|
|
if (compressed)
|
|
{
|
|
if (bpp < 32)
|
|
{
|
|
if (!interleaved_decompress(context->codecs->interleaved,
|
|
pSrcData, SrcSize,
|
|
DstWidth, DstHeight,
|
|
bpp,
|
|
bitmap->data, bitmap->format,
|
|
0, 0, 0, DstWidth, DstHeight,
|
|
&gdi->palette))
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
if (!planar_decompress(context->codecs->planar, pSrcData, SrcSize,
|
|
DstWidth, DstHeight,
|
|
bitmap->data, bitmap->format, 0, 0, 0,
|
|
DstWidth, DstHeight, TRUE))
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
const UINT32 SrcFormat = gdi_get_pixel_format(bpp);
|
|
const size_t sbpp = GetBytesPerPixel(SrcFormat);
|
|
const size_t dbpp = GetBytesPerPixel(bitmap->format);
|
|
|
|
if ((sbpp == 0) || (dbpp == 0))
|
|
return FALSE;
|
|
else
|
|
{
|
|
const size_t dstSize = SrcSize * dbpp / sbpp;
|
|
|
|
if (dstSize < bitmap->length)
|
|
return FALSE;
|
|
}
|
|
|
|
if (!freerdp_image_copy(bitmap->data, bitmap->format, 0, 0, 0,
|
|
DstWidth, DstHeight, pSrcData, SrcFormat,
|
|
0, 0, 0, &gdi->palette, FREERDP_FLIP_VERTICAL))
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL gdi_Bitmap_SetSurface(rdpContext* context, rdpBitmap* bitmap,
|
|
BOOL primary)
|
|
{
|
|
rdpGdi* gdi;
|
|
|
|
if (!context)
|
|
return FALSE;
|
|
|
|
gdi = context->gdi;
|
|
|
|
if (!gdi)
|
|
return FALSE;
|
|
|
|
if (primary)
|
|
gdi->drawing = gdi->primary;
|
|
else
|
|
gdi->drawing = (gdiBitmap*) bitmap;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/* Glyph Class */
|
|
static BOOL gdi_Glyph_New(rdpContext* context, const rdpGlyph* glyph)
|
|
{
|
|
BYTE* data;
|
|
gdiGlyph* gdi_glyph;
|
|
|
|
if (!context || !glyph)
|
|
return FALSE;
|
|
|
|
gdi_glyph = (gdiGlyph*) glyph;
|
|
gdi_glyph->hdc = gdi_GetDC();
|
|
|
|
if (!gdi_glyph->hdc)
|
|
return FALSE;
|
|
|
|
gdi_glyph->hdc->format = PIXEL_FORMAT_MONO;
|
|
data = freerdp_glyph_convert(glyph->cx, glyph->cy, glyph->aj);
|
|
|
|
if (!data)
|
|
{
|
|
gdi_DeleteDC(gdi_glyph->hdc);
|
|
return FALSE;
|
|
}
|
|
|
|
gdi_glyph->bitmap = gdi_CreateBitmap(glyph->cx, glyph->cy, PIXEL_FORMAT_MONO,
|
|
data);
|
|
|
|
if (!gdi_glyph->bitmap)
|
|
{
|
|
gdi_DeleteDC(gdi_glyph->hdc);
|
|
_aligned_free(data);
|
|
return FALSE;
|
|
}
|
|
|
|
gdi_SelectObject(gdi_glyph->hdc, (HGDIOBJECT) gdi_glyph->bitmap);
|
|
gdi_glyph->org_bitmap = NULL;
|
|
return TRUE;
|
|
}
|
|
|
|
static void gdi_Glyph_Free(rdpContext* context, rdpGlyph* glyph)
|
|
{
|
|
gdiGlyph* gdi_glyph;
|
|
gdi_glyph = (gdiGlyph*) glyph;
|
|
|
|
if (gdi_glyph)
|
|
{
|
|
gdi_SelectObject(gdi_glyph->hdc, (HGDIOBJECT) gdi_glyph->org_bitmap);
|
|
gdi_DeleteObject((HGDIOBJECT) gdi_glyph->bitmap);
|
|
gdi_DeleteDC(gdi_glyph->hdc);
|
|
free(glyph->aj);
|
|
free(glyph);
|
|
}
|
|
}
|
|
|
|
static BOOL gdi_Glyph_Draw(rdpContext* context, const rdpGlyph* glyph, INT32 x,
|
|
INT32 y, INT32 w, INT32 h, INT32 sx, INT32 sy, BOOL fOpRedundant)
|
|
{
|
|
gdiGlyph* gdi_glyph;
|
|
rdpGdi* gdi;
|
|
HGDI_BRUSH brush;
|
|
BOOL rc = FALSE;
|
|
|
|
if (!context || !glyph)
|
|
return FALSE;
|
|
|
|
gdi = context->gdi;
|
|
gdi_glyph = (gdiGlyph*) glyph;
|
|
|
|
if (!fOpRedundant && 0)
|
|
{
|
|
GDI_RECT rect = { 0 };
|
|
|
|
if (x > 0)
|
|
rect.left = x;
|
|
|
|
if (y > 0)
|
|
rect.top = y;
|
|
|
|
if (x + w > 0)
|
|
rect.right = x + w - 1;
|
|
|
|
if (y + h > 0)
|
|
rect.bottom = y + h - 1;
|
|
|
|
if ((rect.left < rect.right) && (rect.top < rect.bottom))
|
|
{
|
|
brush = gdi_CreateSolidBrush(gdi->drawing->hdc->bkColor);
|
|
|
|
if (!brush)
|
|
return FALSE;
|
|
|
|
gdi_FillRect(gdi->drawing->hdc, &rect, brush);
|
|
gdi_DeleteObject((HGDIOBJECT)brush);
|
|
}
|
|
}
|
|
|
|
brush = gdi_CreateSolidBrush(gdi->drawing->hdc->textColor);
|
|
|
|
if (!brush)
|
|
return FALSE;
|
|
|
|
gdi_SelectObject(gdi->drawing->hdc, (HGDIOBJECT)brush);
|
|
rc = gdi_BitBlt(gdi->drawing->hdc, x, y, w, h, gdi_glyph->hdc, sx, sy,
|
|
GDI_GLYPH_ORDER, &context->gdi->palette);
|
|
gdi_DeleteObject((HGDIOBJECT)brush);
|
|
return rc;
|
|
}
|
|
|
|
static BOOL gdi_Glyph_SetBounds(rdpContext* context, INT32 x, INT32 y, INT32 width, INT32 height)
|
|
{
|
|
rdpGdi* gdi;
|
|
|
|
if (!context || !context->gdi)
|
|
return FALSE;
|
|
|
|
gdi = context->gdi;
|
|
|
|
if (!gdi->drawing || !gdi->drawing->hdc)
|
|
return FALSE;
|
|
|
|
return gdi_SetClipRgn(gdi->drawing->hdc, x, y, width, height);
|
|
}
|
|
|
|
static BOOL gdi_Glyph_BeginDraw(rdpContext* context, INT32 x, INT32 y,
|
|
INT32 width, INT32 height, UINT32 bgcolor,
|
|
UINT32 fgcolor, BOOL fOpRedundant)
|
|
{
|
|
rdpGdi* gdi;
|
|
|
|
if (!context || !context->gdi)
|
|
return FALSE;
|
|
|
|
gdi = context->gdi;
|
|
|
|
if (!gdi->drawing || !gdi->drawing->hdc)
|
|
return FALSE;
|
|
|
|
if (!fOpRedundant)
|
|
{
|
|
if (!gdi_decode_color(gdi, bgcolor, &bgcolor, NULL))
|
|
return FALSE;
|
|
|
|
if (!gdi_decode_color(gdi, fgcolor, &fgcolor, NULL))
|
|
return FALSE;
|
|
|
|
gdi_SetClipRgn(gdi->drawing->hdc, x, y, width, height);
|
|
gdi_SetTextColor(gdi->drawing->hdc, bgcolor);
|
|
gdi_SetBkColor(gdi->drawing->hdc, fgcolor);
|
|
|
|
if (1)
|
|
{
|
|
GDI_RECT rect = { 0 };
|
|
HGDI_BRUSH brush = gdi_CreateSolidBrush(fgcolor);
|
|
|
|
if (!brush)
|
|
return FALSE;
|
|
|
|
if (x > 0)
|
|
rect.left = x;
|
|
|
|
if (y > 0)
|
|
rect.top = y;
|
|
|
|
rect.right = x + width - 1;
|
|
rect.bottom = y + height - 1;
|
|
|
|
if ((x + width > rect.left) && (y + height > rect.top))
|
|
gdi_FillRect(gdi->drawing->hdc, &rect, brush);
|
|
|
|
gdi_DeleteObject((HGDIOBJECT)brush);
|
|
}
|
|
|
|
return gdi_SetNullClipRgn(gdi->drawing->hdc);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL gdi_Glyph_EndDraw(rdpContext* context, INT32 x, INT32 y,
|
|
INT32 width, INT32 height, UINT32 bgcolor, UINT32 fgcolor)
|
|
{
|
|
rdpGdi* gdi;
|
|
|
|
if (!context || !context->gdi)
|
|
return FALSE;
|
|
|
|
gdi = context->gdi;
|
|
|
|
if (!gdi->drawing || !gdi->drawing->hdc)
|
|
return FALSE;
|
|
|
|
gdi_SetNullClipRgn(gdi->drawing->hdc);
|
|
return TRUE;
|
|
}
|
|
|
|
/* Graphics Module */
|
|
BOOL gdi_register_graphics(rdpGraphics* graphics)
|
|
{
|
|
rdpBitmap bitmap;
|
|
rdpGlyph glyph;
|
|
bitmap.size = sizeof(gdiBitmap);
|
|
bitmap.New = gdi_Bitmap_New;
|
|
bitmap.Free = gdi_Bitmap_Free;
|
|
bitmap.Paint = gdi_Bitmap_Paint;
|
|
bitmap.Decompress = gdi_Bitmap_Decompress;
|
|
bitmap.SetSurface = gdi_Bitmap_SetSurface;
|
|
graphics_register_bitmap(graphics, &bitmap);
|
|
glyph.size = sizeof(gdiGlyph);
|
|
glyph.New = gdi_Glyph_New;
|
|
glyph.Free = gdi_Glyph_Free;
|
|
glyph.Draw = gdi_Glyph_Draw;
|
|
glyph.BeginDraw = gdi_Glyph_BeginDraw;
|
|
glyph.EndDraw = gdi_Glyph_EndDraw;
|
|
glyph.SetBounds = gdi_Glyph_SetBounds;
|
|
graphics_register_glyph(graphics, &glyph);
|
|
return TRUE;
|
|
}
|