/**

 * FreeRDP: A Remote Desktop Protocol Implementation

 * RemoteFX Codec

 *

 * Copyright 2011 Vic Lee

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

 */

#ifndef FREERDP_CODEC_REMOTEFX_H

#define FREERDP_CODEC_REMOTEFX_H

typedef struct _RFX_RECT RFX_RECT;

typedef struct _RFX_TILE RFX_TILE;

typedef struct _RFX_MESSAGE RFX_MESSAGE;

typedef struct _RFX_CONTEXT RFX_CONTEXT;

#include <freerdp/api.h>

#include <freerdp/types.h>

#include <freerdp/freerdp.h>

#include <freerdp/constants.h>

#include <freerdp/codec/region.h>

#include <winpr/stream.h>

#ifdef __cplusplus

extern "C"

{

#endif

	enum _RLGR_MODE

	{

		RLGR1,

		RLGR3

	};

	typedef enum _RLGR_MODE RLGR_MODE;

	struct _RFX_RECT

	{

		UINT16 x;

		UINT16 y;

		UINT16 width;

		UINT16 height;

	};

	struct _RFX_TILE

	{

		UINT16 x;

		UINT16 y;

		UINT32 width;

		UINT32 height;

		BYTE* data;

		UINT32 scanline;

		BOOL allocated;

		BYTE quantIdxY;

		BYTE quantIdxCb;

		BYTE quantIdxCr;

		UINT16 xIdx;

		UINT16 yIdx;

		UINT16 YLen;

		UINT16 CbLen;

		UINT16 CrLen;

		BYTE* YData;

		BYTE* CbData;

		BYTE* CrData;

		BYTE* YCbCrData;

	};

	struct _RFX_MESSAGE

	{

		UINT32 frameIdx;

		/**

		 * The rects array represents the updated region of the frame. The UI

		 * requires to clip drawing destination base on the union of the rects.

		 */

		UINT16 numRects;

		RFX_RECT* rects;

		BOOL freeRects;

		/**

		 * The tiles array represents the actual frame data. Each tile is always

		 * 64x64. Note that only pixels inside the updated region (represented as

		 * rects described above) are valid. Pixels outside of the region may

		 * contain arbitrary data.

		 */

		UINT16 numTiles;

		RFX_TILE** tiles;

		UINT16 numQuant;

		UINT32* quantVals;

		UINT32 tilesDataSize;

		BOOL freeArray;

	};

	typedef struct _RFX_CONTEXT_PRIV RFX_CONTEXT_PRIV;

	enum _RFX_STATE

	{

		RFX_STATE_INITIAL,

		RFX_STATE_SERVER_UNINITIALIZED,

		RFX_STATE_SEND_HEADERS,

		RFX_STATE_SEND_FRAME_DATA,

		RFX_STATE_FRAME_DATA_SENT,

		RFX_STATE_FINAL

	};

	typedef enum _RFX_STATE RFX_STATE;

#define _RFX_DECODED_SYNC 0x00000001

#define _RFX_DECODED_CONTEXT 0x00000002

#define _RFX_DECODED_VERSIONS 0x00000004

#define _RFX_DECODED_CHANNELS 0x00000008

#define _RFX_DECODED_HEADERS 0x0000000F

	struct _RFX_CONTEXT

	{

		RFX_STATE state;

		BOOL encoder;

		UINT16 flags;

		UINT16 properties;

		UINT16 width;

		UINT16 height;

		RLGR_MODE mode;

		UINT32 version;

		UINT32 codec_id;

		UINT32 codec_version;

		UINT32 pixel_format;

		BYTE bits_per_pixel;

		/* color palette allocated by the application */

		const BYTE* palette;

		/* temporary data within a frame */

		UINT32 frameIdx;

		BYTE numQuant;

		UINT32* quants;

		BYTE quantIdxY;

		BYTE quantIdxCb;

		BYTE quantIdxCr;

		/* decoded header blocks */

		UINT32 decodedHeaderBlocks;

		UINT16 expectedDataBlockType;

		RFX_MESSAGE currentMessage;

		/* routines */

		void (*quantization_decode)(INT16* buffer, const UINT32* quantization_values);

		void (*quantization_encode)(INT16* buffer, const UINT32* quantization_values);

		void (*dwt_2d_decode)(INT16* buffer, INT16* dwt_buffer);

		void (*dwt_2d_encode)(INT16* buffer, INT16* dwt_buffer);

		int (*rlgr_decode)(RLGR_MODE mode, const BYTE* data, UINT32 data_size, INT16* buffer,

		                   UINT32 buffer_size);

		int (*rlgr_encode)(RLGR_MODE mode, const INT16* data, UINT32 data_size, BYTE* buffer,

		                   UINT32 buffer_size);

		/* private definitions */

		RFX_CONTEXT_PRIV* priv;

	};

	FREERDP_API void rfx_context_set_pixel_format(RFX_CONTEXT* context, UINT32 pixel_format);

	FREERDP_API BOOL rfx_process_message(RFX_CONTEXT* context, const BYTE* data, UINT32 length,

	                                     UINT32 left, UINT32 top, BYTE* dst, UINT32 dstFormat,

	                                     UINT32 dstStride, UINT32 dstHeight,

	                                     REGION16* invalidRegion);

	FREERDP_API UINT16 rfx_message_get_tile_count(RFX_MESSAGE* message);

	FREERDP_API UINT16 rfx_message_get_rect_count(RFX_MESSAGE* message);

	FREERDP_API void rfx_message_free(RFX_CONTEXT* context, RFX_MESSAGE* message);

	FREERDP_API BOOL rfx_compose_message(RFX_CONTEXT* context, wStream* s, const RFX_RECT* rects,

	                                     int num_rects, BYTE* image_data, int width, int height,

	                                     int rowstride);

	FREERDP_API RFX_MESSAGE* rfx_encode_message(RFX_CONTEXT* context, const RFX_RECT* rects,

	                                            int numRects, BYTE* data, int width, int height,

	                                            int scanline);

	FREERDP_API RFX_MESSAGE* rfx_encode_messages(RFX_CONTEXT* context, const RFX_RECT* rects,

	                                             int numRects, BYTE* data, int width, int height,

	                                             int scanline, int* numMessages, int maxDataSize);

	FREERDP_API BOOL rfx_write_message(RFX_CONTEXT* context, wStream* s, RFX_MESSAGE* message);

	FREERDP_API BOOL rfx_context_reset(RFX_CONTEXT* context, UINT32 width, UINT32 height);

	FREERDP_API RFX_CONTEXT* rfx_context_new(BOOL encoder);

	FREERDP_API void rfx_context_free(RFX_CONTEXT* context);

#ifdef __cplusplus

}

#endif

#endif /* FREERDP_CODEC_REMOTEFX_H */