msapi_gop.c

mstar 776 开发的车载dvd

            x = ((x + pixLines) % winW);
            break;

        default:
            break;
    }
    rolX[winId] = x;
    rolY[winId] = y;
    msAPI_GOP_GWIN_SetWinPositionOffset(winId, x, y);
    }
    else
    {
        msAPI_GOP_GWIN_SetWinPositionOffset(winId, 0, 0);
    }
    return;
}

/*****************************************************************************/
// not used
void msAPI_GOP_GWIN_GetScrollPosition(U8 winId, U16 *scrX, U16 *scrY)
{
    GOP_GWIN_INFO gwin;

    if (!MDrv_GOP_GWIN_IsGwinExist(winId))
    {
        DEBUG_INFO( printf("msAPI_GOP_GWIN_ScrollLine: winId=%d is not in existence\n",winId));
        return;
    }

    MDrv_GOP_GWIN_Enable(winId, FALSE);
    MDrv_GOP_GWIN_GetWinInfo(winId, &gwin);
    *scrX = (U16)(gwin.u32scrX << 2);  // unit: 4-pix
    *scrY = (U16)(gwin.u32scrY << 2);
    MDrv_GOP_GWIN_Enable(winId, TRUE);
    return;
}

#endif

/*****************************************************************************/
/// Get the free GWIN id
/// @return the GWIN id
/*****************************************************************************/
U8 msAPI_GOP_GWIN_GetFreeWinID(void)
{
    U8 GWID = 0xFF;
    U8 i;

    for(i = 0; i < MAX_GWIN_SUPPORT; i++)
    {
        if(!MDrv_GOP_GWIN_IsGwinExist(i))
        {
            GWID = i;
            break;
        }
    }
	return GWID;
}


/*****************************************************************************/
/// Get the free GWIN id
/// @return the GWIN id
/*****************************************************************************/
U8 msAPI_GOP_GWIN_GetMaxFreeWinID(void)
{
    U8 GWID = 0xFF;
    U8 i;

    for(i = MAX_GWIN_SUPPORT; i >-1; i--)
    {
        if(!MDrv_GOP_GWIN_IsGwinExist(i))
        {
            GWID = i;
            break;
        }
    }
	return GWID;
}


/*****************************************************************************/
// not used
U8 msAPI_GOP_GWIN_GetFreeFBID(void)
{
    U8 i;
    U8 FBId = 0xFF;

	for(i=0; i<MAX_GWIN_FB_SUPPORT; i++)
	{
    	if(!MDrv_GOP_GWIN_IsFBExist(i))
    	{
    	    FBId = i;
    	    break;
    	}
    }
	return FBId;
}

/******************************************************************************/
/// Change a GWIN's frame buffer, this enables an off screen buffer to be shown
/// @param u8GEFrameBuffer_ID \b IN frame buffer id
/// @param u8GWID \b IN GWIN id
/******************************************************************************/
void msAPI_GOP_GWIN_MapFBToWIN(U8 u8GEFrameBuffer_ID, U8 u8GWID)
{
	MDrv_GOP_GWIN_MapFB2Win(u8GEFrameBuffer_ID, u8GWID);
}
/*
void msAPI_GOP_GWIN_MapFBToWIN1(U8 u8GEFrameBuffer_ID, U8 u8GWID)
{
    GOP_GWIN_INFO gwin;
    Gwin_FB_Attr fbAttr;

	MDrv_GOP_GWIN_GetFBInfo(u8GEFrameBuffer_ID, &fbAttr);
    MDrv_GOP_GWIN_GetWinInfo(u8GWID, &gwin);

    gwin.u32DRAMRBlkStart = fbAttr.addr;


    MDrv_GOP_GWIN_SetWinInfo(u8GWID, &gwin);
}
*/
/******************************************************************************/
/// Create frame buffer, (width * height * 2) bytes will be allocated from SDRAM
/// @param FBId  \b IN frame buffer id 0 ~ (MAX_GWIN_FB_SUPPORT - 1)
/// @param width \b IN width
/// @param height \b IN height
/// @param fbFmt \b IN frame buffer format
/******************************************************************************/
U8 msAPI_GOP_GWIN_CreateFB(U8 FBId, U16 width, U16 height, U16 fbFmt)
{
    if (MDrv_GOP_GWIN_CreateFB(FBId, 0, 0, width, height, fbFmt) == GWIN_OK)
    {
	    return TRUE;
    }
	else
    {
	    return FALSE;
    }
}

/******************************************************************************/
/// Set GE to render on the frame buffer
/// @param fbId \b IN frame buffer id
/******************************************************************************/
void msAPI_GOP_GWIN_Switch2FB(U8 fbId)
{
    MDrv_GOP_GWIN_Switch2FB(fbId);
}

/******************************************************************************/
/// Destroy a frame buffer
/// @param fbId \b IN frame buffer id
/******************************************************************************/
void msAPI_GOP_GWIN_DeleteFB(U8 fbId)
{
    MDrv_GOP_GWIN_DestroyFB(fbId);
}

#if (KEEP_UNUSED_FUNC == 1)
/*****************************************************************************/
// not used
U8 msAPI_GOP_GWIN_GetOSDID(void)
{
    return MAX_GWIN_SUPPORT;
}

/*****************************************************************************/
// not used
void msAPI_GOP_GWIN_Swap(U8 gId0, U8 gId1)
{
    MDrv_GOP_GWIN_Swap(gId0, gId1);
}
#endif
/********************************************************************************/
/// Set GWIN alpha blending
/// @param u8win \b IN GWIN id
/// @param bEnable \b IN
///   - # TRUE enable alpha blending
///   - # FALSE disable alpha blending
/// @param u8coef \b IN alpha blending coefficient (0-7)
/********************************************************************************/
void msAPI_GOP_GWIN_SetBlending(U8 u8win, BOOLEAN bEnable, U8 u8coef)
{
       if(u8win >=4)
        u8win -=4;
	MDrv_GOP_GWIN_SetBlending(u8win,bEnable,u8coef);
}
#if 1
/*****************************************************************************/
// not used
void msAPI_GOP_RGB_Data_Mode_Select(U8 bEnable)
{
    if(bEnable)
    {
    }
}
#endif
/********************************************************************************/
/// Set transparent color and enable it for the GWIN
/// @param clr \b IN transparent color
/********************************************************************************/
void msAPI_GOP_GWIN_SetFMT0TransClr(U16 clr)
{
	MDrv_GOP_GWIN_SetTransClr(GOPTRANSCLR_FMT0,clr);
	MDrv_GOP_GWIN_EnableTransClr(GOPTRANSCLR_FMT0,TRUE);
}
/*****************************************************************************/
// not used
U8 msAPI_GOP_GWIN_GetMAXFBID(void)
{
	return MAX_GWIN_FB_SUPPORT;
}

/*****************************************************************************/
/// Get max GWIN id
/// @return the maximum number of GWIN id
/*****************************************************************************/
U8 msAPI_GOP_GWIN_GetMAXWinID(void)
{
	return MAX_GWIN_SUPPORT;
}
/*****************************************************************************/

void msAPI_GOP_GWIN_SetGOPInit(void)
{
	U8 u8Loop_i;

	for (u8Loop_i=0; u8Loop_i < MAX_GWIN_SUPPORT; u8Loop_i++)
	{
		rolX[u8Loop_i] = 0;
		rolY[u8Loop_i] = 0;
		msAPI_GOP_GWIN_SetWinPositionOffset(u8Loop_i, rolX[u8Loop_i], rolY[u8Loop_i]);
	}
}
#if 1
/*****************************************************************************/
void msAPI_GOP_GWIN_SetHScroll(U8 nWinID, U8 nRate, BOOLEAN bEnable)
{
    MDrv_GOP_GWIN_SetScrollRate(nRate);
    MDrv_GOP_GWIN_SetHScroll(nWinID, GOP_SCROLL_LEFT, bEnable);
}

/*****************************************************************************/
void msAPI_GOP_GWIN_SetVScroll(U8 nWinID, U8 nRate, BOOLEAN bEnable)
{
    MDrv_GOP_GWIN_SetScrollRate(nRate);
    MDrv_GOP_GWIN_SetVScroll(nWinID, GOP_SCROLL_UP, bEnable);
    //MDrv_GOP_GWIN_SetVScroll(nWinID, GOP_SCROLL_DOWN, bEnable);
}
#endif

/*****************************************************************************/
void msAPI_GOP_GWIN_SetAlphaValue(U16 * Gwin01AlphaValue, U16 * Gwin23AlphaValue)
{
    MDrv_GOP_GWIN_SetAlpha(Gwin01AlphaValue, Gwin23AlphaValue);
}

/*****************************************************************************/
void msAPI_GOP_GWIN_GetAlphaValue(U16 * Gwin01AlphaValue, U16 * Gwin23AlphaValue)
{
    MDrv_GOP_GWIN_GetAlpha(Gwin01AlphaValue, Gwin23AlphaValue);
}

/*****************************************************************************/
void msAPI_GOP_GWIN_SetPallete(void)
{
    MDrv_GOP_GWIN_SetPalette();
}

/*****************************************************************************/

void msAPI_GOP_GWIN_MapFB2Win(U8 fbId, U8 gwinId)
{
    MDrv_GOP_GWIN_MapFB2Win(fbId,gwinId);
}

void msAPI_GOP_GWIN_ReleaseWin(U8 gId)
{
    MDrv_GOP_GWIN_ReleaseWin(gId);
}

U8 msAPI_GOP_GWIN_DestroyFB(U8 fbId)
{
    return MDrv_GOP_GWIN_DestroyFB(fbId);
}

void msAPI_GOP_GWIN_GetWinPosition(U8 winId, U16 * dispX, U16 *dispY)
{
    GOP_GWIN_INFO gwin;

    if (!MDrv_GOP_GWIN_IsGwinExist(winId))
    {
        DEBUG_INFO( printf("msAPI_GOP_GWIN_GetWinPosition: winId=%d is not in existence\n",winId));
        return;
    }

        MDrv_GOP_GWIN_GetWinInfo(winId, &gwin);
	 *dispX = gwin.u16DispHPixelStart;
	 *dispY = gwin.u16DispVPixelStart;
}

U8 msAPI_GOP_GWIN_GetFBfromGWIN(U8 gwinId) {
    return MDrv_GOP_GWIN_GetFBfromGWIN(gwinId);
}

void msAPI_GOP_GWIN_GetFBRegion(U8 fbID, U16 *pX, U16 *pY, U16 *pW, U16 *pH)
{
    Gwin_FB_Attr fbAttr;
    MDrv_GOP_GWIN_GetFBInfo(fbID, &fbAttr);
    *pX = fbAttr.x0;
    *pY = fbAttr.y0;
    *pW = fbAttr.width;
    *pH = fbAttr.height;
}

void msAPI_GOP_GWIN_GetFBPosition(U8 fbID, U16 *pX, U16 *pY)
{
    Gwin_FB_Attr fbAttr;
    MDrv_GOP_GWIN_GetFBInfo(fbID, &fbAttr);
    *pX = fbAttr.x0;
    *pY = fbAttr.y0;
}

U8 msAPI_GOP_GWIN_CreateFB2(U8 FBId, U16 x, U16 y, U16 width, U16 height, U16 fbFmt)
{
    U8    alignFactor;

    alignFactor = x%4;
    if(0 != alignFactor)
    {
        x = x - alignFactor;
        width = width + alignFactor;
    }

    alignFactor = width%4;
    if(0 != alignFactor)
    {
        width = width + 4 - alignFactor;
    }

    if (MDrv_GOP_GWIN_CreateFB(FBId, x, y, width, height, fbFmt) == GWIN_OK)
    {
	    return TRUE;
    }
	else
    {
	    return FALSE;
    }
}
void msAPI_GOP_GWIN_GetFBInfo(U8 fbId, Gwin_FB_Attr *fbAttr)
{
  MDrv_GOP_GWIN_GetFBInfo(fbId,fbAttr);
}
#undef MSAPI_GOP_C