drvgop.c

mstar 776 开发的车载dvd

        gwinMap[index] = GWIN_ID_INVALID;
    }

    MDrv_GE_GetFrameBufferInfo(&width, &height, &pitch, &fbFmt, &addr);
    gwinFB[MAX_GWIN_FB_SUPPORT].enable = TRUE;
    gwinFB[MAX_GWIN_FB_SUPPORT].allocated = TRUE;
    gwinFB[MAX_GWIN_FB_SUPPORT].gWinId = MAX_GWIN_SUPPORT;
    gwinFB[MAX_GWIN_FB_SUPPORT].x0 = 0;
    gwinFB[MAX_GWIN_FB_SUPPORT].y0 = 0;
    gwinFB[MAX_GWIN_FB_SUPPORT].width = width;
    gwinFB[MAX_GWIN_FB_SUPPORT].height = height;
    gwinFB[MAX_GWIN_FB_SUPPORT].x1  = gwinFB[MAX_GWIN_FB_SUPPORT].x0 + gwinFB[MAX_GWIN_FB_SUPPORT].width;
    gwinFB[MAX_GWIN_FB_SUPPORT].y1  = gwinFB[MAX_GWIN_FB_SUPPORT].y0 + gwinFB[MAX_GWIN_FB_SUPPORT].height;
    gwinFB[MAX_GWIN_FB_SUPPORT].pitch = (pitch & 0xFFF8);  // pitch must be 4-pix alignment;
    gwinFB[MAX_GWIN_FB_SUPPORT].addr   = addr;
    gwinFB[MAX_GWIN_FB_SUPPORT].size  =  ((U32)width) * ((U32)height) * ((U32)bytePerPix);
    // FB format
    gwinFB[MAX_GWIN_FB_SUPPORT].fbFmt  = fbFmt;
    // update ptrs
    gwinFB[MAX_GWIN_FB_SUPPORT].prev = GWIN_SDRAM_NULL;
    gwinFB[MAX_GWIN_FB_SUPPORT].next = GWIN_SDRAM_NULL;

    gwinMap[MAX_GWIN_SUPPORT] = MAX_GWIN_FB_SUPPORT;

}

/******************************************************************************/
/// Create GWIN
/// @param dispX \b IN x
/// @param dispY \b IN y
/// @param width \b IN width
/// @param height \b IN height
/// @param fbFmt \b IN frame buffer pixel format
///   - #0xFFFF default FB format
/// @see MDrv_GOP_GWIN_DestroyWin
/******************************************************************************/
U8 MDrv_GOP_GWIN_CreateWin(U16 dispX, U16 dispY, U16 width, U16 height,  U16 fbFmt)
{
    U8 bytePerPix = 2;
    U8 gId, fbId;
    GOP_GWIN_INFO gWin;

    // look for an availavle gwin index
    for (gId = 0; gId < MAX_GWIN_SUPPORT; gId++ )
    {
        if (gwinMap[gId] == GWIN_ID_INVALID)
        {
            break;
        }
    }
    if (gId >= MAX_GWIN_SUPPORT)
    {
     GOP_DEBUGINFO(printf("MDrv_GOP_GWIN_CreateWin: gwin max already reached, cannot open new win\n"));
        return GWIN_NO_AVAILABLE;
    }

    GOP_DEBUGINFO(printf("MDrv_GOP_GWIN_CreateWin: new gwinId = %bd \r\n", gId));

    // look for available Sdram slot
    for (fbId = 0; fbId < MAX_GWIN_FB_SUPPORT; fbId++)
    {
        if (gwinFB[fbId].allocated == FALSE)
        {
            break;
        }
    }

    if (MDrv_GOP_GWIN_CreateFB(fbId, dispX, dispY, width, height,  fbFmt) != GWIN_OK)
    {
        GOP_DEBUGINFO(printf("MDrv_GOP_GWIN_CreateWin: failed to create FB\n"));
        return GWIN_NO_AVAILABLE;
    }

    // update gwin_map
    gwinMap[gId] = fbId;

    MDrv_GOP_GWIN_Enable(gId, FALSE);
    gwinFB[fbId].enable = TRUE;
    gwinFB[fbId].gWinId = gId;

    gWin.u16DispHPixelStart = gwinFB[fbId].x0;
    gWin.u16DispVPixelStart = gwinFB[fbId].y0;
    gWin.u16RBlkHPixSize = gwinFB[fbId].width;
    gWin.u16RBlkVPixSize = gwinFB[fbId].height;
    gWin.u16RBlkHRblkSize = gwinFB[fbId].pitch;
    gWin.u16DispHPixelEnd = gwinFB[fbId].x1;
    gWin.u16DispVPixelEnd = gwinFB[fbId].y1;
    gWin.u32DRAMRBlkStart = gwinFB[fbId].addr;
    gWin.u16WinX = gWin.u16WinY = 0;
    gWin.clrType = MDrv_GOP_GWIN_BufFmtMap(0, gwinFB[fbId].fbFmt);

    // update gwin regs
    MDrv_GOP_GWIN_SetWinInfo(gId, &gWin);
    // MDrv_GOP_GWIN_Enable(gId, TRUE); // Enable it may cause flicker

    return (gId);
}
#if ( KEEP_UNUSED_FUNC == 1 )
/******************************************************************************/
/// Get corresponding frame buffer attribute from a GWIN id
/// @param gId \b IN \copydoc GWINID
/// @param x0 \b OUT buffer to store left top x
/// @param y0 \b OUT buffer to store left top y
/// @param width \b OUT buffer to store width
/// @param height \b OUT buffer to store height
/// @param fbPitch \b OUT buffer to store pitch
/// @param fbFmt \b OUT buffer to store FB format
/// @param addr \b OUT buffer to store addr
/// @param size \b OUT buffer to store size
/******************************************************************************/
void MDrv_GOP_GWIN_GetWinAttr(U8 gId, U16 *x0, U16 *y0, U16 *width, U16 *height,  U16 *fbPitch, U16 *fbFmt, U32 *addr, U32 *size)
{
    U8 fbId;

    if ((gId > MAX_GWIN_SUPPORT))
    {
        GOP_DEBUGINFO( printf( "MDrv_GOP_GWIN_GetWinAttr(Id....), gId out of bound\n" ) );
        return;
    }

    fbId = gwinMap[gId];

    if ((fbId == GWIN_ID_INVALID) || (gwinFB[fbId].allocated== FALSE))
    {
        GOP_DEBUGINFO( printf("MDrv_GOP_GWIN_GetWinAttr: gId=%d not allocated\n",gId));
        return;
    }

    if(fbId >= MAX_GWIN_FB_SUPPORT)
    {
        GOP_DEBUGINFO( printf( "MDrv_GOP_GWIN_GetWinAttr(Id....), gId --> fb out of bound\n" ) );
        return;
    }

    *x0 = gwinFB[fbId].x0;
    *y0 = gwinFB[fbId].y0;
    *width = gwinFB[fbId].width;
    *height = gwinFB[fbId].height;
    *fbPitch = gwinFB[fbId].pitch;
    *fbFmt = gwinFB[fbId].fbFmt;
    *addr = gwinFB[fbId].addr;
    *size = gwinFB[fbId].size;

    return;
}
#endif
/******************************************************************************/
/// Set GWIN register to initial value and free corresponding frame buffe
/// @param gId \b IN \copydoc GWINID
/******************************************************************************/
void MDrv_GOP_GWIN_DestroyWin(U8 gId)
{
    U8 fbId;
    GOP_GWIN_INFO gWin;

    if (gId >= MAX_GWIN_SUPPORT )
    {
        GOP_DEBUGINFO( printf( "MDrv_GOP_GWIN_DestroyWin(Id....), gId out of bound\n" ) );
        return;
    }

    MDrv_GOP_GWIN_Enable(gId, FALSE);
    fbId = gwinMap[gId];

    if ((MDrv_GOP_GWIN_DestroyFB(fbId)) != GWIN_OK)
    {
        GOP_DEBUGINFO( printf( "MDrv_GOP_GWIN_DestroyWin(Id....), failed to delete FB %bd\n", fbId ) );
        return;
    }

    gwinMap[gId] = GWIN_ID_INVALID;

    gWin.u16DispHPixelStart = 0;
    gWin.u16DispVPixelStart = 0;
    gWin.u16DispHPixelEnd = 0;
    gWin.u16DispVPixelEnd = 0;
    gWin.u16RBlkHPixSize = 0;
    gWin.u16RBlkVPixSize = 0;
    gWin.u16RBlkHRblkSize = 0;
    gWin.u32DRAMRBlkStart  = 0;
    gWin.u16WinX = gWin.u16WinY = 0;
    gWin.clrType = 0;

    if(gId>=4)
        gId -=4;
    MDrv_GOP_GWIN_SetWinInfo(gId, &gWin);
}

/******************************************************************************/
/// Get the GWIN id that GE is currently rendering on
/// @return \copydoc GWINID
/******************************************************************************/
U8 MDrv_GOP_GWIN_GetCurrentWinId()
{
    return Gwin_Current;
}

/******************************************************************************/
/// Switch GE to render on a GWIN's frame buffer
/// @param gId \b IN \copydoc GWINID
/******************************************************************************/
void MDrv_GOP_GWIN_Switch2Win(U8 gId)
{
    U8 fbId;

    if (gId > MAX_GWIN_SUPPORT)  // may go to GWIN_OSD_DEFAULT (==MAX_GWIN_SUPPORT) for OSD
    {
        GOP_DEBUGINFO( printf( "MDrv_GOP_GWIN_Switch2Win(Id....), out of bound\n" ) );
        return;
    }

    fbId = gwinMap[gId];

    if ((fbId == GWIN_ID_INVALID) || (gwinFB[fbId].allocated== FALSE))
    {
        GOP_DEBUGINFO( printf("MDrv_GOP_GWIN_GetWinAttr: gId=%d not allocated\n",gId));
        return;
    }

    Gwin_Prev = Gwin_Current;
    Gwin_Current = gId;

    //printf("\r\n MDrv_GOP_GWIN_Switch2Win>W:%u, H:%u, P:%u, Addr:0x%08LX ", gwinFB[fbId].width, gwinFB[fbId].height, gwinFB[fbId].pitch, gwinFB[fbId].addr);
    MDrv_GE_SetFrameBufferInfo(gwinFB[fbId].width, gwinFB[fbId].height, gwinFB[fbId].pitch, gwinFB[fbId].fbFmt, gwinFB[fbId].addr);
}

/******************************************************************************/
/// Switch GE to render on previous GWIN's frame buffer.
/// default previous GWIN is GWIN_OSD_DEFAULT
/******************************************************************************/
#if ( KEEP_UNUSED_FUNC == 1 )

void MDrv_GOP_GWIN_Back2PrevWin()
{
    MDrv_GOP_GWIN_Switch2Win(Gwin_Prev);
}

/******************************************************************************/
/// Switch GE to render on OSD frame buffer
/******************************************************************************/
void MDrv_GOP_GWIN_Back2DefaultOSDWin()
{
    MDrv_GOP_GWIN_Switch2Win(GWIN_OSD_DEFAULT);
}
#endif
/******************************************************************************/
/// Check if GWIN is created
/// @param gId \b IN \copydoc GWINID
/******************************************************************************/
U8   MDrv_GOP_GWIN_IsGwinExist(U8 gId)
{

    if ((gId > MAX_GWIN_SUPPORT) || (gwinMap[gId]>MAX_GWIN_FB_SUPPORT) || \
        (gwinFB[gwinMap[gId]].allocated == FALSE) || (gwinMap[gId] == GWIN_ID_INVALID))
    {
        return FALSE;
    }

    return TRUE;
}

/******************************************************************************/
/// Move a GWIN's display left top position
/// @param gId  \b IN \copydoc GWINID
/// @param dispX \b IN left top x
/// @param dispY \b IN left top y
/******************************************************************************/
void MDrv_GOP_GWIN_SetWinDispPosition(U8 gId, U16 dispX, U16 dispY)
{
    GOP_GWIN_INFO gWin;
    U8 fbId;

    if (gId >= MAX_GWIN_SUPPORT )
    {
        GOP_DEBUGINFO( printf( "MDrv_GOP_GWIN_SetWinDispPosition(Id....), gId out of bound\n" ) );
        return;
    }

    fbId = gwinMap[gId];

    if ((fbId == GWIN_ID_INVALID) || (gwinFB[fbId].allocated== FALSE))
    {
        GOP_DEBUGINFO( printf("MDrv_GOP_GWIN_SetWinDispPosition: gId=%d not allocated\n",gId));
        return;
    }

    if (fbId > MAX_GWIN_FB_SUPPORT)
    {
        GOP_DEBUGINFO( printf( "MDrv_GOP_GWIN_SetWinDispPosition(Id....), gId --> fb out of bound\n" ) );
        return;
    }
    if(gId >=4)
        gId -=4;
    MDrv_GOP_GWIN_GetWinInfo(gId, &gWin);

    gwinFB[fbId].x0 = gWin.u16DispHPixelStart = dispX;
    gwinFB[fbId].y0 = gWin.u16DispVPixelStart = dispY;
    gwinFB[fbId].x1 = gWin.u16DispHPixelEnd = dispX + gwinFB[fbId].width;
    gwinFB[fbId].y1 = gWin.u16DispVPixelEnd = dispY + gwinFB[fbId].height;

    //printf("\r\n MDrv_GOP_GWIN_SetWinDispPosition>");
    //printf("(%u, %u)-(%u, %u)", gwinFB[fbId].x0, gwinFB[fbId].y0, gwinFB[fbId].x1, gwinFB[fbId].y1);
    MDrv_GOP_GWIN_SetWinInfo(gId, &gWin);
}

/******************************************************************************/
/// Move and Resize a GWIN
/// @param WinProperty \b IN \copydoc GOP_GWIN_DISP_PROPERTY
/******************************************************************************/
void MDrv_GOP_GWIN_SetWinViewPosition(GOP_GWIN_DISP_PROPERTY WinProperty)
{
    GOP_GWIN_INFO gWin;
    U8 fbId;

    if (WinProperty.gId >= MAX_GWIN_SUPPORT )
    {
        GOP_DEBUGINFO( printf( "MDrv_GOP_GWIN_SetWinProperty(Id....), gId out of bound\n" ) );
        return;
    }

    fbId = gwinMap[WinProperty.gId];

    if ((fbId == GWIN_ID_INVALID) || (gwinFB[fbId].allocated== FALSE))
    {
        GOP_DEBUGINFO( printf("MDrv_GOP_GWIN_SetWinProperty: gId=%d not allocated\n",WinProperty.gId));
        return;
    }

    if (fbId > MAX_GWIN_FB_SUPPORT)
    {
        GOP_DEBUGINFO( printf( "MDrv_GOP_GWIN_SetWinProperty(Id....), gId --> fb out of bound\n" ) );
        return;
    }

    MDrv_GOP_GWIN_GetWinInfo(WinProperty.gId, &gWin);

    gwinFB[fbId].x0 = gWin.u16DispHPixelStart = WinProperty.StartX;
    gwinFB[fbId].y0 = gWin.u16DispVPixelStart = WinProperty.StartY;
    gwinFB[fbId].x1 = gWin.u16DispHPixelEnd = WinProperty.StartX + WinProperty.Win_Width;
    gwinFB[fbId].y1 = gWin.u16DispVPixelEnd = WinProperty.StartY + WinProperty.Win_Height;

    MDrv_GOP_GWIN_SetWinInfo(WinProperty.gId, &gWin);
}

/******************************************************************************/
/// Move, Resize and scroll a GWIN
/// @param WinProperty \b IN \copydoc GOP_GWIN_DISP_PROPERTY
/******************************************************************************/
void MDrv_GOP_GWIN_SetWinProperty(GOP_GWIN_DISP_PROPERTY WinProperty)
{
    GOP_GWIN_INFO gWin;
    U8 fbId;

    if (WinProperty.gId >= MAX_GWIN_SUPPORT )
    {
        GOP_DEBUGINFO( printf( "MDrv_GOP_GWIN_SetWinProperty(Id....), gId out of bound\n" ) );
        return;
    }

    fbId = gwinMap[WinProperty.gId];

    if ((fbId == GWIN_ID_INVALID) || (gwinFB[fbId].allocated== FALSE))
    {
        GOP_DEBUGINFO( printf("MDrv_GOP_GWIN_SetWinProperty: gId=%d not allocated\n",WinProperty.gId));
        return;
    }

    if (fbId > MAX_GWIN_FB_SUPPORT)
    {
        GOP_DEBUGINFO( printf( "MDrv_GOP_GWIN_SetWinProperty(Id....), gId --> fb out of bound\n" ) );
        return;
    }

    MDrv_GOP_GWIN_GetWinInfo(WinProperty.gId, &gWin);

    gwinFB[fbId].x0 = gWin.u16DispHPixelStart = WinProperty.Sta