payton/nt9856x
Template
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
dc700c78d8
nt9856x/code/application/source/cardv/SrcCode/Gx/GxDisplay/GxDisplay.c
payton 543d2da268 1.一次S530代码提交
2023-03-28 15:07:53 +08:00

1449 lines
35 KiB
C
Executable File
Raw Blame History

#include "GxDisplay.h"
#include "GxDisplay_int.h"
#include "DL.h"
#if !defined(__FREERTOS)
#include "vendor_videoout.h"
#include <sys/ioctl.h>
#include <linux/fb.h>
#include <fcntl.h>
#include <sys/mman.h>
static struct fb_var_screeninfo vinfo;
static int fb_fd = 0;
#endif
#define COLOR_YUV_BLACK 0x00808000 ///< built-in color
#define COLOR_BLACK COLOR_YUV_BLACK
#define REMOVE 0
#define _DL_SetAutoWait(a,b)
#define _DL_Wait_VSync(a)
#define _DL_Wait_Load(a)
#define _DL_UpdateOutput(a)
#define _DL_Dirty(a,b)
//#define _DL_SetOSDMix(a,b,c,d,e,f,g,h,i,j)
//#define _DL_SetVDOMix(a,b,c,d,e,f,g,h,i,j)
#define _DL_SetCtrl(a,b,c)
//#define _DL_GetOSDCk(a,b,c) 0
#define _DL_BufferExit(a)
#define _DD_GetLayerEn(a) 0
#define _DD_SetLayerEn(a,b)
//disp-1
LAYER_BUFMAN *_gBM_1[LAYER_NUM] = {0};
DISPLAY_MIXER _gDM_1;
DISPLAY_LAYER _gDL_1[LAYER_NUM];
#if (DEVICE_COUNT >= 2)
//disp-2
LAYER_BUFMAN *_gBM_2[LAYER_NUM] = {0};
DISPLAY_MIXER _gDM_2;
DISPLAY_LAYER _gDL_2[LAYER_NUM];
#endif
UINT32 _gDisp_RenderOBJ = 0;
void GxDisplay_RegBufMan(UINT32 LayerID, LAYER_BUFMAN *pBufMan)
{
UINT32 cDevID = _DD(LayerID);
UINT32 cLayerID = _DL(LayerID);
if (cDevID == 0) {
_gBM_1[cLayerID] = pBufMan;
}
#if (DEVICE_COUNT >= 2)
if (cDevID == 1) {
_gBM_2[cLayerID] = pBufMan;
}
#endif
}
static LAYER_BUFMAN *_DL_GetBufMan(UINT32 LayerID)
{
LAYER_BUFMAN *pthisBM = 0;
UINT32 cDevID = _DD(LayerID);
UINT32 cLayerID = _DL(LayerID);
//GX_ASSERT(LayerID < LAYER_NUM);
if (cDevID == 0) {
pthisBM = _gBM_1[cLayerID];
}
#if (DEVICE_COUNT >= 2)
if (cDevID == 1) {
pthisBM = _gBM_2[cLayerID];
}
#endif
return pthisBM;
}
static DISPLAY_LAYER *_DL_GetLayer(UINT32 LayerID)
{
DISPLAY_LAYER *pthisDL = 0;
UINT32 cDevID = _DD(LayerID);
UINT32 cLayerID = _DL(LayerID);
//GX_ASSERT(LayerID < LAYER_NUM);
if (cDevID == 0) {
pthisDL = &(_gDL_1[cLayerID]);
}
#if (DEVICE_COUNT >= 2)
if (cDevID == 1) {
pthisDL = &(_gDL_2[cLayerID]);
}
#endif
return pthisDL;
}
static DISPLAY_MIXER *_DL_GetMixer(UINT32 LayerID)
{
DISPLAY_MIXER *pthisDM = 0;
UINT32 cDevID = _DD(LayerID);
if (cDevID == 0) {
pthisDM = &(_gDM_1);
}
#if defined(_BSP_NA51000_)
if (cDevID == 1) {
pthisDM = &(_gDM_2);
}
#endif
return pthisDM;
}
static void *_DL_GetBufferDC(UINT32 LayerID, UINT32 BufferID)
{
void *pDC = 0;
INT32 DevID = _DD(LayerID);
LayerID = _DL(LayerID);
if (DevID == 0) {
if ((LayerID == 0) | (LayerID == 1) | (LayerID == 2) | (LayerID == 3)) {
pDC = _gBM_1[LayerID]->get(BufferID);
}
}
#if (DEVICE_COUNT >= 2)
if (DevID == 1) {
if ((LayerID == 0) | (LayerID == 2)) {
pDC = _gBM_2[LayerID]->get(BufferID);
}
}
#endif
return pDC;
}
static UINT8 _GxDisplay_GetNextBufID(UINT32 LayerID, UINT8 uiBufIndex)
{
DISPLAY_LAYER *pthisDL = _DL_GetLayer(LayerID);
if (pthisDL == NULL) {
return 0;
}
//get next buffer index
uiBufIndex ++;
if (uiBufIndex > pthisDL->uiBufCount) {
uiBufIndex = 0;
}
return uiBufIndex;
}
#if !defined(__FREERTOS)
UINT8 *GxDisplay_InitFB(UINT32 LayerID,UINT32 uiBufAddr,UINT32 uiBufSize,UINT32 uiBufCount)
{
VENDOR_FB_INIT fb_init;
struct fb_fix_screeninfo finfo;
long int screensize = 0;
char *fbp = 0;
int count =1000;
fb_init.fb_id = HD_FB0;
fb_init.pa_addr = uiBufAddr;
fb_init.buf_len = uiBufSize*(uiBufCount+1);
vendor_videoout_set(VENDOR_VIDEOOUT_ID0, VENDOR_VIDEOOUT_ITEM_FB_INIT, &fb_init);
while(count){
fb_fd = open("/dev/fb0", O_RDWR);
if (fb_fd<0) {
usleep(100);
count--;
} else {
break;
}
}
if(fb_fd<0){
DBG_ERR("Error: Cannot open framebuffer device.\n");
return 0;
}
if (ioctl(fb_fd, FBIOGET_FSCREENINFO, &finfo)) {
DBG_ERR("Error reading fixed information.\n");
return 0;
}
screensize = finfo.smem_len;
fbp = (char *)mmap(0, screensize, PROT_READ | PROT_WRITE, MAP_SHARED,fb_fd, 0);
if(uiBufCount)//ping-pong buffer should set yres_virtual for pan disp
{
if (ioctl(fb_fd, FBIOGET_VSCREENINFO, &vinfo)) {
DBG_ERR("Error reading variable information\n");
}
vinfo.xres_virtual = vinfo.xres;
vinfo.yres_virtual = vinfo.yres * 2;
if (ioctl(fb_fd, FBIOPUT_VSCREENINFO, &vinfo) == -1) {
DBG_ERR("Could not set variable screen info!\n");
}
}
return (UINT8 *)fbp;
}
#endif
RESULT GxDisplay_InitLayer(UINT32 LayerID, const LAYER_INIT *pInit, BOOL bClear)
{
DISPLAY_LAYER *pthisDL = 0;
LAYER_BUFMAN *pthisBM = 0;
UINT16 fmt;
register INT8 i;
DBG_FUNC_BEGIN("\r\n");
DBG_IND("uiSwapEffect %x\r\n",pInit->uiSwapEffect);
pthisDL = _DL_GetLayer(LayerID);
if (pthisDL == 0) {
return GX_NULL_DL;
}
pthisBM = _DL_GetBufMan(LayerID);
if (pthisBM == 0) {
DBG_ERR("Lyr(0x%02x) - Buffer manager is not registered!\r\n", LayerID);
return GX_NULL_BUFMAN;
}
//*((LAYER_INIT *)pthisDL) = *pInit;
memcpy((void *)pthisDL,(void *)pInit,sizeof(LAYER_INIT));
fmt = pthisDL->uiPxlfmt;
//check buffer count
if (pthisDL->uiBufCount + 1 > LAYER_BUFFER_NUM) {
DBG_ERR("Lyr(0x%02x) - Too may buffers!\r\n", LayerID);
return GX_OUTOF_BUFCOUNT;
}
//check swap effect
if ((pthisDL->uiBufCount == 0) &&
((pthisDL->uiSwapEffect & BUFATTR_SWAPEFFECT) != SWAPEFFECT_DISCARD)) {
DBG_ERR("Lyr(0x%02x) - Single buffer only DISCARD swapping effect!\r\n", LayerID);
return GX_FAIL_SWAPEFFECT;
}
//check buf size
if (pthisDL->uiBufSize < pthisBM->calcsize((LAYER_INIT *)pthisDL)) {
DBG_ERR("Lyr(0x%02x) - Buffer size is not enough!\r\n", LayerID);
return GX_NOTENOUGH_BUFSIZE;
}
//check buf address
for (i = 0; i <= pthisDL->uiBufCount; i++)
if (pthisDL->pBufAddr[i] == 0) {
DBG_ERR("Lyr(0x%02x) - Some buffer address is not assigned!\r\n", LayerID);
return GX_NULL_BUF;
}
//clear all flag
pthisDL->uiFlag = 0;
//init general state //valid, but not draw, clear dirty
pthisDL->uiFlag &= ~LRFLAG_SIGN_MASK;
pthisDL->uiFlag |= LRFLAG_SIGN;
//init palette state
pthisDL->uiPalCount = 0;
if (fmt == DISP_PXLFMT_INDEX8) {
pthisDL->uiPalCount = 0x100;
}
//update dc
pthisDL->uiFlag |= LRFLAG_INITDC;
//assign first buffer ID
pthisDL->uiBufShowID = 0;
//update window state
pthisDL->uiFlag |= LRFLAG_INITID;
//update window state
pthisDL->uiFlag |= LRFLAG_SETWIN;
#if 0
pthisDL->uiEnable = 0; //initial with disable
pthisDL->uiFlag |= LRFLAG_SETEN;
#else
//do NOT control enable state by GxDisplay_InitLayer()!
//only control enable state by GxDisplay_Set()!
#endif
if (bClear) {
pthisDL->uiFlag |= LRFLAG_CLEAR;
}
return GX_OK;
}
void GxDisplay_ExitLayer(UINT32 LayerID)
{
DISPLAY_LAYER *pthisDL = 0;
LAYER_BUFMAN *pthisBM = 0;
register INT8 i;
DBG_FUNC_BEGIN("\r\n");
pthisDL = _DL_GetLayer(LayerID);
if (pthisDL == 0) {
return;
}
pthisBM = _DL_GetBufMan(LayerID);
if (pthisBM == 0) {
return;
}
if (!((pthisDL->uiFlag & LRFLAG_SIGN_MASK) == LRFLAG_SIGN)) {
DBG_WRN("Lyr(0x%02x) - Layer is not initialized, ignore.\r\n", LayerID);
return; //ignore
}
//del DC
for (i = 0; i <= pthisDL->uiBufCount; i++) {
pthisBM->detach(_DL_GetBufferDC(LayerID, i));
}
pthisDL->uiFlag = 0; //invalid it, clear all dirty
}
void GxDisplay_Init(UINT32 DevID, UINT32 uiDispWidth, UINT32 uiDispHeight)
{
UINT32 cDevID = _DD(DevID);
DBG_FUNC_BEGIN("\r\n");
#if (DEVICE_COUNT < 2)
if (cDevID >= 1) {
DBG_ERR("GxDisplay_Init() fail, DevID%d no support\r\n", cDevID);
return;
}
#endif
//install debug cmd
//GxDisplay_InstallCmd();
//clear MIXER object
{
DISPLAY_MIXER *pthisDM = _DL_GetMixer(_LayerID(cDevID, 0));
if (pthisDM == 0) {
return;
}
memset(pthisDM, 0, sizeof(DISPLAY_MIXER));
//init OSD mix method
pthisDM->uiOSD1KeyOp = COMPARE_KEY_NEVER;
pthisDM->uiOSD1KeyColor = 0;
pthisDM->uiOSD1BlendOp = BLEND_PIXELALPHA;
pthisDM->uiOSD1ConstAlpha = 0xff;
pthisDM->uiOSD2KeyOp = COMPARE_KEY_NEVER;
pthisDM->uiOSD2KeyColor = 0;
pthisDM->uiOSD2BlendOp = BLEND_PIXELALPHA;
pthisDM->uiOSD2ConstAlpha = 0xff;
//init VDO mix method
pthisDM->uiVDO1KeyOp = COMPARE_KEY_NEVER;
pthisDM->uiVDO1KeyColor = COLOR_BLACK;
pthisDM->uiVDO1BlendOp = BLEND_CONSTALPHA;
pthisDM->uiVDO1ConstAlpha = 0xff;
pthisDM->uiVDO2KeyOp = COMPARE_KEY_NEVER;
pthisDM->uiVDO2KeyColor = COLOR_BLACK;
pthisDM->uiVDO2BlendOp = BLEND_CONSTALPHA;
pthisDM->uiVDO2ConstAlpha = 0xff;
//init background - black color
pthisDM->uiBackColor = COLOR_BLACK;
pthisDM->uiAllCtrl = 0;
//_DL_Init(DevID, uiDispWidth, uiDispHeight);
pthisDM->uiFlag = 0;
pthisDM->uiFlag |= LRFLAG_SETOSDMIX;
pthisDM->uiFlag |= LRFLAG_SETVDOMIX;
pthisDM->uiFlag |= LRFLAG_SETCTRL;
pthisDM->PalStart[LAYER_OSD1] = 0;
pthisDM->PalCount[LAYER_OSD1] = 0;
memset(&(pthisDM->Pal[LAYER_OSD1]), 0x00, 256 * sizeof(PALETTE_ITEM));
pthisDM->PalStart[LAYER_OSD2] = 0;
pthisDM->PalCount[LAYER_OSD2] = 0;
memset(&(pthisDM->Pal[LAYER_OSD2]), 0x00, 256 * sizeof(PALETTE_ITEM));
}
//clear all LAYER objects
if (cDevID == 0) {
DISPLAY_LAYER *pthisDL;
pthisDL = _DL_GetLayer(_LayerID(cDevID, LAYER_OSD1));
if (pthisDL != 0) {
memset(pthisDL, 0, sizeof(DISPLAY_LAYER));
}
pthisDL = _DL_GetLayer(_LayerID(cDevID, LAYER_OSD2));
if (pthisDL != 0) {
memset(pthisDL, 0, sizeof(DISPLAY_LAYER));
}
pthisDL = _DL_GetLayer(_LayerID(cDevID, LAYER_VDO1));
if (pthisDL != 0) {
memset(pthisDL, 0, sizeof(DISPLAY_LAYER));
}
pthisDL = _DL_GetLayer(_LayerID(cDevID, LAYER_VDO2));
if (pthisDL != 0) {
memset(pthisDL, 0, sizeof(DISPLAY_LAYER));
}
}
#if (DEVICE_COUNT >= 2)
if (cDevID == 1) {
DISPLAY_LAYER *pthisDL;
pthisDL = _DL_GetLayer(_LayerID(cDevID, LAYER_OSD1));
if (pthisDL != 0) {
memset(pthisDL, 0, sizeof(DISPLAY_LAYER));
}
pthisDL = _DL_GetLayer(_LayerID(cDevID, LAYER_VDO1));
if (pthisDL != 0) {
memset(pthisDL, 0, sizeof(DISPLAY_LAYER));
}
}
#endif
}
void GxDisplay_Exit(UINT32 DevID)
{
UINT32 cDevID = _DD(DevID);
DBG_FUNC_BEGIN("\r\n");
if (cDevID == 0) {
GxDisplay_ExitLayer(_LayerID(cDevID, LAYER_OSD1));
GxDisplay_ExitLayer(_LayerID(cDevID, LAYER_OSD2));
GxDisplay_ExitLayer(_LayerID(cDevID, LAYER_VDO1));
GxDisplay_ExitLayer(_LayerID(cDevID, LAYER_VDO2));
}
#if (DEVICE_COUNT >= 2)
if (cDevID == 1) {
GxDisplay_ExitLayer(_LayerID(cDevID, LAYER_OSD1));
GxDisplay_ExitLayer(_LayerID(cDevID, LAYER_VDO1));
}
#endif
//_DL_Exit();
}
PALETTE_ITEM _gTempPalette[256];
void GxDisplay_SetPalette(UINT32 LayerID, UINT16 uiStartID, UINT16 uiCount, const PALETTE_ITEM *pTable)
{
UINT16 i;
DISPLAY_LAYER *pthisDL = 0;
DISPLAY_MIXER *pthisDM = 0;
UINT32 cLayerID = _DL(LayerID);
DBG_FUNC_BEGIN("\r\n");
pthisDL = _DL_GetLayer(LayerID);
if (pthisDL == 0) {
return;
}
pthisDM = _DL_GetMixer(LayerID);
if (pthisDM == 0) {
return;
}
if (pTable == 0) {
DBG_ERR("Lyr(0x%02x) - no palette , ignore.\r\n", LayerID);
return;
}
if ((cLayerID == LAYER_OSD1)
|| (cLayerID == LAYER_OSD2)) {
for (i = uiStartID; i < uiStartID + uiCount; i++) {
pthisDM->Pal[cLayerID][i] = pTable[i];
}
if (pthisDL->uiFlag & LRFLAG_SETPAL) {
pthisDM->PalStart[cLayerID] = 0;
pthisDM->PalCount[cLayerID] = 256;
} else {
pthisDL->uiFlag |= LRFLAG_SETPAL;
pthisDM->PalStart[cLayerID] = uiStartID;
pthisDM->PalCount[cLayerID] = uiCount;
}
}
}
void GxDisplay_GetPalette(UINT32 LayerID, UINT16 uiStartID, UINT16 uiCount, PALETTE_ITEM *pTable)
{
UINT16 i;
DISPLAY_LAYER *pthisDL = 0;
DISPLAY_MIXER *pthisDM = 0;
UINT32 cLayerID = _DL(LayerID);
DBG_FUNC_BEGIN("\r\n");
pthisDL = _DL_GetLayer(LayerID);
if (pthisDL == 0) {
return;
}
pthisDM = _DL_GetMixer(LayerID);
if (pthisDM == 0) {
return;
}
switch (pthisDL->uiPxlfmt) {
case DISP_PXLFMT_INDEX8:
break;
default:
DBG_ERR("Lyr(0x%02x) - Cannot get palette in this format!\r\n", LayerID);
return;
}
if ((cLayerID == LAYER_OSD1)
|| (cLayerID == LAYER_OSD2)) {
_DL_GetPalette(LayerID,
uiStartID,
uiCount,
pthisDM->Pal[cLayerID] + uiStartID);
for (i = uiStartID; i < uiStartID + uiCount; i++) {
pTable[i - uiStartID] = pthisDM->Pal[cLayerID][i];
}
}
}
void GxDisplay_SetColorKey(UINT32 LayerID, UINT32 enable,UINT32 color)
{
DISPLAY_LAYER *pthisDL = 0;
DISPLAY_MIXER *pthisDM = 0;
UINT32 cLayerID = _DL(LayerID);
DBG_FUNC_BEGIN("\r\n");
pthisDL = _DL_GetLayer(LayerID);
if (pthisDL == 0) {
return;
}
pthisDM = _DL_GetMixer(LayerID);
if (pthisDM == 0) {
return;
}
if ((cLayerID == LAYER_OSD1)
|| (cLayerID == LAYER_OSD2)) {
pthisDM->uiOSD1KeyOp = enable;
pthisDM->uiOSD1KeyColor = color;
pthisDL->uiFlag |= LRFLAG_SETKEY;
}
}
#if REMOVE
BOOL GxDisplay_IsReady(UINT32 LayerID)
{
UINT32 cLayerID = _DL(LayerID);
DBG_FUNC_BEGIN("\r\n");
if (cLayerID < LAYER_NUM) {
DISPLAY_LAYER *pthisDL = 0;
pthisDL = _DL_GetLayer(LayerID);
if (pthisDL == 0) {
return FALSE;
}
return ((pthisDL->uiFlag & LRFLAG_SIGN_MASK) == LRFLAG_SIGN);
} else {
return TRUE;
}
}
UINT32 _DD_GetLayerEn(UINT32 DevID);
void _DD_SetLayerEn(UINT32 DevID, UINT32 EnMask);
#endif
void GxDisplay_Set(UINT32 LayerID, UINT16 nState, UINT32 nValue)
{
UINT32 cLayerID = _DL(LayerID);
UINT32 *pState;
DBG_IND("nState 0x%x nValue 0x%x\r\n",nState,nValue);
if (cLayerID < LAYER_NUM) {
DISPLAY_LAYER *pthisDL = 0;
pthisDL = _DL_GetLayer(LayerID);
if (pthisDL == 0) {
return;
}
pState = (UINT32 *)pthisDL;
//allow disable even this layer is never initialized.
if ((nState == LAYER_STATE_ENABLE) && (nValue == 0)) {
if (!((pthisDL->uiFlag & LRFLAG_SIGN_MASK) == LRFLAG_SIGN)) {
pthisDL->uiFlag = 0;
} else {
//GX_ASSERT((pthisDL->uiFlag & LRFLAG_SIGN_MASK) == LRFLAG_SIGN);
}
}
if (!(nState < LAYER_STATE_NUM)) {
DBG_WRN("Lyr(0x%02x) - Out of state!\r\n", LayerID);
return;
}
//apply state
switch (nState) {
case LAYER_STATE_ENABLE :
nValue = (nValue != 0);
{
pState[nState] = nValue;
pthisDL->uiFlag |= LRFLAG_SETEN;
}
break;
case LAYER_STATE_BUFADDR0:
case LAYER_STATE_BUFADDR1:
case LAYER_STATE_BUFADDR2:
//if(pState[nState] != nValue)
if ((pthisDL->uiSwapEffect & BUFATTR_SWAPEFFECT) == SWAPEFFECT_DISCARD) {
//allow modify buffer address if swapeffect = DISCARD
pState[nState] = nValue;
pthisDL->uiFlag |= LRFLAG_INITDC;
pthisDL->uiFlag |= LRFLAG_SETWIN;
}
break;
case LAYER_STATE_WINX :
case LAYER_STATE_WINY :
case LAYER_STATE_WINW :
case LAYER_STATE_WINH :
case LAYER_STATE_WINATTR :
{
pState[nState] = nValue;
pthisDL->uiFlag |= LRFLAG_SETWIN;
}
break;
case LAYER_STATE_BUFATTR :
{
pState[nState] = nValue;
pthisDL->uiFlag |= LRFLAG_SETSWAP;
}
break;
case LAYER_STATE_INFO :
if (pthisDL->uiFlag & LRFLAG_INITID) { //before init layer flushed
pState[nState] = nValue; //allow user to modifid show id (only)
}
break;
}
} else { //control
DISPLAY_MIXER *pthisDM = 0;
UINT32 cDevID = _DD(LayerID);
INT32 iState = (INT32)nState;
pthisDM = _DL_GetMixer(LayerID);
if (pthisDM == 0) {
return;
}
pState = (UINT32 *)pthisDM;
if (!(iState < CTRL_STATE_NUM)) {
DBG_WRN("Lyr(0x%02x) - Out of state!\r\n", LayerID);
return;
}
//apply state
if ((iState >= CTRL_STATE_BLEND_MIN) && (iState <= CTRL_STATE_BLEND_MAX)) {
{
pState[nState] = nValue;
pthisDM->uiFlag |= LRFLAG_SETCTRL;
if(iState == CTRL_STATE_ALLENABLE) {
if(cDevID == 0) {
_DD_SetLayerEn(DOUT1, nValue);
} else if(cDevID == 1) {
_DD_SetLayerEn(DOUT2, nValue);
}
}
}
}
if ((iState >= CTRL_STATE_OSD_MIN) && (iState <= CTRL_STATE_OSD_MAX)) {
if (pthisDM->uiFlag & LRFLAG_SETCTRL) {
pState[nState] = nValue;
pthisDM->uiFlag |= LRFLAG_SETOSDMIX;
}
}
if ((iState >= CTRL_STATE_VDO_MIN) && (iState <= CTRL_STATE_VDO_MAX)) {
if (pthisDM->uiFlag & LRFLAG_SETCTRL) {
pState[nState] = nValue;
pthisDM->uiFlag |= LRFLAG_SETVDOMIX;
}
}
}
}
UINT32 GxDisplay_Get(UINT32 LayerID, UINT16 nState)
{
UINT32 cLayerID = _DL(LayerID);
UINT32 *pState;
DBG_FUNC_BEGIN("\r\n");
if (cLayerID < LAYER_NUM) {
DISPLAY_LAYER *pthisDL = 0;
pthisDL = _DL_GetLayer(LayerID);
if (pthisDL == 0) {
return 0;
}
pState = (UINT32 *)pthisDL;
if (!(nState < LAYER_STATE_NUM)) {
DBG_WRN("Lyr(0x%02x) - Out of state!\r\n", LayerID);
return 0;
}
if (nState == LAYER_STATE_ENABLE) {
pState[nState] = (_DL_GetEnable(LayerID) != 0); //update state from h/w
}
} else { //control
DISPLAY_MIXER *pthisDM = 0;
UINT32 cDevID = _DD(LayerID);
pthisDM = _DL_GetMixer(LayerID);
if (pthisDM == 0) {
return 0;
}
pState = (UINT32 *)pthisDM;
if(nState == CTRL_STATE_ALLENABLE) {
if(cDevID == 0) {
pState[nState] = _DD_GetLayerEn(DOUT1);
} else if(cDevID == 1) {
pState[nState] = _DD_GetLayerEn(DOUT2);
}
}
if (!(nState < CTRL_STATE_NUM)) {
DBG_WRN("Lyr(0x%02x) - Out of state!\r\n", LayerID);
return 0;
}
}
return pState[nState];
}
static void _GxDisplay_Flush(UINT32 LayerID)
{
UINT32 cLayerID = _DL(LayerID);
//BOOL bDirty = FALSE;
DBG_FUNC_BEGIN("\r\n");
if (cLayerID < LAYER_NUM) {
DISPLAY_LAYER *pthisDL = 0;
BOOL bDelayEnable = FALSE;
pthisDL = _DL_GetLayer(LayerID);
if (pthisDL == 0) {
return;
}
if (!((pthisDL->uiFlag & LRFLAG_SIGN_MASK) == LRFLAG_SIGN)) {
//allow disable even this layer is never initialized.
if ((pthisDL->uiFlag == LRFLAG_SETEN) && (pthisDL->uiEnable == 0)) {
//allow
} else {
DBG_IND("Lyr(0x%02x) - layer not init yet, ignore.\r\n", LayerID);
return; //ignore
}
}
//apply state
if (pthisDL->uiFlag & LRFLAG_SETEN) {
if (pthisDL->uiEnable == 0) {
DBG_IND("set disable\r\n");
_DL_SetEnable(LayerID, pthisDL->uiEnable);
pthisDL->uiFlag &= ~LRFLAG_SETEN;
} else {
bDelayEnable = TRUE;
}
}
if (pthisDL->uiFlag & LRFLAG_SETSWAP) {
if (pthisDL->uiBufCount > 0) {
if ((pthisDL->uiSwapEffect & BUFATTR_SWAPEFFECT) == SWAPEFFECT_DISCARD) {
pthisDL->uiBufDrawID = pthisDL->uiBufShowID;
} else {
pthisDL->uiBufDrawID = _GxDisplay_GetNextBufID(LayerID, pthisDL->uiBufShowID);
}
}
DBG_IND("swap uiBufDrawID %x\r\n",pthisDL->uiBufDrawID);
pthisDL->uiFlag &= ~LRFLAG_SETSWAP;
}
if (pthisDL->uiFlag & LRFLAG_INITID) {
//init buffer state
if ((pthisDL->uiSwapEffect & BUFATTR_SWAPEFFECT) == SWAPEFFECT_DISCARD) {
pthisDL->uiBufDrawID = pthisDL->uiBufShowID;
} else {
pthisDL->uiBufDrawID = _GxDisplay_GetNextBufID(LayerID, pthisDL->uiBufShowID);
}
DBG_IND("init uiBufDrawID %x\r\n",pthisDL->uiBufDrawID);
pthisDL->uiFlag &= ~LRFLAG_INITID;
}
if (pthisDL->uiFlag & LRFLAG_INITDC) {
LAYER_BUFMAN *pthisBM = 0;
register INT8 i;
//UINT16 w,h;
//UINT16 fmt;
DBG_IND("init DC\r\n");
pthisBM = _DL_GetBufMan(LayerID);
if (pthisBM == 0) {
DBG_ERR("Lyr(0x%02x) - Buffer manager is not registered!\r\n", LayerID);
return;
}
if (pthisDL->uiFlag & LRFLAG_DRAW) {
//if DC is on drawing, cannot change window immediately
DBG_ERR("Lyr(0x%02x) - Still under drawing, cannot init DC!\r\n", LayerID);
goto _close_initdc;
}
//w = (UINT16)pthisDL->uiWidth;
//h = (UINT16)pthisDL->uiHeight;
//fmt = pthisDL->uiPxlfmt;
//init DC
for (i = 0; i <= pthisDL->uiBufCount; i++) {
//create DC at buffer
pthisBM->attach(_DL_GetBufferDC(LayerID, i), (LAYER_INIT *)pthisDL, i);
if (pthisDL->uiFlag & LRFLAG_CLEAR) {
//clear DC
pthisBM->clear(_DL_GetBufferDC(LayerID, i));
}
}
_close_initdc:
pthisDL->uiFlag &= ~LRFLAG_INITDC;
pthisDL->uiFlag &= ~LRFLAG_CLEAR;
}
//not only discard should set addr, after init GxDisplay_InitLayer flush should set
//if ((pthisDL->uiSwapEffect & BUFATTR_SWAPEFFECT) == SWAPEFFECT_DISCARD) {
{
DBG_IND("set win & buf\r\n");
//do window setup (first time)
if (pthisDL->uiFlag & LRFLAG_SETWIN) {
UINT32 w, h;
UINT32 fmt;
UINT8 *pBufAddr;
IRECT rwin;
if(pthisDL->uiSwapEffect & SWAPEFFECT_XY) {
h = pthisDL->uiWidth;
w = pthisDL->uiHeight;
rwin.x = pthisDL->win.y;
rwin.y = pthisDL->win.x;
rwin.w = pthisDL->win.h;
rwin.h = pthisDL->win.w;
} else {
w = pthisDL->uiWidth;
h = pthisDL->uiHeight;
rwin.x = pthisDL->win.x;
rwin.y = pthisDL->win.y;
rwin.w = pthisDL->win.w;
rwin.h = pthisDL->win.h;
}
fmt = pthisDL->uiPxlfmt;
pBufAddr = pthisDL->pBufAddr[(UINT8)pthisDL->uiBufShowID];
//destroy buffer
_DL_BufferExit(LayerID);
//create buffer
_DL_BufferInit(LayerID,
w, h, fmt,
(UINT32)pBufAddr,
&rwin,
pthisDL->uiWinAttr);
#if !defined(__FREERTOS)
{
UINT8 *fb_buf=0;
HD_RESULT ERcode=0;
HD_COMMON_MEM_VIRT_INFO vir_meminfo = {0};
vir_meminfo.va = (void *)(pthisDL->pBufAddr[0]);
ERcode = hd_common_mem_get(HD_COMMON_MEM_PARAM_VIRT_INFO, &vir_meminfo);
if ( ERcode != HD_OK) {
DBG_ERR("map fail %d\n",ERcode);
return ;
}
fb_buf = GxDisplay_InitFB(LayerID,(UINT32)vir_meminfo.pa,pthisDL->uiBufSize,pthisDL->uiBufCount);
if(fb_buf) {
pthisDL->pBufAddr[0] = fb_buf;
if(pthisDL->uiBufCount) {
pthisDL->pBufAddr[1] = fb_buf+pthisDL->uiBufSize;
}
} else {
DBG_ERR("fb init fail\r\n");
}
}
#endif
pthisDL->uiFlag &= ~LRFLAG_SETWIN;
}
}
if (pthisDL->uiFlag & LRFLAG_SETEN) {
if (bDelayEnable) {
DBG_IND("set enable\r\n");
_DL_SetEnable(LayerID, pthisDL->uiEnable);
pthisDL->uiFlag &= ~LRFLAG_SETEN;
}
}
} else { //control
DISPLAY_MIXER *pthisDM = 0;
pthisDM = _DL_GetMixer(LayerID);
if (pthisDM == 0) {
return;
}
#if REMOVE
if (pthisDM->uiFlag & LRFLAG_SETOSDMIX) {
UINT32 O1KeyColor, O2KeyColor;
DISPLAY_LAYER *pthisDL = 0;
UINT32 O1Fmt, O2Fmt;
DBG_IND("set osd mix\r\n");
O1KeyColor = 0;
pthisDL = _DL_GetLayer(LAYER_OSD1);
if(pthisDL) {
O1Fmt = pthisDL->uiPxlfmt;
switch(O1Fmt) {
//case DISP_PXLFMT_INDEX1 :
//case DISP_PXLFMT_INDEX2 :
//case DISP_PXLFMT_INDEX4 :
case DISP_PXLFMT_INDEX8 :
//it is a index value
O1KeyColor = pthisDM->Pal[LAYER_OSD1][(UINT8)pthisDM->uiOSD1KeyColor];
break;
case DISP_PXLFMT_ARGB1555_PK :
//it is a 16bits RGB value
O1KeyColor = pthisDM->uiOSD1KeyColor & 0x0000ffff;
O1KeyColor = _DL_GetOSDCk(LayerID, DISP_PXLFMT_ARGB1555_PK, O1KeyColor);
break;
case DISP_PXLFMT_ARGB4444_PK :
//it is a 16bits RGB value
O1KeyColor = pthisDM->uiOSD1KeyColor & 0x0000ffff;
O1KeyColor = _DL_GetOSDCk(LayerID, DISP_PXLFMT_ARGB4444_PK, O1KeyColor);
break;
//case DISP_PXLFMT_ARGB4565_PK :
case DISP_PXLFMT_ARGB8565_PK :
//it is a 16bits RGB value
O1KeyColor = pthisDM->uiOSD1KeyColor & 0x0000ffff;
O1KeyColor = _DL_GetOSDCk(LayerID, DISP_PXLFMT_ARGB8565_PK, O1KeyColor);
break;
case DISP_PXLFMT_ARGB8888_PK :
//it is a 24bits RGB value
O1KeyColor = pthisDM->uiOSD1KeyColor & 0x00ffffff;
O1KeyColor = _DL_GetOSDCk(LayerID, DISP_PXLFMT_ARGB8888_PK, O1KeyColor);
break;
default:
break;
}
}
O2KeyColor = 0;
pthisDL = _DL_GetLayer(LAYER_OSD2);
if(pthisDL) {
O2Fmt = pthisDL->uiPxlfmt;
switch(O2Fmt) {
//case DISP_PXLFMT_INDEX1 :
//case DISP_PXLFMT_INDEX2 :
//case DISP_PXLFMT_INDEX4 :
case DISP_PXLFMT_INDEX8 :
//it is a index value
O2KeyColor = pthisDM->Pal[LAYER_OSD2][(UINT8)pthisDM->uiOSD2KeyColor];
break;
default:
break;
}
}
_DL_SetOSDMix(LayerID, pthisDM->uiAllCtrl,
(UINT8)pthisDM->uiOSD1KeyOp, O1KeyColor, (UINT8)pthisDM->uiOSD1BlendOp, (UINT8)pthisDM->uiOSD1ConstAlpha,
(UINT8)pthisDM->uiOSD2KeyOp, O2KeyColor, (UINT8)pthisDM->uiOSD2BlendOp, (UINT8)pthisDM->uiOSD2ConstAlpha
);
pthisDM->uiFlag &= ~LRFLAG_SETOSDMIX;
}
if (pthisDM->uiFlag & LRFLAG_SETVDOMIX) {
DBG_IND("set vdo mix\r\n");
_DL_SetVDOMix(LayerID, pthisDM->uiAllCtrl,
(UINT8)pthisDM->uiVDO1KeyOp, pthisDM->uiVDO1KeyColor, (UINT8)pthisDM->uiVDO1BlendOp, (UINT8)pthisDM->uiVDO1ConstAlpha,
(UINT8)pthisDM->uiVDO2KeyOp, pthisDM->uiVDO2KeyColor, (UINT8)pthisDM->uiVDO2BlendOp, (UINT8)pthisDM->uiVDO2ConstAlpha
);
pthisDM->uiFlag &= ~LRFLAG_SETVDOMIX;
}
#endif
if (pthisDM->uiFlag & LRFLAG_SETCTRL) {
DBG_IND("set ctrl\r\n");
_DL_SetCtrl(LayerID, pthisDM->uiAllCtrl,
pthisDM->uiBackColor
);
pthisDM->uiFlag &= ~LRFLAG_SETCTRL;
}
}
#if 0
if (bDirty) {
_DL_UpdateOutput(LayerID);
//bDirty = FALSE;
}
#endif
}
void *GxDisplay_BeginDraw(UINT32 LayerID)
{
DISPLAY_LAYER *pthisDL = 0;
LAYER_BUFMAN *pthisBM = 0;
BOOL bCopy;
DBG_FUNC_BEGIN("\r\n");
pthisDL = _DL_GetLayer(LayerID);
if (pthisDL == 0) {
return NULL;
}
pthisBM = _DL_GetBufMan(LayerID);
if (pthisBM == 0) {
return NULL;
}
//deal with BeginDraw re-entry case
if (pthisDL->uiFlag & LRFLAG_DRAW) {
DBG_ERR("Lyr(0x%02x) - BeginDraw before EndDraw!\r\n", LayerID);
return _DL_GetBufferDC(LayerID, pthisDL->uiBufDrawID);
}
//do copy effect
bCopy = 0;
DBG_IND("uiSwapEffect %x\r\n",pthisDL->uiSwapEffect);
switch (pthisDL->uiSwapEffect & BUFATTR_SWAPEFFECT) {
case SWAPEFFECT_DISCARD :
bCopy = 0;
break;
case SWAPEFFECT_COPY :
case SWAPEFFECT_ROTATE:
bCopy = 1;
break;
case SWAPEFFECT_FLIP :
bCopy = 0;
break;
}
if (bCopy) {
DBG_IND("copy buf uiBufShowID:%x to uiBufShowID:%x uiSwapEffect:%x\r\n",pthisDL->uiBufShowID,pthisDL->uiBufDrawID,pthisDL->uiSwapEffect);
//copy show buffer to draw buffer
pthisBM->copy(
_DL_GetBufferDC(LayerID, pthisDL->uiBufDrawID),
_DL_GetBufferDC(LayerID, pthisDL->uiBufShowID),pthisDL->uiSwapEffect,0
);
}
pthisDL->uiFlag |= LRFLAG_DRAW;
//return DC of drawing buffer
return _DL_GetBufferDC(LayerID, pthisDL->uiBufDrawID);
}
void GxDisplay_EndDraw(UINT32 LayerID, void *pLayerBuf)
{
DISPLAY_LAYER *pthisDL = 0;
DBG_FUNC_BEGIN("\r\n");
pthisDL = _DL_GetLayer(LayerID);
//GX_ASSERT((pthisDL->uiFlag & LRFLAG_SIGN_MASK) == LRFLAG_SIGN);
if (pthisDL == 0) {
return;
}
if (pLayerBuf == NULL) {
DBG_ERR("Lyr(0x%02x) - EndDraw without buf!\r\n", LayerID);
return;
}
//deal with BeginDraw re-entry case
if (!(pthisDL->uiFlag & LRFLAG_DRAW)) {
DBG_ERR("Lyr(0x%02x) - EndDraw before BeginDraw!\r\n", LayerID);
return;
}
pthisDL->uiFlag &= ~LRFLAG_DRAW;
pthisDL->uiFlag |= LRFLAG_FLIP;
_DL_Dirty(LayerID, TRUE);
}
#if REMOVE
void GxDisplay_ForceFlip(UINT32 LayerID)
{
DISPLAY_LAYER *pthisDL = 0;
DBG_FUNC_BEGIN("\r\n");
pthisDL = _DL_GetLayer(LayerID);
//GX_ASSERT((pthisDL->uiFlag & LRFLAG_SIGN_MASK) == LRFLAG_SIGN);
if (pthisDL == 0) {
return;
}
pthisDL->uiFlag |= LRFLAG_FLIP;
_DL_Dirty(LayerID, TRUE);
}
#endif
static void _GxDisplay_Flip(UINT32 LayerID)
{
UINT32 cLayerID = _DL(LayerID);
DISPLAY_LAYER *pthisDL = 0;
DISPLAY_MIXER *pthisDM = 0;
BOOL bSwap;
pthisDL = _DL_GetLayer(LayerID);
if (pthisDL == 0) {
return;
}
DBG_IND("uiFlag %x\r\n",pthisDL->uiFlag);
pthisDM = _DL_GetMixer(LayerID);
if (pthisDM == 0) {
return;
}
//check palette flag
if (pthisDL->uiFlag & LRFLAG_SETPAL) {
if ((cLayerID == LAYER_OSD1)
|| (cLayerID == LAYER_OSD2)) {
DBG_IND("set pal \r\n");
_DL_SetPalette(LayerID,
pthisDM->PalStart[cLayerID],
pthisDM->PalCount[cLayerID],
pthisDM->Pal[cLayerID] + pthisDM->PalStart[cLayerID]);
}
pthisDL->uiFlag &= ~LRFLAG_SETPAL;
}
//check key flag,should be set format first
if (pthisDL->uiFlag & LRFLAG_SETKEY) {
if ((cLayerID == LAYER_OSD1)
|| (cLayerID == LAYER_OSD2)) {
DBG_IND("set color key %x \r\n",pthisDM->uiOSD1KeyColor);
_DL_SetColorKey(LayerID,
pthisDL->uiPxlfmt,
pthisDM->uiOSD1KeyOp,
pthisDM->uiOSD1KeyColor);
}
pthisDL->uiFlag &= ~LRFLAG_SETKEY;
}
//check draw flag
if (pthisDL->uiFlag & LRFLAG_DRAW) {
DBG_WRN("Lyr(0x%02x) - Flip before EndDraw, ignore this Flip.\r\n", LayerID);
return; //cannot flip when drawing
}
//check draw flag
if (!(pthisDL->uiFlag & LRFLAG_FLIP) && !(pthisDL->uiFlag & LRFLAG_SETWIN)) {
if (pthisDL->uiEnable) {
DBG_WRN("Lyr(0x%02x) - No BeginDraw~EndDraw, ignore this Flip.\r\n", LayerID);
}
return; //not need to flip
}
//do swap effect
bSwap = 0;
switch (pthisDL->uiSwapEffect & BUFATTR_SWAPEFFECT) {
case SWAPEFFECT_DISCARD :
bSwap = 0;
break;
case SWAPEFFECT_COPY :
case SWAPEFFECT_ROTATE:
bSwap = 1;
break;
case SWAPEFFECT_FLIP :
bSwap = 1;
break;
}
if (bSwap) {
//change new show buffer to old draw buffer
pthisDL->uiBufShowID = pthisDL->uiBufDrawID;
//change old draw buffer to new draw buffer
pthisDL->uiBufDrawID = _GxDisplay_GetNextBufID(LayerID, pthisDL->uiBufDrawID);
DBG_IND("swap uiBufShowID: %x uiBufDrawID: %x \r\n",pthisDL->uiBufShowID,pthisDL->uiBufDrawID);
//do window setup (first time)
if (pthisDL->uiFlag & LRFLAG_SETWIN) {
UINT16 w, h;
UINT16 fmt;
UINT8 *pBufAddr;
IRECT rwin;
DBG_IND("set win & buf\r\n");
if(pthisDL->uiSwapEffect & SWAPEFFECT_XY) {
h = (UINT16)pthisDL->uiWidth;
w = (UINT16)pthisDL->uiHeight;
rwin.x = pthisDL->win.y;
rwin.y = pthisDL->win.x;
rwin.w = pthisDL->win.h;
rwin.h = pthisDL->win.w;
} else {
w = (UINT16)pthisDL->uiWidth;
h = (UINT16)pthisDL->uiHeight;
rwin.x = pthisDL->win.x;
rwin.y = pthisDL->win.y;
rwin.w = pthisDL->win.w;
rwin.h = pthisDL->win.h;
}
fmt = pthisDL->uiPxlfmt;
pBufAddr = pthisDL->pBufAddr[(UINT8)pthisDL->uiBufShowID];
//destroy buffer
_DL_BufferExit(LayerID);
//create buffer
_DL_BufferInit(LayerID,
w, h, fmt,
(UINT32)pBufAddr,
&rwin,
pthisDL->uiWinAttr);
pthisDL->uiFlag &= ~LRFLAG_SETWIN;
} else { //do buffer swap
UINT16 w, h;
UINT16 fmt;
UINT8 *pBufAddr;
if(pthisDL->uiSwapEffect & SWAPEFFECT_XY) {
h = (UINT16)pthisDL->uiWidth;
w = (UINT16)pthisDL->uiHeight;
} else {
w = (UINT16)pthisDL->uiWidth;
h = (UINT16)pthisDL->uiHeight;
}
fmt = pthisDL->uiPxlfmt;
pBufAddr = pthisDL->pBufAddr[(UINT8)pthisDL->uiBufShowID];
DBG_IND("set uiBufShowID:%d addr:%x \r\n",pthisDL->uiBufShowID,pBufAddr);
//swap display layer buffer to new show buffer
_DL_BufferSwitch(LayerID,
w, h, fmt,
(UINT32)pBufAddr);
#if !defined(__FREERTOS)
if(fb_fd)
{
if (ioctl(fb_fd, FBIOGET_VSCREENINFO, &vinfo)) {
DBG_ERR("Error reading variable information\n");
}
vinfo.xoffset = 0;
if(pthisDL->uiBufShowID)
vinfo.yoffset = vinfo.yres;
else
vinfo.yoffset =0;
if (ioctl(fb_fd, FBIOPAN_DISPLAY, &vinfo)) {
DBG_ERR("Error to do pan display. %s\n",strerror(errno));
}
}
#endif
}
} else {
//do window setup (first time)
if (pthisDL->uiFlag & LRFLAG_SETWIN) {
UINT16 w, h;
UINT16 fmt;
UINT8 *pBufAddr;
IRECT rwin;
DBG_IND("set win & buf\r\n");
if(pthisDL->uiSwapEffect & SWAPEFFECT_XY) {
h = (UINT16)pthisDL->uiWidth;
w = (UINT16)pthisDL->uiHeight;
} else {
w = (UINT16)pthisDL->uiWidth;
h = (UINT16)pthisDL->uiHeight;
}
rwin.y = pthisDL->win.x;
rwin.x = pthisDL->win.y;
rwin.w = pthisDL->win.w;
rwin.h = pthisDL->win.h;
fmt = pthisDL->uiPxlfmt;
pBufAddr = pthisDL->pBufAddr[(UINT8)pthisDL->uiBufShowID];
//destroy buffer
_DL_BufferExit(LayerID);
//create buffer
_DL_BufferInit(LayerID,
w, h, fmt,
(UINT32)pBufAddr,
&rwin,
pthisDL->uiWinAttr);
pthisDL->uiFlag &= ~LRFLAG_SETWIN;
}
}
pthisDL->uiFlag &= ~LRFLAG_FLIP;
}
void GxDisplay_FlipEx(UINT32 LayerID, BOOL bWait)
{
UINT32 cDevID = _DD(LayerID);
DBG_FUNC_BEGIN("\r\n");
if (cDevID == 0) {
//begin send Command
_GxDisplay_Flip(_LayerID(cDevID, LAYER_OSD1));
_GxDisplay_Flip(_LayerID(cDevID, LAYER_OSD2));
_GxDisplay_Flip(_LayerID(cDevID, LAYER_VDO1));
_GxDisplay_Flip(_LayerID(cDevID, LAYER_VDO2));
_DL_UpdateOutput(LayerID);
//end send Command
_DL_Dirty(_LayerID(cDevID, LAYER_OSD1), FALSE);
_DL_Dirty(_LayerID(cDevID, LAYER_OSD2), FALSE);
_DL_Dirty(_LayerID(cDevID, LAYER_VDO1), FALSE);
_DL_Dirty(_LayerID(cDevID, LAYER_VDO2), FALSE);
}
#if (DEVICE_COUNT >= 2)
if (cDevID == 1) {
//begin send Command
_GxDisplay_Flip(_LayerID(cDevID, LAYER_OSD1));
_GxDisplay_Flip(_LayerID(cDevID, LAYER_VDO1));
_DL_UpdateOutput(LayerID);
//end send Command
_DL_Dirty(_LayerID(cDevID, LAYER_OSD1), FALSE);
_DL_Dirty(_LayerID(cDevID, LAYER_VDO1), FALSE);
}
#endif
if (bWait) {
//WAIT
_DL_Wait_Load(LayerID); //Wait until last command is loaded completely.
//_DL_Wait_VSync(LayerID); //Wait until last frame is updated completely.
}
}
void GxDisplay_WaitVDEx(UINT32 LayerID)
{
DBG_FUNC_BEGIN("\r\n");
//_DL_Wait_VSync(LayerID);
}
#if REMOVE
/////////////////////////////////////
// Macro function
//void GxDisplay_SetSrcWindow(UINT32 LayerID, LVALUE x, LVALUE y, LVALUE w, LVALUE h)
void GxDisplay_SetSrcWindow(UINT32 LayerID, INT32 x, INT32 y, INT32 w, INT32 h)
{
}
//void GxDisplay_SetDestWindow(UINT32 LayerID, LVALUE x, LVALUE y, LVALUE w, LVALUE h, UINT32 uiMirror)
void GxDisplay_SetDestWindow(UINT32 LayerID, INT32 x, INT32 y, INT32 w, INT32 h, UINT32 uiMirror)
{
GxDisplay_Set(LayerID, LAYER_STATE_WINX, x);
GxDisplay_Set(LayerID, LAYER_STATE_WINY, y);
GxDisplay_Set(LayerID, LAYER_STATE_WINW, w);
GxDisplay_Set(LayerID, LAYER_STATE_WINH, h);
GxDisplay_Set(LayerID, LAYER_STATE_WINATTR, uiMirror);
}
void GxDisplay_SetSwapEffect(UINT32 LayerID, UINT32 uiSwapEffect)
{
UINT32 v, v2;
v = GxDisplay_Get(LayerID, LAYER_STATE_BUFATTR);
v2 = BUFATTR_MAKE(uiSwapEffect, BUFATTR_GET_BUFCOUNT(v));
GxDisplay_Set(LayerID, LAYER_STATE_BUFATTR, v2);
}
#endif
void GxDisplay_FlushEx(UINT32 LayerID, BOOL bWait)
{
UINT32 cDevID = _DD(LayerID);
UINT32 cLayerID = _DL(LayerID);
DBG_FUNC_BEGIN("\r\n");
if (cLayerID == LAYER_ALL) {
if (!bWait) {
_DL_SetAutoWait(LayerID, FALSE);
}
if (cDevID == 0) {
// _GxDisplay_Flush(_LayerID(cDevID, LAYER_OUTPUT)); //not support control
_GxDisplay_Flush(_LayerID(cDevID, LAYER_VDO1));
_GxDisplay_Flush(_LayerID(cDevID, LAYER_VDO2));
_GxDisplay_Flush(_LayerID(cDevID, LAYER_OSD1));
_GxDisplay_Flush(_LayerID(cDevID, LAYER_OSD2));
}
#if (DEVICE_COUNT >= 2)
if (cDevID == 1) {
// _GxDisplay_Flush(_LayerID(cDevID, LAYER_OUTPUT)); //not support control
_GxDisplay_Flush(_LayerID(cDevID, LAYER_VDO1));
_GxDisplay_Flush(_LayerID(cDevID, LAYER_OSD1));
}
#endif
if (!bWait) {
_DL_SetAutoWait(LayerID, TRUE);
}
} else { //Only 1 LAYER
if (!bWait) {
_DL_SetAutoWait(LayerID, FALSE);
}
_GxDisplay_Flush(LayerID);
if (!bWait) {
_DL_SetAutoWait(LayerID, TRUE);
}
}
}
//--------------------------------------------------------------------------------------
// function - others (internal render function)
//--------------------------------------------------------------------------------------
UINT32 GxRender_GetRenderObject(void)
{
return _gDisp_RenderOBJ;
}
void GxRender_SetScale(int scale)
{
}
#if REMOVE
void GxRender_TriggerInput(UINT32 LayerID)
{
_DL_Dirty(LayerID, TRUE);
//_GxDisplay_Flip(LayerID);
}
void GxRender_SetInputCB(UINT32 LayerID, GXRENDER_INPUT_CB pfInputCB)
{
}
#endif
//thread-safe API
void GxRender_Reflash(void)
{
_DL_UpdateOutput(DOUT1);
}
Reference in New Issue View Git Blame Copy Permalink