gfx_osi_surface.c

IBM source for pallas/vulcan/vesta

            {
                pSurface->pPal = (BYTE *)pCntl + sizeof(STB_OSD_GI_CONTROL_BLOCK_T);
                PDEBUG("pSurface->pPal = %08x\n", pSurface->pPal);
                gfx_osi_reset_surface_palette(pSurface);
            }
            if(IS_OSD_SURFACE_CLUT(uPlaneConfig))
                pCntl->color_table_update = 1;
            else
                pCntl->color_table_update = 0;  // direct color mode, default to no per pixel blend control
            pCntl->region_hsize = pSurface->plane[0].uAllocWidth * pSurface->plane[0].uPixelSize / 32;
            pCntl->high_color = (uPlaneConfig&0x02) ? 1 : 0;
            pCntl->link_addr = 0;   // self loop
            pCntl->color_resolution = (uPlaneConfig&0x01) ? 1 : 0;
            pCntl->region_vsize = pSurface->plane[0].uAllocHeight/2;
            pCntl->pixel_resolution = (uPlaneConfig&0x04) ? 1 : 0;
            pCntl->extlink_addr = pSurface->plane[0].uBMLA >> 2;
            pCntl->h_ext_2 = 1;     // we have ext 2
            pCntl->h_fir_scaling = 0xF; // enable horizontal scaling; use custom ratio -- BJC 102102
            if(uNumBuf > 1)
            {
                pCntl->chroma_lnk_en = 1;
                pCntl->chroma_lnk = pSurface->plane[1].uBMLA >> 2;
            }
            if(twinheader && uNumBuf > 2)   // only for 32bit color mode
            {
                pSurface->uBufferBase2 = pSurface->uBufferBase + 
                    ((uHeaderSize + OSD_BMLA_ALIGNMENT-1) / OSD_BMLA_ALIGNMENT) * OSD_BMLA_ALIGNMENT;
                pCntl = (STB_OSD_GI_CONTROL_BLOCK_T *)((BYTE *)os_get_logical_address(pSurface->hBuffer)
                    + pSurface->uBufferBase2 - pSurface->uBufferBase);     // move to next header
                PDEBUG("Twinheader pCntl= %08x, base= %08x\n", pCntl, pSurface->uBufferBase2);
                _OS_MEMSET(pCntl, 0, sizeof(STB_OSD_GI_CONTROL_BLOCK_T));
                pCntl->region_hsize = pSurface->plane[2].uAllocWidth * pSurface->plane[2].uPixelSize / 32;
                pCntl->high_color = (uPlaneConfig&0x20) ? 1 : 0;
                pCntl->link_addr = 0;   // self loop
                pCntl->color_resolution = (uPlaneConfig&0x10) ? 1 : 0;
                pCntl->region_vsize = pSurface->plane[2].uAllocHeight/2;
                pCntl->pixel_resolution = (uPlaneConfig&0x40) ? 1 : 0;
                pCntl->extlink_addr = pSurface->plane[2].uBMLA >> 2;
                pCntl->h_ext_2 = 1;     // we have ext 2
                pSurface->twinheader = 1;
            }
        }
    }

    PDEBUGE("Surface (x,y,bpl,bpp)= %d [%8.8x], %d [%8.8x], %d [%8.8x], %d\n", 
        pSurface->plane[0].uAllocWidth,  pSurface->plane[0].uAllocWidth,
        pSurface->plane[0].uAllocHeight, pSurface->plane[0].uAllocHeight,
        pSurface->plane[0].uBytePerLine, pSurface->plane[0].uBytePerLine, 
        pSurface->plane[0].uPixelSize);


    return 0;
}


INT gfx_osi_destroy_surface(GFX_SURFACE_T * pSurface)
{
    // first, a rough check of the parameters
    if(!gfx_osi_pSurface_valid(pSurface) || (GFX_VDEV_NULL != pSurface->attachedDev)) 
    {
        PDEBUG("Invalid parameter or attached surface !\n");
        return -1;    // we cann't do it
    }

    if(pSurface->hBuffer) 
    {
       if(__STB_GRAPHICS_MEM_SIZE>0)  //we are using a specific graphics memory pool
          pm_free_physical(gpGraphicsPMRoot,pSurface->hBuffer);
       else
          os_free_physical(pSurface->hBuffer);
    }

    if(pSurface->pPalette) FREE(pSurface->pPalette);

    gfx_osi_init_surface_t(pSurface);

    return 0;
}

INT gfx_osi_reconfig_surface_dimension(GFX_SURFACE_T *pSurface, UINT uNewWidth, UINT uNewHeight)
{
    UINT uNumBuf, uBytePerLine;
    UINT cursor=0, twinheader=0;

    // first, a rough check of the parameters
    if(!gfx_osi_pSurface_valid(pSurface)) 
    {
        PDEBUG("Invalid parameter!\n");
        return -1;    // we cann't do it
    }

    if( uNewWidth < 4 || uNewHeight < 2
        || uNewWidth > GFX_SURFACE_MAX_WIDTH || uNewHeight > GFX_SURFACE_MAX_HEIGHT) 
    {
        PDEBUG("Invalid parameter: width=%d, height=%d !\n", uNewWidth, uNewHeight);
        return -1;    // we cann't do it
    }

    __gfx_osi_adjust_surface_wh(pSurface->uPlaneConfig, &uNewWidth, &uNewHeight, &uBytePerLine);
    
    if(uBytePerLine * uNewHeight > pSurface->plane[0].uAllocSize)
    {
        PDEBUG("New size too large: width=%d, height=%d !\n", uNewWidth, uNewHeight);
        return -1;    // we cann't do it
    }

    uNumBuf = GET_GFX_SURFACE_SUBPLANES(pSurface->uPlaneConfig);

    //ok, we now try to alloc the surface
    switch(pSurface->uPlaneConfig)
    {

    case GFX_SURFACE_CURSOR4BPP_RGB:   
    case GFX_SURFACE_CURSOR4BPP_YCBCR: 
    case GFX_SURFACE_CURSOR2BPP_RGB:   
    case GFX_SURFACE_CURSOR2BPP_YCBCR: 
        cursor = 1;

    case GFX_SURFACE_CLUT8BPP_ARGB:
    case GFX_SURFACE_CLUT8BPP_AYCBCR: 
    case GFX_SURFACE_CLUT4BPP_ARGB:   
    case GFX_SURFACE_CLUT4BPP_AYCBCR: 
    case GFX_SURFACE_CLUT2BPP_ARGB:   
    case GFX_SURFACE_CLUT2BPP_AYCBCR: 
    case GFX_SURFACE_ARGB_8888:       
    case GFX_SURFACE_RAW8BPP :
    case GFX_SURFACE_RAW1BPP :
        pSurface->plane[0].uAllocWidth = uNewWidth;
        pSurface->plane[0].uAllocHeight = uNewHeight;
        pSurface->plane[0].uBytePerLine = uBytePerLine;
        break;

    case GFX_SURFACE_CURSOR4BPPP_RGB:   
    case GFX_SURFACE_CURSOR4BPPP_YCBCR: 
    case GFX_SURFACE_CURSOR2BPPP_RGB:   
    case GFX_SURFACE_CURSOR2BPPP_YCBCR: 
        cursor = 1;

    case GFX_SURFACE_CLUT8BPPP_ARGB:
    case GFX_SURFACE_CLUT8BPPP_AYCBCR: 
    case GFX_SURFACE_CLUT4BPPP_ARGB:  
    case GFX_SURFACE_CLUT4BPPP_AYCBCR:
    case GFX_SURFACE_CLUT2BPPP_ARGB:   
    case GFX_SURFACE_CLUT2BPPP_AYCBCR: 
        pSurface->plane[0].uAllocWidth = uNewWidth/2;
        pSurface->plane[0].uAllocHeight = uNewHeight;
        pSurface->plane[0].uBytePerLine = uBytePerLine;
        break;


    case GFX_SURFACE_AYCBCR_422_8888: 
        // A
        pSurface->plane[2].uAllocWidth = uNewWidth;
        pSurface->plane[2].uAllocHeight = uNewHeight;
        pSurface->plane[2].uBytePerLine = uBytePerLine;
        twinheader = 1;
        // fall through
    case GFX_SURFACE_YCBCR_422_888:
        // Y
        pSurface->plane[0].uAllocWidth = uNewWidth;
        pSurface->plane[0].uAllocHeight = uNewHeight;
        pSurface->plane[0].uBytePerLine = uBytePerLine;
        // UV
        pSurface->plane[1].uAllocWidth = uNewWidth;
        pSurface->plane[1].uAllocHeight = uNewHeight;
        pSurface->plane[1].uBytePerLine = uBytePerLine;
        break;

    case GFX_SURFACE_AYCBCR_420_8888: 
        // A
        pSurface->plane[2].uAllocWidth = uNewWidth;
        pSurface->plane[2].uAllocHeight = uNewHeight;
        pSurface->plane[2].uBytePerLine = uBytePerLine;
        twinheader = 1;
        // fall through
    case GFX_SURFACE_YCBCR_420_888:
        // Y
        pSurface->plane[0].uAllocWidth = uNewWidth;
        pSurface->plane[0].uAllocHeight = uNewHeight;
        pSurface->plane[0].uBytePerLine = uBytePerLine;
        // UV
        pSurface->plane[1].uAllocWidth = uNewWidth;
        pSurface->plane[1].uAllocHeight = uNewHeight/2;
        pSurface->plane[1].uBytePerLine = uBytePerLine;
        break;

    default:
        PDEBUG("Invalid plane config 0x%8.8x !\n", pSurface->uPlaneConfig);
        return -1;
    }

    PDEBUG("Parameter: numbuf = %d, width=%d, height=%d\n", uNumBuf, uNewWidth, uNewHeight);


    // the initial clip region
    pSurface->clip.x1 = pSurface->clip.y1 = 0;
    pSurface->clip.x2 = uNewWidth-1;
    pSurface->clip.y2 = uNewHeight-1;

    // initialize bounding clip
    pSurface->bound = pSurface->clip;


    // then we will config for the initial parameters for osd control block
    // although this is not nessesary for normal gfx surface, but we just do it.
    if(cursor)
    {
        STB_OSD_CURSOR_CONTROL_BLOCK_T *pCntl;

        pCntl = (STB_OSD_CURSOR_CONTROL_BLOCK_T *)os_get_logical_address(pSurface->hBuffer);
        PDEBUG("pCntl = %08x\n", pCntl);
        pCntl->region_hsize = pSurface->plane[0].uAllocWidth * 2 / pSurface->plane[0].uPixelSize;
        pCntl->region_vsize = pSurface->plane[0].uAllocHeight/2;
    }
    else
    {
        if(IS_SURFACE_OSD_COMP(pSurface->uPlaneConfig))
        {
            STB_OSD_GI_CONTROL_BLOCK_T *pCntl;
            pCntl = (STB_OSD_GI_CONTROL_BLOCK_T *)os_get_logical_address(pSurface->hBuffer);
            PDEBUG("pCntl = %08x\n", pCntl);
            pCntl->region_hsize = pSurface->plane[0].uAllocWidth * 2 / pSurface->plane[0].uPixelSize;
            pCntl->region_vsize = pSurface->plane[0].uAllocHeight/2;
            if(twinheader && uNumBuf > 2)   // only for 32bit color mode
            {
                pCntl = (STB_OSD_GI_CONTROL_BLOCK_T *)((BYTE *)os_get_logical_address(pSurface->hBuffer)
                    + pSurface->uBufferBase2 - pSurface->uBufferBase);     // move to next header
                PDEBUG("Twinheader pCntl= %08x, base= %08x\n", pCntl, pSurface->uBufferBase2);
                pCntl->region_hsize = pSurface->plane[2].uAllocWidth * 2 / pSurface->plane[2].uPixelSize;
                pCntl->region_vsize = pSurface->plane[2].uAllocHeight/2;
            }
        }
    }

    PDEBUGE("Surface (x,y,bpl,bpp)= %d [%8.8x], %d [%8.8x], %d [%8.8x], %d\n", 
        pSurface->plane[0].uAllocWidth,  pSurface->plane[0].uAllocWidth,
        pSurface->plane[0].uAllocHeight, pSurface->plane[0].uAllocHeight,
        pSurface->plane[0].uBytePerLine, pSurface->plane[0].uBytePerLine, 
        pSurface->plane[0].uPixelSize);


    return 0;
}


INT gfx_osi_get_surface_physical_parm(GFX_SURFACE_PHYSICAL_PARM_T *pParm, GFX_SURFACE_T *pSurface)
{
    UINT uNumBuf, i;
    // first, a rough check of the parameters
    if(!gfx_osi_pSurface_valid(pSurface) || NULL == pParm) 
    {
        PDEBUG("Invalid parm !\n");
        return -1;    // we cann't do it
    }

    uNumBuf = GET_GFX_SURFACE_SUBPLANES(pSurface->uPlaneConfig);

    _OS_MEMSET(pParm, 0, sizeof(GFX_SURFACE_PHYSICAL_PARM_T));

    pParm->uGFXBufferPhysicalBase = os_get_physical_address(pSurface->hBuffer);
    pParm->uGFXBufferPhysicalSize = os_get_actual_physical_size(pSurface->hBuffer);

    for(i=0; i<uNumBuf; i++) 
    {
        pParm->uPlanePhysicalBaseAddr[i] = pSurface->plane[i].uBMLA + pParm->uGFXBufferPhysicalBase;
        pParm->uPlanePhysicalOffset[i] = 0;
        pParm->uPlanePhysicalSize[i] = ((pSurface->plane[i].uAllocHeight*pSurface->plane[i].uBytePerLine + OSD_BUFFER_ALIGNMENT - 1) / OSD_BUFFER_ALIGNMENT)*OSD_BUFFER_ALIGNMENT ;
    }
    return 0;
}



//////////////////////////////////////////////////////////////////////////////
// Color space conversion helpers
//////////////////////////////////////////////////////////////////////////////

void gfx_osi_rgb2ycbcr(BYTE r, BYTE g,  BYTE b,  BYTE *y, BYTE *cb, BYTE *cr)
{
    // Y  =  0.257*R + 0.504*G + 0.098*B + 16
    // CB = -0.148*R - 0.291*G + 0.439*B + 128
    // CR =  0.439*R - 0.368*G - 0.071*B + 128
    *y  = (BYTE)((8432*(ULONG)r + 16425*(ULONG)g + 3176*(ULONG)b + 16*32768)>>15);
    *cb = (BYTE)((128*32768 + 14345*(ULONG)b - 4818*(ULONG)r -9527*(ULONG)g)>>15);
    *cr = (BYTE)((128*32768 + 14345*(ULONG)r - 12045*(ULONG)g-2300*(ULONG)b)>>15);
}

void gfx_osi_ycbcr2rgb(BYTE y, BYTE cb,  BYTE cr,  BYTE *r, BYTE *g, BYTE *b)
{
    // R = 1.164*(Y - 16) + 1.596*(CR - 128)
    // G = 1.164*(Y - 16) - 0.813*(CR - 128) - 0.391*(CB - 128)
    // B = 1.164*(Y - 16)                    + 2.018*(CB - 128)

    // R = 1.164*Y + 1.596*CR - 222.4[1.164*16 + 1.592*128]
    // G = 1.164*Y + 135.488[0.813*128 + 0.391*128 - 1.164*16] - 0.813*CR - 0.391*CB
    // B = 1.164*Y + 2.018*CB - 276.928[1.164*16 + 2.018*128]
    int rr, gg, bb, my;

    my = 38142*(int)y;

    rr = (my + 52298*(int)cr - 7287603)>>15;

    if(rr > 255) *r = 255;
    else if(rr < 0) *r = 0;
    else *r = (BYTE)rr;

    gg = (my + 4439671 - 26640*cr - 12812*cb)>> 15;

    if(gg > 255) *g = 255;
    else if(gg < 0) *g = 0;
    else *g = (BYTE)gg;
    
    bb = (my + 66126*cb - 9074377)>>15;

    if(bb > 255) *b = 255;
    else if(bb < 0) *b = 0;
    else *b = (BYTE)bb;

}