gfx_drawcontrol.c

sigmadesign smp8623 gui source code ,bingo

	}
	else if (isJpeg(g_bitmaps[bmpindex].path))
	{
		status = load_jpeg(pRua, &g_bitmaps[bmpindex], bmpsize);
	}
	else
	{
		status = load_gif(pRua, &g_bitmaps[bmpindex], bmpsize);
	}

	if (RMFAILED(status) || g_bitmaps[bmpindex].bmp.uiDataSize == 0)
	{
		RMDBGLOG((GFXDBG, "Error %s while loading %s \n", RMstatusToString(status), g_bitmaps[bmpindex].path));
		RMMemset(&g_bitmaps[bmpindex], '\0', sizeof(g_bitmaps[bmpindex]));
		return status;
	}
	return status;
}

void ResetNonBackgroundBuffers()
{
	RMuint8 i;
	RMuint32 usedbuffer = 0;

	RMEnterCriticalSection(g_cs);
	for (i = 1; i < MAX_BITMAPS; i++)
	{
		if (g_bitmaps[i].path[0] != '\0')
		{
			usedbuffer += g_bitmaps[i].bmp.uiDataSize;
			// clear bmp buffer
			RMMemset(&g_bitmaps[i], 0, sizeof(RMbitmapdata));
		}
		else
			break;
	}
	ResetUsedBuffer(usedbuffer);
	RMLeaveCriticalSection(g_cs);
}

RMstatus GetBitmapIndex(struct RUA *pRua, RMascii* path, RMuint8 *bmpindex, RMbool attemptReload)
{
	RMuint8 i;
	RMstatus status;
	RMuint32 bmpsize = 0;
	RMuint8 index;

	RMEnterCriticalSection(g_cs);

	// check if we already have the bitmap data from index 1 since 0 is reserved to background image
	for (i = 1; i < MAX_BITMAPS; i++)
	{
		if (g_bitmaps[i].path[0] != '\0')
		{
			if (RMCompareAscii(g_bitmaps[i].path, path) && g_bitmaps[i].charwidth == 0)
			{
				*bmpindex = i;
				UpdateCache(i);
				RMLeaveCriticalSection(g_cs);
				return RM_OK;
			}
			// not loaded
			continue;
		}
		else
		{
			RMCopyAscii(g_bitmaps[i].path, path);
			g_bitmaps[i].charwidth = 0;
			*bmpindex = i;
			status = LoadImage(pRua, i, &bmpsize);

			// check if not background file and try loading again by
			// resetting used bitmap buffers one at the time

			if (status == RM_FATALOUTOFMEMORY)
			{
				status = FindFreeSpace(bmpsize, &index);
				{
					RMCopyAscii(g_bitmaps[index].path, path);
					g_bitmaps[index].charwidth = 0;
					*bmpindex = index;
					status = LoadImage(pRua, index, &bmpsize);
				}
			}
			RMLeaveCriticalSection(g_cs);
			return status;
		}
	}
	RMLeaveCriticalSection(g_cs);

	// more than MAX_BITMAPS!!!!
	return RM_ERROR;
}

// background is stored at index 0
RMstatus LoadPageBackground(struct RUA *pRua, RMascii* path)
{
	// check if we already have the bitmap data
	//	printf("%s\n%s\n", path, g_bitmaps[0].path);
	if (RMCompareAscii(g_bitmaps[0].path, path))
	{
		return RM_OK;
	}
	else
	{
		RMstatus status;
		RMuint32 bmpsize = 0;
		RMEnterCriticalSection(g_cs);
		RMCopyAscii(g_bitmaps[0].path, path);
		g_bitmaps[0].isBackground = TRUE;
		printf("load background\n");
		status = LoadImage(pRua, 0, &bmpsize);
		UpdateCache(0);
		RMLeaveCriticalSection(g_cs);
		return status;
	}
	return RM_ERROR;
}

RMstatus SetTextPalette(struct RUA *pRua, RMuint32 foregroundcolor, RMuint32 backgroundcolor, RMbool transparentbkgnd)
{
	struct GFXEngine_Palette_1BPP_type palette_param;
	RMstatus status;

	palette_param.Palette[0] = foregroundcolor;
	palette_param.Palette[1] = (transparentbkgnd ? backgroundcolor & 0xffffffff : 0);
	palette_param.SurfaceID = GFX_SURFACE_ID_Y;

	if (CompareTextPalette(&palette_param))
	{
		//		printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> skipping TEXT palette\n");
		return RM_OK;
	}

	//	printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> setting TEXT palette\n");
	status = GFX1BPPPaletteProperty(pRua, &palette_param);
	if (RMFAILED(status))
		RMDBGLOG((GFXDBG, "Error sending command set palette\n"));

	RMMemcpy(&g_lastpal, &palette_param, sizeof(palette_param));
	g_last_palbpp = 1;

	return status;
}

RMstatus SetTextColorFormat(struct RUA *pRua)
{
	struct GFXEngine_ColorFormat_type format_param;
	RMstatus status;

	// color format
	format_param.SurfaceID = GFX_SURFACE_ID_Y;
	format_param.MainMode = EMhwlibColorMode_LUT_1BPP;
	format_param.SubMode = EMhwlibColorFormat_32BPP;
	status = GFXColorFormatProperty(pRua, &format_param);
	if (RMFAILED(status))
		RMDBGLOG((GFXDBG, "Error setting color format parameters\n"));

	return status;
}

RMstatus SetPalette(struct RUA *pRua, RMuint8 alpha, RMuint8 bmpindex, RMuint32 surfaceID)
{
	RMstatus status = RM_OK;
	RMuint32 i;
	RMuint8 bpp = g_bitmaps[bmpindex].bmp.uiNbBitPerPixel;
	RMuint32 uiNbLUTColor = g_bitmaps[bmpindex].bmp.uiPaletteSize / sizeof(struct tagRMRGBQuad);
	struct GFXEngine_Palette_1BPP_type palette1bpp_param;
	struct GFXEngine_Palette_2BPP_type palette2bpp_param;
	struct GFXEngine_Palette_4BPP_type palette4bpp_param;
	struct GFXEngine_Palette_8BPP_type palette8bpp_param;

	switch (bpp)
	{

	case 1:
		for (i = 0; i < uiNbLUTColor; i++)
		{
			struct tagRMRGBQuad *pQuad;
			pQuad = (struct tagRMRGBQuad*) (g_bitmaps[bmpindex].bmp.palette + i);
			palette1bpp_param.Palette[i] = alpha << 24 | pQuad->rgbRed << 16 | pQuad->rgbGreen << 8 | pQuad->rgbBlue;
			if (g_bitmaps[bmpindex].usetransparentcolor)
				if ((palette1bpp_param.Palette[i] & 0x00ffffff) == (g_bitmaps[bmpindex].transparentcolor & 0x00ffffff))
					palette1bpp_param.Palette[i] = palette1bpp_param.Palette[i] & 0x00ffffff;
		}
		palette1bpp_param.SurfaceID = surfaceID;
		status = GFX1BPPPaletteProperty(pRua, &palette1bpp_param);
		break;

	case 2:
		for (i = 0; i < uiNbLUTColor; i++)
		{
			struct tagRMRGBQuad *pQuad;
			pQuad = (struct tagRMRGBQuad*) (g_bitmaps[bmpindex].bmp.palette + i);
			palette2bpp_param.Palette[i] = alpha << 24 | pQuad->rgbRed << 16 | pQuad->rgbGreen << 8 | pQuad->rgbBlue;
			if (g_bitmaps[bmpindex].usetransparentcolor)
				if ((palette2bpp_param.Palette[i] & 0x00ffffff) == (g_bitmaps[bmpindex].transparentcolor & 0x00ffffff))
					palette2bpp_param.Palette[i] = palette2bpp_param.Palette[i] & 0x00ffffff;
		}
		palette2bpp_param.SurfaceID = surfaceID;
		status = GFX2BPPPaletteProperty(pRua, &palette2bpp_param);
		break;

	case 4:
		for (i = 0; i < uiNbLUTColor; i++)
		{
			struct tagRMRGBQuad *pQuad;
			pQuad = (struct tagRMRGBQuad*) (g_bitmaps[bmpindex].bmp.palette + i);
			palette4bpp_param.Palette[i] = alpha << 24 | pQuad->rgbRed << 16 | pQuad->rgbGreen << 8 | pQuad->rgbBlue;
			if (g_bitmaps[bmpindex].usetransparentcolor)
				if ((palette4bpp_param.Palette[i] & 0x00ffffff) == (g_bitmaps[bmpindex].transparentcolor & 0x00ffffff))
					palette4bpp_param.Palette[i] = palette4bpp_param.Palette[i] & 0x00ffffff;
		}
		palette4bpp_param.SurfaceID = surfaceID;
		status = GFX4BPPPaletteProperty(pRua, &palette4bpp_param);
		break;

	case 8:
		for (i = 0; i < uiNbLUTColor; i++)
		{
			struct tagRMRGBQuad *pQuad;
			pQuad = (struct tagRMRGBQuad*) (g_bitmaps[bmpindex].bmp.palette + i);
			palette8bpp_param.Palette[i] = alpha << 24 | pQuad->rgbRed << 16 | pQuad->rgbGreen << 8 | pQuad->rgbBlue;
			if (g_bitmaps[bmpindex].usetransparentcolor)
				if ((palette8bpp_param.Palette[i] & 0x00ffffff) == (g_bitmaps[bmpindex].transparentcolor & 0x00ffffff))
				{
					palette8bpp_param.Palette[i] = palette8bpp_param.Palette[i] & 0x00ffffff;
				}
		}

		if (CompareBitmapPalette(&palette8bpp_param))
		{
			//				printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> skipping palette %d bpp\n", bpp);
			return RM_OK;
		}

		//			printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> setting palette %d bpp\n", bpp);
		palette8bpp_param.SurfaceID = surfaceID;
		status = GFX8BPPPaletteProperty(pRua, &palette8bpp_param);

		RMMemcpy(&g_lastpal, &palette8bpp_param, sizeof(palette4bpp_param));
		g_last_palbpp = 8;
		break;

	default:
		status = RM_ERROR;
		break;

	}

	if (RMFAILED(status))
		RMDBGLOG((GFXDBG, "Error sending command set palette\n"));

	return status;
}

RMstatus DrawBitmapBlendBack(struct RUA *pRua, RMint32 x, RMint32 y, RMuint32 transparentcolor, RMbool usetransparentcolor,
		RMuint8 alpha, RMuint8 bmpindex, RMbool blend, RMuint8 parentindex)
{
	RMstatus status = RM_OK;
	struct GFXEngine_BlendRectangles_type blend_param;
	RMuint32 width, height;
	RMuint32 mainmode, bkmode;
	RMuint32 startaddr;

	width = g_bitmaps[bmpindex].bmp.uiWidth;
	height = g_bitmaps[bmpindex].bmp.uiHeight;

	//verify bitmap fits within surface
	if ((RMuint32) (width + x) > gdata.osdWidth || (RMuint32) (height + y) > gdata.osdHeight)
	{
		RMDBGLOG((ENABLE, "GOES OUTSIDE SURFACE BOUNDARIES\n", g_bitmaps[bmpindex].path));
		return RM_ERROR;
	}

	// setup input Y surface

	// set transparency
	g_bitmaps[bmpindex].transparentcolor = transparentcolor;
	g_bitmaps[bmpindex].usetransparentcolor = usetransparentcolor;

	// fill the palette
	if (g_bitmaps[bmpindex].bmp.uiNbBitPerPixel <= 8)
		SetPalette(pRua, alpha, bmpindex, GFX_SURFACE_ID_Y);

	// color format
	switch (g_bitmaps[bmpindex].bmp.uiNbBitPerPixel)
	{
	case 1:
		mainmode = EMhwlibColorMode_LUT_1BPP;
		break;
	case 2:
		mainmode = EMhwlibColorMode_LUT_2BPP;
		break;
	case 4:
		mainmode = EMhwlibColorMode_LUT_4BPP;
		break;
	case 8:
		mainmode = EMhwlibColorMode_LUT_8BPP;
		break;
	default:
		mainmode = EMhwlibColorMode_TrueColor;
		break;
	}

	startaddr = g_bitmaps[bmpindex].pBmpAddr;

	if (g_bitmaps[parentindex].pBmpAddr == 0)
		return RM_ERROR;

	// setup X surface -- background
	// color format
	bkmode = EMhwlibColorMode_TrueColor;

	status = SetInputSurface(pRua, bkmode, gdata.backBuffer.baseAddr, g_bitmaps[0].bmp.uiWidth, GFX_SURFACE_ID_X);
	if (RMFAILED(status))
		RMDBGLOG((GFXDBG, "Error setting surface parameters\n"));

	// setup Y surface
	// color format -- set above
	status = SetInputSurface(pRua, mainmode, startaddr, width, GFX_SURFACE_ID_Y);
	if (RMFAILED(status))
		RMDBGLOG((GFXDBG, "Error setting surface parameters\n"));

	blend_param.Src1X = 0; // YZ
	blend_param.Src1Y = 0;
	blend_param.Src2X = x; // X
	blend_param.Src2Y = y;
	blend_param.DstX = x;
	blend_param.DstY = y;
	blend_param.Width = width;
	blend_param.Height = height;
	blend_param.SaturateAlpha = FALSE;

	status = GFXBlendRectanglesProperty(pRua, &blend_param);

	return RM_OK;
}

RMstatus DrawBitmap(struct RUA *pRua, RMint32 x, RMint32 y, RMuint32 transparentcolor, RMbool usetransparentcolor, RMuint8 alpha,
		RMuint8 bmpindex, RMbool blend, RMuint8 parentindex)
{
	RMstatus status = RM_OK;
	struct GFXEngine_BlendRectangles_type blend_param;
	struct GFXEngine_MoveReplaceRectangle_type move_param;
	RMuint32 width, height;
	RMuint32 mainmode, bkmode;
	RMuint32 startaddr;

	width = g_bitmaps[bmpindex].bmp.uiWidth;
	height = g_bitmaps[bmpindex].bmp.uiHeight;

	//verify bitmap fits within surface
	if ((RMuint32) (width + x) > gdata.osdWidth || (RMuint32) (height + y) > gdata.osdHeight)
	{
		RMDBGLOG((ENABLE, "GOES OUTSIDE SURFACE BOUNDARIES\n", g_bitmaps[bmpindex].path));
		return RM_ERROR;
	}

	// setup input Y surface

	// set transparency
	g_bitmaps[bmpindex].transparentcolor = transparentcolor;
	g_bitmaps[bmpindex].usetransparentcolor = usetransparentcolor;

	// fill the palette
	if (g_bitmaps[bmpindex].bmp.uiNbBitPerPixel <= 8)
		SetPalette(pRua, alpha, bmpindex, GFX_SURFACE_ID_Y);

	// color format
	switch (g_bitmaps[bmpindex].bmp.uiNbBitPerPixel)
	{
	case 1:
		mainmode = EMhwlibColorMode_LUT_1BPP;
		break;
	case 2:
		mainmode = EMhwlibColorMode_LUT_2BPP;
		break;
	case 4:
		mainmode = EMhwlibColorMode_LUT_4BPP;
		break;
	case 8:
		mainmode = EMhwlibColorMode_LUT_8BPP;
		break;
	default:
		mainmode = EMhwlibColorMode_TrueColor;
		break;
	}

	startaddr = g_bitmaps[bmpindex].pBmpAddr;

	if (bmpindex == 0 || blend == FALSE)
	{
		//		RMuint16 i;
		RMASSERT(startaddr != 0);

		// setup Y surface
		status = SetInputSurface(pRua, mainmode, startaddr, width, GFX_SURFACE_ID_Y);
		if (RMFAILED(status))
			RMDBGLOG((GFXDBG, "Error setting surface parameters\n"));
		//		for(i = 0; i < x; i++){
		move_param.SrcX = 0;
		move_param.SrcY = 0;
		move_param.AlphaX = 0;
		move_param.AlphaY = 0;
		move_param.DstX = x;
		//		move_param.DstX = i;
		move_param.DstY = y;
		move_param.Width = width;
		move_param.Height = height;
		move_param.Merge = FALSE;
		status = GFXReplaceRectangleProperty(pRua, &move_param);
		//		}
		return RM_OK;
	}

	if (g_bitmaps[parentindex].pBmpAddr == 0)
		return RM_ERROR;

	// setup X surface -- background
	// color format
	switch (g_bitmaps[parentindex].bmp.uiNbBitPerPixel)
	{
	case 1:
		bkmode = EMhwlibColorMode_LUT_1BPP;
		break;
	case 2:
		bkmode = EMhwlibColorMode_LUT_2BPP;
		break;
	case 4:
		bkmode = EMhwlibColorMode_LUT_4BPP;
		break;
	case 8:
		bkmode = EMhwlibColorMode_LUT_8BPP;
		break;
	default:
		bkmode = EMhwlibColorMode_TrueColor;
		break;
	}
	status = SetInputSurface(pRua, bkmode, g_bitmaps[parentindex].pBmpAddr, g_bitmaps[parentindex].bmp.uiWidth, GFX_SURFACE_ID_X);
	if (RMFAILED(status))
		RMDBGLOG((GFXDBG, "Error setting surface parameters\n"));

	// setup Y surface
	// color format -- set above
	status = SetInputSurface(pRua, mainmode, startaddr, width, GFX_SURFACE_ID_Y);
	if (RMFAILED(status))
		RMDBGLOG((GFXDBG, "Error setting surface parameters\n"));

	blend_param.Src1X = 0; // YZ