/**

 * FreeRDP: A Remote Desktop Protocol Implementation

 * ClearCodec Bitmap Compression

 *

 * Copyright 2014 Marc-Andre Moreau <marcandre.moreau@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.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <winpr/crt.h>

#include <winpr/print.h>

#include <winpr/bitstream.h>

#include <freerdp/codec/color.h>

#include <freerdp/codec/clear.h>

#include <freerdp/log.h>

#define TAG FREERDP_TAG("codec.clear")

#define CLEARCODEC_FLAG_GLYPH_INDEX	0x01

#define CLEARCODEC_FLAG_GLYPH_HIT	0x02

#define CLEARCODEC_FLAG_CACHE_RESET	0x04

#define CLEARCODEC_VBAR_SIZE 32768

#define CLEARCODEC_VBAR_SHORT_SIZE 16384

struct _CLEAR_GLYPH_ENTRY

{

	UINT32 size;

	UINT32 count;

	UINT32* pixels;

};

typedef struct _CLEAR_GLYPH_ENTRY CLEAR_GLYPH_ENTRY;

struct _CLEAR_VBAR_ENTRY

{

	UINT32 size;

	UINT32 count;

	BYTE* pixels;

};

typedef struct _CLEAR_VBAR_ENTRY CLEAR_VBAR_ENTRY;

struct _CLEAR_CONTEXT

{

	BOOL Compressor;

	NSC_CONTEXT* nsc;

	UINT32 seqNumber;

	BYTE* TempBuffer;

	UINT32 TempSize;

	UINT32 nTempStep;

	UINT32 TempFormat;

	UINT32 format;

	CLEAR_GLYPH_ENTRY GlyphCache[4000];

	UINT32 VBarStorageCursor;

	CLEAR_VBAR_ENTRY VBarStorage[CLEARCODEC_VBAR_SIZE];

	UINT32 ShortVBarStorageCursor;

	CLEAR_VBAR_ENTRY ShortVBarStorage[CLEARCODEC_VBAR_SHORT_SIZE];

};

static const UINT32 CLEAR_LOG2_FLOOR[256] =

{

	0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,

	4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,

	5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,

	5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,

	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,

	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,

	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,

	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,

	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,

	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,

	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,

	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,

	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,

	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,

	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,

	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7

};

static const BYTE CLEAR_8BIT_MASKS[9] =

{

	0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF

};

static BOOL convert_color(BYTE* dst, UINT32 nDstStep, UINT32 DstFormat,

                          UINT32 nXDst, UINT32 nYDst, UINT32 nWidth, UINT32 nHeight,

                          const BYTE* src, UINT32 nSrcStep, UINT32 SrcFormat,

                          UINT32 nDstWidth, UINT32 nDstHeight, const gdiPalette* palette)

{

	if (nWidth + nXDst > nDstWidth)

		nWidth = nDstWidth - nXDst;

	if (nHeight + nYDst > nDstHeight)

		nHeight = nDstHeight - nYDst;

	return freerdp_image_copy(dst, DstFormat, nDstStep, nXDst, nYDst, nWidth, nHeight,

	                          src, SrcFormat, nSrcStep, 0, 0, palette, 0);

}

static BOOL clear_decompress_nscodec(NSC_CONTEXT* nsc, UINT32 width,

                                     UINT32 height,

                                     wStream* s, UINT32 bitmapDataByteCount,

                                     BYTE* pDstData, UINT32 DstFormat, UINT32 nDstStep,

                                     UINT32 nXDstRel, UINT32 nYDstRel)

{

	BOOL rc;

	if (Stream_GetRemainingLength(s) < bitmapDataByteCount)

	{

		WLog_ERR(TAG, "stream short %"PRIuz" [%"PRIu32" expected]", Stream_GetRemainingLength(s),

		         bitmapDataByteCount);

		return FALSE;

	}

	rc = nsc_process_message(nsc, 32, width, height, Stream_Pointer(s),

	                         bitmapDataByteCount, pDstData, DstFormat,

	                         nDstStep, nXDstRel, nYDstRel, width, height, FREERDP_FLIP_NONE);

	Stream_Seek(s, bitmapDataByteCount);

	return rc;

}

static BOOL clear_decompress_subcode_rlex(wStream* s,

        UINT32 bitmapDataByteCount,

        UINT32 width, UINT32 height,

        BYTE* pDstData, UINT32 DstFormat, UINT32 nDstStep,

        UINT32 nXDstRel, UINT32 nYDstRel, UINT32 nDstWidth, UINT32 nDstHeight)

{

	UINT32 x = 0, y = 0;

	UINT32 i;

	UINT32 pixelCount;

	UINT32 bitmapDataOffset;

	UINT32 pixelIndex;

	UINT32 numBits;

	BYTE startIndex;

	BYTE stopIndex;

	BYTE suiteIndex;

	BYTE suiteDepth;

	BYTE paletteCount;

	UINT32 palette[128] = { 0 };

	if (Stream_GetRemainingLength(s) < bitmapDataByteCount)

	{

		WLog_ERR(TAG, "stream short %"PRIuz" [%"PRIu32" expected]", Stream_GetRemainingLength(s),

		         bitmapDataByteCount);

		return FALSE;

	}

	Stream_Read_UINT8(s, paletteCount);

	bitmapDataOffset = 1 + (paletteCount * 3);

	if (paletteCount > 127)

	{

		WLog_ERR(TAG, "paletteCount %"PRIu8"", paletteCount);

		return FALSE;

	}

	for (i = 0; i < paletteCount; i++)

	{

		BYTE r, g, b;

		Stream_Read_UINT8(s, b);

		Stream_Read_UINT8(s, g);

		Stream_Read_UINT8(s, r);

		palette[i] = FreeRDPGetColor(DstFormat, r, g, b, 0xFF);

	}

	pixelIndex = 0;

	pixelCount = width * height;

	numBits = CLEAR_LOG2_FLOOR[paletteCount - 1] + 1;

	while (bitmapDataOffset < bitmapDataByteCount)

	{

		UINT32 tmp;

		UINT32 color;

		UINT32 runLengthFactor;

		if (Stream_GetRemainingLength(s) < 2)

		{

			WLog_ERR(TAG, "stream short %"PRIuz" [2 expected]", Stream_GetRemainingLength(s));

			return FALSE;

		}

		Stream_Read_UINT8(s, tmp);

		Stream_Read_UINT8(s, runLengthFactor);

		bitmapDataOffset += 2;

		suiteDepth = (tmp >> numBits) & CLEAR_8BIT_MASKS[(8 - numBits)];

		stopIndex = tmp & CLEAR_8BIT_MASKS[numBits];

		startIndex = stopIndex - suiteDepth;

		if (runLengthFactor >= 0xFF)

		{

			if (Stream_GetRemainingLength(s) < 2)

			{

				WLog_ERR(TAG, "stream short %"PRIuz" [2 expected]", Stream_GetRemainingLength(s));

				return FALSE;

			}

			Stream_Read_UINT16(s, runLengthFactor);

			bitmapDataOffset += 2;

			if (runLengthFactor >= 0xFFFF)

			{

				if (Stream_GetRemainingLength(s) < 4)

				{

					WLog_ERR(TAG, "stream short %"PRIuz" [4 expected]", Stream_GetRemainingLength(s));

					return FALSE;

				}

				Stream_Read_UINT32(s, runLengthFactor);

				bitmapDataOffset += 4;

			}

		}

		if (startIndex >= paletteCount)

		{

			WLog_ERR(TAG, "startIndex %"PRIu8" > paletteCount %"PRIu8"]", startIndex, paletteCount);

			return FALSE;

		}

		if (stopIndex >= paletteCount)

		{

			WLog_ERR(TAG, "stopIndex %"PRIu8" > paletteCount %"PRIu8"]", stopIndex, paletteCount);

			return FALSE;

		}

		suiteIndex = startIndex;

		if (suiteIndex > 127)

		{

			WLog_ERR(TAG, "suiteIndex %"PRIu8" > 127]", suiteIndex);

			return FALSE;

		}

		color = palette[suiteIndex];

		if ((pixelIndex + runLengthFactor) > pixelCount)

		{

			WLog_ERR(TAG, "pixelIndex %"PRIu32" + runLengthFactor %"PRIu32" > pixelCount %"PRIu32"",

			         pixelIndex, runLengthFactor,

			         pixelCount);

			return FALSE;

		}

		for (i = 0; i < runLengthFactor; i++)

		{

			BYTE* pTmpData = &pDstData[(nXDstRel + x) * GetBytesPerPixel(DstFormat) +

			                                          (nYDstRel + y) * nDstStep];

			if ((nXDstRel + x < nDstWidth) && (nYDstRel + y < nDstHeight))

				WriteColor(pTmpData, DstFormat, color);

			if (++x >= width)

			{

				y++;

				x = 0;

			}

		}

		pixelIndex += runLengthFactor;

		if ((pixelIndex + (suiteDepth + 1)) > pixelCount)

		{

			WLog_ERR(TAG, "pixelIndex %"PRIu32" + suiteDepth %"PRIu8" + 1 > pixelCount %"PRIu32"",

			         pixelIndex, suiteDepth,

			         pixelCount);

			return FALSE;

		}

		for (i = 0; i <= suiteDepth; i++)

		{

			BYTE* pTmpData = &pDstData[(nXDstRel + x) * GetBytesPerPixel(DstFormat) +

			                                          (nYDstRel + y) * nDstStep];

			UINT32 color = palette[suiteIndex];

			if (suiteIndex > 127)

			{

				WLog_ERR(TAG, "suiteIndex %"PRIu8" > 127", suiteIndex);

				return FALSE;

			}

			suiteIndex++;

			if ((nXDstRel + x < nDstWidth) && (nYDstRel + y < nDstHeight))

				WriteColor(pTmpData, DstFormat, color);

			if (++x >= width)

			{

				y++;

				x = 0;

			}

		}

		pixelIndex += (suiteDepth + 1);

	}

	if (pixelIndex != pixelCount)

	{

		WLog_ERR(TAG, "pixelIndex %"PRIu32" != pixelCount %"PRIu32"", pixelIndex, pixelCount);

		return FALSE;

	}

	return TRUE;

}

static BOOL clear_resize_buffer(CLEAR_CONTEXT* clear, UINT32 width, UINT32 height)

{

	UINT32 size;

	if (!clear)

		return FALSE;

	size = ((width + 16) * (height + 16) * GetBytesPerPixel(clear->format));

	if (size > clear->TempSize)

	{

		BYTE* tmp = (BYTE*) realloc(clear->TempBuffer, size);

		if (!tmp)

		{

			WLog_ERR(TAG, "clear->TempBuffer realloc failed for %"PRIu32" bytes",

			         size);

			return FALSE;

		}

		clear->TempSize = size;

		clear->TempBuffer = tmp;

	}

	return TRUE;

}

static BOOL clear_decompress_residual_data(CLEAR_CONTEXT* clear,

        wStream* s,

        UINT32 residualByteCount,

        UINT32 nWidth, UINT32 nHeight,

        BYTE* pDstData, UINT32 DstFormat, UINT32 nDstStep,

        UINT32 nXDst, UINT32 nYDst,

        UINT32 nDstWidth, UINT32 nDstHeight,

        const gdiPalette* palette)

{

	UINT32 i;

	UINT32 nSrcStep;

	UINT32 suboffset;

	BYTE* dstBuffer;

	UINT32 pixelIndex;

	UINT32 pixelCount;

	if (Stream_GetRemainingLength(s) < residualByteCount)

	{

		WLog_ERR(TAG, "stream short %"PRIuz" [%"PRIu32" expected]", Stream_GetRemainingLength(s),

		         residualByteCount);

		return FALSE;

	}

	suboffset = 0;

	pixelIndex = 0;

	pixelCount = nWidth * nHeight;

	if (!clear_resize_buffer(clear, nWidth, nHeight))

		return FALSE;

	dstBuffer = clear->TempBuffer;

	while (suboffset < residualByteCount)

	{

		BYTE r, g, b;

		UINT32 runLengthFactor;

		UINT32 color;

		if (Stream_GetRemainingLength(s) < 4)

		{

			WLog_ERR(TAG, "stream short %"PRIuz" [4 expected]", Stream_GetRemainingLength(s));

			return FALSE;

		}

		Stream_Read_UINT8(s, b);

		Stream_Read_UINT8(s, g);

		Stream_Read_UINT8(s, r);

		Stream_Read_UINT8(s, runLengthFactor);

		suboffset += 4;

		color = FreeRDPGetColor(clear->format, r, g, b, 0xFF);

		if (runLengthFactor >= 0xFF)

		{

			if (Stream_GetRemainingLength(s) < 2)

			{

				WLog_ERR(TAG, "stream short %"PRIuz" [2 expected]", Stream_GetRemainingLength(s));

				return FALSE;

			}

			Stream_Read_UINT16(s, runLengthFactor);

			suboffset += 2;

			if (runLengthFactor >= 0xFFFF)

			{

				if (Stream_GetRemainingLength(s) < 4)

				{

					WLog_ERR(TAG, "stream short %"PRIuz" [4 expected]", Stream_GetRemainingLength(s));

					return FALSE;

				}

				Stream_Read_UINT32(s, runLengthFactor);

				suboffset += 4;

			}

		}

		if ((pixelIndex + runLengthFactor) > pixelCount)

		{

			WLog_ERR(TAG, "pixelIndex %"PRIu32" + runLengthFactor %"PRIu32" > pixelCount %"PRIu32"",

			         pixelIndex, runLengthFactor,

			         pixelCount);

			return FALSE;

		}

		for (i = 0; i < runLengthFactor; i++)

		{

			WriteColor(dstBuffer, clear->format, color);

			dstBuffer += GetBytesPerPixel(clear->format);

		}

		pixelIndex += runLengthFactor;

	}

	nSrcStep = nWidth * GetBytesPerPixel(clear->format);

	if (pixelIndex != pixelCount)

	{

		WLog_ERR(TAG, "pixelIndex %"PRIu32" != pixelCount %"PRIu32"", pixelIndex, pixelCount);

		return FALSE;

	}

	return convert_color(pDstData, nDstStep, DstFormat,

	                     nXDst, nYDst, nWidth, nHeight,

	                     clear->TempBuffer, nSrcStep, clear->format,

	                     nDstWidth, nDstHeight, palette);

}

static BOOL clear_decompress_subcodecs_data(CLEAR_CONTEXT* clear, wStream* s,

        UINT32 subcodecByteCount, UINT32 nWidth, UINT32 nHeight,

        BYTE* pDstData, UINT32 DstFormat, UINT32 nDstStep,

        UINT32 nXDst, UINT32 nYDst, UINT32 nDstWidth, UINT32 nDstHeight,

        const gdiPalette* palette)

{

	UINT16 xStart;

	UINT16 yStart;

	UINT16 width;

	UINT16 height;

	UINT32 bitmapDataByteCount;

	BYTE subcodecId;

	UINT32 suboffset;

	if (Stream_GetRemainingLength(s) < subcodecByteCount)

	{

		WLog_ERR(TAG, "stream short %"PRIuz" [%"PRIu32" expected]", Stream_GetRemainingLength(s),

		         subcodecByteCount);

		return FALSE;

	}

	suboffset = 0;

	while (suboffset < subcodecByteCount)

	{

		UINT32 nXDstRel;

		UINT32 nYDstRel;

		if (Stream_GetRemainingLength(s) < 13)

		{

			WLog_ERR(TAG, "stream short %"PRIuz" [13 expected]", Stream_GetRemainingLength(s));

			return FALSE;

		}

		Stream_Read_UINT16(s, xStart);

		Stream_Read_UINT16(s, yStart);

		Stream_Read_UINT16(s, width);

		Stream_Read_UINT16(s, height);

		Stream_Read_UINT32(s, bitmapDataByteCount);

		Stream_Read_UINT8(s, subcodecId);

		suboffset += 13;

		if (Stream_GetRemainingLength(s) < bitmapDataByteCount)

		{

			WLog_ERR(TAG, "stream short %"PRIuz" [%"PRIu32" expected]", Stream_GetRemainingLength(s),

			         bitmapDataByteCount);

			return FALSE;

		}

		nXDstRel = nXDst + xStart;

		nYDstRel = nYDst + yStart;

		if (width > nWidth)

		{

			WLog_ERR(TAG, "width %"PRIu16" > nWidth %"PRIu32"", width, nWidth);

			return FALSE;

		}

		if (height > nHeight)

		{

			WLog_ERR(TAG, "height %"PRIu16" > nHeight %"PRIu32"", height, nHeight);

			return FALSE;

		}

		if (!clear_resize_buffer(clear, width, height))

			return FALSE;

		switch (subcodecId)

		{

			case 0: /* Uncompressed */

				{

					UINT32 nSrcStep = width * GetBytesPerPixel(PIXEL_FORMAT_BGR24);

					UINT32 nSrcSize = nSrcStep * height;

					if (bitmapDataByteCount != nSrcSize)

					{

						WLog_ERR(TAG, "bitmapDataByteCount %"PRIu32" != nSrcSize %"PRIu32"", bitmapDataByteCount,

						         nSrcSize);

						return FALSE;

					}

					if (!convert_color(pDstData, nDstStep, DstFormat,

					                   nXDstRel, nYDstRel, width, height,

					                   Stream_Pointer(s), nSrcStep,

					                   PIXEL_FORMAT_BGR24,

					                   nDstWidth, nDstHeight, palette))

						return FALSE;

					Stream_Seek(s, bitmapDataByteCount);

				}

				break;

			case 1: /* NSCodec */

				if (!clear_decompress_nscodec(clear->nsc, width, height,

				                              s, bitmapDataByteCount,

				                              pDstData, DstFormat, nDstStep,

				                              nXDstRel, nYDstRel))

					return FALSE;

				break;

			case 2: /* CLEARCODEC_SUBCODEC_RLEX */

				if (!clear_decompress_subcode_rlex(s,

				                                   bitmapDataByteCount,

				                                   width, height,

				                                   pDstData, DstFormat, nDstStep,

				                                   nXDstRel, nYDstRel,

				                                   nDstWidth, nDstHeight))

					return FALSE;

				break;

			default:

				WLog_ERR(TAG, "Unknown subcodec ID %"PRIu8"", subcodecId);

				return FALSE;

		}

		suboffset += bitmapDataByteCount;

	}

	return TRUE;

}

static BOOL resize_vbar_entry(CLEAR_CONTEXT* clear, CLEAR_VBAR_ENTRY* vBarEntry)

{

	if (vBarEntry->count > vBarEntry->size)

	{

		const UINT32 bpp = GetBytesPerPixel(clear->format);

		const UINT32 oldPos = vBarEntry->size * bpp;

		const UINT32 diffSize = (vBarEntry->count - vBarEntry->size) * bpp;

		BYTE* tmp;

		vBarEntry->size = vBarEntry->count;

		tmp = (BYTE*) realloc(vBarEntry->pixels,

		                      vBarEntry->count * bpp);

		if (!tmp)

		{

			WLog_ERR(TAG, "vBarEntry->pixels realloc %"PRIu32" failed", vBarEntry->count * bpp);

			return FALSE;

		}

		memset(&tmp[oldPos], 0, diffSize);

		vBarEntry->pixels = tmp;

	}

	if (!vBarEntry->pixels && vBarEntry->size)

	{

		WLog_ERR(TAG, "vBarEntry->pixels is NULL but vBarEntry->size is %"PRIu32"",

		         vBarEntry->size);

		return FALSE;

	}

	return TRUE;

}

static BOOL clear_decompress_bands_data(CLEAR_CONTEXT* clear,

                                        wStream* s, UINT32 bandsByteCount,

                                        UINT32 nWidth, UINT32 nHeight,

                                        BYTE* pDstData, UINT32 DstFormat, UINT32 nDstStep,

                                        UINT32 nXDst, UINT32 nYDst)

{

	UINT32 i, y;

	UINT32 count;

	UINT32 suboffset;

	UINT32 nXDstRel;

	UINT32 nYDstRel;

	if (Stream_GetRemainingLength(s) < bandsByteCount)

	{

		WLog_ERR(TAG, "stream short %"PRIuz" [11 expected]", Stream_GetRemainingLength(s));

		return FALSE;

	}

	suboffset = 0;

	while (suboffset < bandsByteCount)

	{

		BYTE r, g, b;

		UINT16 xStart;

		UINT16 xEnd;

		UINT16 yStart;

		UINT16 yEnd;

		UINT32 colorBkg;

		UINT16 vBarHeader;

		UINT16 vBarYOn;

		UINT16 vBarYOff;

		UINT32 vBarCount;

		UINT32 vBarPixelCount;

		UINT32 vBarShortPixelCount;

		if (Stream_GetRemainingLength(s) < 11)

		{

			WLog_ERR(TAG, "stream short %"PRIuz" [11 expected]", Stream_GetRemainingLength(s));

			return FALSE;

		}

		Stream_Read_UINT16(s, xStart);

		Stream_Read_UINT16(s, xEnd);

		Stream_Read_UINT16(s, yStart);

		Stream_Read_UINT16(s, yEnd);

		Stream_Read_UINT8(s, b);

		Stream_Read_UINT8(s, g);

		Stream_Read_UINT8(s, r);

		suboffset += 11;

		colorBkg = FreeRDPGetColor(clear->format, r, g, b, 0xFF);

		if (xEnd < xStart)

		{

			WLog_ERR(TAG, "xEnd %"PRIu16" < xStart %"PRIu16"", xEnd, xStart);

			return FALSE;

		}

		if (yEnd < yStart)

		{

			WLog_ERR(TAG, "yEnd %"PRIu16" < yStart %"PRIu16"", yEnd, yStart);

			return FALSE;

		}

		vBarCount = (xEnd - xStart) + 1;

		for (i = 0; i < vBarCount; i++)

		{

			UINT32 vBarHeight;

			CLEAR_VBAR_ENTRY* vBarEntry = NULL;

			CLEAR_VBAR_ENTRY* vBarShortEntry;

			BOOL vBarUpdate = FALSE;

			const BYTE* pSrcPixel;

			if (Stream_GetRemainingLength(s) < 2)

			{

				WLog_ERR(TAG, "stream short %"PRIuz" [2 expected]", Stream_GetRemainingLength(s));

				return FALSE;

			}

			Stream_Read_UINT16(s, vBarHeader);

			suboffset += 2;

			vBarHeight = (yEnd - yStart + 1);

			if (vBarHeight > 52)

			{

				WLog_ERR(TAG, "vBarHeight (%"PRIu32") > 52", vBarHeight);

				return FALSE;

			}

			if ((vBarHeader & 0xC000) == 0x4000) /* SHORT_VBAR_CACHE_HIT */

			{

				const UINT16 vBarIndex = (vBarHeader & 0x3FFF);

				vBarShortEntry = &(clear->ShortVBarStorage[vBarIndex]);

				if (!vBarShortEntry)

				{

					WLog_ERR(TAG, "missing vBarShortEntry %"PRIu16"", vBarIndex);

					return FALSE;

				}

				if (Stream_GetRemainingLength(s) < 1)

				{

					WLog_ERR(TAG, "stream short %"PRIuz" [1 expected]", Stream_GetRemainingLength(s));

					return FALSE;

				}

				Stream_Read_UINT8(s, vBarYOn);

				suboffset += 1;

				vBarShortPixelCount = vBarShortEntry->count;

				vBarUpdate = TRUE;

			}

			else if ((vBarHeader & 0xC000) == 0x0000) /* SHORT_VBAR_CACHE_MISS */

			{

				vBarYOn = (vBarHeader & 0xFF);

				vBarYOff = ((vBarHeader >> 8) & 0x3F);

				if (vBarYOff < vBarYOn)

				{

					WLog_ERR(TAG, "vBarYOff %"PRIu16" < vBarYOn %"PRIu16"", vBarYOff, vBarYOn);

					return FALSE;

				}

				vBarShortPixelCount = (vBarYOff - vBarYOn);

				if (vBarShortPixelCount > 52)

				{

					WLog_ERR(TAG, "vBarShortPixelCount %"PRIu32" > 52", vBarShortPixelCount);

					return FALSE;

				}

				if (Stream_GetRemainingLength(s) < (vBarShortPixelCount * 3))

				{

					WLog_ERR(TAG, "stream short %"PRIuz" [%"PRIu32" expected]", Stream_GetRemainingLength(s),

					         (vBarShortPixelCount * 3));

					return FALSE;

				}

				if (clear->ShortVBarStorageCursor >= CLEARCODEC_VBAR_SHORT_SIZE)

				{

					WLog_ERR(TAG,

					         "clear->ShortVBarStorageCursor %"PRIu32" >= CLEARCODEC_VBAR_SHORT_SIZE (%"PRIu32")",

					         clear->ShortVBarStorageCursor, CLEARCODEC_VBAR_SHORT_SIZE);

					return FALSE;

				}

				vBarShortEntry = &(clear->ShortVBarStorage[clear->ShortVBarStorageCursor]);

				vBarShortEntry->count = vBarShortPixelCount;

				if (!resize_vbar_entry(clear, vBarShortEntry))

					return FALSE;

				for (y = 0; y < vBarShortPixelCount; y++)

				{

					BYTE r, g, b;

					BYTE* dstBuffer =

					    &vBarShortEntry->pixels[y * GetBytesPerPixel(clear->format)];

					UINT32 color;

					Stream_Read_UINT8(s, b);

					Stream_Read_UINT8(s, g);

					Stream_Read_UINT8(s, r);

					color = FreeRDPGetColor(clear->format, r, g, b, 0xFF);

					if (!WriteColor(dstBuffer, clear->format, color))

						return FALSE;

				}

				suboffset += (vBarShortPixelCount * 3);

				clear->ShortVBarStorageCursor =

				    (clear->ShortVBarStorageCursor + 1) % CLEARCODEC_VBAR_SHORT_SIZE;

				vBarUpdate = TRUE;

			}

			else if ((vBarHeader & 0x8000) == 0x8000) /* VBAR_CACHE_HIT */

			{

				const UINT16 vBarIndex = (vBarHeader & 0x7FFF);

				vBarEntry = &(clear->VBarStorage[vBarIndex]);

				/* If the cache was reset we need to fill in some dummy data. */

				if (vBarEntry->size == 0)

				{

					WLog_WARN(TAG, "Empty cache index %"PRIu16", filling dummy data", vBarIndex);

					vBarEntry->count = vBarHeight;

					if (!resize_vbar_entry(clear, vBarEntry))

						return FALSE;

				}

			}

			else

			{

				WLog_ERR(TAG, "invalid vBarHeader 0x%04"PRIX16"", vBarHeader);

				return FALSE; /* invalid vBarHeader */

			}

			if (vBarUpdate)

			{

				UINT32 x;

				BYTE* pSrcPixel;

				BYTE* dstBuffer;

				if (clear->VBarStorageCursor >= CLEARCODEC_VBAR_SIZE)

				{

					WLog_ERR(TAG, "clear->VBarStorageCursor %"PRIu32" >= CLEARCODEC_VBAR_SIZE %"PRIu32"",

					         clear->VBarStorageCursor,

					         CLEARCODEC_VBAR_SIZE);

					return FALSE;

				}

				vBarEntry = &(clear->VBarStorage[clear->VBarStorageCursor]);

				vBarPixelCount = vBarHeight;

				vBarEntry->count = vBarPixelCount;

				if (!resize_vbar_entry(clear, vBarEntry))

					return FALSE;

				dstBuffer = vBarEntry->pixels;

				/* if (y < vBarYOn), use colorBkg */

				y = 0;

				count = vBarYOn;

				if ((y + count) > vBarPixelCount)

					count = (vBarPixelCount > y) ? (vBarPixelCount - y) : 0;

				while (count--)

				{

					WriteColor(dstBuffer, clear->format, colorBkg);

					dstBuffer += GetBytesPerPixel(clear->format);

				}

				/*

				 * if ((y >= vBarYOn) && (y < (vBarYOn + vBarShortPixelCount))),

				 * use vBarShortPixels at index (y - shortVBarYOn)

				 */

				y = vBarYOn;

				count = vBarShortPixelCount;

				if ((y + count) > vBarPixelCount)

					count = (vBarPixelCount > y) ? (vBarPixelCount - y) : 0;

				pSrcPixel = &vBarShortEntry->pixels[(y - vBarYOn) * GetBytesPerPixel(

				                                                      clear->format)];

				for (x = 0; x < count; x++)

				{

					UINT32 color;

					color =	ReadColor(&pSrcPixel[x * GetBytesPerPixel(clear->format)],

					                  clear->format);

					if (!WriteColor(dstBuffer, clear->format, color))

						return FALSE;

					dstBuffer += GetBytesPerPixel(clear->format);

				}

				/* if (y >= (vBarYOn + vBarShortPixelCount)), use colorBkg */

				y = vBarYOn + vBarShortPixelCount;

				count = (vBarPixelCount > y) ? (vBarPixelCount - y) : 0;

				while (count--)

				{

					if (!WriteColor(dstBuffer, clear->format, colorBkg))

						return FALSE;

					dstBuffer += GetBytesPerPixel(clear->format);

				}

				vBarEntry->count = vBarPixelCount;

				clear->VBarStorageCursor = (clear->VBarStorageCursor + 1) %

				                           CLEARCODEC_VBAR_SIZE;

			}

			if (vBarEntry->count != vBarHeight)

			{

				WLog_ERR(TAG, "vBarEntry->count %"PRIu32" != vBarHeight %"PRIu32"", vBarEntry->count,

				         vBarHeight);