gfx_inf_helper.c

IBM source for pallas/vulcan/vesta

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

    rtn =  gfx_osi_wait_for_engine(nTimeout);

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

int gfx_inf_h_reset_engine(void)
{
    int rtn;
    /////////////////////////////
    if(os_get_mutex(gGFXMutex))
    {
        PDEBUG("Failed on mutex!\n");
        return -1;
    }
        
    rtn =  gfx_osi_reset_engine();
    
    os_release_mutex(gGFXMutex);
    /////////////////////////////
    return rtn;
}

int gfx_inf_h_set_engine_mode(int enable_sync)
{
    /////////////////////////////
    if(os_get_mutex(gGFXMutex))
    {
        PDEBUG("Failed on mutex!\n");
        return -1;
    }
        
    gWait_for_finish = enable_sync ? 1 : 0;
    
    os_release_mutex(gGFXMutex);
    /////////////////////////////
    return 0;
    
}

int gfx_inf_h_get_engine_mode()
{
    return gWait_for_finish;
}


int gfx_inf_h_set_surface_clip_rect(GFX_SET_CLIP_PARM_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))
    {
        rtn = gfx_osi_set_surface_clip_region(&gpHandles[pParm->hSurface].surface, 
            &pParm->rect);
    }

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



int gfx_inf_h_bitBLT(GFX_BITBLT_PARM_T *pParm)
{
    int rtn= -1;

    if(NULL == pParm 
        || pParm->hSrcSurface < 0 || pParm->hSrcSurface >= (int)guMaxHandles 
        || pParm->hDesSurface < 0 || pParm->hDesSurface >= (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->hDesSurface].surface) &&
        gfx_osi_pSurface_alloc(&gpHandles[pParm->hSrcSurface].surface)   )
    {
        rtn = gfx_osi_bitBLT(&gpHandles[pParm->hDesSurface].surface, 
            pParm->uDesX, pParm->uDesY, pParm->uWidth, pParm->uHeight,
            &gpHandles[pParm->hSrcSurface].surface,
            pParm->uSrcX, pParm->uSrcY,
            &pParm->alphaSelect, pParm->enableGammaCorrection);
        if(rtn == 0) 
            rtn = gfx_osi_run_engine(gWait_for_finish);
    }

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



int gfx_inf_h_advancedBitBLT(GFX_ADV_BITBLT_PARM_T *pParm)
{
    int rtn= -1;

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

    if(pParm->hMaskSurface >= 0 && !gfx_osi_pSurface_alloc(&gpHandles[pParm->hMaskSurface].surface))
    {
        PDEBUG("Bad mask\n");
        return -1;
    }

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

    if(gfx_osi_pSurface_alloc(&gpHandles[pParm->hDesSurface].surface) &&
        gfx_osi_pSurface_alloc(&gpHandles[pParm->hSrcSurface].surface))
    {
        rtn = gfx_osi_advancedBitBLT(&gpHandles[pParm->hDesSurface].surface, 
            pParm->uDesX, pParm->uDesY, pParm->uWidth, pParm->uHeight,
            &gpHandles[pParm->hSrcSurface].surface,
            pParm->uSrcX, pParm->uSrcY,
            pParm->hMaskSurface >= 0 ? &gpHandles[pParm->hMaskSurface].surface : NULL, 
            pParm->uMaskX, pParm->uMaskY,
            pParm->ROP, pParm->enablePixelBitMask, pParm->uPixelBitMask,
            &pParm->alphaSelect);
        if(rtn == 0) 
            rtn = gfx_osi_run_engine(gWait_for_finish);
    }

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


int gfx_inf_h_fillBLT(GFX_FILLBLT_PARM_T *pParm)
{
    int rtn= -1;

    if(NULL == pParm 
        || pParm->hDesSurface  < 0 || pParm->hDesSurface  >= (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->hDesSurface].surface) )
    {
        rtn = gfx_osi_fillBLT(&gpHandles[pParm->hDesSurface].surface, 
            pParm->uDesX, pParm->uDesY, pParm->uWidth, pParm->uHeight,
            pParm->uFillColor);
        if(rtn == 0) 
            rtn = gfx_osi_run_engine(gWait_for_finish);
    }

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


int gfx_inf_h_advancedFillBLT(GFX_ADV_FILLBLT_PARM_T *pParm)
{
    int rtn= -1;

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

    if(pParm->hMaskSurface >= 0 && !gfx_osi_pSurface_alloc(&gpHandles[pParm->hMaskSurface].surface))
    {
        PDEBUG("Bad mask\n");
        return -1;
    }

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

    if(gfx_osi_pSurface_alloc(&gpHandles[pParm->hDesSurface].surface))
    {
        rtn = gfx_osi_advancedFillBLT(&gpHandles[pParm->hDesSurface].surface, 
            pParm->uDesX, pParm->uDesY, pParm->uWidth, pParm->uHeight,
            pParm->uFillColor,
            pParm->hMaskSurface >= 0 ? &gpHandles[pParm->hMaskSurface].surface : NULL, 
            pParm->uMaskX, pParm->uMaskY,
            pParm->ROP, pParm->transparencyEnable, pParm->uBackGroundColor,
            pParm->enablePixelBitMask, pParm->uPixelBitMask );
        if(rtn == 0) 
            rtn = gfx_osi_run_engine(gWait_for_finish);
    }

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


int gfx_inf_h_blend(GFX_BLEND_PARM_T *pParm)
{
    int rtn= -1;

    if(NULL == pParm 
        || pParm->hSrcSurface < 0 || pParm->hSrcSurface >= (int)guMaxHandles 
        || pParm->hDesSurface < 0 || pParm->hDesSurface >= (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->hDesSurface].surface) &&
        gfx_osi_pSurface_alloc(&gpHandles[pParm->hSrcSurface].surface)   )
    {
        rtn = gfx_osi_blend(&gpHandles[pParm->hDesSurface].surface, 
            pParm->uDesX, pParm->uDesY, pParm->uWidth, pParm->uHeight,
            &gpHandles[pParm->hSrcSurface].surface,
            pParm->uSrcX, pParm->uSrcY,
            &pParm->blendSelect);
        if(rtn == 0) 
            rtn = gfx_osi_run_engine(gWait_for_finish);
    }

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


int gfx_inf_h_advancedBlend(GFX_ADV_BLEND_PARM_T *pParm)
{
    int rtn= -1;

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

    if(pParm->hAlphaSurface >= 0 && !gfx_osi_pSurface_alloc(&gpHandles[pParm->hAlphaSurface].surface))
    {
        PDEBUG("Bad alpha \n");
        return -1;
    }

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

    if(gfx_osi_pSurface_alloc(&gpHandles[pParm->hDesSurface].surface) &&
        gfx_osi_pSurface_alloc(&gpHandles[pParm->hSrcSurface].surface))
    {
        rtn = gfx_osi_advancedBlend(&gpHandles[pParm->hDesSurface].surface, 
            pParm->uDesX, pParm->uDesY, pParm->uWidth, pParm->uHeight,
            &gpHandles[pParm->hSrcSurface].surface,
            pParm->uSrcX, pParm->uSrcY,
            pParm->hAlphaSurface >= 0 ? &gpHandles[pParm->hAlphaSurface].surface : NULL, 
            pParm->uAlphaX, pParm->uAlphaY,
            &pParm->blendSelect);
        if(rtn == 0) 
            rtn = gfx_osi_run_engine(gWait_for_finish);
    }

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

}


int gfx_inf_h_colorKey(GFX_COLORKEY_PARM_T *pParm)
{
    int rtn= -1;

    if(NULL == pParm 
        || pParm->hSrcSurface < 0 || pParm->hSrcSurface >= (int)guMaxHandles 
        || pParm->hDesSurface < 0 || pParm->hDesSurface >= (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->hDesSurface].surface) &&
        gfx_osi_pSurface_alloc(&gpHandles[pParm->hSrcSurface].surface)   )
    {
        rtn = gfx_osi_colorKey(&gpHandles[pParm->hDesSurface].surface, 
            pParm->uDesX, pParm->uDesY, pParm->uWidth, pParm->uHeight,
            &gpHandles[pParm->hSrcSurface].surface,
            pParm->uSrcX, pParm->uSrcY,
            &pParm->colorKeySelect, &pParm->alphaSelect);
        if(rtn == 0) 
            rtn = gfx_osi_run_engine(gWait_for_finish);
    }

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


int gfx_inf_h_resize(GFX_RESIZE_PARM_T *pParm)
{
    int rtn= -1;

    if(NULL == pParm 
        || pParm->hSrcSurface < 0 || pParm->hSrcSurface >= (int)guMaxHandles 
        || pParm->hDesSurface < 0 || pParm->hDesSurface >= (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->hDesSurface].surface) &&
        gfx_osi_pSurface_alloc(&gpHandles[pParm->hSrcSurface].surface)   )
    {
        rtn = gfx_osi_resize(&gpHandles[pParm->hDesSurface].surface, 
            pParm->uDesX, pParm->uDesY, pParm->uDesWidth, pParm->uDesHeight,
            &gpHandles[pParm->hSrcSurface].surface,
            pParm->uSrcX, pParm->uSrcY, pParm->uSrcWidth, pParm->uSrcHeight,
            pParm->destAlpha, pParm->enableGammaCorrection);
        if(rtn == 0) 
            rtn = gfx_osi_run_engine(gWait_for_finish);
    }

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

/*
 * Dispatch dmablt request. -- BJC 102102
 */
int gfx_inf_h_dmablt(GFX_DMABLT_PARM_T *pParm)
{
    gfx_atom_dmablt_handle_request(pParm);
    return 0;
}

/*
 * Dispatch dmablt wait request. -- BJC 102102
 */
int gfx_inf_h_dmablt_wait(void)
{
    gfx_atom_dmablt_wait_handle_request();
    return 0;
}

/*
 * Dispatch pmalloc request. -- BJC 102102
 */
int gfx_inf_h_pmalloc(GFX_PMALLOC_PARM_T *pParm)
{
    return gfx_atom_pmalloc_handle_request(pParm);
}