osd_osi.c

IBM source for pallas/vulcan/vesta

                UINT xoff = (UINT)lValue1;
                UINT yoff = (UINT)lValue2;
                
                if(xoff >= OSD_SURFACE_MAX_WIDTH || yoff >= OSD_SURFACE_MAX_HEIGHT)
                {
                    PDEBUG("Surface offset (%d,%d) out of range!\n", xoff, yoff);
                    return -1;
                }
                
                pCntl->start_column = xoff>>1;
                pCntl->start_column_odd = xoff&1;
                pCntl->start_row = yoff>>1;
                pCntl->start_row_odd = yoff&1;
            }
            break;
            
        case OSD_GRAPH_SURFACE_SINGLE_PALETTE:           // access a single palette (v1 as index and v2 as value)
            return gfx_osi_set_surface_palette(pSurface, (GFX_PALETTE_T *)&lValue2, (UINT)lValue1, 1);
            
        case OSD_GRAPH_SURFACE_ALL_PALETTE:              // access all palette from 0 (v1 as num of entries, v2 is used as pointer to palette array)
            // if v1 == NULL, the default palette is used
            if(IS_GFX_SURFACE_CLUT(pSurface->uPlaneConfig))
            {
                GFX_PALETTE_T *pPal = (GFX_PALETTE_T *)lValue2;
                UINT numpal = (UINT)lValue1;
                if(numpal > 16 && (pSurface->uAttr & __GFX_SURFACE_OSDCURSOR))
                {
                    numpal = 16;
                }
                else if(numpal > 256)
                {
                    numpal = 256;
                }
                if(NULL == pPal) // he want default palette
                {
                    return gfx_osi_reset_surface_palette(pSurface);
                }
                else
                {
                    gfx_osi_set_surface_palette(pSurface, pPal, 0, numpal);
                }
            }
            else
            {
                PDEBUG("Could not set palette on non clut planes!\n");
                return -1;
            }
            break;
        default:
            PDEBUG("Could not set the parm!\n");
            return -1;
        }


    }
    else    // image / graphics
    {
        STB_OSD_GI_CONTROL_BLOCK_T *pCntl;
        pCntl = os_get_logical_address(pSurface->hBuffer);
        
        switch(parm)
        {
        case OSD_GRAPH_SURFACE_FLICKER_CORRECTION:       // set the antiflicker filter value (v1)
            pCntl->anti_flicker = (unsigned)lValue1&0x03;   // two bits
            break;
            
        case OSD_GRAPH_SURFACE_SCREEN_OFFSET:            // the offset of surface to screen (v1 as horizontal, v2 as vertical)
            {
                UINT xoff = (UINT)lValue1;
                UINT yoff = (UINT)lValue2;
                
                if(xoff >= OSD_SURFACE_MAX_WIDTH || yoff >= OSD_SURFACE_MAX_HEIGHT)
                {
                    PDEBUG("Surface offset (%d,%d) out of range!\n", xoff, yoff);
                    return -1;
                }
                
                pCntl->start_column = xoff>>1;
                pCntl->start_row = yoff>>1;
                if(pSurface->twinheader)
                {
                    STB_OSD_GI_CONTROL_BLOCK_T *pCntl2 = (STB_OSD_GI_CONTROL_BLOCK_T *)((BYTE *)pCntl + pSurface->uBufferBase2 - pSurface->uBufferBase);
                    pCntl2->start_column = xoff>>1;
                    pCntl2->start_row = yoff>>1;
                }
            }
            break;
            
        case OSD_GRAPH_SURFACE_SINGLE_PALETTE:           // access a single palette (v1 as index and v2 as value)
            return gfx_osi_set_surface_palette(pSurface, (GFX_PALETTE_T *)&lValue2, (UINT)lValue1, 1);
            
        case OSD_GRAPH_SURFACE_ALL_PALETTE:              // access all palette from 0 (v1 as num of entries, v2 is used as pointer to palette array)
            // if v1 == NULL, the default palette is used
            if(IS_GFX_SURFACE_CLUT(pSurface->uPlaneConfig))
            {
                GFX_PALETTE_T *pPal = (GFX_PALETTE_T *)lValue2;
                UINT numpal = (UINT)lValue1;
                if(numpal > 16 && (pSurface->uAttr & __GFX_SURFACE_OSDCURSOR))
                {
                    numpal = 16;
                }
                else if(numpal > 256)
                {
                    numpal = 256;
                }
                if(NULL == pPal) // he want default palette
                {
                    return gfx_osi_reset_surface_palette(pSurface);
                }
                else
                {
                    gfx_osi_set_surface_palette(pSurface, pPal, 0, numpal);
                }
            }
            else
            {
                PDEBUG("Could not set palette on non clut planes!\n");
                return -1;
            }
            break;
        default:
            PDEBUG("Could not set the parm!\n");
            return -1;
        }
    }

    return 0;
}


INT osd_osi_get_comp_gfx_surface_parm(GFX_SURFACE_T *pSurface, OSD_GRAPH_SURFACE_PARM_T parm, ULONG *plValue1, ULONG *plValue2)
{
    if(!gfx_osi_pSurface_valid(pSurface) 
        || !IS_SURFACE_OSD_COMP(pSurface->uPlaneConfig) || NULL == plValue1) 
    {
        PDEBUG("Invalid parameter or uninitialized surface!\n");
        return -1;    // we cann't do it
    }
    
    if(pSurface->uAttr & __GFX_SURFACE_OSDCURSOR)   // cursor
    {
        STB_OSD_CURSOR_CONTROL_BLOCK_T *pCntl;
        pCntl = os_get_logical_address(pSurface->hBuffer);
        
        switch(parm)
        {
        case OSD_GRAPH_SURFACE_FLICKER_CORRECTION:       // get the antiflicker filter value (v1)
            *plValue1 = (ULONG)(pCntl->anti_flicker);    // two bits
            break;
            
        case OSD_GRAPH_SURFACE_SCREEN_OFFSET:            // the offset of surface to screen (v1 as horizontal, v2 as vertical)
            {
                if(NULL == plValue2)
                {
                    PDEBUG("Unexpacted input NULL pointer!\n");
                    return -1;
                }
                // xoff
                *plValue1 = ((ULONG)pCntl->start_column<<1) + pCntl->start_column_odd;
                // yoff
                *plValue2 = ((ULONG)pCntl->start_row<<1) + pCntl->start_row_odd;
            }
            break;
            
        case OSD_GRAPH_SURFACE_SINGLE_PALETTE:           // access a single palette (v1 as index and v2 as value)
            if(NULL == plValue2)
            {
                PDEBUG("Unexpacted input NULL pointer!\n");
                return -1;
            }
            if(IS_GFX_SURFACE_CLUT(pSurface->uPlaneConfig))
            {
                UINT index = (UINT)*plValue1;
                if(index > 255 || (index > 15 && (pSurface->uAttr & __GFX_SURFACE_OSDCURSOR)))
                {
                    PDEBUG("palette index out of range!\n");
                    return -1;
                }
                *(GFX_PALETTE_T *)plValue2  = pSurface->pPalette[index];
            }
            else
            {
                PDEBUG("Could not get palette on non clut planes!\n");
                return -1;
            }
            break;
            
        case OSD_GRAPH_SURFACE_ALL_PALETTE:              // access all palette from 0 (v1 as num of entries, v2 is used as pointer to palette array)
            if(NULL == plValue2)
            {
                PDEBUG("Unexpacted input NULL pointer!\n");
                return -1;
            }
            if(IS_GFX_SURFACE_CLUT(pSurface->uPlaneConfig))
            {
                GFX_PALETTE_T *pPal = (GFX_PALETTE_T *)plValue2;
                UINT numpal = (UINT)*plValue1;
                if(numpal > 16 && (pSurface->uAttr & __GFX_SURFACE_OSDCURSOR))
                {
                    numpal = 16;
                }
                else if(numpal > 256)
                {
                    numpal = 256;
                }
                _OS_MEMCPY(pPal, pSurface->pPalette, sizeof(GFX_PALETTE_T)*numpal);
            }
            else
            {
                PDEBUG("Could not get palette on non clut planes!\n");
                return -1;
            }
            break;
            
        default:
            PDEBUG("Could not get the parm!\n");
            return -1;
            
        }
    }
    else  // gaphics / image
    {
        STB_OSD_GI_CONTROL_BLOCK_T *pCntl;
        pCntl = os_get_logical_address(pSurface->hBuffer);
        
        switch(parm)
        {
        case OSD_GRAPH_SURFACE_FLICKER_CORRECTION:       // get the antiflicker filter value (v1)
            *plValue1 = (ULONG)(pCntl->anti_flicker);    // two bits
            break;
            
        case OSD_GRAPH_SURFACE_SCREEN_OFFSET:            // the offset of surface to screen (v1 as horizontal, v2 as vertical)
            {
                if(NULL == plValue2)
                {
                    PDEBUG("Unexpacted input NULL pointer!\n");
                    return -1;
                }
                // xoff
                *plValue1 = ((ULONG)pCntl->start_column<<1);
                // yoff
                *plValue2 = ((ULONG)pCntl->start_row<<1);
            }
            break;
            
        case OSD_GRAPH_SURFACE_SINGLE_PALETTE:           // access a single palette (v1 as index and v2 as value)
            if(NULL == plValue2)
            {
                PDEBUG("Unexpacted input NULL pointer!\n");
                return -1;
            }
            if(IS_GFX_SURFACE_CLUT(pSurface->uPlaneConfig))
            {
                UINT index = (UINT)*plValue1;
                if(index > 255 || (index > 15 && (pSurface->uAttr & __GFX_SURFACE_OSDCURSOR)))
                {
                    PDEBUG("palette index out of range!\n");
                    return -1;
                }
                *(GFX_PALETTE_T *)plValue2  = pSurface->pPalette[index];
            }
            else
            {
                PDEBUG("Could not get palette on non clut planes!\n");
                return -1;
            }
            break;
            
        case OSD_GRAPH_SURFACE_ALL_PALETTE:              // access all palette from 0 (v1 as num of entries, v2 is used as pointer to palette array)
            if(NULL == plValue2)
            {
                PDEBUG("Unexpacted input NULL pointer!\n");
                return -1;
            }
            if(IS_GFX_SURFACE_CLUT(pSurface->uPlaneConfig))
            {
                GFX_PALETTE_T *pPal = (GFX_PALETTE_T *)plValue2;
                UINT numpal = (UINT)*plValue1;
                if(numpal > 16 && (pSurface->uAttr & __GFX_SURFACE_OSDCURSOR))
                {
                    numpal = 16;
                }
                else if(numpal > 256)
                {
                    numpal = 256;
                }
                _OS_MEMCPY(pPal, pSurface->pPalette, sizeof(GFX_PALETTE_T)*numpal);
            }
            else
            {
                PDEBUG("Could not get palette on non clut planes!\n");
                return -1;
            }
            break;
            
        default:
            PDEBUG("Could not get the parm!\n");
            return -1;
        }
    }
    
    return 0;
}
    

//////////////////////////////////////////////////////////////////////////////
// Cursor specific interfaces
//////////////////////////////////////////////////////////////////////////////


INT osd_osi_create_cursor(GFX_SURFACE_T *pCursor, UINT uPlaneConfig, UINT uWidth, UINT uHeight)
{
    return gfx_osi_create_surface(pCursor, GFX_VDEV_OSDCUR, uPlaneConfig, uWidth, uHeight);
}

INT osd_osi_destory_cursor(GFX_SURFACE_T *pCursor)
{
    return gfx_osi_destroy_surface(pCursor);
}

INT osd_osi_attach_cursor(GFX_SURFACE_T *pCursor)
{
    return osd_osi_attach_comp_gfx_surface(GFX_VDEV_OSDCUR, pCursor);
}

INT osd_osi_detach_cursor(GFX_SURFACE_T *pCursor)
{
    return osd_osi_detach_comp_gfx_surface(GFX_VDEV_OSDCUR, pCursor);
}

INT osd_osi_set_cursor_position(INT nHorizontal, INT nVertical)
{

    if(!(gOSDDev[GFX_VDEV_OSDCUR].uAttr & __OSD_GRAPH_DEVICE_INIT)) 
    {
        PDEBUG("Cursor device is not initlized!\n");
        return -1;
    }
    if(NULL == gOSDDev[GFX_VDEV_OSDCUR].pSurface)
    {
        PDEBUG("No surface is attached to cursor device!\n");
        return -1;
    }
    if(nHorizontal < 0) nHorizontal = 0;
    if(nHorizontal > OSD_CURSOR_POSITION_RANGE) nHorizontal = OSD_CURSOR_POSITION_RANGE;
    if(nVertical < 0) nVertical = 0;
    if(nVertical > OSD_CURSOR_POSITION_RANGE) nVertical = OSD_CURSOR_POSITION_RANGE;
    
    return osd_osi_set_comp_gfx_surface_parm(gOSDDev[GFX_VDEV_OSDCUR].pSurface, OSD_GRAPH_SURFACE_SCREEN_OFFSET, nHorizontal, nVertical);
}


INT osd_osi_get_cursor_position(INT *pnHorizontal, INT *pnVertical)
{
    int rtn;
    ULONG x, y;

    if(!(gOSDDev[GFX_VDEV_OSDCUR].uAttr & __OSD_GRAPH_DEVICE_INIT)) 
    {
        PDEBUG("Cursor device is not initlized!\n");
        return -1;
    }
    if(NULL == gOSDDev[GFX_VDEV_OSDCUR].pSurface)
    {
        PDEBUG("No surface is attached to cursor device!\n");
        return -1;
    }
    rtn = osd_osi_get_comp_gfx_surface_parm(gOSDDev[GFX_VDEV_OSDCUR].pSurface, OSD_GRAPH_SURFACE_SCREEN_OFFSET, &x, &y);

    if(pnHorizontal)  *pnHorizontal = (INT)x;
    if(pnVertical) *pnVertical = (INT)y;

    return rtn;
}



INT osd_osi_set_cursor_attributes(GFX_SURFACE_T *pCursor, UINT uIndex, GFX_CURSOR_ATTRIBUTE_T attr)
{
    STB_OSD_C_PALETTE_T *pPal;
    UINT32 val = (UINT32)attr;

    if(!gfx_osi_pSurface_valid(pCursor) ||  !(pCursor->uAttr & __GFX_SURFACE_OSDCURSOR) || uIndex >= (1<<pCursor->plane[0].uPixelSize))
    {
        PDEBUG("Invalid parameter or uninitialized surface!\n");
        return -1;    // we cann't do it
    }
    pPal = pCursor->pPal;
    pPal[uIndex].peep   = (val&2) ? 1 : 0;
    pPal[uIndex].steady = (val&1) ? 1 : 0;
    return 0;
}