gdi/bitmap.c

 
#include <freerdp/config.h>
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
#include <freerdp/api.h>
#include <freerdp/freerdp.h>
#include <freerdp/gdi/gdi.h>
#include <freerdp/codec/color.h>
 
#include <freerdp/gdi/region.h>
#include <freerdp/gdi/bitmap.h>
#include <freerdp/log.h>
#include <freerdp/gdi/shape.h>
 
#include "brush.h"
#include "clipping.h"
#include "../gdi/gdi.h"
 
#define TAG FREERDP_TAG("gdi.bitmap")
 
UINT32 gdi_GetPixel(HGDI_DC hdc, UINT32 nXPos, UINT32 nYPos)
{
  HGDI_BITMAP hBmp = (HGDI_BITMAP)hdc->selectedObject;
  BYTE* data =
      &(hBmp->data[(nYPos * hBmp->scanline) + nXPos * FreeRDPGetBytesPerPixel(hBmp->format)]);
  return FreeRDPReadColor(data, hBmp->format);
}
 
BYTE* gdi_GetPointer(HGDI_BITMAP hBmp, UINT32 X, UINT32 Y)
{
  UINT32 bpp = FreeRDPGetBytesPerPixel(hBmp->format);
  return &hBmp->data[(Y * hBmp->width * bpp) + X * bpp];
}
 
static INLINE UINT32 gdi_SetPixelBmp(HGDI_BITMAP hBmp, UINT32 X, UINT32 Y, UINT32 crColor)
{
  BYTE* p = &hBmp->data[(Y * hBmp->scanline) + X * FreeRDPGetBytesPerPixel(hBmp->format)];
  FreeRDPWriteColor(p, hBmp->format, crColor);
  return crColor;
}
 
UINT32 gdi_SetPixel(HGDI_DC hdc, UINT32 X, UINT32 Y, UINT32 crColor)
{
  HGDI_BITMAP hBmp = (HGDI_BITMAP)hdc->selectedObject;
  return gdi_SetPixelBmp(hBmp, X, Y, crColor);
}
 
HGDI_BITMAP gdi_CreateBitmap(UINT32 nWidth, UINT32 nHeight, UINT32 format, BYTE* data)
{
  return gdi_CreateBitmapEx(nWidth, nHeight, format, 0, data, winpr_aligned_free);
}
 
HGDI_BITMAP gdi_CreateBitmapEx(UINT32 nWidth, UINT32 nHeight, UINT32 format, UINT32 stride,
                               BYTE* data, void (*fkt_free)(void*))
{
  HGDI_BITMAP hBitmap = (HGDI_BITMAP)calloc(1, sizeof(GDI_BITMAP));
 
  if (!hBitmap)
    return NULL;
 
  hBitmap->objectType = GDIOBJECT_BITMAP;
  hBitmap->format = format;
 
  if (stride > 0)
    hBitmap->scanline = stride;
  else
    hBitmap->scanline = nWidth * FreeRDPGetBytesPerPixel(hBitmap->format);
 
  hBitmap->width = nWidth;
  hBitmap->height = nHeight;
  hBitmap->data = data;
  hBitmap->free = fkt_free;
  return hBitmap;
}
 
HGDI_BITMAP gdi_CreateCompatibleBitmap(HGDI_DC hdc, UINT32 nWidth, UINT32 nHeight)
{
  HGDI_BITMAP hBitmap = (HGDI_BITMAP)calloc(1, sizeof(GDI_BITMAP));
 
  if (!hBitmap)
    return NULL;
 
  hBitmap->objectType = GDIOBJECT_BITMAP;
  hBitmap->format = hdc->format;
  WINPR_ASSERT(nWidth <= INT32_MAX);
  hBitmap->width = (INT32)nWidth;
 
  WINPR_ASSERT(nHeight <= INT32_MAX);
  hBitmap->height = (INT32)nHeight;
 
  size_t size = 1ull * nWidth * nHeight * FreeRDPGetBytesPerPixel(hBitmap->format);
  hBitmap->data = winpr_aligned_malloc(size, 16);
  hBitmap->free = winpr_aligned_free;
 
  if (!hBitmap->data)
  {
    free(hBitmap);
    return NULL;
  }
 
  /* Initialize with 0xff */
  memset(hBitmap->data, 0xff, size);
  hBitmap->scanline = nWidth * FreeRDPGetBytesPerPixel(hBitmap->format);
  return hBitmap;
}
 
static BOOL op_not(UINT32* stack, const UINT32* stackp)
{
  if (!stack || !stackp)
    return FALSE;
 
  if (*stackp < 1)
    return FALSE;
 
  stack[(*stackp) - 1] = ~stack[(*stackp) - 1];
  return TRUE;
}
 
static BOOL op_and(UINT32* stack, UINT32* stackp)
{
  if (!stack || !stackp)
    return FALSE;
 
  if (*stackp < 2)
    return FALSE;
 
  (*stackp)--;
  stack[(*stackp) - 1] &= stack[(*stackp)];
  return TRUE;
}
 
static BOOL op_or(UINT32* stack, UINT32* stackp)
{
  if (!stack || !stackp)
    return FALSE;
 
  if (*stackp < 2)
    return FALSE;
 
  (*stackp)--;
  stack[(*stackp) - 1] |= stack[(*stackp)];
  return TRUE;
}
 
static BOOL op_xor(UINT32* stack, UINT32* stackp)
{
  if (!stack || !stackp)
    return FALSE;
 
  if (*stackp < 2)
    return FALSE;
 
  (*stackp)--;
  stack[(*stackp) - 1] ^= stack[(*stackp)];
  return TRUE;
}
 
static UINT32 process_rop(UINT32 src, UINT32 dst, UINT32 pat, const char* rop, UINT32 format)
{
  UINT32 stack[10] = { 0 };
  UINT32 stackp = 0;
 
  while (*rop != '\0')
  {
    char op = *rop++;
 
    switch (op)
    {
      case '0':
        stack[stackp++] = FreeRDPGetColor(format, 0, 0, 0, 0xFF);
        break;
 
      case '1':
        stack[stackp++] = FreeRDPGetColor(format, 0xFF, 0xFF, 0xFF, 0xFF);
        break;
 
      case 'D':
        stack[stackp++] = dst;
        break;
 
      case 'S':
        stack[stackp++] = src;
        break;
 
      case 'P':
        stack[stackp++] = pat;
        break;
 
      case 'x':
        op_xor(stack, &stackp);
        break;
 
      case 'a':
        op_and(stack, &stackp);
        break;
 
      case 'o':
        op_or(stack, &stackp);
        break;
 
      case 'n':
        op_not(stack, &stackp);
        break;
 
      default:
        break;
    }
  }
 
  return stack[0];
}
 
static INLINE BOOL BitBlt_write(HGDI_DC hdcDest, HGDI_DC hdcSrc, INT32 nXDest, INT32 nYDest,
                                INT32 nXSrc, INT32 nYSrc, INT32 x, INT32 y, BOOL useSrc,
                                BOOL usePat, UINT32 style, const char* rop,
                                const gdiPalette* palette)
{
  UINT32 dstColor = 0;
  UINT32 colorA = 0;
  UINT32 colorB = 0;
  UINT32 colorC = 0;
  const INT32 dstX = nXDest + x;
  const INT32 dstY = nYDest + y;
  BYTE* dstp = gdi_get_bitmap_pointer(hdcDest, dstX, dstY);
 
  if (!dstp)
  {
    WLog_ERR(TAG, "dstp=%p", (const void*)dstp);
    return FALSE;
  }
 
  colorA = FreeRDPReadColor(dstp, hdcDest->format);
 
  if (useSrc)
  {
    const BYTE* srcp = gdi_get_bitmap_pointer(hdcSrc, nXSrc + x, nYSrc + y);
 
    if (!srcp)
    {
      WLog_ERR(TAG, "srcp=%p", (const void*)srcp);
      return FALSE;
    }
 
    colorC = FreeRDPReadColor(srcp, hdcSrc->format);
    colorC = FreeRDPConvertColor(colorC, hdcSrc->format, hdcDest->format, palette);
  }
 
  if (usePat)
  {
    switch (style)
    {
      case GDI_BS_SOLID:
        colorB = hdcDest->brush->color;
        break;
 
      case GDI_BS_HATCHED:
      case GDI_BS_PATTERN:
      {
        const BYTE* patp = gdi_get_brush_pointer(hdcDest, nXDest + x, nYDest + y);
 
        if (!patp)
        {
          WLog_ERR(TAG, "patp=%p", (const void*)patp);
          return FALSE;
        }
 
        colorB = FreeRDPReadColor(patp, hdcDest->format);
      }
      break;
 
      default:
        break;
    }
  }
 
  dstColor = process_rop(colorC, colorA, colorB, rop, hdcDest->format);
  return FreeRDPWriteColor(dstp, hdcDest->format, dstColor);
}
 
static BOOL adjust_src_coordinates(HGDI_DC hdcSrc, INT32 nWidth, INT32 nHeight, INT32* px,
                                   INT32* py)
{
  HGDI_BITMAP hSrcBmp = NULL;
  INT32 nXSrc = 0;
  INT32 nYSrc = 0;
 
  if (!hdcSrc || (nWidth < 0) || (nHeight < 0) || !px || !py)
    return FALSE;
 
  hSrcBmp = (HGDI_BITMAP)hdcSrc->selectedObject;
  nXSrc = *px;
  nYSrc = *py;
 
  if (!hSrcBmp)
    return FALSE;
 
  if (nYSrc < 0)
  {
    nYSrc = 0;
    nHeight = nHeight + nYSrc;
  }
 
  if ((nXSrc) < 0)
  {
    nXSrc = 0;
    nWidth = nWidth + nXSrc;
  }
 
  if (hSrcBmp->width < (nXSrc + nWidth))
    nXSrc = hSrcBmp->width - nWidth;
 
  if (hSrcBmp->height < (nYSrc + nHeight))
    nYSrc = hSrcBmp->height - nHeight;
 
  if ((nXSrc < 0) || (nYSrc < 0))
    return FALSE;
 
  *px = nXSrc;
  *py = nYSrc;
  return TRUE;
}
 
static BOOL adjust_src_dst_coordinates(HGDI_DC hdcDest, INT32* pnXSrc, INT32* pnYSrc, INT32* pnXDst,
                                       INT32* pnYDst, INT32* pnWidth, INT32* pnHeight)
{
  HGDI_BITMAP hDstBmp = NULL;
  volatile INT32 diffX = 0;
  volatile INT32 diffY = 0;
  volatile INT32 nXSrc = 0;
  volatile INT32 nYSrc = 0;
  volatile INT32 nXDst = 0;
  volatile INT32 nYDst = 0;
  volatile INT32 nWidth = 0;
  volatile INT32 nHeight = 0;
 
  if (!hdcDest || !pnXSrc || !pnYSrc || !pnXDst || !pnYDst || !pnWidth || !pnHeight)
    return FALSE;
 
  hDstBmp = (HGDI_BITMAP)hdcDest->selectedObject;
  nXSrc = *pnXSrc;
  nYSrc = *pnYSrc;
  nXDst = *pnXDst;
  nYDst = *pnYDst;
  nWidth = *pnWidth;
  nHeight = *pnHeight;
 
  if (!hDstBmp)
    return FALSE;
 
  if (nXDst < 0)
  {
    nXSrc -= nXDst;
    nWidth += nXDst;
    nXDst = 0;
  }
 
  if (nYDst < 0)
  {
    nYSrc -= nYDst;
    nHeight += nYDst;
    nYDst = 0;
  }
 
  diffX = hDstBmp->width - nXDst - nWidth;
 
  if (diffX < 0)
    nWidth += diffX;
 
  diffY = hDstBmp->height - nYDst - nHeight;
 
  if (diffY < 0)
    nHeight += diffY;
 
  if ((nXDst < 0) || (nYDst < 0) || (nWidth < 0) || (nHeight < 0))
  {
    nXDst = 0;
    nYDst = 0;
    nWidth = 0;
    nHeight = 0;
  }
 
  *pnXSrc = nXSrc;
  *pnYSrc = nYSrc;
  *pnXDst = nXDst;
  *pnYDst = nYDst;
  *pnWidth = nWidth;
  *pnHeight = nHeight;
  return TRUE;
}
 
static BOOL BitBlt_process(HGDI_DC hdcDest, INT32 nXDest, INT32 nYDest, INT32 nWidth, INT32 nHeight,
                           HGDI_DC hdcSrc, INT32 nXSrc, INT32 nYSrc, const char* rop,
                           const gdiPalette* palette)
{
  UINT32 style = 0;
  BOOL useSrc = FALSE;
  BOOL usePat = FALSE;
  const char* iter = rop;
 
  while (*iter != '\0')
  {
    switch (*iter++)
    {
      case 'P':
        usePat = TRUE;
        break;
 
      case 'S':
        useSrc = TRUE;
        break;
 
      default:
        break;
    }
  }
 
  if (!hdcDest)
    return FALSE;
 
  if (!adjust_src_dst_coordinates(hdcDest, &nXSrc, &nYSrc, &nXDest, &nYDest, &nWidth, &nHeight))
    return FALSE;
 
  if (useSrc && !hdcSrc)
    return FALSE;
 
  if (useSrc)
  {
    if (!adjust_src_coordinates(hdcSrc, nWidth, nHeight, &nXSrc, &nYSrc))
      return FALSE;
  }
 
  if (usePat)
  {
    style = gdi_GetBrushStyle(hdcDest);
 
    switch (style)
    {
      case GDI_BS_SOLID:
      case GDI_BS_HATCHED:
      case GDI_BS_PATTERN:
        break;
 
      default:
        WLog_ERR(TAG, "Invalid brush!!");
        return FALSE;
    }
  }
 
  if ((nXDest > nXSrc) && (nYDest > nYSrc))
  {
    for (INT32 y = nHeight - 1; y >= 0; y--)
    {
      for (INT32 x = nWidth - 1; x >= 0; x--)
      {
        if (!BitBlt_write(hdcDest, hdcSrc, nXDest, nYDest, nXSrc, nYSrc, x, y, useSrc,
                          usePat, style, rop, palette))
          return FALSE;
      }
    }
  }
  else if (nXDest > nXSrc)
  {
    for (INT32 y = 0; y < nHeight; y++)
    {
      for (INT32 x = nWidth - 1; x >= 0; x--)
      {
        if (!BitBlt_write(hdcDest, hdcSrc, nXDest, nYDest, nXSrc, nYSrc, x, y, useSrc,
                          usePat, style, rop, palette))
          return FALSE;
      }
    }
  }
  else if (nYDest > nYSrc)
  {
    for (INT32 y = nHeight - 1; y >= 0; y--)
    {
      for (INT32 x = 0; x < nWidth; x++)
      {
        if (!BitBlt_write(hdcDest, hdcSrc, nXDest, nYDest, nXSrc, nYSrc, x, y, useSrc,
                          usePat, style, rop, palette))
          return FALSE;
      }
    }
  }
  else
  {
    for (INT32 y = 0; y < nHeight; y++)
    {
      for (INT32 x = 0; x < nWidth; x++)
      {
        if (!BitBlt_write(hdcDest, hdcSrc, nXDest, nYDest, nXSrc, nYSrc, x, y, useSrc,
                          usePat, style, rop, palette))
          return FALSE;
      }
    }
  }
 
  return TRUE;
}
 
BOOL gdi_BitBlt(HGDI_DC hdcDest, INT32 nXDest, INT32 nYDest, INT32 nWidth, INT32 nHeight,
                HGDI_DC hdcSrc, INT32 nXSrc, INT32 nYSrc, DWORD rop, const gdiPalette* palette)
{
  HGDI_BITMAP hSrcBmp = NULL;
  HGDI_BITMAP hDstBmp = NULL;
 
  if (!hdcDest)
    return FALSE;
 
  if (!gdi_ClipCoords(hdcDest, &nXDest, &nYDest, &nWidth, &nHeight, &nXSrc, &nYSrc))
    return TRUE;
 
  /* Check which ROP should be performed.
   * Some specific ROP are used heavily and are resource intensive,
   * add optimized versions for these here.
   *
   * For all others fall back to the generic implementation.
   */
  switch (rop)
  {
    case GDI_SRCCOPY:
      if (!hdcSrc)
        return FALSE;
 
      if (!adjust_src_dst_coordinates(hdcDest, &nXSrc, &nYSrc, &nXDest, &nYDest, &nWidth,
                                      &nHeight))
        return FALSE;
 
      if (!adjust_src_coordinates(hdcSrc, nWidth, nHeight, &nXSrc, &nYSrc))
        return FALSE;
 
      hSrcBmp = (HGDI_BITMAP)hdcSrc->selectedObject;
      hDstBmp = (HGDI_BITMAP)hdcDest->selectedObject;
 
      if (!hSrcBmp || !hDstBmp)
        return FALSE;
 
      if (!freerdp_image_copy(hDstBmp->data, hDstBmp->format, hDstBmp->scanline, nXDest,
                              nYDest, nWidth, nHeight, hSrcBmp->data, hSrcBmp->format,
                              hSrcBmp->scanline, nXSrc, nYSrc, palette, FREERDP_FLIP_NONE))
        return FALSE;
 
      break;
 
    case GDI_DSTCOPY:
      hSrcBmp = (HGDI_BITMAP)hdcDest->selectedObject;
      hDstBmp = (HGDI_BITMAP)hdcDest->selectedObject;
 
      if (!adjust_src_dst_coordinates(hdcDest, &nXSrc, &nYSrc, &nXDest, &nYDest, &nWidth,
                                      &nHeight))
        return FALSE;
 
      if (!adjust_src_coordinates(hdcDest, nWidth, nHeight, &nXSrc, &nYSrc))
        return FALSE;
 
      if (!hSrcBmp || !hDstBmp)
        return FALSE;
 
      if (!freerdp_image_copy(hDstBmp->data, hDstBmp->format, hDstBmp->scanline, nXDest,
                              nYDest, nWidth, nHeight, hSrcBmp->data, hSrcBmp->format,
                              hSrcBmp->scanline, nXSrc, nYSrc, palette, FREERDP_FLIP_NONE))
        return FALSE;
 
      break;
 
    default:
      if (!BitBlt_process(hdcDest, nXDest, nYDest, nWidth, nHeight, hdcSrc, nXSrc, nYSrc,
                          gdi_rop_to_string(rop), palette))
        return FALSE;
 
      break;
  }
 
  if (!gdi_InvalidateRegion(hdcDest, nXDest, nYDest, nWidth, nHeight))
    return FALSE;
 
  return TRUE;
}