gfx_inf_helper.c

IBM source for pallas/vulcan/vesta

int gfx_inf_h_set_screen_info(GFX_SCREEN_INFO_T *pInfo)
{
    int i;
    
    UINT oldLeft, oldUpper;
    
    if(NULL == pInfo)
    {
        PDEBUG("Bad parm\n");
        return -1;
    }
    /////////////////////////////
    if(os_get_mutex(gGFXMutex))
    {
        PDEBUG("Failed on mutex!\n");
        return -1;
    }
    
    oldLeft = gScreenInfo.uLeft;
    oldUpper = gScreenInfo.uUpper;
    
    _OS_MEMCPY(&gScreenInfo, pInfo, sizeof(GFX_SCREEN_INFO_T));

    // adjust cursor
    {
        int x,y, rtn;
        rtn =  osd_osi_get_cursor_position(&x, &y);
        if(0 == rtn)
        {
            if(x < (INT)gScreenInfo.uLeft) x = 0;
            else x = x - (INT)gScreenInfo.uLeft;
            if(y < (INT)gScreenInfo.uUpper) y = 0;
            else y = y - (INT)gScreenInfo.uUpper;

            osd_osi_set_cursor_position(x + (INT)gScreenInfo.uLeft, 
            y + (INT)gScreenInfo.uUpper);
        }
    }
    // adjust every allocated surface
    for(i=0; i<guMaxHandles; i++)
    {
        if(gfx_osi_pSurface_alloc(&gpHandles[i].surface) &&
            IS_SURFACE_OSD_COMP(gpHandles[i].surface.uPlaneConfig) &&
            !IS_SURFACE_CURSOR_COMP(gpHandles[i].surface.uPlaneConfig))
        {
            ULONG lparm1, lparm2;

            PDEBUG("Surface %d %8.8x\n", i, gpHandles[i].surface.uPlaneConfig); 
            
            osd_osi_get_comp_gfx_surface_parm(&gpHandles[i].surface, 
                OSD_GRAPH_SURFACE_SCREEN_OFFSET, &lparm1, &lparm2);
            if(lparm1 < (ULONG)oldLeft) 
            {
                lparm1 = (ULONG)gScreenInfo.uLeft;
            }
            else 
            {
                lparm1 = lparm1 - (ULONG)oldLeft + (ULONG)gScreenInfo.uLeft;
            }
            
            if(lparm2 < (ULONG)oldUpper) 
            {
                lparm2 = (ULONG)gScreenInfo.uUpper;
            }
            else 
            {
                lparm2 = lparm2 - (ULONG)oldUpper + (ULONG)gScreenInfo.uUpper;
            }
            osd_osi_set_comp_gfx_surface_parm(&gpHandles[i].surface, 
                OSD_GRAPH_SURFACE_SCREEN_OFFSET, lparm1, lparm2);
    	    PDEBUG("done\n"); 
        }
    }
    
    os_release_mutex(gGFXMutex);
    /////////////////////////////
    return 0;
}


int gfx_inf_h_get_surface_display_parm(GFX_SURFACE_DISPLAY_T *pParm)
{
    int rtn= -1;

    if(NULL == pParm || pParm->hSurface < 0 || pParm->hSurface >= (int)guMaxHandles)
    {
        PDEBUG("Bad parm\n");
        return -1;
    }

    /////////////////////////////
    if(os_get_mutex(gGFXMutex))
    {
        PDEBUG("Failed on mutex!\n");
        return -1;
    }

    if(gfx_osi_pSurface_alloc(&gpHandles[pParm->hSurface].surface)
        && IS_SURFACE_OSD_COMP(gpHandles[pParm->hSurface].surface.uPlaneConfig))
    {
        ULONG lparm1, lparm2;

        pParm->uStartX = 0;
        pParm->uStartY = 0;
        osd_osi_get_comp_gfx_surface_parm(&gpHandles[pParm->hSurface].surface, 
            OSD_GRAPH_SURFACE_FLICKER_CORRECTION, &lparm1, &lparm2);
        pParm->bFlickerCorrect = (BYTE)lparm1;

        osd_osi_get_comp_gfx_surface_parm(&gpHandles[pParm->hSurface].surface, 
            OSD_GRAPH_SURFACE_SCREEN_OFFSET, &lparm1, &lparm2);
        if((UINT)lparm1 < gScreenInfo.uLeft) 
        {
            pParm->uWinX = 0;
        }
        else 
        {
            pParm->uWinX = (UINT)lparm1 - gScreenInfo.uLeft;
        }

        if((UINT)lparm2 < gScreenInfo.uUpper) 
        {
            pParm->uWinY = 0;
        }
        else 
        {
            pParm->uWinY = (UINT)lparm2 - gScreenInfo.uUpper;
        }

        pParm->uWinWidth  = gpHandles[pParm->hSurface].surface.plane[0].uAllocWidth;
        pParm->uWinHeight = gpHandles[pParm->hSurface].surface.plane[0].uAllocHeight;
        rtn = 0;
    }

    os_release_mutex(gGFXMutex);
    /////////////////////////////
    return rtn;
}


int gfx_inf_h_set_surface_display_parm(GFX_SURFACE_DISPLAY_T *pParm)
{
    int rtn= -1;

    if(NULL == pParm || pParm->hSurface < 0 || pParm->hSurface >= (int)guMaxHandles)
    {
        PDEBUG("Bad parm\n");
        return -1;
    }

    /////////////////////////////
    if(os_get_mutex(gGFXMutex))
    {
        PDEBUG("Failed on mutex!\n");
        return -1;
    }

    if(gfx_osi_pSurface_alloc(&gpHandles[pParm->hSurface].surface)
        && IS_SURFACE_OSD_COMP(gpHandles[pParm->hSurface].surface.uPlaneConfig))
    {
        PDEBUGE("Surface %d win change to (%d, %d)\n", pParm->hSurface, pParm->uWinWidth, pParm->uWinHeight);

        osd_osi_set_comp_gfx_surface_parm(&gpHandles[pParm->hSurface].surface, 
            OSD_GRAPH_SURFACE_SCREEN_OFFSET, 
            (ULONG)(gScreenInfo.uLeft  + pParm->uWinX),
            (ULONG)(gScreenInfo.uUpper + pParm->uWinY));
        
        osd_osi_set_comp_gfx_surface_parm(&gpHandles[pParm->hSurface].surface, 
            OSD_GRAPH_SURFACE_FLICKER_CORRECTION, 
            (ULONG)pParm->bFlickerCorrect, (ULONG)0);

        rtn = 0;
    }

    os_release_mutex(gGFXMutex);
    /////////////////////////////
    return rtn;
}


int gfx_inf_h_get_palette(GFX_SURFACE_ACCESS_PALETTE_PARM_T *pParm)
{
    int rtn= -1;

    if(!pParm || !pParm->pPalette ||  pParm->hSurface < 0 || pParm->hSurface >= (int)guMaxHandles)
    {
        PDEBUG("Bad parm\n");
        return -1;
    }
    /////////////////////////////
    if(os_get_mutex(gGFXMutex))
    {
        PDEBUG("Failed on mutex!\n");
        return -1;
    }

    if(gfx_osi_pSurface_alloc(&gpHandles[pParm->hSurface].surface)
        && IS_GFX_SURFACE_CLUT(gpHandles[pParm->hSurface].surface.uPlaneConfig))
    {
        rtn = gfx_osi_get_surface_palette(&gpHandles[pParm->hSurface].surface, pParm->pPalette, pParm->uStart, pParm->uCount);
    }

    os_release_mutex(gGFXMutex);
    /////////////////////////////
    return rtn;
}

int gfx_inf_h_set_palette(GFX_SURFACE_ACCESS_PALETTE_PARM_T *pParm)
{
    int rtn= -1;

    if(!pParm || !pParm->pPalette ||  pParm->hSurface < 0 || pParm->hSurface >= (int)guMaxHandles)
    {
        PDEBUG("Bad parm\n");
        return -1;
    }
    /////////////////////////////
    if(os_get_mutex(gGFXMutex))
    {
        PDEBUG("Failed on mutex!\n");
        return -1;
    }

    if(gfx_osi_pSurface_alloc(&gpHandles[pParm->hSurface].surface)
        && IS_GFX_SURFACE_CLUT(gpHandles[pParm->hSurface].surface.uPlaneConfig))
    {
        rtn = gfx_osi_set_surface_palette(&gpHandles[pParm->hSurface].surface, pParm->pPalette, pParm->uStart, pParm->uCount);
    }

    os_release_mutex(gGFXMutex);
    /////////////////////////////
    return rtn;
}



int gfx_inf_h_move_cursor(GFX_COORDINATE_T *pParm)
{
    if(NULL == pParm || pParm->nCursorX < 0 || pParm->nCursorY < 0)
    {
        PDEBUG("Bad parm\n");
        return -1;
    }

    return osd_osi_set_cursor_position(pParm->nCursorX + (INT)gScreenInfo.uLeft, 
        pParm->nCursorY + (INT)gScreenInfo.uUpper);
}

int gfx_inf_h_report_cursor_position(GFX_COORDINATE_T *pParm)
{
    int rtn;
    int x, y;
    if(NULL == pParm< 0)
    {
        PDEBUG("Bad parm\n");
        return -1;
    }

    rtn =  osd_osi_get_cursor_position(&x, &y);

    if(rtn == 0)
    {
        if(x < (INT)gScreenInfo.uLeft) pParm->nCursorX = 0;
        else pParm->nCursorX = x - (INT)gScreenInfo.uLeft;
        if(y < (INT)gScreenInfo.uUpper) pParm->nCursorY = 0;
        else pParm->nCursorY = y - (INT)gScreenInfo.uUpper;
    }
    return rtn;
}

int gfx_inf_h_set_cursor_attributes(GFX_CURSOR_ATTRUBUTE_PARM_T *pParm)
{
    int rtn = -1;

    if(NULL == pParm || pParm->hCursor < 0 || pParm->hCursor >= (int)guMaxHandles)
    {
        PDEBUG("Bad parm\n");
        return -1;
    }
    /////////////////////////////
    if(os_get_mutex(gGFXMutex))
    {
        PDEBUG("Failed on mutex!\n");
        return -1;
    }

    if(gfx_osi_pSurface_alloc(&gpHandles[pParm->hCursor].surface)
        && IS_SURFACE_CURSOR_COMP(gpHandles[pParm->hCursor].surface.uPlaneConfig))
    {
        rtn = osd_osi_set_cursor_attributes(&gpHandles[pParm->hCursor].surface, pParm->uIndex, pParm->attr);
    }
 
    os_release_mutex(gGFXMutex);
    /////////////////////////////
    return rtn;
}



int gfx_inf_h_set_display_control(GFX_DISPLAY_CONTROL_PARM_T *pParm)
{
	int rtn;

    if(NULL == pParm)
    {
        PDEBUG("Bad parm\n");
        return -1;
    }
    switch(pParm->parm)
    {
    case GFX_DISP_CNTL_BACKCOLOR:  // 16 bits background color in y8:u4:v4
        return osd_osi_set_display_parm(OSD_DISP_CNTL_BACKCOLOR, pParm->uAttr);
    case GFX_DISP_CNTL_VALPHA:    // Video alpha, 8 bits attr  00 transparnet, ff opaque
        return -1;                  // not supported
    case GFX_DISP_CNTL_AVALPHA:   // Alternative video alpha, 8 bits attr  00 transparnet, ff opaque
        return -1;                  // not supported
    case GFX_DISP_CNTL_AFVP:      // Anti-flicker video plane, 0 disable, 1 enable
        return osd_osi_set_display_parm(OSD_DISP_CNTL_AFVP, pParm->uAttr);
    case GFX_DISP_CNTL_EDAF:      // Enable display anti-flicker, 0 disable, 1 enable
        return osd_osi_set_display_parm(OSD_DISP_CNTL_EDAF, pParm->uAttr);
    case GFX_DISP_CNTL_AFDT:      // Anti-flicker detection threshold, 2 bits attr
        return osd_osi_set_display_parm(OSD_DISP_CNTL_AFDT, pParm->uAttr);
    case GFX_DISP_CNTL_VPAFC:     // Video plane anti-flicker correction, 2 bits attr
        return osd_osi_set_display_parm(OSD_DISP_CNTL_VPAFC, pParm->uAttr);
    case GFX_DISP_CNTL_FP:        // Force progressive, 0 don't, 1 upsample progressive
        return -1;                  // not supported
    case GFX_DISP_CNTL_OSDIRQ:    // OSD animation interrupt enable, 1 bit attr -- BJC 102102
        if(pParm->uAttr == 1) {
            // first set animation rate to 30Fps NTSC / 25 Fps PAL
	        rtn = osd_osi_set_display_parm(OSD_DISP_CNTL_ANIMR, 0);// Animation rate, 3 bits attr
            if(rtn != 0) {
                return rtn;
		    }
		}
                
       return osd_osi_set_display_parm(OSD_DISP_CNTL_ANIM, pParm->uAttr);// Animation mode, 0 no, 1 yes
       
    case GFX_DISP_CNTL_OSDHSR:     // OSD horizontal FIR scaling ratio, 9 bits attr -- BJC 102102
        return osd_osi_set_display_parm(OSD_DISP_CNTL_CHFSR, pParm->uAttr);
	    
    default:
        return -1;
    }
}

int gfx_inf_h_get_display_control(GFX_DISPLAY_CONTROL_PARM_T *pParm)
{
    if(NULL == pParm)
    {
        PDEBUG("Bad parm\n");
        return -1;
    }
    switch(pParm->parm)
    {
    case GFX_DISP_CNTL_BACKCOLOR:  // 16 bits background color in y8:u4:v4
        pParm->uAttr = osd_osi_get_display_parm(OSD_DISP_CNTL_BACKCOLOR);
        break;
    case GFX_DISP_CNTL_VALPHA:    // Video alpha, 8 bits attr  00 transparnet, ff opaque
        return -1;          // not supported
    case GFX_DISP_CNTL_AVALPHA:   // Alternative video alpha, 8 bits attr  00 transparnet, ff opaque
        return -1;          // not supported
    case GFX_DISP_CNTL_AFVP:      // Anti-flicker video plane, 0 disable, 1 enable
        pParm->uAttr = osd_osi_get_display_parm(OSD_DISP_CNTL_AFVP);
        break;
    case GFX_DISP_CNTL_EDAF:      // Enable display anti-flicker, 0 disable, 1 enable
        pParm->uAttr = osd_osi_get_display_parm(OSD_DISP_CNTL_EDAF);
        break;
    case GFX_DISP_CNTL_AFDT:      // Anti-flicker detection threshold, 2 bits attr
        pParm->uAttr = osd_osi_get_display_parm(OSD_DISP_CNTL_AFDT);
        break;
    case GFX_DISP_CNTL_VPAFC:     // Video plane anti-flicker correction, 2 bits attr
        pParm->uAttr = osd_osi_get_display_parm(OSD_DISP_CNTL_VPAFC);
        break;
    case GFX_DISP_CNTL_FP:        // Force progressive, 0 don't, 1 upsample progressive
        return -1;      // not supported
    case GFX_DISP_CNTL_OSDIRQ:    // OSD animation interrupt enable, 1 bit attr -- BJC 102102
	    pParm->uAttr = osd_osi_get_display_parm(OSD_DISP_CNTL_ANIM);// Animation mode, 0 no, 1 yes
	    break;
    case GFX_DISP_CNTL_OSDHSR:     // OSD horizontal FIR scaling ratio, 9 bits attr -- BJC 102102
        pParm->uAttr = osd_osi_get_display_parm(OSD_DISP_CNTL_CHFSR);
	    break;
    default:
        return -1;
    }
    return 0;
}


int gfx_inf_h_get_visual_device_control(GFX_VISUAL_DEVICE_CONTROL_PARM_T *pParm)
{
    if(NULL == pParm)
    {
        PDEBUG("Bad parm\n");
        return -1;
    }
    switch(pParm->cntl)
    {
    case GFX_VISUAL_DEVICE_GLOBAL_ALPHA:
        pParm->uAttr = osd_osi_get_device_parm(pParm->graphDev, OSD_GRAPH_DEVICE_GLOBAL_ALPHA); 
        break;

    case GFX_VISUAL_DEVICE_ENABLE:
        pParm->uAttr = osd_osi_get_device_parm(pParm->graphDev, OSD_GRAPH_DEVICE_ENABLE); 
        break;

    default:
        return -1;
    }
    return 0;
}

int gfx_inf_h_set_visual_device_control(GFX_VISUAL_DEVICE_CONTROL_PARM_T *pParm)
{
    if(NULL == pParm)
    {
        PDEBUG("Bad parm\n");
        return -1;
    }
    switch(pParm->cntl)
    {
    case GFX_VISUAL_DEVICE_GLOBAL_ALPHA:
        return osd_osi_set_device_parm(pParm->graphDev, OSD_GRAPH_DEVICE_GLOBAL_ALPHA, pParm->uAttr);

    case GFX_VISUAL_DEVICE_ENABLE:
        return osd_osi_set_device_parm(pParm->graphDev, OSD_GRAPH_DEVICE_ENABLE, pParm->uAttr); 
       
    default:
        return -1;
    }
    return 0;
}