#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <poll.h>
#include <errno.h>
#include <pthread.h>

#include "sample_comm.h"
#include "loadbmp.h"

#define OverlayMinHandle 0
#define OverlayExMinHandle 20
#define CoverMinHandle 40
#define CoverExMinHandle 60
#define MosaicMinHandle 80
#define OdecHandle 100

RGN_RGBQUARD_S overlay_palette[256];
CVI_S32 SAMPLE_COMM_REGION_MST_LoadBmp(const char *filename, BITMAP_S *pstBitmap, CVI_BOOL bFil,
			CVI_U32 u16FilColor, PIXEL_FORMAT_E enPixelFormat)
{
	OSD_SURFACE_S Surface;
	OSD_BITMAPFILEHEADER bmpFileHeader;
	OSD_BITMAPINFO bmpInfo;
	CVI_S32 Bpp;
	CVI_U32 nColors;
	CVI_U32 i, u32PdataSize;

	if (GetBmpInfo(filename, &bmpFileHeader, &bmpInfo) < 0) {
		printf("GetBmpInfo err!\n");
		return CVI_FAILURE;
	}
	Bpp = bmpInfo.bmiHeader.biBitCount/8;
	nColors = 0;
	if (Bpp == 1) {
		if (bmpInfo.bmiHeader.biClrUsed == 0)
			nColors = 1 << bmpInfo.bmiHeader.biBitCount;
		else
			nColors = bmpInfo.bmiHeader.biClrUsed;

		if (nColors > 256) {
			printf("Number of indexed palette is over 256.");
			return CVI_FAILURE;
		}

		/* Create the palette */
		for (i = 0; i < nColors; i++) {
			overlay_palette[i].argbAlpha = bmpInfo.bmiColors[i].rgbReserved;
			overlay_palette[i].argbRed = bmpInfo.bmiColors[i].rgbRed;
			overlay_palette[i].argbGreen = bmpInfo.bmiColors[i].rgbGreen;
			overlay_palette[i].argbBlue = bmpInfo.bmiColors[i].rgbBlue;
#ifdef _SAMPLE_COMMON_REGION_DEBUG_
			CVI_U32 u32Pixel =
				((overlay_palette[i].argbBlue | overlay_palette[i].argbGreen << 8) |
				(overlay_palette[i].argbRed << 16 | overlay_palette[i].argbAlpha << 24));
			printf("overlay_palette index(%d) (0x%x).\n", i, u32Pixel);
#endif
		}
	}

	if (enPixelFormat == PIXEL_FORMAT_ARGB_4444) {
		Surface.enColorFmt = OSD_COLOR_FMT_RGB4444;
	} else if (enPixelFormat == PIXEL_FORMAT_ARGB_1555) {
		Surface.enColorFmt = OSD_COLOR_FMT_RGB1555;
	} else if (enPixelFormat == PIXEL_FORMAT_ARGB_8888) {
		Surface.enColorFmt = OSD_COLOR_FMT_RGB8888;
	} else if (enPixelFormat == PIXEL_FORMAT_8BIT_MODE) {
		Surface.enColorFmt = OSD_COLOR_FMT_8BIT_MODE;
	} else {
		printf("enPixelFormat err %d\n", enPixelFormat);
		return CVI_FAILURE;
	}

	u32PdataSize = Bpp * (bmpInfo.bmiHeader.biWidth) * (bmpInfo.bmiHeader.biHeight);
	pstBitmap->pData = malloc(u32PdataSize);
	if (pstBitmap->pData == NULL) {
		printf("malloc osd memory err!\n");
		return CVI_FAILURE;
	}

	CreateSurfaceByBitMap(filename, &Surface, (CVI_U8 *)(pstBitmap->pData));

	pstBitmap->u32Width = Surface.u16Width;
	pstBitmap->u32Height = Surface.u16Height;
	pstBitmap->enPixelFormat = enPixelFormat;

	if (bFil) {
		CVI_U32 i, j;
		CVI_U16 *pu16Temp;

		pu16Temp = (CVI_U16 *)pstBitmap->pData;
		for (i = 0; i < pstBitmap->u32Height; i++) {
			for (j = 0; j < pstBitmap->u32Width; j++) {
				if (u16FilColor == *pu16Temp) {
					*pu16Temp &= 0x7FFF;
				}

				pu16Temp++;
			}
		}
	}

	return CVI_SUCCESS;
}

CVI_S32 SAMPLE_COMM_REGION_MST_UpdateCanvas(const char *filename, BITMAP_S *pstBitmap, CVI_BOOL bFil,
				CVI_U32 u16FilColor, SIZE_S *pstSize, CVI_U32 u32Stride, PIXEL_FORMAT_E enPixelFormat)
{
	OSD_SURFACE_S Surface;
	OSD_BITMAPFILEHEADER bmpFileHeader;
	OSD_BITMAPINFO bmpInfo;

	if (GetBmpInfo(filename, &bmpFileHeader, &bmpInfo) < 0) {
		printf("GetBmpInfo err!\n");
		return CVI_FAILURE;
	}

	if (enPixelFormat == PIXEL_FORMAT_ARGB_1555) {
		Surface.enColorFmt = OSD_COLOR_FMT_RGB1555;
	} else if (enPixelFormat == PIXEL_FORMAT_ARGB_4444) {
		Surface.enColorFmt = OSD_COLOR_FMT_RGB4444;
	} else if (enPixelFormat == PIXEL_FORMAT_ARGB_8888) {
		Surface.enColorFmt = OSD_COLOR_FMT_RGB8888;
	} else if (enPixelFormat == PIXEL_FORMAT_8BIT_MODE) {
		Surface.enColorFmt = OSD_COLOR_FMT_RGB8888;
	} else {
		printf("Pixel format is not support!\n");
		return CVI_FAILURE;
	}

	if (pstBitmap->pData == NULL) {
		printf("malloc osd memory err!\n");
		return CVI_FAILURE;
	}

	CreateSurfaceByCanvas(filename, &Surface, (CVI_U8 *)(pstBitmap->pData)
			     , pstSize->u32Width, pstSize->u32Height, u32Stride);

	pstBitmap->u32Width = Surface.u16Width;
	pstBitmap->u32Height = Surface.u16Height;
	pstBitmap->enPixelFormat = enPixelFormat;

	// if pixel value match color, make it transparent.
	// Only works for ARGB1555
	if (bFil) {
		CVI_U32 i, j;
		CVI_U16 *pu16Temp;

		pu16Temp = (CVI_U16 *)pstBitmap->pData;
		for (i = 0; i < pstBitmap->u32Height; i++) {
			for (j = 0; j < pstBitmap->u32Width; j++) {
				if (u16FilColor == *pu16Temp)
					*pu16Temp &= 0x7FFF;

				pu16Temp++;
			}
		}
	}

	return CVI_SUCCESS;
}

CVI_S32 SAMPLE_COMM_REGION_GetMinHandle(RGN_TYPE_E enType)
{
	CVI_S32 MinHandle;

	switch (enType) {
	case OVERLAY_RGN:
		MinHandle = OverlayMinHandle;
		break;
	case OVERLAYEX_RGN:
		MinHandle = OverlayExMinHandle;
		break;
	case COVER_RGN:
		MinHandle = CoverMinHandle;
		break;
	case COVEREX_RGN:
		MinHandle = CoverExMinHandle;
		break;
	case MOSAIC_RGN:
		MinHandle = MosaicMinHandle;
		break;
	default:
		MinHandle = -1;
		break;
	}
	return MinHandle;
}

CVI_S32 SAMPLE_REGION_CreateOverLay(CVI_S32 HandleNum, PIXEL_FORMAT_E pixelFormat)
{
	CVI_S32 s32Ret = CVI_SUCCESS;
	CVI_S32 i;
	RGN_ATTR_S stRegion;

	stRegion.enType = OVERLAY_RGN;
	if (pixelFormat ==  PIXEL_FORMAT_8BIT_MODE)
		stRegion.unAttr.stOverlay.enPixelFormat = PIXEL_FORMAT_8BIT_MODE;
	else
		stRegion.unAttr.stOverlay.enPixelFormat = PIXEL_FORMAT_ARGB_1555;

	stRegion.unAttr.stOverlay.stSize.u32Height = 200;
	stRegion.unAttr.stOverlay.stSize.u32Width = 300;
	stRegion.unAttr.stOverlay.u32BgColor = 0x00000000; // ARGB1555 transparent
	stRegion.unAttr.stOverlay.u32CanvasNum = 2;
	stRegion.unAttr.stOverlay.stCompressInfo.enOSDCompressMode = OSD_COMPRESS_MODE_NONE;
	for (i = OverlayMinHandle; i < OverlayMinHandle + HandleNum; i++) {
		s32Ret = CVI_RGN_Create(i, &stRegion);
		if (s32Ret != CVI_SUCCESS) {
			SAMPLE_PRT("CVI_RGN_Create failed with %#x!\n", s32Ret);
			return CVI_FAILURE;
		}
	}

	return s32Ret;
}

CVI_S32 SAMPLE_REGION_CreateOverLayEx(CVI_S32 HandleNum)
{
	CVI_S32 s32Ret = CVI_SUCCESS;
	CVI_S32 i;
	RGN_ATTR_S stRegion;

	stRegion.enType = OVERLAYEX_RGN;
	stRegion.unAttr.stOverlayEx.enPixelFormat = PIXEL_FORMAT_ARGB_1555;
	stRegion.unAttr.stOverlayEx.stSize.u32Height = 200;
	stRegion.unAttr.stOverlayEx.stSize.u32Width = 300;
	stRegion.unAttr.stOverlayEx.u32BgColor = 0x00000000; // ARGB1555 transparent
	stRegion.unAttr.stOverlayEx.u32CanvasNum = 2;
	stRegion.unAttr.stOverlayEx.stCompressInfo.enOSDCompressMode = OSD_COMPRESS_MODE_NONE;
	for (i = OverlayExMinHandle; i < OverlayExMinHandle + HandleNum; i++) {
		s32Ret = CVI_RGN_Create(i, &stRegion);
		if (s32Ret != CVI_SUCCESS) {
			SAMPLE_PRT("CVI_RGN_Create failed with %#x!\n", s32Ret);
			return CVI_FAILURE;
		}
	}

	return s32Ret;
}

CVI_S32 SAMPLE_REGION_CreateCover(CVI_S32 HandleNum)
{
	CVI_S32 s32Ret = CVI_SUCCESS;
	CVI_S32 i;
	RGN_ATTR_S stRegion;

	stRegion.enType = COVER_RGN;

	for (i = CoverMinHandle; i < CoverMinHandle + HandleNum; i++) {
		s32Ret = CVI_RGN_Create(i, &stRegion);
		if (s32Ret != CVI_SUCCESS) {
			SAMPLE_PRT("CVI_RGN_Create failed with %#x!\n", s32Ret);
			return CVI_FAILURE;
		}
	}

	return s32Ret;
}

CVI_S32 SAMPLE_REGION_CreateCoverEx(CVI_S32 HandleNum)
{
	CVI_S32 s32Ret = CVI_SUCCESS;
	CVI_S32 i;
	RGN_ATTR_S stRegion;

	stRegion.enType = COVEREX_RGN;

	for (i = CoverExMinHandle; i < CoverExMinHandle + HandleNum; i++) {
		s32Ret = CVI_RGN_Create(i, &stRegion);
		if (s32Ret != CVI_SUCCESS) {
			SAMPLE_PRT("CVI_RGN_Create failed with %#x!\n", s32Ret);
			return CVI_FAILURE;
		}
	}

	return s32Ret;
}

CVI_S32 SAMPLE_REGION_CreateMosaic(CVI_S32 HandleNum)
{
	CVI_S32 s32Ret = CVI_SUCCESS;
	CVI_S32 i;
	RGN_ATTR_S stRegion;

	stRegion.enType = MOSAIC_RGN;

	for (i = MosaicMinHandle; i < MosaicMinHandle + HandleNum; i++) {
		s32Ret = CVI_RGN_Create(i, &stRegion);
		if (s32Ret != CVI_SUCCESS) {
			SAMPLE_PRT("CVI_RGN_Create failed with %#x!\n", s32Ret);
			return CVI_FAILURE;
		}
	}

	return s32Ret;
}

CVI_S32 SAMPLE_REGION_Destroy(RGN_HANDLE Handle)
{
	CVI_S32 s32Ret;

	s32Ret = CVI_RGN_Destroy(Handle);
	if (s32Ret != CVI_SUCCESS) {
		SAMPLE_PRT("CVI_RGN_Destroy failed with %#x!\n", s32Ret);
		return CVI_FAILURE;
	}
	return s32Ret;
}

CVI_S32 SAMPLE_REGION_AttachToChn(RGN_HANDLE Handle, MMF_CHN_S *pstChn, RGN_CHN_ATTR_S *pstChnAttr)
{
	CVI_S32 s32Ret;

	s32Ret = CVI_RGN_AttachToChn(Handle, pstChn, pstChnAttr);
	if (s32Ret != CVI_SUCCESS) {
		SAMPLE_PRT("CVI_RGN_AttachToChn failed with %#x!\n", s32Ret);
		return CVI_FAILURE;
	}
	return s32Ret;
}

CVI_S32 SAMPLE_REGION_DetachFromChn(RGN_HANDLE Handle, MMF_CHN_S *pstChn)
{
	CVI_S32 s32Ret;

	s32Ret = CVI_RGN_DetachFromChn(Handle, pstChn);
	if (s32Ret != CVI_SUCCESS) {
		SAMPLE_PRT("CVI_RGN_DetachFromChn failed with %#x!\n", s32Ret);
		return CVI_FAILURE;
	}
	return s32Ret;
}

CVI_S32 SAMPLE_REGION_SetDisplayAttr(RGN_HANDLE Handle, MMF_CHN_S *pstChn, RGN_CHN_ATTR_S *pstChnAttr)
{
	CVI_S32 s32Ret;

	s32Ret = CVI_RGN_SetDisplayAttr(Handle, pstChn, pstChnAttr);
	if (s32Ret != CVI_SUCCESS) {
		SAMPLE_PRT("CVI_RGN_SetDisplayAttr failed with %#x!\n", s32Ret);
		return CVI_FAILURE;
	}
	return s32Ret;
}

CVI_S32 SAMPLE_REGION_GetDisplayAttr(RGN_HANDLE Handle, MMF_CHN_S *pstChn, RGN_CHN_ATTR_S *pstChnAttr)
{
	CVI_S32 s32Ret;

	s32Ret = CVI_RGN_GetDisplayAttr(Handle, pstChn, pstChnAttr);
	if (s32Ret != CVI_SUCCESS) {
		SAMPLE_PRT("CVI_RGN_GetDisplayAttr failed with %#x!\n", s32Ret);
		return CVI_FAILURE;
	}
	return s32Ret;
}

CVI_S32 SAMPLE_REGION_SetBitMap(RGN_HANDLE Handle, BITMAP_S *pstBitmap)
{
	CVI_S32 s32Ret;

	s32Ret = CVI_RGN_SetBitMap(Handle, pstBitmap);
	if (s32Ret != CVI_SUCCESS) {
		SAMPLE_PRT("CVI_RGN_SetBitMap failed with %#x!\n", s32Ret);
		return CVI_FAILURE;
	}
	return s32Ret;
}

CVI_S32 SAMPLE_REGION_GetUpCanvasInfo(RGN_HANDLE Handle, RGN_CANVAS_INFO_S *pstCanvasInfo)
{
	CVI_S32 s32Ret;

	s32Ret = CVI_RGN_GetCanvasInfo(Handle, pstCanvasInfo);
	if (s32Ret != CVI_SUCCESS) {
		SAMPLE_PRT("CVI_RGN_GetCanvasInfo failed with %#x!\n", s32Ret);
		return CVI_FAILURE;
	}

	s32Ret = CVI_RGN_UpdateCanvas(Handle);
	if (s32Ret != CVI_SUCCESS) {
		SAMPLE_PRT("CVI_RGN_UpdateCanvas failed with %#x!\n", s32Ret);
		return CVI_FAILURE;
	}
	return s32Ret;
}

CVI_S32 SAMPLE_COMM_REGION_Create(CVI_S32 HandleNum, RGN_TYPE_E enType, PIXEL_FORMAT_E pixelFormat)
{
	CVI_S32 s32Ret;

	if (HandleNum <= 0 || HandleNum > 16) {
		SAMPLE_PRT("HandleNum is illegal %d!\n", HandleNum);
		return CVI_FAILURE;
	}
	if (enType < OVERLAY_RGN || enType >= RGN_BUTT) {
		SAMPLE_PRT("enType is illegal %d!\n", enType);
		return CVI_FAILURE;
	}
	switch (enType) {
	case OVERLAY_RGN:
		s32Ret = SAMPLE_REGION_CreateOverLay(HandleNum, pixelFormat);
		break;
	case OVERLAYEX_RGN:
		s32Ret = SAMPLE_REGION_CreateOverLayEx(HandleNum);
		break;
	case COVER_RGN:
		s32Ret = SAMPLE_REGION_CreateCover(HandleNum);
		break;
	case COVEREX_RGN:
		s32Ret = SAMPLE_REGION_CreateCoverEx(HandleNum);
		break;
	case MOSAIC_RGN:
		s32Ret = SAMPLE_REGION_CreateMosaic(HandleNum);
		break;
	default:
		s32Ret = CVI_FAILURE;
		break;
	}
	if (s32Ret != CVI_SUCCESS) {
		SAMPLE_PRT("SAMPLE_COMM_REGION_Create failed! HandleNum%d,entype:%d!\n", HandleNum, enType);
		return CVI_FAILURE;
	}
	return s32Ret;
}

CVI_S32 SAMPLE_COMM_REGION_Destroy(CVI_S32 HandleNum, RGN_TYPE_E enType)
{
	CVI_S32 i;
	CVI_S32 s32Ret = CVI_SUCCESS;
	CVI_S32 MinHandle;

	if (HandleNum <= 0 || HandleNum > 16) {
		SAMPLE_PRT("HandleNum is illegal %d!\n", HandleNum);
		return CVI_FAILURE;
	}
	if (enType < OVERLAY_RGN || enType >= RGN_BUTT) {
		SAMPLE_PRT("enType is illegal %d!\n", enType);
		return CVI_FAILURE;
	}
	switch (enType) {
	case OVERLAY_RGN:
		MinHandle = OverlayMinHandle;
		break;
	case OVERLAYEX_RGN:
		MinHandle = OverlayExMinHandle;
		break;
	case COVER_RGN:
		MinHandle = CoverMinHandle;
		break;
	case COVEREX_RGN:
		MinHandle = CoverExMinHandle;
		break;
	case MOSAIC_RGN:
		MinHandle = MosaicMinHandle;
		break;
	default:
		return CVI_FAILURE;
	}
	for (i = MinHandle; i < MinHandle + HandleNum; i++) {
		s32Ret = SAMPLE_REGION_Destroy(i);
		if (s32Ret != CVI_SUCCESS)
			SAMPLE_PRT("SAMPLE_COMM_REGION_Destroy failed!\n");
	}
	return s32Ret;
}

CVI_S32 SAMPLE_COMM_REGION_AttachToChn(CVI_S32 HandleNum, RGN_TYPE_E enType, MMF_CHN_S *pstChn)
{
	CVI_S32 i;
	CVI_S32 s32Ret = CVI_SUCCESS;
	CVI_S32 MinHadle;
	RGN_CHN_ATTR_S stChnAttr;

	if (HandleNum <= 0 || HandleNum > 16) {
		SAMPLE_PRT("HandleNum is illegal %d!\n", HandleNum);
		return CVI_FAILURE;
	}
	if (enType < OVERLAY_RGN || enType >= RGN_BUTT) {
		SAMPLE_PRT("enType is illegal %d!\n", enType);
		return CVI_FAILURE;
	}
	if (pstChn == CVI_NULL) {
		SAMPLE_PRT("pstChn is NULL !\n");
		return CVI_FAILURE;
	}
	memset(&stChnAttr, 0, sizeof(stChnAttr));

	/*set the chn config*/
	stChnAttr.bShow = CVI_TRUE;
	switch (enType) {
	case OVERLAY_RGN:
		MinHadle = OverlayMinHandle;
		stChnAttr.bShow = CVI_TRUE;
		stChnAttr.enType = OVERLAY_RGN;
		stChnAttr.unChnAttr.stOverlayChn.stInvertColor.bInvColEn = CVI_FALSE;
		break;
	case OVERLAYEX_RGN:
		MinHadle = OverlayExMinHandle;
		stChnAttr.bShow = CVI_TRUE;
		stChnAttr.enType = OVERLAYEX_RGN;
		stChnAttr.unChnAttr.stOverlayExChn.stInvertColor.bInvColEn = CVI_FALSE;
		break;
	case COVER_RGN:
		MinHadle = CoverMinHandle;

		stChnAttr.bShow = CVI_TRUE;
		stChnAttr.enType = COVER_RGN;
		stChnAttr.unChnAttr.stCoverChn.enCoverType = AREA_RECT;

		stChnAttr.unChnAttr.stCoverChn.stRect.u32Height = 100;
		stChnAttr.unChnAttr.stCoverChn.stRect.u32Width = 100;

		stChnAttr.unChnAttr.stCoverChn.u32Color = 0x0000ffff;

		stChnAttr.unChnAttr.stCoverChn.enCoordinate = RGN_ABS_COOR;
		break;
	case COVEREX_RGN:
		MinHadle = CoverExMinHandle;

		stChnAttr.bShow = CVI_TRUE;
		stChnAttr.enType = COVEREX_RGN;
		stChnAttr.unChnAttr.stCoverExChn.enCoverType = AREA_RECT;

		stChnAttr.unChnAttr.stCoverExChn.stRect.u32Height = 100;
		stChnAttr.unChnAttr.stCoverExChn.stRect.u32Width = 100;

		stChnAttr.unChnAttr.stCoverExChn.u32Color = 0x0000ffff;
		break;
	case MOSAIC_RGN:
		MinHadle = MosaicMinHandle;
		stChnAttr.enType = MOSAIC_RGN;
		stChnAttr.unChnAttr.stMosaicChn.enBlkSize = MOSAIC_BLK_SIZE_8;
		stChnAttr.unChnAttr.stMosaicChn.stRect.u32Height = 96; // 8 pixel align
		stChnAttr.unChnAttr.stMosaicChn.stRect.u32Width = 96;
		break;
	default:
		return CVI_FAILURE;
	}
	/*attach to Chn*/
	for (i = MinHadle; i < MinHadle + HandleNum; i++) {
		if (enType == OVERLAY_RGN) {
			stChnAttr.unChnAttr.stOverlayChn.stPoint.s32X = 20 + 200 * (i - OverlayMinHandle);
			stChnAttr.unChnAttr.stOverlayChn.stPoint.s32Y = 20 + 200 * (i - OverlayMinHandle);
			stChnAttr.unChnAttr.stOverlayChn.u32Layer = (i - OverlayMinHandle);
		}
		if (enType == OVERLAYEX_RGN) {
			stChnAttr.unChnAttr.stOverlayExChn.stPoint.s32X = 20 + 200 * (i - OverlayExMinHandle);
			stChnAttr.unChnAttr.stOverlayExChn.stPoint.s32Y = 20 + 200 * (i - OverlayExMinHandle);
			stChnAttr.unChnAttr.stOverlayExChn.u32Layer = i - OverlayExMinHandle;
		}
		if (enType == COVER_RGN) {
			stChnAttr.unChnAttr.stCoverChn.stRect.s32X = 20 + 200 * (i - CoverMinHandle);
			stChnAttr.unChnAttr.stCoverChn.stRect.s32Y = 20 + 200 * (i - CoverMinHandle);
			stChnAttr.unChnAttr.stCoverChn.u32Layer = (i - CoverMinHandle);
		}
		if (enType == COVEREX_RGN) {
			stChnAttr.unChnAttr.stCoverExChn.stRect.s32X = 20 + 200 * (i - CoverExMinHandle);
			stChnAttr.unChnAttr.stCoverExChn.stRect.s32Y = 20 + 200 * (i - CoverExMinHandle);
			stChnAttr.unChnAttr.stCoverExChn.u32Layer = i - CoverExMinHandle;
		}
		if (enType == MOSAIC_RGN) {
			stChnAttr.unChnAttr.stMosaicChn.stRect.s32X = 20 + 200 * (i - MosaicMinHandle);
			stChnAttr.unChnAttr.stMosaicChn.stRect.s32Y = 20 + 200 * (i - MosaicMinHandle);
			stChnAttr.unChnAttr.stMosaicChn.u32Layer = i - MosaicMinHandle;
		}
		s32Ret = SAMPLE_REGION_AttachToChn(i, pstChn, &stChnAttr);
		if (s32Ret != CVI_SUCCESS) {
			SAMPLE_PRT("SAMPLE_REGION_AttachToChn failed!\n");
			break;
		}
	}
	/*detach region from chn */
	if (s32Ret != CVI_SUCCESS && i > 0) {
		i--;
		for (; i >= MinHadle; i--)
			s32Ret = SAMPLE_REGION_DetachFromChn(i, pstChn);
	}
	return s32Ret;
}

CVI_S32 SAMPLE_COMM_REGION_DetachFrmChn(CVI_S32 HandleNum, RGN_TYPE_E enType, MMF_CHN_S *pstChn)
{
	CVI_S32 i;
	CVI_S32 s32Ret = CVI_SUCCESS;
	CVI_S32 MinHadle;

	if (HandleNum <= 0 || HandleNum > 16) {
		SAMPLE_PRT("HandleNum is illegal %d!\n", HandleNum);
		return CVI_FAILURE;
	}
	if (enType < OVERLAY_RGN || enType >= RGN_BUTT) {
		SAMPLE_PRT("enType is illegal %d!\n", enType);
		return CVI_FAILURE;
	}
	if (pstChn == CVI_NULL) {
		SAMPLE_PRT("pstChn is NULL !\n");
		return CVI_FAILURE;
	}
	switch (enType) {
	case OVERLAY_RGN:
		MinHadle = OverlayMinHandle;
		break;
	case OVERLAYEX_RGN:
		MinHadle = OverlayExMinHandle;
		break;
	case COVER_RGN:
		MinHadle = CoverMinHandle;
		break;
	case COVEREX_RGN:
		MinHadle = CoverExMinHandle;
		break;
	case MOSAIC_RGN:
		MinHadle = MosaicMinHandle;
		break;
	default:
		return CVI_FAILURE;
	}
	for (i = MinHadle; i < MinHadle + HandleNum; i++) {
		s32Ret = SAMPLE_REGION_DetachFromChn(i, pstChn);
		if (s32Ret != CVI_SUCCESS)
			SAMPLE_PRT("SAMPLE_REGION_DetachFromChn failed! Handle:%d\n", i);
	}
	return s32Ret;
}

CVI_S32 SAMPLE_COMM_REGION_SetBitMap(RGN_HANDLE Handle, const char *filename,
		PIXEL_FORMAT_E pixelFormat, CVI_BOOL bCompressed)
{
	CVI_S32 s32Ret, u32FileSize;
	BITMAP_S stBitmap;
	RGN_CANVAS_INFO_S stCanvasInfo;
	FILE *pFile;

	s32Ret = CVI_RGN_GetCanvasInfo(Handle, &stCanvasInfo);
	if (s32Ret != CVI_SUCCESS) {
		SAMPLE_PRT("CVI_RGN_GetCanvasInfo failed with %#x!\n", s32Ret);
		return CVI_FAILURE;
	}
	s32Ret = CVI_RGN_UpdateCanvas(Handle);
	if (s32Ret != CVI_SUCCESS) {
		SAMPLE_PRT("CVI_RGN_UpdateCanvas failed with %#x!\n", s32Ret);
		return CVI_FAILURE;
	}

	if (bCompressed) {
		if (filename == NULL) {
			printf("OSD_LoadBMP: filename=NULL\n");
			return -1;
		}

		pFile = fopen((char *)filename, "rb");
		fseek(pFile, 0, SEEK_END); // seek to end of file
		u32FileSize = ftell(pFile); // get current file pointer
		fseek(pFile, 0, SEEK_SET); // seek back to beginning of file

		stBitmap.pData = malloc(u32FileSize);
		if (stBitmap.pData == NULL) {
			printf("malloc osd memory err!\n");
			return CVI_FAILURE;
		}

		stBitmap.enPixelFormat = pixelFormat;
		stBitmap.u32Width = stCanvasInfo.stSize.u32Width;
		stBitmap.u32Height = stCanvasInfo.stSize.u32Height;

		fread(stBitmap.pData, 1, u32FileSize, pFile);
		fclose(pFile);
	} else
		SAMPLE_COMM_REGION_MST_LoadBmp(filename, &stBitmap, CVI_FALSE, 0, pixelFormat);

	s32Ret = SAMPLE_REGION_SetBitMap(Handle, &stBitmap);
	if (s32Ret != CVI_SUCCESS)
		SAMPLE_PRT("SAMPLE_REGION_SetBitMap failed!Handle:%d\n", Handle);
	free(stBitmap.pData);
	return s32Ret;
}

CVI_S32 SAMPLE_COMM_REGION_GetUpCanvas(RGN_HANDLE Handle, const char *filename)
{
	CVI_S32 s32Ret;
	SIZE_S stSize;
	BITMAP_S stBitmap;
	RGN_CANVAS_INFO_S stCanvasInfo;
	FILE *pFile;

	s32Ret = CVI_RGN_GetCanvasInfo(Handle, &stCanvasInfo);
	if (s32Ret != CVI_SUCCESS) {
		SAMPLE_PRT("CVI_RGN_GetCanvasInfo failed with %#x!\n", s32Ret);
		return CVI_FAILURE;
	}

	stBitmap.pData = stCanvasInfo.pu8VirtAddr;
	stSize.u32Width = stCanvasInfo.stSize.u32Width;
	stSize.u32Height = stCanvasInfo.stSize.u32Height;

	if (stCanvasInfo.enOSDCompressMode == OSD_COMPRESS_MODE_SW) {
		pFile = fopen((char *)filename, "rb");

		if (pFile == NULL) {
			printf("Open file failed:%s!\n", filename);
			return -1;
		}

		fread(stBitmap.pData, 1, stCanvasInfo.u32CompressedSize, pFile);
		fclose(pFile);
	} else {
		if (stCanvasInfo.enPixelFormat == PIXEL_FORMAT_8BIT_MODE)
			SAMPLE_COMM_REGION_MST_UpdateCanvas(filename, &stBitmap, CVI_FALSE, 0, &stSize,
						stCanvasInfo.u32Stride, PIXEL_FORMAT_8BIT_MODE);
		else
			SAMPLE_COMM_REGION_MST_UpdateCanvas(filename, &stBitmap, CVI_FALSE, 0, &stSize,
						stCanvasInfo.u32Stride, PIXEL_FORMAT_ARGB_1555);
	}

	s32Ret = CVI_RGN_UpdateCanvas(Handle);
	if (s32Ret != CVI_SUCCESS) {
		SAMPLE_PRT("CVI_RGN_UpdateCanvas failed with %#x!\n", s32Ret);
		return CVI_FAILURE;
	}

	return s32Ret;
}

CVI_S32 SAMPLE_COMM_ODEC_REGION_Create(CVI_U32 u32FileSize, SIZE_S *stSize)
{
	CVI_S32 s32Ret = CVI_SUCCESS;
	RGN_ATTR_S stRegion;

	memset(&stRegion, 0, sizeof(stRegion));
	stRegion.enType = OVERLAY_RGN;
	stRegion.unAttr.stOverlay.enPixelFormat = PIXEL_FORMAT_ARGB_8888;
	stRegion.unAttr.stOverlay.stSize.u32Height = stSize->u32Height;
	stRegion.unAttr.stOverlay.stSize.u32Width = stSize->u32Width;
	stRegion.unAttr.stOverlay.u32BgColor = 0x00000000; // ARGB1555 transparent
	stRegion.unAttr.stOverlay.u32CanvasNum = 2;
	stRegion.unAttr.stOverlay.stCompressInfo.enOSDCompressMode = OSD_COMPRESS_MODE_SW;
	stRegion.unAttr.stOverlay.stCompressInfo.u32EstCompressedSize = u32FileSize;
	s32Ret = CVI_RGN_Create(OdecHandle, &stRegion);
	if (s32Ret != CVI_SUCCESS)
		SAMPLE_PRT("CVI_RGN_Create failed with %#x, hdl(%d)\n", s32Ret, OdecHandle);

	return s32Ret;
}

CVI_S32 SAMPLE_COMM_ODEC_REGION_Destroy(void)
{
	CVI_S32 s32Ret = CVI_SUCCESS;

	s32Ret = SAMPLE_REGION_Destroy(OdecHandle);
	if (s32Ret != CVI_SUCCESS)
		SAMPLE_PRT("SAMPLE_REGION_Destroy failed with %#x, hdl(%d)\n",
			s32Ret, OdecHandle);
	return s32Ret;
}

CVI_S32 SAMPLE_COMM_ODEC_REGION_AttachToChn(MMF_CHN_S *pstChn)
{
	CVI_S32 s32Ret = CVI_SUCCESS;
	RGN_CHN_ATTR_S stChnAttr;

	if (pstChn == CVI_NULL) {
		SAMPLE_PRT("pstChn is NULL !\n");
		return CVI_FAILURE;
	}

	/*set the chn config*/
	memset(&stChnAttr, 0, sizeof(stChnAttr));
	stChnAttr.bShow = CVI_TRUE;
	stChnAttr.enType = OVERLAY_RGN;
	stChnAttr.unChnAttr.stOverlayChn.stInvertColor.bInvColEn = CVI_FALSE;
	stChnAttr.unChnAttr.stOverlayChn.stPoint.s32X = 0;
	stChnAttr.unChnAttr.stOverlayChn.stPoint.s32Y = 0;
	stChnAttr.unChnAttr.stOverlayChn.u32Layer = 0;
	s32Ret = SAMPLE_REGION_AttachToChn(OdecHandle, pstChn, &stChnAttr);
	if (s32Ret != CVI_SUCCESS)
		SAMPLE_PRT("SAMPLE_REGION_AttachToChn failed with %#x, hdl(%d), chn(%d %d %d)\n",
			s32Ret, OdecHandle, pstChn->enModId, pstChn->s32DevId, pstChn->s32ChnId);

	return s32Ret;
}

CVI_S32 SAMPLE_COMM_ODEC_REGION_DetachFrmChn(MMF_CHN_S *pstChn)
{
	CVI_S32 s32Ret = CVI_SUCCESS;

	if (pstChn == CVI_NULL) {
		SAMPLE_PRT("pstChn is NULL !\n");
		return CVI_FAILURE;
	}

	s32Ret = SAMPLE_REGION_DetachFromChn(OdecHandle, pstChn);
	if (s32Ret != CVI_SUCCESS)
		SAMPLE_PRT("SAMPLE_REGION_DetachFromChn failedwith %#x, hdl(%d), chn(%d %d %d)\n",
			s32Ret, OdecHandle, pstChn->enModId, pstChn->s32DevId, pstChn->s32ChnId);
	return s32Ret;
}