gfx_osi_engine.c

IBM source for pallas/vulcan/vesta

                pdes[x] = (pBuf[s>>3] & (0x80 >> (s&7))) ? vf : vb;
        }
        pBuf += bplsrc;
        pdes += bpldes;
    }
}


void __gfx_osi_g2d_bitblt_clut_32(BYTE *pdes,  INT bpldes, INT nDesX, INT nDesY,
                UINT uWidth, UINT uHeight, BYTE *psrc, INT bplsrc, INT nSrcX,  INT nSrcY, GFX_PALETTE_T *pPal)
{
    int y, x;
    UINT32 *pPal32 = (UINT32 *)pPal;
    // we assume that the palette is the same as argb32 color
    psrc = psrc + nSrcX + nSrcY*bplsrc;
    pdes = pdes + (nDesX<<2) + nDesY*bpldes;
    for(y=0; y<uHeight; y++)
    {
        UINT32 *pBuf = (UINT32 *)pdes;
        for(x=0; x<uWidth; x++)
        {
            pBuf[x] = pPal32[psrc[x]];
        }
        psrc += bplsrc;
        pdes += bpldes;
    }
}

void __gfx_osi_g2d_bitblt_32(BYTE *pdes,  INT bpldes, INT nDesX, INT nDesY,
                UINT uWidth, UINT uHeight, BYTE *psrc, INT bplsrc, INT nSrcX,  INT nSrcY)
{
    int y;
    psrc = psrc + (nSrcX<<2) + nSrcY*bplsrc;
    pdes = pdes + (nDesX<<2) + nDesY*bpldes;
    uWidth <<= 2;
    for(y=0; y<uHeight; y++)
    {
        _OS_MEMCPY(pdes, psrc, uWidth);
        psrc += bplsrc;
        pdes += bpldes;
    }
}


void __gfx_osi_g2d_bitblt_yuv422_32(BYTE *pdes,  INT bpldes, INT nDesX, INT nDesY,
                UINT uWidth, UINT uHeight, BYTE *psrcy, BYTE *psrcuv, BYTE *psrca, INT bplsrc, INT nSrcX,  INT nSrcY)
{
    int y, x, n;
    // we assume that the palette is the same as argb32 color
    psrcy = psrcy + nSrcX + nSrcY*bplsrc;
    psrcuv = psrcuv + (nSrcX&0xfffffffe) + nSrcY*bplsrc;
    pdes = pdes + (nDesX<<2) + nDesY*bpldes;
    if(psrca)
    {
        psrca = psrca + nSrcX + nSrcY*bplsrc;
        for(y=0; y<uHeight; y++)
        {
            for(x=0,n=0; x<uWidth; x++, n+=4)
            {
                gfx_osi_ycbcr2rgb(psrcy[x], psrcuv[x&0xfffffffe], psrcuv[((x)&0xfffffffe) + 1], pdes + n+1, pdes + n+2, pdes + n+3);
                pdes[n] = psrca[x];
            }
            psrcy += bplsrc;
            psrcuv += bplsrc;
            psrca += bplsrc;
            pdes += bpldes;
        }
    }
    else
    {
        for(y=0; y<uHeight; y++)
        {
            for(x=0,n=0; x<uWidth; x++, n+=4)
            {
                gfx_osi_ycbcr2rgb(psrcy[x], psrcuv[x&0xfffffffe], psrcuv[((x)&0xfffffffe) + 1], pdes + n+1, pdes + n+2, pdes + n+3);
                pdes[n] = 255;
            }
            psrcy += bplsrc;
            psrcuv += bplsrc;
            pdes += bpldes;
        }
    }
}


void __gfx_osi_g2d_bitblt_yuv420_32(BYTE *pdes,  INT bpldes, INT nDesX, INT nDesY,
                UINT uWidth, UINT uHeight, BYTE *psrcy, BYTE *psrcuv, BYTE *psrca, INT bplsrc, INT nSrcX,  INT nSrcY)
{
    int y, x, n;
    // we assume that the palette is the same as argb32 color
    psrcy = psrcy + nSrcX + nSrcY*bplsrc;
    psrcuv = psrcuv + (nSrcX&0xfffffffe) + (nSrcY>>1)*bplsrc;
    pdes = pdes + (nDesX<<2) + nDesY*bpldes;
    if(psrca)
    {
        psrca = psrca + nSrcX + nSrcY*bplsrc;
        for(y=0; y<uHeight; y++)
        {
            for(x=0,n=0; x<uWidth; x++, n+=4)
            {
                gfx_osi_ycbcr2rgb(psrcy[x], psrcuv[x&0xfffffffe], psrcuv[((x)&0xfffffffe) + 1], pdes + n+1, pdes + n+2, pdes + n+3);
                pdes[n] = psrca[x];
            }
            psrcy += bplsrc;
            if((y+nSrcY)&1) psrcuv += bplsrc;
            psrca += bplsrc;
            pdes += bpldes;
        }
    }
    else
    {
        for(y=0; y<uHeight; y++)
        {
            for(x=0,n=0; x<uWidth; x++, n+=4)
            {
                gfx_osi_ycbcr2rgb(psrcy[x], psrcuv[x&0xfffffffe], psrcuv[((x)&0xfffffffe) + 1], pdes + n+1, pdes + n+2, pdes + n+3);
            }
            psrcy += bplsrc;
            if((y+nSrcY)&1) psrcuv += bplsrc;
            pdes += bpldes;
        }
    }
}


void __gfx_osi_g2d_bitblt_32_yuv422(BYTE *pdesy, BYTE *pdesuv, BYTE *pdesa,  INT bpldes, INT nDesX, INT nDesY,
                UINT uWidth, UINT uHeight, BYTE *psrc, INT bplsrc, INT nSrcX,  INT nSrcY)
{
    int y, x, n;
    // we assume that the palette is the same as argb32 color
    psrc = psrc + (nSrcX<<2) + nSrcY*bplsrc;
    pdesy = pdesy + nDesX + nDesY*bpldes;
    pdesuv = pdesuv + (nDesX&0xfffffffe) + nDesY*bpldes;
    if(pdesa)
    {
        pdesa = pdesa + nDesX + nDesY*bpldes;
        for(y=0; y<uHeight; y++)
        {
            for(x=0,n=0; x<uWidth; x++, n+=4)
            {
                gfx_osi_rgb2ycbcr(psrc[n+1], psrc[n+2], psrc[n+3], pdesy+x, pdesuv + (x&0xfffffffe), pdesuv + (x&0xfffffffe)+1);
                pdesa[x] = psrc[n];
            }
            pdesy += bpldes;
            pdesuv += bpldes;
            pdesa += bpldes;
            psrc += bplsrc;
        }
    }
    else
    {
        for(y=0; y<uHeight; y++)
        {
            for(x=0,n=0; x<uWidth; x++, n+=4)
            {
                gfx_osi_rgb2ycbcr(psrc[n+1], psrc[n+2], psrc[n+3], pdesy+x, pdesuv + (x&0xfffffffe), pdesuv + (x&0xfffffffe)+1);
            }
            pdesy += bpldes;
            pdesuv += bpldes;
            psrc += bplsrc;
        }
    }
}

void __gfx_osi_g2d_bitblt_32_yuv420(BYTE *pdesy, BYTE *pdesuv, BYTE *pdesa,  INT bpldes, INT nDesX, INT nDesY,
                UINT uWidth, UINT uHeight, BYTE *psrc, INT bplsrc, INT nSrcX,  INT nSrcY)
{
    int y, x, n;
    // we assume that the palette is the same as argb32 color
    psrc = psrc + (nSrcX<<2) + nSrcY*bplsrc;
    pdesy = pdesy + nDesX + nDesY*bpldes;
    pdesuv = pdesuv + (nDesX&0xfffffffe) + (nDesY>>1)*bpldes;
    if(pdesa)
    {
        pdesa = pdesa + nDesX + nDesY*bpldes;
        for(y=0; y<uHeight; y++)
        {
            for(x=0,n=0; x<uWidth; x++, n+=4)
            {
                gfx_osi_rgb2ycbcr(psrc[n+1], psrc[n+2], psrc[n+3], pdesy+x, pdesuv + (x&0xfffffffe), pdesuv + (x&0xfffffffe)+1);
                pdesa[x] = psrc[n];
            }
            pdesy += bpldes;
            if((y+nDesY)&1) pdesuv += bpldes;
            pdesa += bpldes;
            psrc += bplsrc;
        }
    }
    else
    {
        for(y=0; y<uHeight; y++)
        {
            for(x=0,n=0; x<uWidth; x++, n+=4)
            {
                gfx_osi_rgb2ycbcr(psrc[n+1], psrc[n+2], psrc[n+3], pdesy+x, pdesuv + (x&0xfffffffe), pdesuv + (x&0xfffffffe)+1);
            }
            pdesy += bpldes;
            if((y+nDesY)&1) pdesuv += bpldes;
            psrc += bplsrc;
        }
    }
}



void __gfx_osi_g2d_blend32(BYTE *pdes,  INT bpldes, INT nDesX, INT nDesY,
                UINT uWidth, UINT uHeight, BYTE *psrc, INT bplsrc, INT nSrcX,  INT nSrcY,
                BYTE *palpha, INT bplalpha,  INT nPixIncA, BYTE *pdesta, INT bpldesta,  INT nPixIncDestA)
{
    int y, x;
    register BYTE *ps, *pd, *pa, *pda;
    psrc = psrc + (nSrcX<<2) + nSrcY*bplsrc;
    pdes = pdes + (nDesX<<2) + nDesY*bpldes;
    uWidth <<= 2;
    for(y=0; y<uHeight; y++)
    {
        ps = psrc;
        pd = pdes;
        pa = palpha;
        pda = pdesta;
        for(x=0; x<uWidth; x++)
        {
            *(pd + 1) = ((UINT16)*(ps + 1)*(*pa) + (UINT16)*(pd + 1)*(255 - *pa))>>8;   // should be /255
            *(pd + 2) = ((UINT16)*(ps + 2)*(*pa) + (UINT16)*(pd + 2)*(255 - *pa))>>8;   // should be /255
            *(pd + 3) = ((UINT16)*(ps + 3)*(*pa) + (UINT16)*(pd + 3)*(255 - *pa))>>8;   // should be /255
            *(pd    ) = *pda;
            ps += 4;
            pd += 4;
            pa += nPixIncA;
            pda += nPixIncDestA;
        }
        psrc += bplsrc;
        pdes += bpldes;
        palpha += bplalpha;
        pdesta += bpldesta;
    }
}

void __gfx_osi_g2d_blend32_a(BYTE *pdes,  INT bpldes, INT nDesX, INT nDesY,
                UINT uWidth, UINT uHeight, BYTE *psrc, INT bplsrc, INT nSrcX,  INT nSrcY,
                BYTE *palpha, INT bplalpha,  INT nPixIncA)
{
    int y, x;
    register BYTE *ps, *pd, *pa;
    psrc = psrc + (nSrcX<<2) + nSrcY*bplsrc;
    pdes = pdes + (nDesX<<2) + nDesY*bpldes;
    uWidth <<= 2;
    for(y=0; y<uHeight; y++)
    {
        ps = psrc;
        pd = pdes;
        pa = palpha;
        for(x=0; x<uWidth; x++)
        {
            *(pd + 1) = ((UINT16)*(ps + 1)*(*pa) + (UINT16)*(pd + 1)*(255 - *pa))>>8;   // should be /255
            *(pd + 2) = ((UINT16)*(ps + 2)*(*pa) + (UINT16)*(pd + 2)*(255 - *pa))>>8;   // should be /255
            *(pd + 3) = ((UINT16)*(ps + 3)*(*pa) + (UINT16)*(pd + 3)*(255 - *pa))>>8;   // should be /255
            *(pd    ) = ((UINT16)*(ps + 0)*(*pa) + (UINT16)*(pd + 0)*(255 - *pa))>>8;   // should be /255
            ps += 4;
            pd += 4;
            pa += nPixIncA;
        }
        psrc += bplsrc;
        pdes += bpldes;
        palpha += bplalpha;
    }
}




void __gfx_osi_g2d_resize_nn8(BYTE *pdes,  INT bpldes, INT nDesX, INT nDesY,
                UINT uDesWidth, UINT uDesHeight, BYTE *psrc, INT bplsrc, INT nSrcX,  INT nSrcY, UINT uSrcWidth, UINT uSrcHeight)
{
    int x, y, xp, yp;
    psrc = psrc + nSrcX + nSrcY*bplsrc;
    pdes = pdes + nDesX + nDesY*bpldes;
    for(y=0; y<uDesHeight; y++) 
    {
        yp = (((y*uSrcHeight)<<8)/uDesHeight + 128)>>8;
        yp *= bplsrc;
        for(x=0; x<uDesWidth; x++) 
        {
            xp = (((x*uSrcWidth)<<8)/uDesWidth + 128)>>8;
            pdes[x] = psrc[xp+yp];
        }
        pdes += bpldes;
    }  
}

void __gfx_osi_g2d_resize_bl8(BYTE *pdes,  INT bpldes, INT nDesX, INT nDesY,
                UINT uDesWidth, UINT uDesHeight, BYTE *psrc, INT bplsrc, INT nSrcX,  INT nSrcY, UINT uSrcWidth, UINT uSrcHeight)
{
    int x, y, xp, yp, ypx;
    int xx, yy, dx, dy;
    BYTE *pp;
    BYTE p00, p01, p10, p11;

    psrc = psrc + nSrcX + nSrcY*bplsrc;
    pdes = pdes + nDesX + nDesY*bpldes;
    for(y=0; y<uDesHeight; y++) 
    {
        yy = ((y*uSrcHeight)<<8)/uDesHeight;
        yp = yy>>8;  dy = yy&0xff;
        ypx = yp*bplsrc;
        for(x=0; x<uDesWidth; x++) 
        {
            xx = ((x*uSrcWidth)<<8)/uDesWidth;
            xp = xx>>8; dx = xx&0xff;
            pp = psrc+xp+ypx; 
            p00 = *pp;
            if(xp+1 < uSrcWidth)
            {
                p10 = *(pp+1); 
                if(yp+1 < uSrcHeight)
                {
                    p01 = *(pp+bplsrc);
                    p11 = *(pp+bplsrc+1);
                }
                else
                {
                    p01 = p00;
                    p11 = p10;
                }
            }
            else
            {
                p10 = p00;
                if(yp+1 < uSrcHeight)
                {
                    p01 = *(pp+bplsrc);
                    p11 = p01;
                }
                else
                {
                    p01 = p00;
                    p11 = p10;
                }
            }

            pdes[x] = (BYTE)(((p11*dx+p01*(256-dx))*dy + (p10*dx+p00*(256-dx))*(256-dy))>>16);
        }
        pdes += bpldes;
    }  
}

// uColor = 0/a, 1/r, 2/g, 3/b
void __gfx_osi_g2d_resize_clut_8(BYTE *pdes,  INT bpldes, INT nDesX, INT nDesY,
                UINT uDesWidth, UINT uDesHeight, BYTE *psrc, INT bplsrc, INT nSrcX,  INT nSrcY, UINT uSrcWidth, UINT uSrcHeight, GFX_PALETTE_T *pPal, UINT uColor)
{
    int x, y, xp, yp;
    psrc = psrc + nSrcX + nSrcY*bplsrc;
    pdes = pdes + nDesX + nDesY*bpldes;
    switch(uColor)
    {
    case 0:   // a
        for(y=0; y<uDesHeight; y++) 
        {
            yp = (((y*uSrcHeight)<<8)/uDesHeight + 128)>>8;
            yp *= bplsrc;
            for(x=0; x<uDesWidth; x++) 
            {
                xp = (((x*uSrcWidth)<<8)/uDesWidth + 128)>>8;
                pdes[x] = pPal[psrc[xp+yp]].a;
            }
            pdes += bpldes;
        }
        break;
    case 1:   // r
        for(y=0; y<uDesHeight; y++) 
        {
            yp = (((y*uSrcHeight)<<8)/uDesHeight + 128)>>8;
            yp *= bplsrc;
            for(x=0; x<uDesWidth; x++) 
            {
                xp = (((x*uSrcWidth)<<8)/uDesWidth + 128)>>8;
                pdes[x] = pPal[psrc[xp+yp]].r;
            }
            pdes += bpldes;
        }
        break;
    case 2:   // g
        for(y=0; y<uDesHeight; y++) 
        {
            yp = (((y*uSrcHeight)<<8)/uDesHeight + 128)>>8;
            yp *= bplsrc;
            for(x=0; x<uDesWidth; x++) 
            {
                xp = (((x*uSrcWidth)<<8)/uDesWidth + 128)>>8;
                pdes[x] = pPal[psrc[xp+yp]].g;
            }
            pdes += bpldes;
        }
        break;
    case 3:   // b
        for(y=0; y<uDesHeight; y++) 
        {
            yp = (((y*uSrcHeight)<<8)/uDesHeight + 128)>>8;
            yp *= bplsrc;
            for(x=0; x<uDesWidth; x++) 
            {
                xp = (((x*uSrcWidth)<<8)/uDesWidth + 128)>>8;
                pdes[x] = pPal[psrc[xp+yp]].b;
            }
            pdes += bpldes;
        }
        break;
    }
}

void __gfx_osi_g2d_resize_clut_32(BYTE *pdes,  INT bpldes, INT nDesX, INT nDesY,
                UINT uDesWidth, UINT uDesHeight, BYTE *psrc, INT bplsrc, INT nSrcX,  INT nSrcY, UINT uSrcWidth, UINT uSrcHeight, GFX_PALETTE_T *pPal)
{
    int x, y, xp, yp;
    
    psrc = psrc + nSrcX + nSrcY*bplsrc;
    pdes = pdes + (nDesX<<2) + nDesY*bpldes;
    for(y=0; y<uDesHeight; y++) 
    {
        UINT32  *pBuf = (UINT32 *)pdes;
        yp = (((y*uSrcHeight)<<8)/uDesHeight + 128)>>8;
        yp *= bplsrc;
        for(x=0; x<uDesWidth; x++) 
        {
            xp = (((x*uSrcWidth)<<8)/uDesWidth + 128)>>8;
            pBuf[x] = *(UINT32 *)&pPal[psrc[xp+yp]];
        }
        pdes += bpldes;
    }
}

void __gfx_osi_g2d_resize_clut_uv(BYTE *pdes,  INT bpldes, INT nDesX, INT nDesY,
                UINT uDesWidth, UINT uDesHeight, BYTE *psrc, INT bplsrc, INT nSrcX,  INT nSrcY, UINT uSrcWidth, UINT uSrcHeight, GFX_PALETTE_T *pPal)
{
    int x, y, xp, yp;
    psrc = psrc + nSrcX + nSrcY*bplsrc;
    pdes = pdes + nDesX + nDesY*bpldes;
    uDesWidth &= 0xfffffffe;    // make sure it is even
    for(y=0; y<uDesHeight; y++) 
    {
        yp = (((y*uSrcHeight)<<8)/uDesHeight + 128)>>8;
        yp *= bplsrc;
        for(x=0; x<uDesWidth; x+=2) 
        {
            xp = (((x*uSrcWidth)<<8)/uDesWidth + 128)>>8;
            pdes[x  ] = pPal[psrc[xp+yp]].g;
            pdes[x+1] = pPal[psrc[xp+yp]].b;