/**

 * 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;

}

Unexecuted instantiation: interleaved.c:WriteFgBgImage24to24

Unexecuted instantiation: interleaved.c:WriteFgBgImage16to16

Unexecuted instantiation: interleaved.c:WriteFgBgImage8to8

/**

 * 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;

}

Unexecuted instantiation: interleaved.c:WriteFirstLineFgBgImage24to24

Unexecuted instantiation: interleaved.c:WriteFirstLineFgBgImage16to16

Unexecuted instantiation: interleaved.c:WriteFirstLineFgBgImage8to8

/**

 * 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;

}

Unexecuted instantiation: interleaved.c:RleDecompress24to24

Unexecuted instantiation: interleaved.c:RleDecompress16to16

Unexecuted instantiation: interleaved.c:RleDecompress8to8