rgb24.h

Go to the documentation of this file.

#ifndef RGB24_H
#define RGB24_H

// The contents of this file are partly from 
// http://www.compuphase.com/graphic/scale2.htm#MAGNIFY2

struct rgb24
{
        unsigned char c[3];
        rgb24(){};
        rgb24( unsigned long x )
        {
                // will get shit on other-endian machines
                c[0] = x&0x0000ff;
                c[1] = (x&0x00ff00)>>8;
                c[2] = (x&0xff0000)>>16;
        };
        unsigned long get_long( void )
        {
                return (c[2]<<16)+(c[1]<<8)+c[0];
        };
};

extern unsigned long InterleaveTable24[256];
extern unsigned long InterleaveTable16[64];


void CreateInterleaveTable( void );

inline long InterleavedValue24( rgb24 color )
{

  return (InterleaveTable24[color.c[2]] << 2) |
        (InterleaveTable24[color.c[1]] << 1) |
        InterleaveTable24[color.c[0]];

}

inline long InterleavedValue16( unsigned short color )
{

  return (InterleaveTable16[color>>11] << 2) |
        (InterleaveTable16[(color>>5)&63] << 1) |
        InterleaveTable16[color&31];

}

#define ABS(a)          ( (a) >= 0 ? (a) : -(a) )

inline long colordiff( rgb24 a, rgb24 b )
{
        return ABS(InterleavedValue24(a)-InterleavedValue24(b));
}

inline unsigned long colordiff( unsigned short a, unsigned short b )
{
        return ABS(InterleavedValue16(a)-InterleavedValue16(b));
}


inline rgb24 average( rgb24 a, rgb24 b )
{
        rgb24 ret;
        ret.c[0] = (a.c[0]+(unsigned int)b.c[0])>>1;
        ret.c[1] = (a.c[1]+(unsigned int)b.c[1])>>1;
        ret.c[2] = (a.c[2]+(unsigned int)b.c[2])>>1;
        return ret;
}

/* 16-bit HiColor (565 format) */
inline unsigned short average( unsigned short a, unsigned short b )
{
        if (a == b) {
                return a;
        } else {
        
                // this mask taken from the guy does not work:
                //unsigned short mask = ~ (((a | b) & 0x0410) << 1);
                //return ((a & mask) + (b & mask)) >> 1;
                
                // However, this one is simpler and seems to work:
                unsigned short mask = 0xf7df; // ~ (0x820);
                return ((a&mask) + (b&mask))>>1;

                // reference 
                //return (((((a&0xf800)>>1) + ((b&0xf800)>>1)))&0xf800) +
                        //((((a&0x7e0) + (b&0x7e0))>>1)&0x7e0) +
                        //(((a&0x1f) + (b&0x1f))>>1);
        } /* if */ 
}




/* gray scale */
inline unsigned char average(unsigned char a, unsigned char b)
{
  return (unsigned char)( ((int)a + (int)b) >> 1);
}

/* 24-bit RGB (a pixel is packed in a 32-bit integer) */
inline unsigned long average(unsigned long a, unsigned long b)
{
  return ((a & 0xfefefeffUL) + (b & 0xfefefeffUL)) >> 1;
}


#endif

---