gebmutil.c

Go to the documentation of this file.

#define WIN32_LEAN_AND_MEAN
#pragma warning(disable : 4201 4214 4115)
#include <windows.h>
#pragma warning(default : 4201 4214 4115)

#include "gebmutil.h"
#include "Ram.h"
#include "errorlog.h"
#include <stdlib.h>
#include <assert.h>
#include <math.h>

#include "vfile.h"

#ifdef _LOG
#include "log.h"
#else
#pragma warning (disable:4100)
static _inline void Log_Printf(const char * str, ...) { }
#pragma warning (default:4100)
#endif

#ifdef _TSC
#include "tsc.h"
#else
#define pushTSC()
#define showPopTSC(s)
#endif

/*}{*************** HBITMAP utilities ******************/

HBITMAP geBitmapUtil_CreateHBITMAP(geBitmap *Bitmap,HWND window,int mip)
{
geBitmap * Lock;
gePixelFormat Format;
geBitmap_Info info;
HBITMAP hbm = NULL;

#pragma message("gebmu_CreateHBITMAP : choose format to be 8,16,or 24, whichever is closest to Bitmap")

        Format = GE_PIXELFORMAT_24BIT_BGR;

        if ( geBitmap_GetBits(Bitmap) )
        {
                Lock = Bitmap;
        }
        else
        {
                if ( ! geBitmap_LockForRead(Bitmap, &Lock, mip,mip, Format,     GE_FALSE,0) )
                        return NULL;
        }

        geBitmap_GetInfo(Lock,&info,NULL);

        if ( info.Format != Format )
                return NULL;

        {
        void * bits;
        HDC hdc;
        BITMAPINFOHEADER bmih;
        int pelbytes;

                pelbytes = gePixelFormat_BytesPerPel(Format);
                bits = geBitmap_GetBits(Lock);

                hdc = GetDC(window);

                bmih.biSize = sizeof(bmih);
                bmih.biHeight = - info.Height;
                bmih.biPlanes = 1;
                bmih.biBitCount = 24;
                bmih.biCompression = BI_RGB;
                bmih.biSizeImage = 0;
                bmih.biXPelsPerMeter = bmih.biYPelsPerMeter = 10000;
                bmih.biClrUsed = bmih.biClrImportant = 0;

                if ( (info.Stride*pelbytes) == (((info.Stride*pelbytes)+3)&(~3)) )
                {
                        bmih.biWidth = info.Stride;
                        hbm = CreateDIBitmap( hdc, &bmih , CBM_INIT , bits, (BITMAPINFO *)&bmih , DIB_RGB_COLORS );
                }
                else
                {
                void * newbits;
                int Stride;
                        bmih.biWidth = info.Width;
                        Stride = (((info.Width*pelbytes)+3)&(~3));
                        newbits = geRam_Allocate(Stride * info.Height);
                        if ( newbits )
                        {
                        char *newptr,*oldptr;
                        int y;
                                newptr = newbits;
                                oldptr = bits;
                                for(y=0;y<info.Height;y++)
                                {
                                        memcpy(newptr,oldptr,(info.Width)*pelbytes);
                                        oldptr += info.Stride*pelbytes;
                                        newptr += Stride;
                                }
                                hbm = CreateDIBitmap( hdc, &bmih , CBM_INIT , newbits, (BITMAPINFO *)&bmih , DIB_RGB_COLORS );
                                geRam_Free(newbits);
                        }
                }

                ReleaseDC(window,hdc);
        }

        if ( Lock != Bitmap )
                geBitmap_UnLock(Lock);

return hbm;
}

geBitmap * geBitmapUtil_CreateFromHBITMAP(HWND window,HBITMAP hbm)
{
geBitmap * Bmp;
char bmidata[sizeof(BITMAPINFOHEADER)+12];
BITMAPINFOHEADER * pbmi;
HDC hdc;
int lines;

        if ( ! window || ! hbm )
                return NULL;

        pbmi = (BITMAPINFOHEADER *)bmidata;

        pbmi->biSize = sizeof(BITMAPINFOHEADER);
        pbmi->biWidth = 0;
        pbmi->biHeight = 0;
        pbmi->biPlanes = 1;
        pbmi->biBitCount = 0;
        pbmi->biCompression = BI_RGB;
        pbmi->biSizeImage = 0;
        pbmi->biXPelsPerMeter = pbmi->biYPelsPerMeter = 1000;
        pbmi->biClrUsed = pbmi->biClrImportant = 0;

        hdc = GetDC(window);
        if ( ! hdc )
                return NULL;

        lines = GetDIBits(hdc,hbm,0,0,NULL,(BITMAPINFO *)pbmi,0);

        ReleaseDC(window,hdc);

        if ( ! lines )
                return NULL;

        {
        geBitmap * Lock;
        void * bits;
        int ret;
        uint32 * masks;

                Bmp = geBitmap_Create(pbmi->biWidth,abs(pbmi->biHeight),1,GE_PIXELFORMAT_32BIT_XRGB);
                if ( ! Bmp )
                        return NULL;

                masks = (uint32 *)(bmidata + sizeof(BITMAPINFOHEADER));
                masks[0] = 0x00FF0000;
                masks[1] = 0x0000FF00;
                masks[2] = 0x000000FF;

                if ( ! geBitmap_LockForWrite(Bmp,&Lock,0,0) )
                {
                        geBitmap_Destroy(&Bmp);
                        return NULL;
                }

                bits = geBitmap_GetBits(Lock);
                assert(bits);

                pbmi->biSize = sizeof(BITMAPINFOHEADER);
                pbmi->biHeight = - abs(pbmi->biHeight);
                pbmi->biPlanes = 1;
                pbmi->biBitCount = 32;
                pbmi->biCompression = BI_RGB;
                pbmi->biSizeImage = 0;
                pbmi->biClrUsed = pbmi->biClrImportant = 0;

                hdc = GetDC(window);
                assert(hdc);

                ret = GetDIBits(hdc,hbm,0,lines,bits,(BITMAPINFO *)pbmi,0);

                ReleaseDC(window,hdc);

                geBitmap_UnLock(Lock);

                if ( ! ret )
                {
                        geBitmap_Destroy(&Bmp);
                        return NULL;
                }
        }

return Bmp;
}

/*}{*************** SmoothBits !! ******************/

/*******

SmoothBits with radius == 1 is actually the solution of the diffusion equation (!!)

*pSrc = (pSrc[-1] + pSrc[1] + pSrc[s]+ pSrc[s-1])>>2;

rewriting :

f'(x,y) = ( f(x+1,y) + f(x-1,y) + f(x,y+1) + f(x,y-1) )/4

f'(x,y) - f(x,y)  = ( f(x+1,y) + f(x-1,y) + f(x,y+1) + f(x,y-1) )/4 - f(x,y)

[f'(x,y) - f(x,y)]/a  = (b^2/a) [ ( f(x+1,y) + f(x-1,y) + f(x,y+1) + f(x,y-1) )/4 - f(x,y) ]/b^2

now the left is a time-derivative with time step a and the right side is a grad-squared with
x-spacing of b.  Since b = 1 pixel :

dt f(x,y)  = (1 pixel^2/a) grad^2 f(x,y)

in our application, 'a' is like 1/50 second = 0.02 or such, so we have a diffusion equation:

        dt f() = lambda  grad^2 f()

with a fixed diffusion coefficient lambda = 50 pixel^2/second

********/
geBoolean geBitmapUtil_SmoothBits(geBitmap_Info *pInfo,void *FmBits,void *ToBits,int radius,geBoolean wrap)
{
int bpp,x,y,w,h,s;

        assert(FmBits && ToBits);
        assert(radius > 0);

        if ( radius > 3 ) radius = 3;

        bpp = gePixelFormat_BytesPerPel(pInfo->Format);

        w = pInfo->Width;
        h = pInfo->Height;
        s = pInfo->Stride;

        switch(bpp)
        {
                case 0:
                        return GE_FALSE;
                case 1:
                {
                uint8 *pSrc,*pDst;

                        pSrc = FmBits;
                        pDst = ToBits;

                        if ( wrap )
                        {
                        uint8 *pSrcN,*pSrcP;
                                switch(radius)
                                {
                                case 1:
                                        for(y=0;y<h;y++)
                                        {                                               
                                                pSrcN = pSrc+s;
                                                pSrcP = pSrc-s;

                                                if ( y == 0 )
                                                {
                                                        pSrcP = pSrc + s*(h-1);
                                                }
                                                else if ( y == (h-1) )
                                                {
                                                        pSrcN = FmBits;
                                                }

                                                //first pel                                             
                                                *pDst++ = (pSrc[w-1] + pSrc[1] + *pSrcN + *pSrcP)>>2;
                                                pSrc++;
                                                pSrcN++;
                                                pSrcP++;

                                                for(x = w-2;x--;)
                                                {
                                                        *pDst++ = (pSrc[-1] + pSrc[1] + *pSrcN + *pSrcP)>>2;
                                                        pSrc++;
                                                        pSrcN++;
                                                        pSrcP++;
                                                }

                                                // last pel
                                                *pDst++ = (pSrc[-1] + pSrc[1-w] + *pSrcN + *pSrcP)>>2;
                                                pSrc++;
                                                pSrcN++;
                                                pSrcP++;

                                                pDst += (s-w);
                                                pSrc += (s-w);
                                        }
                                        break;

                                default:
                                case 2:
                                        for(y=0;y<h;y++)
                                        {                                               
                                                pSrcN = pSrc+s;
                                                pSrcP = pSrc-s;

                                                if ( y == 0 )
                                                {
                                                        pSrcP = pSrc + s*(h-1);
                                                }
                                                else if ( y == (h-1) )
                                                {
                                                        pSrcN = FmBits;
                                                }

                                                //first pel                                             
                                                *pDst++ = (pSrcN[-1] + pSrc[1] + *pSrcN + *pSrcP)>>2;
                                                pSrc++;
                                                pSrcN++;
                                                pSrcP++;

                                                for(x = w-2;x--;)
                                                {
                                                        *pDst++ = (pSrc[-1] + pSrc[1] + pSrcN[0] + pSrcP[0] +
                                                                                pSrcN[1] + pSrcN[-1] + pSrcP[1] + pSrcP[-1])>>3;
                                                        pSrc++;
                                                        pSrcN++;
                                                        pSrcP++;
                                                }

                                                // last pel
                                                *pDst++ = (pSrc[-1] + pSrcP[1] + *pSrcN + *pSrcP)>>2;
                                                pSrc++;
                                                pSrcN++;
                                                pSrcP++;

                                                pDst += (s-w);
                                                pSrc += (s-w);
                                        }
                                        break;
                                }
                        }
                        else
                        {
                                switch(radius)
                                {
                                case 1:
                                        
                                                // first line
                                                *pDst++ = (pSrc[1] + pSrc[s])>>1;
                                                pSrc++;
                                                for(x=w-1;x--;)
                                                {
                                                        *pDst++ = (pSrc[-1] + pSrc[1] + pSrc[s]+ pSrc[s-1])>>2;
                                                        pSrc++;
                                                }
                                                pDst += (s-w);
                                                pSrc += (s-w);

                                        for(y=h-2;y--;)
                                        {
                                                // middle lines
                                                
                                                x = w;

                                                #ifdef DONT_USE_ASM //{

                                                while(x--)
                                                {
                                                        *pDst++ = (pSrc[-1] + pSrc[1] + pSrc[s] + pSrc[-s])>>2;
                                                        pSrc++;
                                                }

                                                pDst += (s-w);
                                                pSrc += (s-w);

                                                #else //}{

                                                __asm 
                                                {
                                                        mov esi, pSrc
                                                        mov edi, pDst
                                                
                                                        // something like 10 clocks per byte = molto bene
                                                        
                                                mainloop:
                                                        xor eax,eax                                             // load the sum into eax

                                                        movzx edx,BYTE PTR [esi+1]              // port 2, latency 1
                                                        add eax,edx                                             // port 1, latency 1

                                                        movzx edx,BYTE PTR [esi-1]
                                                        add eax,edx     
                                                                
                                                        mov ecx,esi                                             // ecx = esi + s
                                                        add ecx,s
                                                        movzx edx,BYTE PTR [ecx]                // eax += (BYTE) [ecx]
                                                        add eax,edx                                             // we have to use edx cuz of the byte 

                                                        mov ecx,esi     
                                                        sub ecx,s
                                                        movzx edx,BYTE PTR [ecx]
                                                        add eax,edx     

                                                        shr eax,2

                                                        mov [edi],al

                                                        inc edi
                                                        inc esi
                                                        dec x

                                                        jnz mainloop
                                                }

                                                pDst += s;
                                                pSrc += s;

                                                #endif // }
                                        }
                                        
                                                // last line
                                                for(x=w-1;x--;)
                                                {
                                                        *pDst++ = (pSrc[-1] + pSrc[1] + pSrc[-s]+ pSrc[-s+1])>>2;
                                                        pSrc++;
                                                }
                                                *pDst++ = (pSrc[-1] + pSrc[-s])>>1;
                                                pSrc++;
                                                pSrc += (s-w);
                                                pDst += (s-w);
                                        break;

                                default:
                                case 2:                 
                                                // first line
                                                *pDst++ = (pSrc[1] + pSrc[s])>>1;
                                                pSrc++;
                                                for(x=w-1;x--;)
                                                {
                                                        *pDst++ = (pSrc[-1] + pSrc[1] + pSrc[s]+ pSrc[s-1])>>2;
                                                        pSrc++;
                                                }
                                                pSrc += (s-w);
                                                pDst += (s-w);

                                        for(y=h-2;y--;)
                                        {
                                                *pDst++ = (pSrc[-1] + pSrc[1] + pSrc[s] + pSrc[-s])>>2;
                                                pSrc++;

                                                #ifdef DONT_USE_ASM //{

                                                for(x=w-2;x--;)
                                                {
                                                        *pDst++ = (pSrc[-1] + pSrc[1] + pSrc[s] + pSrc[-s] +
                                                                                pSrc[s+1] + pSrc[s-1] + pSrc[-s+1] + pSrc[-s-1])>>3;
                                                        pSrc++;
                                                }

                                                #else //}{

                                                x = w-2;

                                                __asm 
                                                {
                                                        mov esi, pSrc
                                                        //lea esi, [pSrc]
                                                        mov edi, pDst
                                                        //lea edi, [pDst]
                                                        
                                                mainloop2:
                                                        xor eax,eax                                             // load the sum into eax

                                                        movzx edx,BYTE PTR [esi+1]              // eax += (BYTE) esi[1]
                                                        add eax,edx                                             // we have to use edx cuz of the byte

                                                        movzx edx,BYTE PTR [esi-1]
                                                        add eax,edx     

                                                        mov ecx,esi                                             // ecx = esi + s
                                                        add ecx,s
                                                        movzx edx,BYTE PTR [ecx-1]              
                                                        add eax,edx                                             
                                                        movzx edx,BYTE PTR [ecx]                
                                                        add eax,edx
                                                        movzx edx,BYTE PTR [ecx+1]
                                                        add eax,edx                                             

                                                        mov ecx,esi     
                                                        sub ecx,s
                                                        movzx edx,BYTE PTR [ecx-1]
                                                        add eax,edx     
                                                        movzx edx,BYTE PTR [ecx]
                                                        add eax,edx     
                                                        movzx edx,BYTE PTR [ecx+1]
                                                        add eax,edx     

                                                        shr eax,3

                                                        mov [edi],al

                                                        inc edi
                                                        inc esi
                                                        dec x

                                                        jnz mainloop2
                                                }

                                                pDst += w-2;
                                                pSrc += w-2;

                                                #endif //}

                                                *pDst++ = (pSrc[-1] + pSrc[1] + pSrc[s] + pSrc[-s])>>2;
                                                pSrc++;
                                                pSrc += (s-w);
                                                pDst += (s-w);
                                        }
                                                // last line
                                                for(x=w-1;x--;)
                                                {
                                                        *pDst++ = (pSrc[-1] + pSrc[1] + pSrc[-s]+ pSrc[-s+1])>>2;
                                                        pSrc++;
                                                }
                                                *pDst++ = (pSrc[-1] + pSrc[-s])>>1;
                                                pSrc++;
                                                pSrc += (s-w);
                                                pDst += (s-w);
                                        break;
                                }
                        }

                        assert( pSrc == ((uint8 *)FmBits + h*s) );
                        assert( pDst == ((uint8 *)ToBits + h*s) );
                        break;
                }


                case 2:
                case 3:
                case 4:
                        // can't just use a simple blender for 2-3-4-byte pixel formats;
                        // must decompose pixels to RGBA and blend
                        geErrorLog_AddString(-1,"geBitmapUtil_SmoothBits : only implemented for 1-byte data",NULL);
                        return GE_FALSE;
        }

        return GE_TRUE;
}

geBoolean geBitmapUtil_SetAlphaFromBrightness(geBitmap *Bmp)
{
geBitmap_Palette * Pal;
        assert(Bmp);

        if ( Pal = geBitmap_GetPalette(Bmp) )
        {
        uint32 PalData[256];
        int p;

                if ( ! geBitmap_Palette_SetFormat(Pal,GE_PIXELFORMAT_32BIT_ARGB) )
                        return GE_FALSE;

                if ( ! geBitmap_Palette_GetData(Pal,PalData,GE_PIXELFORMAT_32BIT_ARGB,256) )
                        return GE_FALSE;

                for(p=0;p<256;p++)
                {
                uint32 r,g,b,a,pel;
                        pel = PalData[p];
                        r = (pel>>16)&0xFF;
                        g = (pel>>8)&0xFF;
                        b = (pel>>0)&0xFF;
                        a = (r + g + b + 2)/3;
                        pel = (pel & 0x00FFFFFF) + (a<<24);
                        PalData[p] = pel;
                }

                if ( ! geBitmap_Palette_SetData(Pal,PalData,GE_PIXELFORMAT_32BIT_ARGB,256) )
                        return GE_FALSE;

                return GE_TRUE;
        }
        else
        {
        geBitmap * Alpha;
        geBitmap_Info Info;
                if ( ! geBitmap_GetInfo(Bmp,&Info,NULL) )
                        return GE_FALSE;
                Info.Format = GE_PIXELFORMAT_8BIT_GRAY;
                Alpha = geBitmap_CreateFromInfo(&Info);
                if ( ! geBitmap_BlitBitmap(Bmp,Alpha) )
                        return GE_FALSE;
                if ( ! geBitmap_SetAlpha(Bmp,Alpha) )
                        return GE_FALSE;
                return GE_TRUE;
        }
}

geBoolean geBitmapUtil_SetColor(geBitmap *Bmp,int R,int G,int B,int A)
{
geBitmap *Lock=NULL;
geBitmap_Info Info;
void *Bits;
int w,h,s,bpp,x;

        assert(Bmp);

        if ( ! geBitmap_LockForWrite(Bmp,&Lock,0,0) )
                goto fail;

        if ( ! geBitmap_GetInfo(Lock,&Info,NULL) )
                goto fail;

        Bits = geBitmap_GetBits(Lock);

        if ( ! Bits )
                goto fail; 

        bpp = gePixelFormat_BytesPerPel(Info.Format);

        w = Info.Width;
        h = Info.Height;
        s = Info.Stride;

        switch(bpp)
        {
                default:                
                        goto fail;
                case 1:
                {
                uint8 * pBits,Pixel;
                        pBits = Bits;
                        Pixel = (R+G+B)/3;
                        while(h--)
                        {
                                for(x=w;x--;)
                                {
                                        *pBits++ = Pixel;
                                }       
                                pBits += (s-w);                         
                        }
                        break;
                }               
                case 2:
                {
                uint16 * pBits,Pixel;
                        pBits = Bits;
                        Pixel = (uint16)gePixelFormat_ComposePixel(Info.Format,R,G,B,A);
                        while(h--)
                        {
                                for(x=w;x--;)
                                {
                                        *pBits++ = Pixel;
                                }       
                                pBits += (s-w);                         
                        }
                        break;
                }               
                case 4:
                {
                uint32 * pBits,Pixel;
                        pBits = Bits;
                        Pixel = (uint32)gePixelFormat_ComposePixel(Info.Format,R,G,B,A);
                        while(h--)
                        {
                                for(x=w;x--;)
                                {
                                        *pBits++ = Pixel;
                                }       
                                pBits += (s-w);                         
                        }
                        break;
                }               
                case 3:
                {
                uint8 * pBits,b1,b2,b3;
                uint32 Pixel;
                        pBits = Bits;
                        Pixel = (uint32)gePixelFormat_ComposePixel(Info.Format,R,G,B,A);
                        b1 = (uint8)((Pixel>>16)&0xFF);
                        b2 = (uint8)((Pixel>>8 )&0xFF);
                        b3 = (uint8)((Pixel>>0 )&0xFF);
                        while(h--)
                        {
                                for(x=w;x--;)
                                {
                                        *pBits++ = b1;
                                        *pBits++ = b2;
                                        *pBits++ = b3;
                                }       
                                pBits += 3*(s-w);                               
                        }
                        break;
                }
        }

        if ( ! geBitmap_UnLock(Lock) )
                goto fail;

        geBitmap_RefreshMips(Bmp);

        return GE_TRUE;
fail:

        if ( Lock )
                geBitmap_UnLock(Lock);

        return GE_FALSE;
}

/*}{*************** Bitmap_Create : ******************/

geBitmap * geBitmapUtil_CreateFromFileName(const geVFile * BaseFS,const char * BmName)
{
geVFile * File;
geBitmap * Bmp;

        if ( BaseFS )
                File = geVFile_Open((geVFile *)BaseFS,BmName,GE_VFILE_OPEN_READONLY);
        else
                File = geVFile_OpenNewSystem(NULL,GE_VFILE_TYPE_DOS,BmName,NULL,GE_VFILE_OPEN_READONLY);
        if ( ! File )
                return NULL;

        Bmp = geBitmap_CreateFromFile(File);
        geVFile_Close(File);

return Bmp;
}

geBitmap * geBitmapUtil_CreateFromFileAndAlphaNames(const geVFile * BaseFS,const char * BmName,const char *AlphaName)
{
geBitmap *Bmp,*AlphaBmp;

        Bmp = geBitmapUtil_CreateFromFileName(BaseFS,BmName);
        if ( ! Bmp )
                return NULL;

        AlphaBmp = geBitmapUtil_CreateFromFileName(BaseFS,AlphaName);
        if ( ! AlphaBmp )
        {
                geBitmap_Destroy(&Bmp);
                return NULL;
        }

        if ( ! geBitmap_SetAlpha(Bmp,AlphaBmp) )
        {
                geBitmap_Destroy(&Bmp);
                geBitmap_Destroy(&AlphaBmp);
                return NULL;
        }

        geBitmap_Destroy(&AlphaBmp);

        geBitmap_SetPreferredFormat(Bmp,GE_PIXELFORMAT_16BIT_4444_ARGB);

return Bmp;
}

/*}{****** MSE bitmap compare stuff *********/

static void RGBi_to_YUVi(int R,int G,int B,int *Y,int *U,int *V);
static void YUVi_to_RGBi(int y,int u,int v,int *R,int *G,int *B);

double geBitmapUtil_MSE2PSNR(double mse)
{
return ( 48.165 - 10.0*log10(mse));
}

double geBitmapUtil_PSNR2MSE(double psnr)
{
return pow(10.0,4.8165 - psnr*0.1);
}

geBoolean geBitmapUtil_CompareBitmaps(geBitmap *bm1,geBitmap *bm2,char * IntoStr,double * pMSE)
{
geBitmap *lock1,*lock2;
uint8 *ptr1,*ptr2;
geBitmap_Info wi,oi;
double diff,mse;
int x,y,w,h,cnt;
geBoolean success;

        assert(bm1 && bm2);

        if ( ! geBitmap_LockForRead(bm1,&lock1,0,0,GE_PIXELFORMAT_32BIT_BGRA,0,0) )
                return GE_FALSE;
        if ( ! geBitmap_LockForRead(bm2,&lock2,0,0,GE_PIXELFORMAT_32BIT_BGRA,0,0) )
                return GE_FALSE;

        ptr1 = geBitmap_GetBits(lock1);
        ptr2 = geBitmap_GetBits(lock2);
        assert( ptr1 && ptr2 );

        success = geBitmap_GetInfo(lock1,&wi,NULL); assert(success);
        success = geBitmap_GetInfo(lock2,&oi,NULL); assert(success);

        h = min(oi.Height,wi.Height);
        w = min(oi.Width,wi.Width);

        diff = cnt = 0;
        for(y=h; y--; )
        {
                for(x=w; x--;)
                {
                int dR,dG,dB,dA,R,G,B,A;
                        dA = *ptr1++; dR = *ptr1++; dG = *ptr1++; dB = *ptr1++;
                        A  = *ptr2++; R  = *ptr2++; G  = *ptr2++; B  = *ptr2++;

                        RGBi_to_YUVi(dR,dG,dB,&dR,&dG,&dB);
                        RGBi_to_YUVi( R, G, B, &R, &G, &B);

                        dA -= A;
                        dR -= R;
                        dG -= G;
                        dB -= B;

                        if ( dA )
                        {
                                diff += dA*dA;
                        }

                        if ( A > 40 )
                        {
                                diff +=(dR*dR + dG*dG + dB*dB);
                                cnt ++;
                        }
                }
                ptr1 += (wi.Stride - w)*4;
                ptr2 += (oi.Stride - w)*4;
        }

        geBitmap_UnLock(lock1);
        geBitmap_UnLock(lock2);

        mse = diff / (double)cnt;
        if ( pMSE )
                *pMSE = mse;
        if ( IntoStr )
                sprintf(IntoStr,"mse = %f, rmse = %f, psnr = %f",mse,sqrt(mse),geBitmapUtil_MSE2PSNR(mse));

return GE_TRUE;
}

/*}{*************** the YUV routines : ******************/

#define YUV_SHIFT       14
#define YUV_HALF        (1<<(YUV_SHIFT-1))
#define YUV_ONE         (1<<YUV_SHIFT)
#define Y_R   ((int)( 0.29900 * YUV_ONE ))
#define Y_G   ((int)( 0.58700 * YUV_ONE ))
#define Y_B   ((int)( 0.11400 * YUV_ONE ))
#define U_R   ((int)(-0.16874 * YUV_ONE ))
#define U_G   ((int)(-0.33126 * YUV_ONE ))
#define U_B   ((int)( 0.50000 * YUV_ONE ))
#define V_R   ((int)(-0.50000 * YUV_ONE ))      // ** important sign change of 'V' from jpeg default
#define V_G   ((int)( 0.41869 * YUV_ONE ))
#define V_B   ((int)( 0.08131 * YUV_ONE ))
#define R_Y   (                                 YUV_ONE )       
#define R_U   (0)
#define R_V   ((int)(-1.40200 * YUV_ONE ))
#define G_Y   (                                 YUV_ONE )       
#define G_U   ((int)(-0.34414 * YUV_ONE ))
#define G_V   ((int)( 0.71414 * YUV_ONE ))
#define B_Y   (                         YUV_ONE )       
#define B_U   ((int)( 1.77200 * YUV_ONE ))
#define B_V   (0)       

#define Y_RGB(R,G,B) (( Y_R * (R) + Y_G * (G) + Y_B * (B) + YUV_HALF ) >> YUV_SHIFT)
#define U_RGB(R,G,B) (( U_R * (R) + U_G * (G) + U_B * (B) + YUV_HALF ) >> YUV_SHIFT)
#define V_RGB(R,G,B) (( V_R * (R) + V_G * (G) + V_B * (B) + YUV_HALF ) >> YUV_SHIFT)
#define R_YUV(Y,U,V) (( R_Y * (Y) + R_U * (U) + R_V * (V) + YUV_HALF ) >> YUV_SHIFT)
#define G_YUV(Y,U,V) (( G_Y * (Y) + G_U * (U) + G_V * (V) + YUV_HALF ) >> YUV_SHIFT)
#define B_YUV(Y,U,V) (( B_Y * (Y) + B_U * (U) + B_V * (V) + YUV_HALF ) >> YUV_SHIFT)

#define minmax(x,lo,hi) ( (x)<(lo)?(lo):( (x)>(hi)?(hi):(x)) )

static void RGBi_to_YUVi(int R,int G,int B,int *Y,int *U,int *V)
{
        *Y = Y_RGB(R,G,B);
        *U = U_RGB(R,G,B) + 127;
        *V = V_RGB(R,G,B) + 127;
}

static void YUVi_to_RGBi(int y,int u,int v,int *R,int *G,int *B)
{
int r,g,b;

        u -= 127;
        v -= 127;
        r = R_YUV(y,u,v);
        g = G_YUV(y,u,v);
        b = B_YUV(y,u,v);

        *R = minmax(r,0,255);   // we could get negative ones and whatnot
        *G = minmax(g,0,255);   //      because the y,u,v are not really 24 bits;
        *B = minmax(b,0,255);   //      there are regions of YUV space that will never be reached by RGBb_to_YUVb
}

---