Fixed planar decoding.

diff --git a/include/freerdp/codec/color.h b/include/freerdp/codec/color.h
index f47349f..b5cd806 100644 (file)
--- a/include/freerdp/codec/color.h
+++ b/include/freerdp/codec/color.h
@@ -143,128 +143,128 @@ static const char* GetColorFormatName(UINT32 format)
 {
        switch (format)
        {
-               /* 32bpp formats */
-               case PIXEL_FORMAT_ARGB32:
-                       return "PIXEL_FORMAT_ARGB32";
+           /* 32bpp formats */
+           case PIXEL_FORMAT_ARGB32:
+                   return "PIXEL_FORMAT_ARGB32";
 
-               case PIXEL_FORMAT_ARGB32_VF:
-                       return "PIXEL_FORMAT_ARGB32_VF";
+           case PIXEL_FORMAT_ARGB32_VF:
+                   return "PIXEL_FORMAT_ARGB32_VF";
 
-               case PIXEL_FORMAT_XRGB32:
-                       return "PIXEL_FORMAT_XRGB32";
+           case PIXEL_FORMAT_XRGB32:
+                   return "PIXEL_FORMAT_XRGB32";
 
-               case PIXEL_FORMAT_XRGB32_VF:
-                       return "PIXEL_FORMAT_XRGB32_VF";
+           case PIXEL_FORMAT_XRGB32_VF:
+                   return "PIXEL_FORMAT_XRGB32_VF";
 
-               case PIXEL_FORMAT_ABGR32:
-                       return "PIXEL_FORMAT_ABGR32";
+           case PIXEL_FORMAT_ABGR32:
+                   return "PIXEL_FORMAT_ABGR32";
 
-               case PIXEL_FORMAT_ABGR32_VF:
-                       return "PIXEL_FORMAT_ABGR32_VF";
+           case PIXEL_FORMAT_ABGR32_VF:
+                   return "PIXEL_FORMAT_ABGR32_VF";
 
-               case PIXEL_FORMAT_XBGR32:
-                       return "PIXEL_FORMAT_XBGR32";
+           case PIXEL_FORMAT_XBGR32:
+                   return "PIXEL_FORMAT_XBGR32";
 
-               case PIXEL_FORMAT_XBGR32_VF:
-                       return "PIXEL_FORMAT_XBGR32_VF";
+           case PIXEL_FORMAT_XBGR32_VF:
+                   return "PIXEL_FORMAT_XBGR32_VF";
 
-               case PIXEL_FORMAT_BGRA32:
-                       return "PIXEL_FORMAT_BGRA32";
+           case PIXEL_FORMAT_BGRA32:
+                   return "PIXEL_FORMAT_BGRA32";
 
-               case PIXEL_FORMAT_BGRA32_VF:
-                       return "PIXEL_FORMAT_BGRA32_VF";
+           case PIXEL_FORMAT_BGRA32_VF:
+                   return "PIXEL_FORMAT_BGRA32_VF";
 
-               case PIXEL_FORMAT_BGRX32:
-                       return "PIXEL_FORMAT_BGRX32";
+           case PIXEL_FORMAT_BGRX32:
+                   return "PIXEL_FORMAT_BGRX32";
 
-               case PIXEL_FORMAT_BGRX32_VF:
-                       return "PIXEL_FORMAT_BGRX32_VF";
+           case PIXEL_FORMAT_BGRX32_VF:
+                   return "PIXEL_FORMAT_BGRX32_VF";
 
-               case PIXEL_FORMAT_RGBA32:
-                       return "PIXEL_FORMAT_RGBA32";
+           case PIXEL_FORMAT_RGBA32:
+                   return "PIXEL_FORMAT_RGBA32";
 
-               case PIXEL_FORMAT_RGBA32_VF:
-                       return "PIXEL_FORMAT_RGBA32_VF";
+           case PIXEL_FORMAT_RGBA32_VF:
+                   return "PIXEL_FORMAT_RGBA32_VF";
 
-               case PIXEL_FORMAT_RGBX32:
-                       return "PIXEL_FORMAT_RGBX32";
+           case PIXEL_FORMAT_RGBX32:
+                   return "PIXEL_FORMAT_RGBX32";
 
-               case PIXEL_FORMAT_RGBX32_VF:
-                       return "PIXEL_FORMAT_RGBX32_VF";
+           case PIXEL_FORMAT_RGBX32_VF:
+                   return "PIXEL_FORMAT_RGBX32_VF";
 
                /* 24bpp formats */
-               case PIXEL_FORMAT_RGB24:
-                       return "PIXEL_FORMAT_RGB24";
+           case PIXEL_FORMAT_RGB24:
+                   return "PIXEL_FORMAT_RGB24";
 
-               case PIXEL_FORMAT_RGB24_VF:
-                       return "PIXEL_FORMAT_RGB24_VF";
+           case PIXEL_FORMAT_RGB24_VF:
+                   return "PIXEL_FORMAT_RGB24_VF";
 
-               case PIXEL_FORMAT_BGR24:
-                       return "PIXEL_FORMAT_BGR24";
+           case PIXEL_FORMAT_BGR24:
+                   return "PIXEL_FORMAT_BGR24";
 
-               case PIXEL_FORMAT_BGR24_VF:
-                       return "PIXEL_FORMAT_BGR24_VF";
+           case PIXEL_FORMAT_BGR24_VF:
+                   return "PIXEL_FORMAT_BGR24_VF";
 
                /* 16bpp formats */
-               case PIXEL_FORMAT_RGB16:
-                       return "PIXEL_FORMAT_RGB16";
+           case PIXEL_FORMAT_RGB16:
+                   return "PIXEL_FORMAT_RGB16";
 
-               case PIXEL_FORMAT_RGB16_VF:
-                       return "PIXEL_FORMAT_RGB16_VF";
+           case PIXEL_FORMAT_RGB16_VF:
+                   return "PIXEL_FORMAT_RGB16_VF";
 
-               case PIXEL_FORMAT_BGR16:
-                       return "PIXEL_FORMAT_BGR16";
+           case PIXEL_FORMAT_BGR16:
+                   return "PIXEL_FORMAT_BGR16";
 
-               case PIXEL_FORMAT_BGR16_VF:
-                       return "PIXEL_FORMAT_BGR16_VF";
+           case PIXEL_FORMAT_BGR16_VF:
+                   return "PIXEL_FORMAT_BGR16_VF";
 
-               case PIXEL_FORMAT_ARGB15:
-                       return "PIXEL_FORMAT_ARGB15";
+           case PIXEL_FORMAT_ARGB15:
+                   return "PIXEL_FORMAT_ARGB15";
 
-               case PIXEL_FORMAT_ARGB15_VF:
-                       return "PIXEL_FORMAT_ARGB15_VF";
+           case PIXEL_FORMAT_ARGB15_VF:
+                   return "PIXEL_FORMAT_ARGB15_VF";
 
-               case PIXEL_FORMAT_RGB15:
-                       return "PIXEL_FORMAT_RGB15";
+           case PIXEL_FORMAT_RGB15:
+                   return "PIXEL_FORMAT_RGB15";
 
-               case PIXEL_FORMAT_RGB15_VF:
-                       return "PIXEL_FORMAT_ABGR15";
+           case PIXEL_FORMAT_RGB15_VF:
+                   return "PIXEL_FORMAT_ABGR15";
 
-               case PIXEL_FORMAT_ABGR15:
-                       return "";
+           case PIXEL_FORMAT_ABGR15:
+                   return "";
 
-               case PIXEL_FORMAT_ABGR15_VF:
-                       return "PIXEL_FORMAT_ABGR15_VF";
+           case PIXEL_FORMAT_ABGR15_VF:
+                   return "PIXEL_FORMAT_ABGR15_VF";
 
-               case PIXEL_FORMAT_BGR15:
-                       return "PIXEL_FORMAT_BGR15";
+           case PIXEL_FORMAT_BGR15:
+                   return "PIXEL_FORMAT_BGR15";
 
-               case PIXEL_FORMAT_BGR15_VF:
-                       return "PIXEL_FORMAT_BGR15_VF";
+           case PIXEL_FORMAT_BGR15_VF:
+                   return "PIXEL_FORMAT_BGR15_VF";
 
                /* 8bpp formats */
-               case PIXEL_FORMAT_RGB8:
-                       return "PIXEL_FORMAT_RGB8";
+           case PIXEL_FORMAT_RGB8:
+                   return "PIXEL_FORMAT_RGB8";
 
-               case PIXEL_FORMAT_RGB8_VF:
-                       return "PIXEL_FORMAT_RGB8_VF";
+           case PIXEL_FORMAT_RGB8_VF:
+                   return "PIXEL_FORMAT_RGB8_VF";
 
                /* 4 bpp formats */
-               case PIXEL_FORMAT_A4:
-                       return "PIXEL_FORMAT_A4";
+           case PIXEL_FORMAT_A4:
+                   return "PIXEL_FORMAT_A4";
 
-               case PIXEL_FORMAT_A4_VF:
-                       return "PIXEL_FORMAT_A4_VF";
+           case PIXEL_FORMAT_A4_VF:
+                   return "PIXEL_FORMAT_A4_VF";
 
                /* 1bpp formats */
-               case PIXEL_FORMAT_MONO:
-                       return "PIXEL_FORMAT_MONO";
+           case PIXEL_FORMAT_MONO:
+                   return "PIXEL_FORMAT_MONO";
 
-               case PIXEL_FORMAT_MONO_VF:
-                       return "PIXEL_FORMAT_MONO_VF";
+           case PIXEL_FORMAT_MONO_VF:
+                   return "PIXEL_FORMAT_MONO_VF";
 
-               default:
-                       return "UNKNOWN";
+           default:
+                   return "UNKNOWN";
        }
 }
 
@@ -275,9 +275,9 @@ static INLINE void SplitColor(UINT32 color, UINT32 format, BYTE* _r, BYTE* _g,
 
        switch (FREERDP_PIXEL_FORMAT_FLIP_MASKED(format))
        {
-               /* 32bpp formats */
-               case PIXEL_FORMAT_ARGB32:
-                       if (_a)
+           /* 32bpp formats */
+           case PIXEL_FORMAT_ARGB32:
+                   if (_a)
                                *_a = color >> 24;
 
                        if (_r)
@@ -289,10 +289,10 @@ static INLINE void SplitColor(UINT32 color, UINT32 format, BYTE* _r, BYTE* _g,
                        if (_b)
                                *_b = color;
 
-                       break;
+                   break;
 
-               case PIXEL_FORMAT_XRGB32:
-                       if (_r)
+           case PIXEL_FORMAT_XRGB32:
+                   if (_r)
                                *_r = color >> 16;
 
                        if (_g)
@@ -304,10 +304,10 @@ static INLINE void SplitColor(UINT32 color, UINT32 format, BYTE* _r, BYTE* _g,
                        if (_a)
                                *_a = 0xFF;
 
-                       break;
+                   break;
 
-               case PIXEL_FORMAT_ABGR32:
-                       if (_a)
+           case PIXEL_FORMAT_ABGR32:
+                   if (_a)
                                *_a = color >> 24;
 
                        if (_b)
@@ -319,10 +319,10 @@ static INLINE void SplitColor(UINT32 color, UINT32 format, BYTE* _r, BYTE* _g,
                        if (_r)
                                *_r = color;
 
-                       break;
+                   break;
 
-               case PIXEL_FORMAT_XBGR32:
-                       if (_b)
+           case PIXEL_FORMAT_XBGR32:
+                   if (_b)
                                *_b = color >> 16;
 
                        if (_g)
@@ -334,10 +334,10 @@ static INLINE void SplitColor(UINT32 color, UINT32 format, BYTE* _r, BYTE* _g,
                        if (_a)
                                *_a = 0xFF;
 
-                       break;
+                   break;
 
-               case PIXEL_FORMAT_RGBA32:
-                       if (_r)
+           case PIXEL_FORMAT_RGBA32:
+                   if (_r)
                                *_r = color >> 24;
 
                        if (_g)
@@ -349,10 +349,10 @@ static INLINE void SplitColor(UINT32 color, UINT32 format, BYTE* _r, BYTE* _g,
                        if (_a)
                                *_a = color;
 
-                       break;
+                   break;
 
-               case PIXEL_FORMAT_RGBX32:
-                       if (_r)
+           case PIXEL_FORMAT_RGBX32:
+                   if (_r)
                                *_r = color >> 24;
 
                        if (_g)
@@ -364,10 +364,10 @@ static INLINE void SplitColor(UINT32 color, UINT32 format, BYTE* _r, BYTE* _g,
                        if (_a)
                                *_a = 0xFF;
 
-                       break;
+                   break;
 
-               case PIXEL_FORMAT_BGRA32:
-                       if (_b)
+           case PIXEL_FORMAT_BGRA32:
+                   if (_b)
                                *_b = color >> 24;
 
                        if (_g)
@@ -379,10 +379,10 @@ static INLINE void SplitColor(UINT32 color, UINT32 format, BYTE* _r, BYTE* _g,
                        if (_a)
                                *_a = color;
 
-                       break;
+                   break;
 
-               case PIXEL_FORMAT_BGRX32:
-                       if (_b)
+           case PIXEL_FORMAT_BGRX32:
+                   if (_b)
                                *_b = color >> 24;
 
                        if (_g)
@@ -394,11 +394,11 @@ static INLINE void SplitColor(UINT32 color, UINT32 format, BYTE* _r, BYTE* _g,
                        if (_a)
                                *_a = 0xFF;
 
-                       break;
+                   break;
 
                /* 24bpp formats */
-               case PIXEL_FORMAT_RGB24:
-                       if (_r)
+           case PIXEL_FORMAT_RGB24:
+                   if (_r)
                                *_r = color >> 16;
 
                        if (_g)
@@ -410,10 +410,10 @@ static INLINE void SplitColor(UINT32 color, UINT32 format, BYTE* _r, BYTE* _g,
                        if (_a)
                                *_a = 0xFF;
 
-                       break;
+                   break;
 
-               case PIXEL_FORMAT_BGR24:
-                       if (_b)
+           case PIXEL_FORMAT_BGR24:
+                   if (_b)
                                *_b = color >> 16;
 
                        if (_g)
@@ -425,11 +425,11 @@ static INLINE void SplitColor(UINT32 color, UINT32 format, BYTE* _r, BYTE* _g,
                        if (_a)
                                *_a = 0xFF;
 
-                       break;
+                   break;
 
                /* 16bpp formats */
-               case PIXEL_FORMAT_RGB16:
-                       if (_r)
+           case PIXEL_FORMAT_RGB16:
+                   if (_r)
                                *_r = ((color >> 11) & 0x1F) << 3;
 
                        if (_g)
@@ -441,10 +441,10 @@ static INLINE void SplitColor(UINT32 color, UINT32 format, BYTE* _r, BYTE* _g,
                        if (_a)
                                *_a = 0xFF;
 
-                       break;
+                   break;
 
-               case PIXEL_FORMAT_BGR16:
-                       if (_b)
+           case PIXEL_FORMAT_BGR16:
+                   if (_b)
                                *_b = ((color >> 11) & 0x1F) << 3;
 
                        if (_g)
@@ -456,10 +456,10 @@ static INLINE void SplitColor(UINT32 color, UINT32 format, BYTE* _r, BYTE* _g,
                        if (_a)
                                *_a = 0xFF;
 
-                       break;
+                   break;
 
-               case PIXEL_FORMAT_ARGB15:
-                       if (_r)
+           case PIXEL_FORMAT_ARGB15:
+                   if (_r)
                                *_r = ((color >> 10) & 0x1F) << 3;
 
                        if (_g)
@@ -471,10 +471,10 @@ static INLINE void SplitColor(UINT32 color, UINT32 format, BYTE* _r, BYTE* _g,
                        if (_a)
                                *_a = color & 0x8000 ? 0xFF : 0x00;
 
-                       break;
+                   break;
 
-               case PIXEL_FORMAT_ABGR15:
-                       if (_b)
+           case PIXEL_FORMAT_ABGR15:
+                   if (_b)
                                *_b = ((color >> 10) & 0x1F) << 3;
 
                        if (_g)
@@ -486,11 +486,11 @@ static INLINE void SplitColor(UINT32 color, UINT32 format, BYTE* _r, BYTE* _g,
                        if (_a)
                                *_a = color & 0x8000 ? 0xFF : 0x00;
 
-                       break;
+                   break;
 
                /* 15bpp formats */
-               case PIXEL_FORMAT_RGB15:
-                       if (_r)
+           case PIXEL_FORMAT_RGB15:
+                   if (_r)
                                *_r = ((color >> 10) & 0x1F) << 3;
 
                        if (_g)
@@ -502,10 +502,10 @@ static INLINE void SplitColor(UINT32 color, UINT32 format, BYTE* _r, BYTE* _g,
                        if (_a)
                                *_a = 0xFF;
 
-                       break;
+                   break;
 
-               case PIXEL_FORMAT_BGR15:
-                       if (_b)
+           case PIXEL_FORMAT_BGR15:
+                   if (_b)
                                *_b = ((color >> 10) & 0x1F) << 3;
 
                        if (_g)
@@ -517,21 +517,21 @@ static INLINE void SplitColor(UINT32 color, UINT32 format, BYTE* _r, BYTE* _g,
                        if (_a)
                                *_a = 0xFF;
 
-                       break;
+                   break;
 
                /* 8bpp formats */
-               case PIXEL_FORMAT_RGB8:
-                       if (color <= 0xFF)
+           case PIXEL_FORMAT_RGB8:
+                   if (color <= 0xFF)
                        {
                                tmp = palette->palette[color];
                                SplitColor(tmp, palette->format, _r, _g, _b, _a, NULL);
                        }
 
-                       break;
+                   break;
 
                /* 1bpp formats */
-               case PIXEL_FORMAT_MONO:
-                       if (_r)
+           case PIXEL_FORMAT_MONO:
+                   if (_r)
                                *_r = (color) ? 0xFF : 0x00;
 
                        if (_g)
@@ -543,13 +543,13 @@ static INLINE void SplitColor(UINT32 color, UINT32 format, BYTE* _r, BYTE* _g,
                        if (_a)
                                *_a = (color) ? 0xFF : 0x00;
 
-                       break;
+                   break;
 
                /* 4 bpp formats */
-               case PIXEL_FORMAT_A4:
-               default:
-                       WLog_ERR("xxxxx", "Unsupported format %s", GetColorFormatName(format));
-                       break;
+           case PIXEL_FORMAT_A4:
+           default:
+                   WLog_ERR("xxxxx", "Unsupported format %s", GetColorFormatName(format));
+                   break;
        }
 }
 
@@ -562,75 +562,75 @@ static INLINE UINT32 GetColor(UINT32 format, BYTE r, BYTE g, BYTE b, BYTE a)
 
        switch (FREERDP_PIXEL_FORMAT_FLIP_MASKED(format))
        {
-               /* 32bpp formats */
-               case PIXEL_FORMAT_ARGB32:
-                       return (_a << 24) | (_r << 16) | (_g << 8) | _b;
+           /* 32bpp formats */
+           case PIXEL_FORMAT_ARGB32:
+                   return (_a << 24) | (_r << 16) | (_g << 8) | _b;
 
-               case PIXEL_FORMAT_XRGB32:
-                       return (_r << 16) | (_g << 8) | _b;
+           case PIXEL_FORMAT_XRGB32:
+                   return (_r << 16) | (_g << 8) | _b;
 
-               case PIXEL_FORMAT_ABGR32:
-                       return (_a << 24) | (_b << 16) | (_g << 8) | _r;
+           case PIXEL_FORMAT_ABGR32:
+                   return (_a << 24) | (_b << 16) | (_g << 8) | _r;
 
-               case PIXEL_FORMAT_XBGR32:
-                       return (_b << 16) | (_g << 8) | _r;
+           case PIXEL_FORMAT_XBGR32:
+                   return (_b << 16) | (_g << 8) | _r;
 
-               case PIXEL_FORMAT_RGBA32:
-                       return (_r << 24) | (_g << 16) | (_b << 8) | _a;
+           case PIXEL_FORMAT_RGBA32:
+                   return (_r << 24) | (_g << 16) | (_b << 8) | _a;
 
-               case PIXEL_FORMAT_RGBX32:
-                       return (_r << 24) | (_g << 16) | (_b << 8) | _a;
+           case PIXEL_FORMAT_RGBX32:
+                   return (_r << 24) | (_g << 16) | (_b << 8) | _a;
 
-               case PIXEL_FORMAT_BGRA32:
-                       return (_b << 24) | (_g << 16) | (_r << 8) | _a;
+           case PIXEL_FORMAT_BGRA32:
+                   return (_b << 24) | (_g << 16) | (_r << 8) | _a;
 
-               case PIXEL_FORMAT_BGRX32:
-                       return (_b << 24) | (_g << 16) | (_r << 8) | _a;
+           case PIXEL_FORMAT_BGRX32:
+                   return (_b << 24) | (_g << 16) | (_r << 8) | _a;
 
                /* 24bpp formats */
-               case PIXEL_FORMAT_RGB24:
-                       return (_r << 16) | (_g << 8) | _b;
+           case PIXEL_FORMAT_RGB24:
+                   return (_r << 16) | (_g << 8) | _b;
 
-               case PIXEL_FORMAT_BGR24:
-                       return (_b << 16) | (_g << 8) | _r;
+           case PIXEL_FORMAT_BGR24:
+                   return (_b << 16) | (_g << 8) | _r;
 
                /* 16bpp formats */
-               case PIXEL_FORMAT_RGB16:
-                       return (((_r >> 3) & 0x1F) << 11) | (((_g >> 2) & 0x3F) << 5) | ((
+           case PIXEL_FORMAT_RGB16:
+                   return (((_r >> 3) & 0x1F) << 11) | (((_g >> 2) & 0x3F) << 5) | ((
                                    _b >> 3) & 0x1F);
 
-               case PIXEL_FORMAT_BGR16:
-                       return (((_b >> 3) & 0x1F) << 11) | (((_g >> 2) & 0x3F) << 5) | ((
+           case PIXEL_FORMAT_BGR16:
+                   return (((_b >> 3) & 0x1F) << 11) | (((_g >> 2) & 0x3F) << 5) | ((
                                    _r >> 3) & 0x1F);
 
-               case PIXEL_FORMAT_ARGB15:
-                       return (((_r >> 3) & 0x1F) << 10) | (((_g >> 3) & 0x1F) << 5) | ((
+           case PIXEL_FORMAT_ARGB15:
+                   return (((_r >> 3) & 0x1F) << 10) | (((_g >> 3) & 0x1F) << 5) | ((
                                    _b >> 3) & 0x1F) | (_a ? 0x8000 : 0x0000);
 
-               case PIXEL_FORMAT_ABGR15:
-                       return (((_b >> 3) & 0x1F) << 10) | (((_g >> 3) & 0x1F) << 5) | ((
+           case PIXEL_FORMAT_ABGR15:
+                   return (((_b >> 3) & 0x1F) << 10) | (((_g >> 3) & 0x1F) << 5) | ((
                                    _r >> 3) & 0x1F) | (_a ? 0x8000 : 0x0000);
 
                /* 15bpp formats */
-               case PIXEL_FORMAT_RGB15:
-                       return (((_r >> 3) & 0x1F) << 10) | (((_g >> 3) & 0x1F) << 5) | ((
+           case PIXEL_FORMAT_RGB15:
+                   return (((_r >> 3) & 0x1F) << 10) | (((_g >> 3) & 0x1F) << 5) | ((
                                    _b >> 3) & 0x1F);
 
-               case PIXEL_FORMAT_BGR15:
-                       return (((_b >> 3) & 0x1F) << 10) | (((_g >> 3) & 0x1F) << 5) | ((
+           case PIXEL_FORMAT_BGR15:
+                   return (((_b >> 3) & 0x1F) << 10) | (((_g >> 3) & 0x1F) << 5) | ((
                                    _r >> 3) & 0x1F);
 
                /* 8bpp formats */
-               case PIXEL_FORMAT_RGB8:
+           case PIXEL_FORMAT_RGB8:
 
                /* 4 bpp formats */
-               case PIXEL_FORMAT_A4:
+           case PIXEL_FORMAT_A4:
 
                /* 1bpp formats */
-               case PIXEL_FORMAT_MONO:
-               default:
-                       WLog_ERR("xxxxx", "Unsupported format %s", GetColorFormatName(format));
-                       return 0;
+           case PIXEL_FORMAT_MONO:
+           default:
+                   WLog_ERR("xxxxx", "Unsupported format %s", GetColorFormatName(format));
+                   return 0;
        }
 }
 
@@ -639,6 +639,14 @@ static INLINE UINT32 GetBitsPerPixel(UINT32 format)
        return (((format) >> 24) & 0x3F);
 }
 
+static INLINE UINT32 SetColorFormatAlpha(UINT32 format, BOOL alpha)
+{
+       if (!alpha)
+               return format & ~(1<<12);
+       else
+               return format | (1<<12);
+}
+
 static INLINE BOOL ColorHasAlpha(UINT32 format)
 {
        UINT32 alpha = (((format) >> 12) & 0x0F);
@@ -655,37 +663,37 @@ static INLINE UINT32 ReadColor(const BYTE* src, UINT32 format)
 
        switch (GetBitsPerPixel(format))
        {
-               case 32:
-                       color = ((UINT32)src[0] << 24) | ((UINT32)src[1] << 16) |
+           case 32:
+                   color = ((UINT32)src[0] << 24) | ((UINT32)src[1] << 16) |
                                ((UINT32)src[2] << 8) | src[3];
-                       break;
+                   break;
 
-               case 24:
-                       color = ((UINT32)src[0] << 16) | ((UINT32)src[1] << 8) | src[2];
-                       break;
+           case 24:
+                   color = ((UINT32)src[0] << 16) | ((UINT32)src[1] << 8) | src[2];
+                   break;
 
-               case 16:
-                       color = ((UINT32)src[1] << 8) | src[0];
-                       break;
+           case 16:
+                   color = ((UINT32)src[1] << 8) | src[0];
+                   break;
 
-               case 15:
-                       color = ((UINT32)src[1] << 8) | src[0];
+           case 15:
+                   color = ((UINT32)src[1] << 8) | src[0];
 
                        if (!ColorHasAlpha(format))
                                color = color & 0x7FFF;
 
-                       break;
+                   break;
 
-               case 8:
-               case 4:
-               case 1:
-                       color = *src;
-                       break;
+           case 8:
+           case 4:
+           case 1:
+                   color = *src;
+                   break;
 
-               default:
-                       WLog_ERR("xxxxx", "Unsupported format %s", GetColorFormatName(format));
+           default:
+                   WLog_ERR("xxxxx", "Unsupported format %s", GetColorFormatName(format));
                        color = 0;
-                       break;
+                   break;
        }
 
        return color;
@@ -695,39 +703,39 @@ static INLINE BOOL WriteColor(BYTE* dst, UINT32 format, UINT32 color)
 {
        switch (GetBitsPerPixel(format))
        {
-               case 32:
-                       dst[0] = color >> 24;
+           case 32:
+                   dst[0] = color >> 24;
                        dst[1] = color >> 16;
                        dst[2] = color >> 8;
                        dst[3] = color;
-                       break;
+                   break;
 
-               case 24:
-                       dst[0] = color >> 16;
+           case 24:
+                   dst[0] = color >> 16;
                        dst[1] = color >> 8;
                        dst[2] = color;
-                       break;
+                   break;
 
-               case 16:
-                       dst[1] = color >> 8;
+           case 16:
+                   dst[1] = color >> 8;
                        dst[0] = color;
-                       break;
+                   break;
 
-               case 15:
-                       if (!ColorHasAlpha(format))
+           case 15:
+                   if (!ColorHasAlpha(format))
                                color = color & 0x7FFF;
 
                        dst[1] = color >> 8;
                        dst[0] = color;
-                       break;
+                   break;
 
-               case 8:
-                       dst[0] = color;
-                       break;
+           case 8:
+                   dst[0] = color;
+                   break;
 
-               default:
-                       WLog_ERR("xxxxx", "Unsupported format %s", GetColorFormatName(format));
-                       return FALSE;
+           default:
+                   WLog_ERR("xxxxx", "Unsupported format %s", GetColorFormatName(format));
+                   return FALSE;
        }
 
        return TRUE;

diff --git a/libfreerdp/codec/planar.c b/libfreerdp/codec/planar.c
index 5059169..cbe70a2 100644 (file)
--- a/libfreerdp/codec/planar.c
+++ b/libfreerdp/codec/planar.c
@@ -43,7 +43,7 @@ static BOOL freerdp_bitmap_planar_delta_encode_planes(
     BYTE* outPlanes[4]);
 
 static INT32 planar_skip_plane_rle(const BYTE* pSrcData, UINT32 SrcSize,
-                                   UINT32 nWidth, UINT32 nHeight)
+                                  UINT32 nWidth, UINT32 nHeight)
 {
        UINT32 x, y;
        int cRawBytes;
@@ -92,10 +92,10 @@ static INT32 planar_skip_plane_rle(const BYTE* pSrcData, UINT32 SrcSize,
 }
 
 static INT32 planar_decompress_plane_rle(const BYTE* pSrcData, UINT32 SrcSize,
-        BYTE* pDstData, INT32 nDstStep,
-        UINT32 nXDst, UINT32 nYDst,
-        UINT32 nWidth, UINT32 nHeight,
-        UINT32 nChannel, BOOL vFlip)
+       BYTE* pDstData, INT32 nDstStep,
+       UINT32 nXDst, UINT32 nYDst,
+       UINT32 nWidth, UINT32 nHeight,
+       UINT32 nChannel, BOOL vFlip)
 {
        UINT32 x, y;
        BYTE* dstp;
@@ -227,9 +227,9 @@ static INT32 planar_decompress_plane_rle(const BYTE* pSrcData, UINT32 SrcSize,
 }
 
 static BOOL planar_decompress_planes_raw(const BYTE* pSrcData[4],
-        BYTE* pDstData, UINT32 DstFormat,
-        UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst, UINT32 nWidth, UINT32 nHeight,
-        BOOL alpha, BOOL vFlip)
+       BYTE* pDstData, UINT32 DstFormat,
+       UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst, UINT32 nWidth, UINT32 nHeight,
+       BOOL alpha, BOOL vFlip)
 {
        INT32 x, y;
        INT32 beg, end, inc;
@@ -256,7 +256,7 @@ static BOOL planar_decompress_planes_raw(const BYTE* pSrcData[4],
                for (y = beg; y != end; y += inc)
                {
                        BYTE* pRGB = &pDstData[((nYDst + y) * nDstStep) + (nXDst * GetBytesPerPixel(
-                                                  DstFormat))];
+                                                  DstFormat))];
 
                        for (x = 0; x < nWidth; x++)
                        {
@@ -271,7 +271,7 @@ static BOOL planar_decompress_planes_raw(const BYTE* pSrcData[4],
                for (y = beg; y != end; y += inc)
                {
                        BYTE* pRGB = &pDstData[((nYDst + y) * nDstStep) + (nXDst * GetBytesPerPixel(
-                                                  DstFormat))];
+                                                  DstFormat))];
 
                        for (x = 0; x < nWidth; x++)
                        {
@@ -286,11 +286,11 @@ static BOOL planar_decompress_planes_raw(const BYTE* pSrcData[4],
 }
 
 BOOL planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
-                       const BYTE* pSrcData, UINT32 SrcSize,
-                       UINT32 nSrcWidth, UINT32 nSrcHeight,
-                       BYTE* pDstData, UINT32 DstFormat,
-                       UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
-                       UINT32 nDstWidth, UINT32 nDstHeight, BOOL vFlip)
+                      const BYTE* pSrcData, UINT32 SrcSize,
+                      UINT32 nSrcWidth, UINT32 nSrcHeight,
+                      BYTE* pDstData, UINT32 DstFormat,
+                      UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
+                      UINT32 nDstWidth, UINT32 nDstHeight, BOOL vFlip)
 {
        BOOL cs;
        BOOL rle;
@@ -407,28 +407,28 @@ BOOL planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
                {
                        planes[3] = srcp;
                        rleSizes[3] = planar_skip_plane_rle(planes[3], SrcSize - (planes[3] - pSrcData),
-                                                           rawWidths[3], rawHeights[3]); /* AlphaPlane */
+                                                           rawWidths[3], rawHeights[3]); /* AlphaPlane */
 
                        if (rleSizes[3] < 0)
                                return FALSE;
 
                        planes[0] = planes[3] + rleSizes[3];
                        rleSizes[0] = planar_skip_plane_rle(planes[0], SrcSize - (planes[0] - pSrcData),
-                                                           rawWidths[0], rawHeights[0]); /* RedPlane */
+                                                           rawWidths[0], rawHeights[0]); /* RedPlane */
 
                        if (rleSizes[0] < 0)
                                return FALSE;
 
                        planes[1] = planes[0] + rleSizes[0];
                        rleSizes[1] = planar_skip_plane_rle(planes[1], SrcSize - (planes[1] - pSrcData),
-                                                           rawWidths[1], rawHeights[1]); /* GreenPlane */
+                                                           rawWidths[1], rawHeights[1]); /* GreenPlane */
 
                        if (rleSizes[1] < 1)
                                return FALSE;
 
                        planes[2] = planes[1] + rleSizes[1];
                        rleSizes[2] = planar_skip_plane_rle(planes[2], SrcSize - (planes[2] - pSrcData),
-                                                           rawWidths[2], rawHeights[2]); /* BluePlane */
+                                                           rawWidths[2], rawHeights[2]); /* BluePlane */
 
                        if (rleSizes[2] < 1)
                                return FALSE;
@@ -437,21 +437,21 @@ BOOL planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
                {
                        planes[0] = srcp;
                        rleSizes[0] = planar_skip_plane_rle(planes[0], SrcSize - (planes[0] - pSrcData),
-                                                           rawWidths[0], rawHeights[0]); /* RedPlane */
+                                                           rawWidths[0], rawHeights[0]); /* RedPlane */
 
                        if (rleSizes[0] < 0)
                                return FALSE;
 
                        planes[1] = planes[0] + rleSizes[0];
                        rleSizes[1] = planar_skip_plane_rle(planes[1], SrcSize - (planes[1] - pSrcData),
-                                                           rawWidths[1], rawHeights[1]); /* GreenPlane */
+                                                           rawWidths[1], rawHeights[1]); /* GreenPlane */
 
                        if (rleSizes[1] < 1)
                                return FALSE;
 
                        planes[2] = planes[1] + rleSizes[1];
                        rleSizes[2] = planar_skip_plane_rle(planes[2], SrcSize - (planes[2] - pSrcData),
-                                                           rawWidths[2], rawHeights[2]); /* BluePlane */
+                                                           rawWidths[2], rawHeights[2]); /* BluePlane */
 
                        if (rleSizes[2] < 1)
                                return FALSE;
@@ -469,7 +469,7 @@ BOOL planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
                else
                        TempFormat = PIXEL_FORMAT_BGRX32;
 
-               if ((DstFormat != TempFormat) || (nSrcWidth != nDstWidth)
+               if ((TempFormat != DstFormat) || (nSrcWidth != nDstWidth)
                    || (nSrcHeight != nDstHeight))
                {
                        pTempData = planar->pTempData;
@@ -479,16 +479,16 @@ BOOL planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
                {
                        if (alpha)
                        {
-                               if (!planar_decompress_planes_raw(planes, pTempData, DstFormat, nDstStep,
-                                                                 nXDst, nYDst, nSrcWidth, nSrcHeight, alpha, vFlip))
+                               if (!planar_decompress_planes_raw(planes, pTempData, TempFormat, nDstStep,
+                                                                 nXDst, nYDst, nSrcWidth, nSrcHeight, alpha, vFlip))
                                        return FALSE;
 
                                srcp += rawSizes[0] + rawSizes[1] + rawSizes[2] + rawSizes[3];
                        }
                        else /* NoAlpha */
                        {
-                               if (!planar_decompress_planes_raw(planes, pTempData, DstFormat, nDstStep,
-                                                                 nXDst, nYDst, nSrcWidth, nSrcHeight, alpha, vFlip))
+                               if (!planar_decompress_planes_raw(planes, pTempData, TempFormat, nDstStep,
+                                                                 nXDst, nYDst, nSrcWidth, nSrcHeight, alpha, vFlip))
                                        return FALSE;
 
                                srcp += rawSizes[0] + rawSizes[1] + rawSizes[2];
@@ -502,29 +502,29 @@ BOOL planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
                        if (alpha)
                        {
                                status = planar_decompress_plane_rle(planes[3], rleSizes[3],
-                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 3,
-                                                                    vFlip); /* AlphaPlane */
+                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 3,
+                                                                    vFlip); /* AlphaPlane */
 
                                if (status < 0)
                                        return FALSE;
 
                                status = planar_decompress_plane_rle(planes[0], rleSizes[0],
-                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 2,
-                                                                    vFlip); /* RedPlane */
+                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 2,
+                                                                    vFlip); /* RedPlane */
 
                                if (status < 0)
                                        return FALSE;
 
                                status = planar_decompress_plane_rle(planes[1], rleSizes[1],
-                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 1,
-                                                                    vFlip); /* GreenPlane */
+                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 1,
+                                                                    vFlip); /* GreenPlane */
 
                                if (status < 0)
                                        return FALSE;
 
                                status = planar_decompress_plane_rle(planes[2], rleSizes[2],
-                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 0,
-                                                                    vFlip); /* BluePlane */
+                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 0,
+                                                                    vFlip); /* BluePlane */
 
                                if (status < 0)
                                        return FALSE;
@@ -534,22 +534,22 @@ BOOL planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
                        else /* NoAlpha */
                        {
                                status = planar_decompress_plane_rle(planes[0], rleSizes[0],
-                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 2,
-                                                                    vFlip); /* RedPlane */
+                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 2,
+                                                                    vFlip); /* RedPlane */
 
                                if (status < 0)
                                        return FALSE;
 
                                status = planar_decompress_plane_rle(planes[1], rleSizes[1],
-                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 1,
-                                                                    vFlip); /* GreenPlane */
+                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 1,
+                                                                    vFlip); /* GreenPlane */
 
                                if (status < 0)
                                        return FALSE;
 
                                status = planar_decompress_plane_rle(planes[2], rleSizes[2],
-                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 0,
-                                                                    vFlip); /* BluePlane */
+                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 0,
+                                                                    vFlip); /* BluePlane */
 
                                if (status < 0)
                                        return FALSE;
@@ -561,8 +561,8 @@ BOOL planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
                if (pTempData != pDstData)
                {
                        if (!freerdp_image_copy(pDstData, DstFormat, nDstStep, nXDst, nYDst, w,
-                                               h, pTempData,
-                                               TempFormat, nTempStep, nXDst, nYDst, NULL))
+                                               h, pTempData,
+                                               TempFormat, nTempStep, nXDst, nYDst, NULL))
                                return FALSE;
                }
        }
@@ -586,7 +586,7 @@ BOOL planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
                        if (alpha)
                        {
                                if (!planar_decompress_planes_raw(planes, pTempData, TempFormat, nTempStep,
-                                                                 nXDst, nYDst, nSrcWidth, nSrcHeight, alpha, vFlip))
+                                                                 nXDst, nYDst, nSrcWidth, nSrcHeight, alpha, vFlip))
                                        return FALSE;
 
                                srcp += rawSizes[0] + rawSizes[1] + rawSizes[2] + rawSizes[3];
@@ -594,7 +594,7 @@ BOOL planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
                        else /* NoAlpha */
                        {
                                if (!planar_decompress_planes_raw(planes, pTempData, TempFormat, nTempStep,
-                                                                 nXDst, nYDst, nSrcWidth, nSrcHeight, alpha, vFlip))
+                                                                 nXDst, nYDst, nSrcWidth, nSrcHeight, alpha, vFlip))
                                        return FALSE;
 
                                srcp += rawSizes[0] + rawSizes[1] + rawSizes[2];
@@ -608,29 +608,29 @@ BOOL planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
                        if (alpha)
                        {
                                status = planar_decompress_plane_rle(planes[3], rleSizes[3],
-                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 3,
-                                                                    vFlip); /* AlphaPlane */
+                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 3,
+                                                                    vFlip); /* AlphaPlane */
 
                                if (status < 0)
                                        return FALSE;
 
                                status = planar_decompress_plane_rle(planes[0], rleSizes[0],
-                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 2,
-                                                                    vFlip); /* LumaPlane */
+                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 2,
+                                                                    vFlip); /* LumaPlane */
 
                                if (status < 0)
                                        return FALSE;
 
                                status = planar_decompress_plane_rle(planes[1], rleSizes[1],
-                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 1,
-                                                                    vFlip); /* OrangeChromaPlane */
+                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 1,
+                                                                    vFlip); /* OrangeChromaPlane */
 
                                if (status < 0)
                                        return FALSE;
 
                                status = planar_decompress_plane_rle(planes[2], rleSizes[2],
-                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 0,
-                                                                    vFlip); /* GreenChromaPlane */
+                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 0,
+                                                                    vFlip); /* GreenChromaPlane */
 
                                if (status < 0)
                                        return FALSE;
@@ -640,22 +640,22 @@ BOOL planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
                        else /* NoAlpha */
                        {
                                status = planar_decompress_plane_rle(planes[0], rleSizes[0],
-                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 2,
-                                                                    vFlip); /* LumaPlane */
+                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 2,
+                                                                    vFlip); /* LumaPlane */
 
                                if (status < 0)
                                        return FALSE;
 
                                status = planar_decompress_plane_rle(planes[1], rleSizes[1],
-                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 1,
-                                                                    vFlip); /* OrangeChromaPlane */
+                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 1,
+                                                                    vFlip); /* OrangeChromaPlane */
 
                                if (status < 0)
                                        return FALSE;
 
                                status = planar_decompress_plane_rle(planes[2], rleSizes[2],
-                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 0,
-                                                                    vFlip); /* GreenChromaPlane */
+                                                                    pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 0,
+                                                                    vFlip); /* GreenChromaPlane */
 
                                if (status < 0)
                                        return FALSE;
@@ -665,8 +665,8 @@ BOOL planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
                }
 
                if (prims->YCoCgToRGB_8u_AC4R(pTempData, nTempStep, pDstData, DstFormat,
-                                             nDstStep,
-                                             w, h, cll, alpha) != PRIMITIVES_SUCCESS)
+                                             nDstStep,
+                                             w, h, cll, alpha) != PRIMITIVES_SUCCESS)
                        return FALSE;
        }
 
@@ -674,8 +674,8 @@ BOOL planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
 }
 
 static BOOL freerdp_split_color_planes(const BYTE* data, UINT32 format,
-                                       UINT32 width, UINT32 height,
-                                       UINT32 scanline, BYTE** planes)
+                                      UINT32 width, UINT32 height,
+                                      UINT32 scanline, BYTE** planes)
 {
        INT32 i, j, k;
        k = 0;
@@ -692,7 +692,7 @@ static BOOL freerdp_split_color_planes(const BYTE* data, UINT32 format,
                        const UINT32 color = ReadColor(pixel, format);
                        pixel += GetBytesPerPixel(format);
                        SplitColor(color, format, &planes[1][k], &planes[2][k],
-                                  &planes[3][k], &planes[0][k], NULL);
+                                  &planes[3][k], &planes[0][k], NULL);
                        k++;
                }
        }
@@ -815,9 +815,9 @@ static UINT32 freerdp_bitmap_planar_write_rle_bytes(
 }
 
 static UINT32 freerdp_bitmap_planar_encode_rle_bytes(const BYTE* pInBuffer,
-        UINT32 inBufferSize,
-        BYTE* pOutBuffer,
-        UINT32 outBufferSize)
+       UINT32 inBufferSize,
+       BYTE* pOutBuffer,
+       UINT32 outBufferSize)
 {
        BYTE symbol;
        const BYTE* pInput;
@@ -859,9 +859,9 @@ static UINT32 freerdp_bitmap_planar_encode_rle_bytes(const BYTE* pInBuffer,
                        {
                                pBytes = pInput - (cRawBytes + nRunLength + 1);
                                nBytesWritten = freerdp_bitmap_planar_write_rle_bytes(
-                                                   pBytes, cRawBytes,
-                                                   nRunLength, pOutput,
-                                                   outBufferSize);
+                                                   pBytes, cRawBytes,
+                                                   nRunLength, pOutput,
+                                                   outBufferSize);
                                nRunLength = 0;
 
                                if (!nBytesWritten || (nBytesWritten > outBufferSize))
@@ -883,7 +883,7 @@ static UINT32 freerdp_bitmap_planar_encode_rle_bytes(const BYTE* pInBuffer,
        {
                pBytes = pInput - (cRawBytes + nRunLength);
                nBytesWritten = freerdp_bitmap_planar_write_rle_bytes(pBytes,
-                               cRawBytes, nRunLength, pOutput, outBufferSize);
+                               cRawBytes, nRunLength, pOutput, outBufferSize);
 
                if (!nBytesWritten)
                        return 0;
@@ -898,8 +898,8 @@ static UINT32 freerdp_bitmap_planar_encode_rle_bytes(const BYTE* pInBuffer,
 }
 
 BYTE* freerdp_bitmap_planar_compress_plane_rle(const BYTE* inPlane,
-        UINT32 width, UINT32 height,
-        BYTE* outPlane, UINT32* dstSize)
+       UINT32 width, UINT32 height,
+       BYTE* outPlane, UINT32* dstSize)
 {
        UINT32 index;
        const BYTE* pInput;
@@ -933,7 +933,7 @@ BYTE* freerdp_bitmap_planar_compress_plane_rle(const BYTE* inPlane,
        while (outBufferSize)
        {
                nBytesWritten = freerdp_bitmap_planar_encode_rle_bytes(
-                                   pInput, width, pOutput, outBufferSize);
+                                   pInput, width, pOutput, outBufferSize);
 
                if ((!nBytesWritten) || (nBytesWritten > outBufferSize))
                        return NULL;
@@ -968,7 +968,7 @@ static UINT32 freerdp_bitmap_planar_compress_planes_rle(
                dstSizes[0] = outPlanesSize;
 
                if (!freerdp_bitmap_planar_compress_plane_rle(
-                       inPlanes[0], width, height, outPlanes, &dstSizes[0]))
+                       inPlanes[0], width, height, outPlanes, &dstSizes[0]))
                        return 0;
 
                outPlanes += dstSizes[0];
@@ -979,7 +979,7 @@ static UINT32 freerdp_bitmap_planar_compress_planes_rle(
        dstSizes[1] = outPlanesSize;
 
        if (!freerdp_bitmap_planar_compress_plane_rle(inPlanes[1], width, height,
-               outPlanes, &dstSizes[1]))
+               outPlanes, &dstSizes[1]))
                return 0;
 
        outPlanes += dstSizes[1];
@@ -988,7 +988,7 @@ static UINT32 freerdp_bitmap_planar_compress_planes_rle(
        dstSizes[2] = outPlanesSize;
 
        if (!freerdp_bitmap_planar_compress_plane_rle(inPlanes[2], width, height,
-               outPlanes, &dstSizes[2]))
+               outPlanes, &dstSizes[2]))
                return 0;
 
        outPlanes += dstSizes[2];
@@ -997,7 +997,7 @@ static UINT32 freerdp_bitmap_planar_compress_planes_rle(
        dstSizes[3] = outPlanesSize;
 
        if (!freerdp_bitmap_planar_compress_plane_rle(inPlanes[3], width, height,
-               outPlanes, &dstSizes[3]))
+               outPlanes, &dstSizes[3]))
                return 0;
 
        outPlanes += dstSizes[3];
@@ -1006,8 +1006,8 @@ static UINT32 freerdp_bitmap_planar_compress_planes_rle(
 }
 
 BYTE* freerdp_bitmap_planar_delta_encode_plane(const BYTE* inPlane,
-        UINT32 width, UINT32 height,
-        BYTE* outPlane)
+       UINT32 width, UINT32 height,
+       BYTE* outPlane)
 {
        char s2c;
        INT32 delta;
@@ -1045,15 +1045,15 @@ BYTE* freerdp_bitmap_planar_delta_encode_plane(const BYTE* inPlane,
 }
 
 BOOL freerdp_bitmap_planar_delta_encode_planes(const BYTE** inPlanes,
-        UINT32 width, UINT32 height,
-        BYTE* outPlanes[4])
+       UINT32 width, UINT32 height,
+       BYTE* outPlanes[4])
 {
        UINT32 i;
 
        for (i = 0; i < 4; i++)
        {
                outPlanes[i] = freerdp_bitmap_planar_delta_encode_plane(
-                                  inPlanes[i], width, height, outPlanes[i]);
+                                  inPlanes[i], width, height, outPlanes[i]);
 
                if (!outPlanes[i])
                        return FALSE;
@@ -1063,9 +1063,9 @@ BOOL freerdp_bitmap_planar_delta_encode_planes(const BYTE** inPlanes,
 }
 
 BYTE* freerdp_bitmap_compress_planar(BITMAP_PLANAR_CONTEXT* context,
-                                     const BYTE* data, UINT32 format,
-                                     UINT32 width, UINT32 height, UINT32 scanline,
-                                     BYTE* dstData, UINT32* pDstSize)
+                                    const BYTE* data, UINT32 format,
+                                    UINT32 width, UINT32 height, UINT32 scanline,
+                                    BYTE* dstData, UINT32* pDstSize)
 {
        UINT32 size;
        BYTE* dstp;
@@ -1079,20 +1079,20 @@ BYTE* freerdp_bitmap_compress_planar(BITMAP_PLANAR_CONTEXT* context,
        planeSize = width * height;
 
        if (!freerdp_split_color_planes(data, format, width, height, scanline,
-                                       context->planes))
+                                       context->planes))
                return NULL;
 
        if (context->AllowRunLengthEncoding)
        {
                if (!freerdp_bitmap_planar_delta_encode_planes(
-                       context->planes, width, height,
-                       context->deltaPlanes))
+                       context->planes, width, height,
+                       context->deltaPlanes))
                        return NULL;;
 
                if (freerdp_bitmap_planar_compress_planes_rle(
-                       context->deltaPlanes, width, height,
-                       context->rlePlanesBuffer, dstSizes,
-                       context->AllowSkipAlpha) > 0)
+                       context->deltaPlanes, width, height,
+                       context->rlePlanesBuffer, dstSizes,
+                       context->AllowSkipAlpha) > 0)
                {
                        int offset = 0;
                        FormatHeader |= PLANAR_FORMAT_HEADER_RLE;
@@ -1233,13 +1233,13 @@ BOOL freerdp_bitmap_planar_context_reset(
        context->planes[2] = &context->planesBuffer[context->maxPlaneSize * 2];
        context->planes[3] = &context->planesBuffer[context->maxPlaneSize * 3];
        context->deltaPlanes[0] = &context->deltaPlanesBuffer[context->maxPlaneSize *
-                                 0];
+                                 0];
        context->deltaPlanes[1] = &context->deltaPlanesBuffer[context->maxPlaneSize *
-                                 1];
+                                 1];
        context->deltaPlanes[2] = &context->deltaPlanesBuffer[context->maxPlaneSize *
-                                 2];
+                                 2];
        context->deltaPlanes[3] = &context->deltaPlanesBuffer[context->maxPlaneSize *
-                                 3];
+                                 3];
        return TRUE;
 }