Simplified code, moved bounds check out of loops.

diff --git a/libfreerdp/codec/include/bitmap.c b/libfreerdp/codec/include/bitmap.c
index cba7c27..aedc10a 100644 (file)
--- a/libfreerdp/codec/include/bitmap.c
+++ b/libfreerdp/codec/include/bitmap.c
@@ -28,152 +28,28 @@ static INLINE BYTE* WRITEFGBGIMAGE(BYTE* pbDest, const BYTE* pbDestEnd, UINT32 r
                                    BYTE bitmask, PIXEL fgPel, INT32 cBits)
 {
        PIXEL xorPixel;
-       DESTREADPIXEL(xorPixel, pbDest - rowDelta);
+       BYTE mask = 0x01;
 
-       if (bitmask & g_MaskBit0)
-       {
-               if (!DESTWRITEPIXEL(pbDest, pbDestEnd, xorPixel ^ fgPel))
-                       return NULL;
-       }
-       else
-       {
-               if (!DESTWRITEPIXEL(pbDest, pbDestEnd, xorPixel))
-                       return NULL;
-       }
+       if (cBits > 8)
+               return NULL;
 
-       DESTNEXTPIXEL(pbDest);
-       cBits = cBits - 1;
+       if (!ENSURE_CAPACITY(pbDest, pbDestEnd, cBits))
+               return NULL;
 
-       if (cBits > 0)
+       while (cBits > 0)
        {
+               UINT32 data;
                DESTREADPIXEL(xorPixel, pbDest - rowDelta);
 
-               if (bitmask & g_MaskBit1)
-               {
-                       if (!DESTWRITEPIXEL(pbDest, pbDestEnd, xorPixel ^ fgPel))
-                               return NULL;
-               }
+               if (bitmask & mask)
+                       data = xorPixel ^ fgPel;
                else
-               {
-                       if (!DESTWRITEPIXEL(pbDest, pbDestEnd, xorPixel))
-                               return NULL;
-               }
+                       data = xorPixel;
 
+               DESTWRITEPIXEL(pbDest, data);
                DESTNEXTPIXEL(pbDest);
                cBits = cBits - 1;
-
-               if (cBits > 0)
-               {
-                       DESTREADPIXEL(xorPixel, pbDest - rowDelta);
-
-                       if (bitmask & g_MaskBit2)
-                       {
-                               if (!DESTWRITEPIXEL(pbDest, pbDestEnd, xorPixel ^ fgPel))
-                                       return NULL;
-                       }
-                       else
-                       {
-                               if (!DESTWRITEPIXEL(pbDest, pbDestEnd, xorPixel))
-                                       return NULL;
-                       }
-
-                       DESTNEXTPIXEL(pbDest);
-                       cBits = cBits - 1;
-
-                       if (cBits > 0)
-                       {
-                               DESTREADPIXEL(xorPixel, pbDest - rowDelta);
-
-                               if (bitmask & g_MaskBit3)
-                               {
-                                       if (!DESTWRITEPIXEL(pbDest, pbDestEnd, xorPixel ^ fgPel))
-                                               return NULL;
-                               }
-                               else
-                               {
-                                       if (!DESTWRITEPIXEL(pbDest, pbDestEnd, xorPixel))
-                                               return NULL;
-                               }
-
-                               DESTNEXTPIXEL(pbDest);
-                               cBits = cBits - 1;
-
-                               if (cBits > 0)
-                               {
-                                       DESTREADPIXEL(xorPixel, pbDest - rowDelta);
-
-                                       if (bitmask & g_MaskBit4)
-                                       {
-                                               if (!DESTWRITEPIXEL(pbDest, pbDestEnd, xorPixel ^ fgPel))
-                                                       return NULL;
-                                       }
-                                       else
-                                       {
-                                               if (!DESTWRITEPIXEL(pbDest, pbDestEnd, xorPixel))
-                                                       return NULL;
-                                       }
-
-                                       DESTNEXTPIXEL(pbDest);
-                                       cBits = cBits - 1;
-
-                                       if (cBits > 0)
-                                       {
-                                               DESTREADPIXEL(xorPixel, pbDest - rowDelta);
-
-                                               if (bitmask & g_MaskBit5)
-                                               {
-                                                       if (!DESTWRITEPIXEL(pbDest, pbDestEnd, xorPixel ^ fgPel))
-                                                               return NULL;
-                                               }
-                                               else
-                                               {
-                                                       if (!DESTWRITEPIXEL(pbDest, pbDestEnd, xorPixel))
-                                                               return NULL;
-                                               }
-
-                                               DESTNEXTPIXEL(pbDest);
-                                               cBits = cBits - 1;
-
-                                               if (cBits > 0)
-                                               {
-                                                       DESTREADPIXEL(xorPixel, pbDest - rowDelta);
-
-                                                       if (bitmask & g_MaskBit6)
-                                                       {
-                                                               if (!DESTWRITEPIXEL(pbDest, pbDestEnd, xorPixel ^ fgPel))
-                                                                       return NULL;
-                                                       }
-                                                       else
-                                                       {
-                                                               if (!DESTWRITEPIXEL(pbDest, pbDestEnd, xorPixel))
-                                                                       return NULL;
-                                                       }
-
-                                                       DESTNEXTPIXEL(pbDest);
-                                                       cBits = cBits - 1;
-
-                                                       if (cBits > 0)
-                                                       {
-                                                               DESTREADPIXEL(xorPixel, pbDest - rowDelta);
-
-                                                               if (bitmask & g_MaskBit7)
-                                                               {
-                                                                       if (!DESTWRITEPIXEL(pbDest, pbDestEnd, xorPixel ^ fgPel))
-                                                                               return NULL;
-                                                               }
-                                                               else
-                                                               {
-                                                                       if (!DESTWRITEPIXEL(pbDest, pbDestEnd, xorPixel))
-                                                                               return NULL;
-                                                               }
-
-                                                               DESTNEXTPIXEL(pbDest);
-                                                       }
-                                               }
-                                       }
-                               }
-                       }
-               }
+               mask = mask << 1;
        }
 
        return pbDest;
@@ -186,136 +62,27 @@ static INLINE BYTE* WRITEFGBGIMAGE(BYTE* pbDest, const BYTE* pbDestEnd, UINT32 r
 static INLINE BYTE* WRITEFIRSTLINEFGBGIMAGE(BYTE* pbDest, const BYTE* pbDestEnd, BYTE bitmask,
         PIXEL fgPel, UINT32 cBits)
 {
-       if (bitmask & g_MaskBit0)
-       {
-               if (!DESTWRITEPIXEL(pbDest, pbDestEnd, fgPel))
-                       return NULL;
-       }
-       else
-       {
-               if (!DESTWRITEPIXEL(pbDest, pbDestEnd, BLACK_PIXEL))
-                       return NULL;
-       }
+       BYTE mask = 0x01;
+
+       if (cBits > 8)
+               return NULL;
 
-       DESTNEXTPIXEL(pbDest);
-       cBits = cBits - 1;
+       if (!ENSURE_CAPACITY(pbDest, pbDestEnd, cBits))
+               return NULL;
 
-       if (cBits > 0)
+       while (cBits > 0)
        {
-               if (bitmask & g_MaskBit1)
-               {
-                       if (!DESTWRITEPIXEL(pbDest, pbDestEnd, fgPel))
-                               return NULL;
-               }
+               UINT32 data;
+
+               if (bitmask & mask)
+                       data = fgPel;
                else
-               {
-                       if (!DESTWRITEPIXEL(pbDest, pbDestEnd, BLACK_PIXEL))
-                               return NULL;
-               }
+                       data =  BLACK_PIXEL;
 
+               DESTWRITEPIXEL(pbDest, data);
                DESTNEXTPIXEL(pbDest);
                cBits = cBits - 1;
-
-               if (cBits > 0)
-               {
-                       if (bitmask & g_MaskBit2)
-                       {
-                               if (!DESTWRITEPIXEL(pbDest, pbDestEnd, fgPel))
-                                       return NULL;
-                       }
-                       else
-                       {
-                               if (!DESTWRITEPIXEL(pbDest, pbDestEnd, BLACK_PIXEL))
-                                       return NULL;
-                       }
-
-                       DESTNEXTPIXEL(pbDest);
-                       cBits = cBits - 1;
-
-                       if (cBits > 0)
-                       {
-                               if (bitmask & g_MaskBit3)
-                               {
-                                       if (!DESTWRITEPIXEL(pbDest, pbDestEnd, fgPel))
-                                               return NULL;
-                               }
-                               else
-                               {
-                                       if (!DESTWRITEPIXEL(pbDest, pbDestEnd, BLACK_PIXEL))
-                                               return NULL;
-                               }
-
-                               DESTNEXTPIXEL(pbDest);
-                               cBits = cBits - 1;
-
-                               if (cBits > 0)
-                               {
-                                       if (bitmask & g_MaskBit4)
-                                       {
-                                               if (!DESTWRITEPIXEL(pbDest, pbDestEnd, fgPel))
-                                                       return NULL;
-                                       }
-                                       else
-                                       {
-                                               if (!DESTWRITEPIXEL(pbDest, pbDestEnd, BLACK_PIXEL))
-                                                       return NULL;
-                                       }
-
-                                       DESTNEXTPIXEL(pbDest);
-                                       cBits = cBits - 1;
-
-                                       if (cBits > 0)
-                                       {
-                                               if (bitmask & g_MaskBit5)
-                                               {
-                                                       if (!DESTWRITEPIXEL(pbDest, pbDestEnd, fgPel))
-                                                               return NULL;
-                                               }
-                                               else
-                                               {
-                                                       if (!DESTWRITEPIXEL(pbDest, pbDestEnd, BLACK_PIXEL))
-                                                               return NULL;
-                                               }
-
-                                               DESTNEXTPIXEL(pbDest);
-                                               cBits = cBits - 1;
-
-                                               if (cBits > 0)
-                                               {
-                                                       if (bitmask & g_MaskBit6)
-                                                       {
-                                                               if (!DESTWRITEPIXEL(pbDest, pbDestEnd, fgPel))
-                                                                       return NULL;
-                                                       }
-                                                       else
-                                                       {
-                                                               if (!DESTWRITEPIXEL(pbDest, pbDestEnd, BLACK_PIXEL))
-                                                                       return NULL;
-                                                       }
-
-                                                       DESTNEXTPIXEL(pbDest);
-                                                       cBits = cBits - 1;
-
-                                                       if (cBits > 0)
-                                                       {
-                                                               if (bitmask & g_MaskBit7)
-                                                               {
-                                                                       if (!DESTWRITEPIXEL(pbDest, pbDestEnd, fgPel))
-                                                                               return NULL;
-                                                               }
-                                                               else
-                                                               {
-                                                                       if (!DESTWRITEPIXEL(pbDest, pbDestEnd, BLACK_PIXEL))
-                                                                               return NULL;
-                                                               }
-
-                                                               DESTNEXTPIXEL(pbDest);
-                                                       }
-                                               }
-                                       }
-                               }
-                       }
-               }
+               mask = mask << 1;
        }
 
        return pbDest;
@@ -377,31 +144,22 @@ static INLINE BOOL RLEDECOMPRESS(const BYTE* pbSrcBuffer, UINT32 cbSrcBuffer,
                        {
                                if (fInsertFgPel)
                                {
-                                       if (!DESTWRITEPIXEL(pbDest, pbDestEnd, fgPel))
+                                       if (!ENSURE_CAPACITY(pbDest, pbDestEnd, 1))
                                                return FALSE;
 
+                                       DESTWRITEPIXEL(pbDest, fgPel);
                                        DESTNEXTPIXEL(pbDest);
                                        runLength = runLength - 1;
                                }
 
-                               while (runLength >= UNROLL_COUNT)
-                               {
-                                       UNROLL(
-
-                                           if (!DESTWRITEPIXEL(pbDest, pbDestEnd, BLACK_PIXEL))
-                                           return FALSE;
-                                           DESTNEXTPIXEL(pbDest););
-
-                                       runLength = runLength - UNROLL_COUNT;
-                               }
+                               if (!ENSURE_CAPACITY(pbDest, pbDestEnd, runLength))
+                                       return FALSE;
 
                                while (runLength > 0)
                                {
-                                       if (!DESTWRITEPIXEL(pbDest, pbDestEnd, BLACK_PIXEL))
-                                               return FALSE;
-
+                                       DESTWRITEPIXEL(pbDest, BLACK_PIXEL);
                                        DESTNEXTPIXEL(pbDest);
-                                       runLength = runLength - 1;
+                                       runLength--;
                                }
                        }
                        else
@@ -410,34 +168,23 @@ static INLINE BOOL RLEDECOMPRESS(const BYTE* pbSrcBuffer, UINT32 cbSrcBuffer,
                                {
                                        DESTREADPIXEL(temp, pbDest - rowDelta);
 
-                                       if (!DESTWRITEPIXEL(pbDest, pbDestEnd, temp ^ fgPel))
+                                       if (!ENSURE_CAPACITY(pbDest, pbDestEnd, 1))
                                                return FALSE;
 
+                                       DESTWRITEPIXEL(pbDest, temp ^ fgPel);
                                        DESTNEXTPIXEL(pbDest);
-                                       runLength = runLength - 1;
+                                       runLength--;
                                }
 
-                               while (runLength >= UNROLL_COUNT)
-                               {
-                                       UNROLL(
-                                           DESTREADPIXEL(temp, pbDest - rowDelta);
-
-                                           if (!DESTWRITEPIXEL(pbDest, pbDestEnd, temp))
-                                           return FALSE;
-                                           DESTNEXTPIXEL(pbDest););
-
-                                       runLength = runLength - UNROLL_COUNT;
-                               }
+                               if (!ENSURE_CAPACITY(pbDest, pbDestEnd, runLength))
+                                       return FALSE;
 
                                while (runLength > 0)
                                {
                                        DESTREADPIXEL(temp, pbDest - rowDelta);
-
-                                       if (!DESTWRITEPIXEL(pbDest, pbDestEnd, temp))
-                                               return FALSE;
-
+                                       DESTWRITEPIXEL(pbDest, temp);
                                        DESTNEXTPIXEL(pbDest);
-                                       runLength = runLength - 1;
+                                       runLength--;
                                }
                        }
 
@@ -466,51 +213,26 @@ static INLINE BOOL RLEDECOMPRESS(const BYTE* pbSrcBuffer, UINT32 cbSrcBuffer,
                                        SRCNEXTPIXEL(pbSrc);
                                }
 
+                               if (!ENSURE_CAPACITY(pbDest, pbDestEnd, runLength))
+                                       return FALSE;
+
                                if (fFirstLine)
                                {
-                                       while (runLength >= UNROLL_COUNT)
-                                       {
-                                               UNROLL(
-
-                                                   if (!DESTWRITEPIXEL(pbDest, pbDestEnd, fgPel))
-                                                   return FALSE;
-                                                   DESTNEXTPIXEL(pbDest););
-
-                                               runLength = runLength - UNROLL_COUNT;
-                                       }
-
                                        while (runLength > 0)
                                        {
-                                               if (!DESTWRITEPIXEL(pbDest, pbDestEnd, fgPel))
-                                                       return FALSE;
-
+                                               DESTWRITEPIXEL(pbDest, fgPel);
                                                DESTNEXTPIXEL(pbDest);
-                                               runLength = runLength - 1;
+                                               runLength--;
                                        }
                                }
                                else
                                {
-                                       while (runLength >= UNROLL_COUNT)
-                                       {
-                                               UNROLL(
-                                                   DESTREADPIXEL(temp, pbDest - rowDelta);
-
-                                                   if (!DESTWRITEPIXEL(pbDest, pbDestEnd, temp ^ fgPel))
-                                                   return FALSE;
-                                                   DESTNEXTPIXEL(pbDest););
-
-                                               runLength = runLength - UNROLL_COUNT;
-                                       }
-
                                        while (runLength > 0)
                                        {
                                                DESTREADPIXEL(temp, pbDest - rowDelta);
-
-                                               if (!DESTWRITEPIXEL(pbDest, pbDestEnd, temp ^ fgPel))
-                                                       return FALSE;
-
+                                               DESTWRITEPIXEL(pbDest, temp ^ fgPel);
                                                DESTNEXTPIXEL(pbDest);
-                                               runLength = runLength - 1;
+                                               runLength--;
                                        }
                                }
 
@@ -526,32 +248,16 @@ static INLINE BOOL RLEDECOMPRESS(const BYTE* pbSrcBuffer, UINT32 cbSrcBuffer,
                                SRCREADPIXEL(pixelB, pbSrc);
                                SRCNEXTPIXEL(pbSrc);
 
-                               while (runLength >= UNROLL_COUNT)
-                               {
-                                       UNROLL(
-
-                                           if (!DESTWRITEPIXEL(pbDest, pbDestEnd, pixelA))
-                                           return FALSE;
-                                           DESTNEXTPIXEL(pbDest);
-                                           if (!DESTWRITEPIXEL(pbDest, pbDestEnd, pixelB))
-                                                   return FALSE;
-                                                   DESTNEXTPIXEL(pbDest););
-
-                                       runLength = runLength - UNROLL_COUNT;
-                               }
+                               if (!ENSURE_CAPACITY(pbDest, pbDestEnd, runLength * 2))
+                                       return FALSE;
 
                                while (runLength > 0)
                                {
-                                       if (!DESTWRITEPIXEL(pbDest, pbDestEnd, pixelA))
-                                               return FALSE;
-
+                                       DESTWRITEPIXEL(pbDest, pixelA);
                                        DESTNEXTPIXEL(pbDest);
-
-                                       if (!DESTWRITEPIXEL(pbDest, pbDestEnd, pixelB))
-                                               return FALSE;
-
+                                       DESTWRITEPIXEL(pbDest, pixelB);
                                        DESTNEXTPIXEL(pbDest);
-                                       runLength = runLength - 1;
+                                       runLength--;
                                }
 
                                break;
@@ -564,24 +270,14 @@ static INLINE BOOL RLEDECOMPRESS(const BYTE* pbSrcBuffer, UINT32 cbSrcBuffer,
                                SRCREADPIXEL(pixelA, pbSrc);
                                SRCNEXTPIXEL(pbSrc);
 
-                               while (runLength >= UNROLL_COUNT)
-                               {
-                                       UNROLL(
-
-                                           if (!DESTWRITEPIXEL(pbDest, pbDestEnd, pixelA))
-                                           return FALSE;
-                                           DESTNEXTPIXEL(pbDest););
-
-                                       runLength = runLength - UNROLL_COUNT;
-                               }
+                               if (!ENSURE_CAPACITY(pbDest, pbDestEnd, runLength))
+                                       return FALSE;
 
                                while (runLength > 0)
                                {
-                                       if (!DESTWRITEPIXEL(pbDest, pbDestEnd, pixelA))
-                                               return FALSE;
-
+                                       DESTWRITEPIXEL(pbDest, pixelA);
                                        DESTNEXTPIXEL(pbDest);
-                                       runLength = runLength - 1;
+                                       runLength--;
                                }
 
                                break;
@@ -655,29 +351,16 @@ static INLINE BOOL RLEDECOMPRESS(const BYTE* pbSrcBuffer, UINT32 cbSrcBuffer,
                                runLength = ExtractRunLength(code, pbSrc, &advance);
                                pbSrc = pbSrc + advance;
 
-                               while (runLength >= UNROLL_COUNT)
-                               {
-                                       UNROLL(
-                                           SRCREADPIXEL(temp, pbSrc);
-                                           SRCNEXTPIXEL(pbSrc);
-
-                                           if (!DESTWRITEPIXEL(pbDest, pbDestEnd, temp))
-                                           return FALSE;
-                                           DESTNEXTPIXEL(pbDest););
-
-                                       runLength = runLength - UNROLL_COUNT;
-                               }
+                               if (!ENSURE_CAPACITY(pbDest, pbDestEnd, runLength))
+                                       return FALSE;
 
                                while (runLength > 0)
                                {
                                        SRCREADPIXEL(temp, pbSrc);
                                        SRCNEXTPIXEL(pbSrc);
-
-                                       if (!DESTWRITEPIXEL(pbDest, pbDestEnd, temp))
-                                               return FALSE;
-
+                                       DESTWRITEPIXEL(pbDest, temp);
                                        DESTNEXTPIXEL(pbDest);
-                                       runLength = runLength - 1;
+                                       runLength--;
                                }
 
                                break;
@@ -722,9 +405,10 @@ static INLINE BOOL RLEDECOMPRESS(const BYTE* pbSrcBuffer, UINT32 cbSrcBuffer,
                        case SPECIAL_WHITE:
                                pbSrc = pbSrc + 1;
 
-                               if (!DESTWRITEPIXEL(pbDest, pbDestEnd, WHITE_PIXEL))
+                               if (!ENSURE_CAPACITY(pbDest, pbDestEnd, 1))
                                        return FALSE;
 
+                               DESTWRITEPIXEL(pbDest, WHITE_PIXEL);
                                DESTNEXTPIXEL(pbDest);
                                break;
 
@@ -732,9 +416,10 @@ static INLINE BOOL RLEDECOMPRESS(const BYTE* pbSrcBuffer, UINT32 cbSrcBuffer,
                        case SPECIAL_BLACK:
                                pbSrc = pbSrc + 1;
 
-                               if (!DESTWRITEPIXEL(pbDest, pbDestEnd, BLACK_PIXEL))
+                               if (!ENSURE_CAPACITY(pbDest, pbDestEnd, 1))
                                        return FALSE;
 
+                               DESTWRITEPIXEL(pbDest, BLACK_PIXEL);
                                DESTNEXTPIXEL(pbDest);
                                break;
 

diff --git a/libfreerdp/codec/interleaved.c b/libfreerdp/codec/interleaved.c
index 7adc481..15eec7c 100644 (file)
--- a/libfreerdp/codec/interleaved.c
+++ b/libfreerdp/codec/interleaved.c
@@ -62,15 +62,6 @@
 
 typedef UINT32 PIXEL;
 
-static const BYTE g_MaskBit0 = 0x01; /* Least significant bit */
-static const BYTE g_MaskBit1 = 0x02;
-static const BYTE g_MaskBit2 = 0x04;
-static const BYTE g_MaskBit3 = 0x08;
-static const BYTE g_MaskBit4 = 0x10;
-static const BYTE g_MaskBit5 = 0x20;
-static const BYTE g_MaskBit6 = 0x40;
-static const BYTE g_MaskBit7 = 0x80; /* Most significant bit */
-
 static const BYTE g_MaskSpecialFgBg1 = 0x03;
 static const BYTE g_MaskSpecialFgBg2 = 0x05;
 
@@ -192,47 +183,30 @@ static INLINE UINT32 ExtractRunLength(UINT32 code, const BYTE* pbOrderHdr,
        return runLength;
 }
 
-static INLINE BOOL write_pixel_8(BYTE* _buf, const BYTE* _end, BYTE _pix)
+static INLINE BOOL ensure_capacity(const BYTE* start, const BYTE* end, size_t size, size_t base)
 {
-       if (!_buf || !_end)
-               return FALSE;
-
-       if ((_end - _buf) < 1)
-               return FALSE;
+       const size_t available = (uintptr_t)end - (uintptr_t)start;
+       const BOOL rc = available >= size * base;
+       return rc;
+}
 
+static INLINE void write_pixel_8(BYTE* _buf, BYTE _pix)
+{
        *_buf = _pix;
-       return TRUE;
 }
 
-static INLINE BOOL write_pixel_24(BYTE* _buf, const BYTE* _end, UINT32 _pix)
+static INLINE void write_pixel_24(BYTE* _buf, UINT32 _pix)
 {
-       if (!_buf || !_end)
-               return FALSE;
-
-       if ((_end - _buf) < 3)
-               return FALSE;
-
        (_buf)[0] = (BYTE)(_pix);
        (_buf)[1] = (BYTE)((_pix) >> 8);
        (_buf)[2] = (BYTE)((_pix) >> 16);
-       return TRUE;
 }
 
-static INLINE BOOL write_pixel_16(BYTE* _buf, const BYTE* _end, UINT16 _pix)
+static INLINE void write_pixel_16(BYTE* _buf, UINT16 _pix)
 {
-       if (!_buf || !_end)
-               return FALSE;
-
-       if ((_end - _buf) < 2)
-               return FALSE;
-
        *(UINT16*)_buf = _pix;
-       return TRUE;
 }
 
-#define UNROLL_COUNT 4
-#define UNROLL(_exp) do { _exp _exp _exp _exp } while (0)
-
 #undef DESTWRITEPIXEL
 #undef DESTREADPIXEL
 #undef SRCREADPIXEL
@@ -244,7 +218,7 @@ static INLINE BOOL write_pixel_16(BYTE* _buf, const BYTE* _end, UINT16 _pix)
 #undef RLEEXTRA
 #undef WHITE_PIXEL
 #define WHITE_PIXEL 0xFF
-#define DESTWRITEPIXEL(_buf, _end, _pix) write_pixel_8(_buf, _end, _pix)
+#define DESTWRITEPIXEL(_buf, _pix) write_pixel_8(_buf, _pix)
 #define DESTREADPIXEL(_pix, _buf) _pix = (_buf)[0]
 #define SRCREADPIXEL(_pix, _buf) _pix = (_buf)[0]
 #define DESTNEXTPIXEL(_buf) _buf += 1
@@ -253,6 +227,8 @@ static INLINE BOOL write_pixel_16(BYTE* _buf, const BYTE* _end, UINT16 _pix)
 #define WRITEFIRSTLINEFGBGIMAGE WriteFirstLineFgBgImage8to8
 #define RLEDECOMPRESS RleDecompress8to8
 #define RLEEXTRA
+#undef ENSURE_CAPACITY
+#define ENSURE_CAPACITY(_start, _end, _size) ensure_capacity(_start, _end, _size, 1)
 #include "include/bitmap.c"
 
 #undef DESTWRITEPIXEL
@@ -266,7 +242,7 @@ static INLINE BOOL write_pixel_16(BYTE* _buf, const BYTE* _end, UINT16 _pix)
 #undef RLEEXTRA
 #undef WHITE_PIXEL
 #define WHITE_PIXEL 0xFFFF
-#define DESTWRITEPIXEL(_buf, _end, _pix) write_pixel_16(_buf, _end, _pix)
+#define DESTWRITEPIXEL(_buf, _pix) write_pixel_16(_buf, _pix)
 #define DESTREADPIXEL(_pix, _buf) _pix = ((UINT16*)(_buf))[0]
 #ifdef HAVE_ALIGNED_REQUIRED
 #define SRCREADPIXEL(_pix, _buf) _pix = (_buf)[0] | ((_buf)[1] << 8)
@@ -279,6 +255,8 @@ static INLINE BOOL write_pixel_16(BYTE* _buf, const BYTE* _end, UINT16 _pix)
 #define WRITEFIRSTLINEFGBGIMAGE WriteFirstLineFgBgImage16to16
 #define RLEDECOMPRESS RleDecompress16to16
 #define RLEEXTRA
+#undef ENSURE_CAPACITY
+#define ENSURE_CAPACITY(_start, _end, _size) ensure_capacity(_start, _end, _size, 2)
 #include "include/bitmap.c"
 
 #undef DESTWRITEPIXEL
@@ -292,7 +270,7 @@ static INLINE BOOL write_pixel_16(BYTE* _buf, const BYTE* _end, UINT16 _pix)
 #undef RLEEXTRA
 #undef WHITE_PIXEL
 #define WHITE_PIXEL 0xFFFFFF
-#define DESTWRITEPIXEL(_buf, _end, _pix)  write_pixel_24(_buf, _end, _pix)
+#define DESTWRITEPIXEL(_buf, _pix)  write_pixel_24(_buf, _pix)
 #define DESTREADPIXEL(_pix, _buf) _pix = (_buf)[0] | ((_buf)[1] << 8) | \
         ((_buf)[2] << 16)
 #define SRCREADPIXEL(_pix, _buf) _pix = (_buf)[0] | ((_buf)[1] << 8) | \
@@ -303,6 +281,8 @@ static INLINE BOOL write_pixel_16(BYTE* _buf, const BYTE* _end, UINT16 _pix)
 #define WRITEFIRSTLINEFGBGIMAGE WriteFirstLineFgBgImage24to24
 #define RLEDECOMPRESS RleDecompress24to24
 #define RLEEXTRA
+#undef ENSURE_CAPACITY
+#define ENSURE_CAPACITY(_start, _end, _size) ensure_capacity(_start, _end, _size, 3)
 #include "include/bitmap.c"
 
 BOOL interleaved_decompress(BITMAP_INTERLEAVED_CONTEXT* interleaved,
@@ -404,7 +384,7 @@ BOOL interleaved_compress(BITMAP_INTERLEAVED_CONTEXT* interleaved,
        int status;
        wStream* s;
        UINT32 DstFormat = 0;
-       int maxSize = 64 * 64 * 4;
+       const size_t maxSize = 64 * 64 * 4;
 
        if (nWidth % 4)
        {