Return to pixel_convert.h CVS log

Up to [HATARI the Atari ST Emulator] / hatari / src / includes

Annotation of hatari/src/includes/pixel_convert.h, revision 1.1.1.1

1.1       root        1: /*
                      2:   Hatari - pixel_convert.h
                      3: 
                      4:   Functions to convert pixels from different bit depths to 24 bits RGB or BGR.
                      5:   Used to save png screenshot and to record avi.
                      6: 
                      7:   This file is distributed under the GNU Public License, version 2 or at your
                      8:   option any later version. Read the file gpl.txt for details.
                      9: */
                     10: 
                     11: 
                     12: /*----------------------------------------------------------------------*/
                     13: /* Convert pixels to 24-bit RGB (3 bytes per pixel)                    */
                     14: /*----------------------------------------------------------------------*/
                     15: 
                     16: /**
                     17:  * Unpack 8-bit data with RGB palette to 24-bit RGB pixels
                     18:  */
                     19: static inline void PixelConvert_8to24Bits(Uint8 *dst, Uint8 *src, int w, SDL_Color *colors)
                     20: {
                     21:        int x;
                     22:        for (x = 0; x < w; x++, src++) {
                     23:                *dst++ = colors[*src].r;
                     24:                *dst++ = colors[*src].g;
                     25:                *dst++ = colors[*src].b;
                     26:        }
                     27: }
                     28: 
                     29: /**
                     30:  * Unpack 16-bit RGB pixels to 24-bit RGB pixels
                     31:  */
                     32: static inline void PixelConvert_16to24Bits(Uint8 *dst, Uint16 *src, int w, SDL_PixelFormat *fmt)
                     33: {
                     34:        int x;
                     35:        for (x = 0; x < w; x++, src++) {
                     36:                *dst++ = (((*src & fmt->Rmask) >> fmt->Rshift) << fmt->Rloss);
                     37:                *dst++ = (((*src & fmt->Gmask) >> fmt->Gshift) << fmt->Gloss);
                     38:                *dst++ = (((*src & fmt->Bmask) >> fmt->Bshift) << fmt->Bloss);
                     39:        }
                     40: }
                     41: 
                     42: /**
                     43:  *  unpack 32-bit RGBA pixels to 24-bit RGB pixels
                     44:  */
                     45: static inline void PixelConvert_32to24Bits(Uint8 *dst, Uint32 *src, int w, SDL_PixelFormat *fmt)
                     46: {
                     47:        int x;
                     48:        for (x = 0; x < w; x++, src++)
                     49:        {
                     50:                *dst++ = (((*src & fmt->Rmask) >> fmt->Rshift) << fmt->Rloss);
                     51:                *dst++ = (((*src & fmt->Gmask) >> fmt->Gshift) << fmt->Gloss);
                     52:                *dst++ = (((*src & fmt->Bmask) >> fmt->Bshift) << fmt->Bloss);
                     53:        }
                     54: }
                     55: 
                     56: 
                     57: 
                     58: /*----------------------------------------------------------------------*/
                     59: /* Convert pixels to 24-bit BGR (3 bytes per pixel, used in BMP format)        */
                     60: /*----------------------------------------------------------------------*/
                     61: 
                     62: /**
                     63:  * Unpack 8-bit data with RGB palette to 24-bit BGR pixels
                     64:  */
                     65: static inline void PixelConvert_8to24Bits_BGR(Uint8 *dst, Uint8 *src, int w, SDL_Color *colors)
                     66: {
                     67:        int x;
                     68:        for (x = 0; x < w; x++, src++) {
                     69:                *dst++ = colors[*src].b;
                     70:                *dst++ = colors[*src].g;
                     71:                *dst++ = colors[*src].r;
                     72:        }
                     73: }
                     74: 
                     75: /**
                     76:  * Unpack 16-bit RGB pixels to 24-bit BGR pixels
                     77:  */
                     78: static inline void PixelConvert_16to24Bits_BGR(Uint8 *dst, Uint16 *src, int w, SDL_PixelFormat *fmt)
                     79: {
                     80:        int x;
                     81:        for (x = 0; x < w; x++, src++) {
                     82:                *dst++ = (((*src & fmt->Bmask) >> fmt->Bshift) << fmt->Bloss);
                     83:                *dst++ = (((*src & fmt->Gmask) >> fmt->Gshift) << fmt->Gloss);
                     84:                *dst++ = (((*src & fmt->Rmask) >> fmt->Rshift) << fmt->Rloss);
                     85:        }
                     86: }
                     87: 
                     88: /**
                     89:  *  unpack 24-bit RGB pixels to 24-bit BGR pixels
                     90:  */
                     91: static inline void PixelConvert_24to24Bits_BGR(Uint8 *dst, Uint8 *src, int w)
                     92: {
                     93:        int x;
                     94:        for (x = 0; x < w; x++, src += 3) {
                     95: #if SDL_BYTEORDER == SDL_BIG_ENDIAN
                     96:                *dst++ = src[2];        /* B */
                     97:                *dst++ = src[1];        /* G */
                     98:                *dst++ = src[0];        /* R */
                     99: #else
                    100:                *dst++ = src[0];        /* B */
                    101:                *dst++ = src[1];        /* G */
                    102:                *dst++ = src[2];        /* R */
                    103: #endif
                    104:        }
                    105: }
                    106: 
                    107: /**
                    108:  *  unpack 32-bit RGBA pixels to 24-bit BGR pixels
                    109:  */
                    110: static inline void PixelConvert_32to24Bits_BGR(Uint8 *dst, Uint32 *src, int w, SDL_PixelFormat *fmt)
                    111: {
                    112:        int x;
                    113:        for (x = 0; x < w; x++, src++)
                    114:        {
                    115:                *dst++ = (((*src & fmt->Bmask) >> fmt->Bshift) << fmt->Bloss);
                    116:                *dst++ = (((*src & fmt->Gmask) >> fmt->Gshift) << fmt->Gloss);
                    117:                *dst++ = (((*src & fmt->Rmask) >> fmt->Rshift) << fmt->Rloss);
                    118:        }
                    119: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.