/src/FreeRDP/libfreerdp/codec/include/bitmap.h

Source
/**
 * FreeRDP: A Remote Desktop Protocol Implementation
 * RLE Compressed Bitmap Stream
 *
 * Copyright 2011 Jay Sorg <jay.sorg@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.
 */

#include <winpr/assert.h>
#include <winpr/cast.h>
#include <winpr/wtypes.h>

/* do not compile the file directly */

/**
 * Write a foreground/background image to a destination buffer.
 */
WINPR_ATTR_NODISCARD
static inline BYTE* WRITEFGBGIMAGE(BYTE* WINPR_RESTRICT pbDest,
                                   const BYTE* WINPR_RESTRICT pbDestEnd, UINT32 rowDelta,
                                   BYTE bitmask, PIXEL fgPel, UINT32 cBits)
{
  PIXEL xorPixel = 0;
  BYTE mask = 0x01;

  if (cBits > 8)
  {
    WLog_ERR(TAG, "cBits %" PRIu32 " > 8", cBits);
    return nullptr;
  }

  if (!ENSURE_CAPACITY(pbDest, pbDestEnd, cBits))
    return nullptr;

  UNROLL(cBits, {
    PIXEL data = 0;
    DESTREADPIXEL(xorPixel, pbDest - rowDelta);

    if (bitmask & mask)
      data = xorPixel ^ fgPel;
    else
      data = xorPixel;

    DESTWRITEPIXEL(pbDest, data);
    mask = WINPR_ASSERTING_INT_CAST(BYTE, (mask << 1) & 0xFF);
  });
  return pbDest;
}

/**
 * Write a foreground/background image to a destination buffer
 * for the first line of compressed data.
 */
WINPR_ATTR_NODISCARD
static inline BYTE* WRITEFIRSTLINEFGBGIMAGE(BYTE* WINPR_RESTRICT pbDest,
                                            const BYTE* WINPR_RESTRICT pbDestEnd, BYTE bitmask,
                                            PIXEL fgPel, UINT32 cBits)
{
  BYTE mask = 0x01;

  if (cBits > 8)
  {
    WLog_ERR(TAG, "cBits %" PRIu32 " > 8", cBits);
    return nullptr;
  }

  if (!ENSURE_CAPACITY(pbDest, pbDestEnd, cBits))
    return nullptr;

  UNROLL(cBits, {
    PIXEL data;

    if (bitmask & mask)
      data = fgPel;
    else
      data = BLACK_PIXEL;

    DESTWRITEPIXEL(pbDest, data);
    mask = WINPR_ASSERTING_INT_CAST(BYTE, (mask << 1) & 0xFF);
  });
  return pbDest;
}

/**
 * Decompress an RLE compressed bitmap.
 */
WINPR_ATTR_NODISCARD
static inline BOOL RLEDECOMPRESS(const BYTE* WINPR_RESTRICT pbSrcBuffer, UINT32 cbSrcBuffer,
                                 BYTE* WINPR_RESTRICT pbDestBuffer, UINT32 rowDelta, UINT32 width,
                                 UINT32 height)
{
  const BYTE* pbSrc = pbSrcBuffer;
  BYTE* pbDest = pbDestBuffer;
  PIXEL temp = 0;
  PIXEL fgPel = WHITE_PIXEL;
  BOOL fInsertFgPel = FALSE;
  BOOL fFirstLine = TRUE;
  BYTE bitmask = 0;
  PIXEL pixelA = 0;
  PIXEL pixelB = 0;
  UINT32 runLength = 0;
  UINT32 code = 0;
  UINT32 advance = 0;
  RLEEXTRA

  if ((rowDelta == 0) || (rowDelta < width))
  {
    WLog_ERR(TAG, "Invalid arguments: rowDelta=%" PRIu32 " == 0 || < width=%" PRIu32, rowDelta,
             width);
    return FALSE;
  }

  if (!pbSrcBuffer || !pbDestBuffer)
  {
    WLog_ERR(TAG, "Invalid arguments: pbSrcBuffer=%p, pbDestBuffer=%p",
             WINPR_CXX_COMPAT_CAST(const void*, pbSrcBuffer),
             WINPR_CXX_COMPAT_CAST(const void*, pbDestBuffer));
    return FALSE;
  }

  const BYTE* pbEnd = &pbSrcBuffer[cbSrcBuffer];
  const BYTE* pbDestEnd = &pbDestBuffer[1ULL * rowDelta * height];

  while (pbSrc < pbEnd)
  {
    /* Watch out for the end of the first scanline. */
    if (fFirstLine)
    {
      if ((UINT32)(pbDest - pbDestBuffer) >= rowDelta)
      {
        fFirstLine = FALSE;
        fInsertFgPel = FALSE;
      }
    }

    /*
       Extract the compression order code ID from the compression
       order header.
    */
    code = ExtractCodeId(*pbSrc);

#if defined(WITH_DEBUG_CODECS)
    WLog_VRB(TAG, "pbSrc=%p code=%s, rem=%ld", (const void*)pbSrc, rle_code_str(code),
             pbEnd - pbSrc);
#endif

    /* Handle Background Run Orders. */
    if ((code == REGULAR_BG_RUN) || (code == MEGA_MEGA_BG_RUN))
    {
      runLength = ExtractRunLength(code, pbSrc, pbEnd, &advance);
      if (advance == 0)
        return FALSE;
      pbSrc = pbSrc + advance;

      if (fFirstLine)
      {
        if (fInsertFgPel)
        {
          if (!ENSURE_CAPACITY(pbDest, pbDestEnd, 1))
            return FALSE;

          DESTWRITEPIXEL(pbDest, fgPel);
          runLength = runLength - 1;
        }

        if (!ENSURE_CAPACITY(pbDest, pbDestEnd, runLength))
          return FALSE;

        UNROLL(runLength, { DESTWRITEPIXEL(pbDest, BLACK_PIXEL); });
      }
      else
      {
        if (fInsertFgPel)
        {
          DESTREADPIXEL(temp, pbDest - rowDelta);

          if (!ENSURE_CAPACITY(pbDest, pbDestEnd, 1))
            return FALSE;

          DESTWRITEPIXEL(pbDest, temp ^ fgPel);
          runLength--;
        }

        if (!ENSURE_CAPACITY(pbDest, pbDestEnd, runLength))
          return FALSE;

        UNROLL(runLength, {
          DESTREADPIXEL(temp, pbDest - rowDelta);
          DESTWRITEPIXEL(pbDest, temp);
        });
      }

      /* A follow-on background run order will need a foreground pel inserted. */
      fInsertFgPel = TRUE;
      continue;
    }

    /* For any of the other run-types a follow-on background run
        order does not need a foreground pel inserted. */
    fInsertFgPel = FALSE;

    switch (code)
    {
      /* Handle Foreground Run Orders. */
      case REGULAR_FG_RUN:
      case MEGA_MEGA_FG_RUN:
      case LITE_SET_FG_FG_RUN:
      case MEGA_MEGA_SET_FG_RUN:
        runLength = ExtractRunLength(code, pbSrc, pbEnd, &advance);
        if (advance == 0)
          return FALSE;
        pbSrc = pbSrc + advance;

        if (code == LITE_SET_FG_FG_RUN || code == MEGA_MEGA_SET_FG_RUN)
        {
          if (!buffer_within_range(pbSrc, PIXEL_SIZE, pbEnd))
            return FALSE;
          SRCREADPIXEL(fgPel, pbSrc);
        }

        if (!ENSURE_CAPACITY(pbDest, pbDestEnd, runLength))
          return FALSE;

        if (fFirstLine)
        {
          UNROLL(runLength, { DESTWRITEPIXEL(pbDest, fgPel); });
        }
        else
        {
          UNROLL(runLength, {
            DESTREADPIXEL(temp, pbDest - rowDelta);
            DESTWRITEPIXEL(pbDest, temp ^ fgPel);
          });
        }

        break;

      /* Handle Dithered Run Orders. */
      case LITE_DITHERED_RUN:
      case MEGA_MEGA_DITHERED_RUN:
        runLength = ExtractRunLength(code, pbSrc, pbEnd, &advance);
        if (advance == 0)
          return FALSE;
        pbSrc = pbSrc + advance;
        if (!buffer_within_range(pbSrc, PIXEL_SIZE, pbEnd))
          return FALSE;
        SRCREADPIXEL(pixelA, pbSrc);
        if (!buffer_within_range(pbSrc, PIXEL_SIZE, pbEnd))
          return FALSE;
        SRCREADPIXEL(pixelB, pbSrc);

        if (!ENSURE_CAPACITY(pbDest, pbDestEnd, runLength * 2))
          return FALSE;

        UNROLL(runLength, {
          DESTWRITEPIXEL(pbDest, pixelA);
          DESTWRITEPIXEL(pbDest, pixelB);
        });
        break;

      /* Handle Color Run Orders. */
      case REGULAR_COLOR_RUN:
      case MEGA_MEGA_COLOR_RUN:
        runLength = ExtractRunLength(code, pbSrc, pbEnd, &advance);
        if (advance == 0)
          return FALSE;
        pbSrc = pbSrc + advance;
        if (!buffer_within_range(pbSrc, PIXEL_SIZE, pbEnd))
          return FALSE;
        SRCREADPIXEL(pixelA, pbSrc);

        if (!ENSURE_CAPACITY(pbDest, pbDestEnd, runLength))
          return FALSE;

        UNROLL(runLength, { DESTWRITEPIXEL(pbDest, pixelA); });
        break;

      /* Handle Foreground/Background Image Orders. */
      case REGULAR_FGBG_IMAGE:
      case MEGA_MEGA_FGBG_IMAGE:
      case LITE_SET_FG_FGBG_IMAGE:
      case MEGA_MEGA_SET_FGBG_IMAGE:
        runLength = ExtractRunLength(code, pbSrc, pbEnd, &advance);
        if (advance == 0)
          return FALSE;
        pbSrc = pbSrc + advance;

        if (code == LITE_SET_FG_FGBG_IMAGE || code == MEGA_MEGA_SET_FGBG_IMAGE)
        {
          if (!buffer_within_range(pbSrc, PIXEL_SIZE, pbEnd))
            return FALSE;
          SRCREADPIXEL(fgPel, pbSrc);
        }

        if (!buffer_within_range(pbSrc, runLength / 8, pbEnd))
          return FALSE;
        if (fFirstLine)
        {
          while (runLength > 8)
          {
            bitmask = *pbSrc;
            pbSrc = pbSrc + 1;
            pbDest = WRITEFIRSTLINEFGBGIMAGE(pbDest, pbDestEnd, bitmask, fgPel, 8);

            if (!pbDest)
              return FALSE;

            runLength = runLength - 8;
          }
        }
        else
        {
          while (runLength > 8)
          {
            bitmask = *pbSrc++;

            pbDest = WRITEFGBGIMAGE(pbDest, pbDestEnd, rowDelta, bitmask, fgPel, 8);

            if (!pbDest)
              return FALSE;

            runLength = runLength - 8;
          }
        }

        if (runLength > 0)
        {
          if (!buffer_within_range(pbSrc, 1, pbEnd))
            return FALSE;
          bitmask = *pbSrc++;

          if (fFirstLine)
          {
            pbDest =
                WRITEFIRSTLINEFGBGIMAGE(pbDest, pbDestEnd, bitmask, fgPel, runLength);
          }
          else
          {
            pbDest =
                WRITEFGBGIMAGE(pbDest, pbDestEnd, rowDelta, bitmask, fgPel, runLength);
          }

          if (!pbDest)
            return FALSE;
        }

        break;

      /* Handle Color Image Orders. */
      case REGULAR_COLOR_IMAGE:
      case MEGA_MEGA_COLOR_IMAGE:
        runLength = ExtractRunLength(code, pbSrc, pbEnd, &advance);
        if (advance == 0)
          return FALSE;
        pbSrc = pbSrc + advance;
        if (!ENSURE_CAPACITY(pbDest, pbDestEnd, runLength))
          return FALSE;
        if (!ENSURE_CAPACITY(pbSrc, pbEnd, runLength))
          return FALSE;

        UNROLL(runLength, {
          SRCREADPIXEL(temp, pbSrc);
          DESTWRITEPIXEL(pbDest, temp);
        });
        break;

      /* Handle Special Order 1. */
      case SPECIAL_FGBG_1:
        if (!buffer_within_range(pbSrc, 1, pbEnd))
          return FALSE;
        pbSrc = pbSrc + 1;

        if (fFirstLine)
        {
          pbDest =
              WRITEFIRSTLINEFGBGIMAGE(pbDest, pbDestEnd, g_MaskSpecialFgBg1, fgPel, 8);
        }
        else
        {
          pbDest =
              WRITEFGBGIMAGE(pbDest, pbDestEnd, rowDelta, g_MaskSpecialFgBg1, fgPel, 8);
        }

        if (!pbDest)
          return FALSE;

        break;

      /* Handle Special Order 2. */
      case SPECIAL_FGBG_2:
        if (!buffer_within_range(pbSrc, 1, pbEnd))
          return FALSE;
        pbSrc = pbSrc + 1;

        if (fFirstLine)
        {
          pbDest =
              WRITEFIRSTLINEFGBGIMAGE(pbDest, pbDestEnd, g_MaskSpecialFgBg2, fgPel, 8);
        }
        else
        {
          pbDest =
              WRITEFGBGIMAGE(pbDest, pbDestEnd, rowDelta, g_MaskSpecialFgBg2, fgPel, 8);
        }

        if (!pbDest)
          return FALSE;

        break;

      /* Handle White Order. */
      case SPECIAL_WHITE:
        if (!buffer_within_range(pbSrc, 1, pbEnd))
          return FALSE;
        pbSrc = pbSrc + 1;

        if (!ENSURE_CAPACITY(pbDest, pbDestEnd, 1))
          return FALSE;

        DESTWRITEPIXEL(pbDest, WHITE_PIXEL);
        break;

      /* Handle Black Order. */
      case SPECIAL_BLACK:
        if (!buffer_within_range(pbSrc, 1, pbEnd))
          return FALSE;
        pbSrc = pbSrc + 1;

        if (!ENSURE_CAPACITY(pbDest, pbDestEnd, 1))
          return FALSE;

        DESTWRITEPIXEL(pbDest, BLACK_PIXEL);
        break;

      default:
        WLog_ERR(TAG, "invalid code 0x%08" PRIx32 ", pbSrcBuffer=%p, pbSrc=%p, pbEnd=%p",
                 code, WINPR_CXX_COMPAT_CAST(const void*, pbSrcBuffer),
                 WINPR_CXX_COMPAT_CAST(const void*, pbSrc),
                 WINPR_CXX_COMPAT_CAST(const void*, pbEnd));
        return FALSE;
    }
  }

  return TRUE;
}

Coverage Report

Created: 2026-10-28 06:54