libswscale/rgb2rgb.c

   1 /*
   2  *  rgb2rgb.c, Software RGB to RGB convertor
   3  *  pluralize by Software PAL8 to RGB convertor
   4  *               Software YUV to YUV convertor
   5  *               Software YUV to RGB convertor
   6  *  Written by Nick Kurshev.
   7  *  palette & YUV & runtime CPU stuff by Michael (michaelni@gmx.at)
   8  *
   9  * This file is part of FFmpeg.
  10  *
  11  * FFmpeg is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * FFmpeg is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with FFmpeg; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  24  *
  25  * the C code (not assembly, mmx, ...) of this file can be used
  26  * under the LGPL license too
  27  */
  28 #include <inttypes.h>
  29 #include "config.h"
  30 #include "rgb2rgb.h"
  31 #include "swscale.h"
  32 #include "swscale_internal.h"
  33 #include "x86_cpu.h"
  34 #include "bswap.h"
  35
  36 #define FAST_BGR2YV12 // use 7 bit coeffs instead of 15bit
  37
  38 void (*rgb24to32)(const uint8_t *src,uint8_t *dst,long src_size);
  39 void (*rgb24to16)(const uint8_t *src,uint8_t *dst,long src_size);
  40 void (*rgb24to15)(const uint8_t *src,uint8_t *dst,long src_size);
  41 void (*rgb32to24)(const uint8_t *src,uint8_t *dst,long src_size);
  42 void (*rgb32to16)(const uint8_t *src,uint8_t *dst,long src_size);
  43 void (*rgb32to15)(const uint8_t *src,uint8_t *dst,long src_size);
  44 void (*rgb15to16)(const uint8_t *src,uint8_t *dst,long src_size);
  45 void (*rgb15to24)(const uint8_t *src,uint8_t *dst,long src_size);
  46 void (*rgb15to32)(const uint8_t *src,uint8_t *dst,long src_size);
  47 void (*rgb16to15)(const uint8_t *src,uint8_t *dst,long src_size);
  48 void (*rgb16to24)(const uint8_t *src,uint8_t *dst,long src_size);
  49 void (*rgb16to32)(const uint8_t *src,uint8_t *dst,long src_size);
  50 //void (*rgb24tobgr32)(const uint8_t *src, uint8_t *dst, long src_size);
  51 void (*rgb24tobgr24)(const uint8_t *src, uint8_t *dst, long src_size);
  52 void (*rgb24tobgr16)(const uint8_t *src, uint8_t *dst, long src_size);
  53 void (*rgb24tobgr15)(const uint8_t *src, uint8_t *dst, long src_size);
  54 void (*rgb32tobgr32)(const uint8_t *src, uint8_t *dst, long src_size);
  55 //void (*rgb32tobgr24)(const uint8_t *src, uint8_t *dst, long src_size);
  56 void (*rgb32tobgr16)(const uint8_t *src, uint8_t *dst, long src_size);
  57 void (*rgb32tobgr15)(const uint8_t *src, uint8_t *dst, long src_size);
  58
  59 void (*yv12toyuy2)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,
  60                    long width, long height,
  61                    long lumStride, long chromStride, long dstStride);
  62 void (*yv12touyvy)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,
  63                    long width, long height,
  64                    long lumStride, long chromStride, long dstStride);
  65 void (*yuv422ptoyuy2)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,
  66                       long width, long height,
  67                       long lumStride, long chromStride, long dstStride);
  68 void (*yuy2toyv12)(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
  69                    long width, long height,
  70                    long lumStride, long chromStride, long srcStride);
  71 void (*rgb24toyv12)(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
  72                     long width, long height,
  73                     long lumStride, long chromStride, long srcStride);
  74 void (*planar2x)(const uint8_t *src, uint8_t *dst, long width, long height,
  75                  long srcStride, long dstStride);
  76 void (*interleaveBytes)(uint8_t *src1, uint8_t *src2, uint8_t *dst,
  77                         long width, long height, long src1Stride,
  78                         long src2Stride, long dstStride);
  79 void (*vu9_to_vu12)(const uint8_t *src1, const uint8_t *src2,
  80                     uint8_t *dst1, uint8_t *dst2,
  81                     long width, long height,
  82                     long srcStride1, long srcStride2,
  83                     long dstStride1, long dstStride2);
  84 void (*yvu9_to_yuy2)(const uint8_t *src1, const uint8_t *src2, const uint8_t *src3,
  85                      uint8_t *dst,
  86                      long width, long height,
  87                      long srcStride1, long srcStride2,
  88                      long srcStride3, long dstStride);
  89
  90 #if defined(ARCH_X86) && defined(CONFIG_GPL)
  91 static const uint64_t mmx_null     __attribute__((aligned(8))) = 0x0000000000000000ULL;
  92 static const uint64_t mmx_one      __attribute__((aligned(8))) = 0xFFFFFFFFFFFFFFFFULL;
  93 static const uint64_t mask32b      attribute_used __attribute__((aligned(8))) = 0x000000FF000000FFULL;
  94 static const uint64_t mask32g      attribute_used __attribute__((aligned(8))) = 0x0000FF000000FF00ULL;
  95 static const uint64_t mask32r      attribute_used __attribute__((aligned(8))) = 0x00FF000000FF0000ULL;
  96 static const uint64_t mask32       __attribute__((aligned(8))) = 0x00FFFFFF00FFFFFFULL;
  97 static const uint64_t mask3216br   __attribute__((aligned(8))) = 0x00F800F800F800F8ULL;
  98 static const uint64_t mask3216g    __attribute__((aligned(8))) = 0x0000FC000000FC00ULL;
  99 static const uint64_t mask3215g    __attribute__((aligned(8))) = 0x0000F8000000F800ULL;
 100 static const uint64_t mul3216      __attribute__((aligned(8))) = 0x2000000420000004ULL;
 101 static const uint64_t mul3215      __attribute__((aligned(8))) = 0x2000000820000008ULL;
 102 static const uint64_t mask24b      attribute_used __attribute__((aligned(8))) = 0x00FF0000FF0000FFULL;
 103 static const uint64_t mask24g      attribute_used __attribute__((aligned(8))) = 0xFF0000FF0000FF00ULL;
 104 static const uint64_t mask24r      attribute_used __attribute__((aligned(8))) = 0x0000FF0000FF0000ULL;
 105 static const uint64_t mask24l      __attribute__((aligned(8))) = 0x0000000000FFFFFFULL;
 106 static const uint64_t mask24h      __attribute__((aligned(8))) = 0x0000FFFFFF000000ULL;
 107 static const uint64_t mask24hh     __attribute__((aligned(8))) = 0xffff000000000000ULL;
 108 static const uint64_t mask24hhh    __attribute__((aligned(8))) = 0xffffffff00000000ULL;
 109 static const uint64_t mask24hhhh   __attribute__((aligned(8))) = 0xffffffffffff0000ULL;
 110 static const uint64_t mask15b      __attribute__((aligned(8))) = 0x001F001F001F001FULL; /* 00000000 00011111  xxB */
 111 static const uint64_t mask15rg     __attribute__((aligned(8))) = 0x7FE07FE07FE07FE0ULL; /* 01111111 11100000  RGx */
 112 static const uint64_t mask15s      __attribute__((aligned(8))) = 0xFFE0FFE0FFE0FFE0ULL;
 113 static const uint64_t mask15g      __attribute__((aligned(8))) = 0x03E003E003E003E0ULL;
 114 static const uint64_t mask15r      __attribute__((aligned(8))) = 0x7C007C007C007C00ULL;
 115 #define mask16b mask15b
 116 static const uint64_t mask16g      __attribute__((aligned(8))) = 0x07E007E007E007E0ULL;
 117 static const uint64_t mask16r      __attribute__((aligned(8))) = 0xF800F800F800F800ULL;
 118 static const uint64_t red_16mask   __attribute__((aligned(8))) = 0x0000f8000000f800ULL;
 119 static const uint64_t green_16mask __attribute__((aligned(8))) = 0x000007e0000007e0ULL;
 120 static const uint64_t blue_16mask  __attribute__((aligned(8))) = 0x0000001f0000001fULL;
 121 static const uint64_t red_15mask   __attribute__((aligned(8))) = 0x00007c0000007c00ULL;
 122 static const uint64_t green_15mask __attribute__((aligned(8))) = 0x000003e0000003e0ULL;
 123 static const uint64_t blue_15mask  __attribute__((aligned(8))) = 0x0000001f0000001fULL;
 124
 125 #ifdef FAST_BGR2YV12
 126 static const uint64_t bgr2YCoeff   attribute_used __attribute__((aligned(8))) = 0x000000210041000DULL;
 127 static const uint64_t bgr2UCoeff   attribute_used __attribute__((aligned(8))) = 0x0000FFEEFFDC0038ULL;
 128 static const uint64_t bgr2VCoeff   attribute_used __attribute__((aligned(8))) = 0x00000038FFD2FFF8ULL;
 129 #else
 130 static const uint64_t bgr2YCoeff   attribute_used __attribute__((aligned(8))) = 0x000020E540830C8BULL;
 131 static const uint64_t bgr2UCoeff   attribute_used __attribute__((aligned(8))) = 0x0000ED0FDAC23831ULL;
 132 static const uint64_t bgr2VCoeff   attribute_used __attribute__((aligned(8))) = 0x00003831D0E6F6EAULL;
 133 #endif
 134 static const uint64_t bgr2YOffset  attribute_used __attribute__((aligned(8))) = 0x1010101010101010ULL;
 135 static const uint64_t bgr2UVOffset attribute_used __attribute__((aligned(8))) = 0x8080808080808080ULL;
 136 static const uint64_t w1111        attribute_used __attribute__((aligned(8))) = 0x0001000100010001ULL;
 137
 138 #if 0
 139 static volatile uint64_t __attribute__((aligned(8))) b5Dither;
 140 static volatile uint64_t __attribute__((aligned(8))) g5Dither;
 141 static volatile uint64_t __attribute__((aligned(8))) g6Dither;
 142 static volatile uint64_t __attribute__((aligned(8))) r5Dither;
 143
 144 static uint64_t __attribute__((aligned(8))) dither4[2]={
 145     0x0103010301030103LL,
 146     0x0200020002000200LL,};
 147
 148 static uint64_t __attribute__((aligned(8))) dither8[2]={
 149     0x0602060206020602LL,
 150     0x0004000400040004LL,};
 151 #endif
 152 #endif /* defined(ARCH_X86) */
 153
 154 #define RGB2YUV_SHIFT 8
 155 #define BY ((int)( 0.098*(1<<RGB2YUV_SHIFT)+0.5))
 156 #define BV ((int)(-0.071*(1<<RGB2YUV_SHIFT)+0.5))
 157 #define BU ((int)( 0.439*(1<<RGB2YUV_SHIFT)+0.5))
 158 #define GY ((int)( 0.504*(1<<RGB2YUV_SHIFT)+0.5))
 159 #define GV ((int)(-0.368*(1<<RGB2YUV_SHIFT)+0.5))
 160 #define GU ((int)(-0.291*(1<<RGB2YUV_SHIFT)+0.5))
 161 #define RY ((int)( 0.257*(1<<RGB2YUV_SHIFT)+0.5))
 162 #define RV ((int)( 0.439*(1<<RGB2YUV_SHIFT)+0.5))
 163 #define RU ((int)(-0.148*(1<<RGB2YUV_SHIFT)+0.5))
 164
 165 //Note: we have C, MMX, MMX2, 3DNOW version therse no 3DNOW+MMX2 one
 166 //Plain C versions
 167 #undef HAVE_MMX
 168 #undef HAVE_MMX2
 169 #undef HAVE_3DNOW
 170 #undef HAVE_SSE2
 171 #define RENAME(a) a ## _C
 172 #include "rgb2rgb_template.c"
 173
 174 #if defined(ARCH_X86) && defined(CONFIG_GPL)
 175
 176 //MMX versions
 177 #undef RENAME
 178 #define HAVE_MMX
 179 #undef HAVE_MMX2
 180 #undef HAVE_3DNOW
 181 #undef HAVE_SSE2
 182 #define RENAME(a) a ## _MMX
 183 #include "rgb2rgb_template.c"
 184
 185 //MMX2 versions
 186 #undef RENAME
 187 #define HAVE_MMX
 188 #define HAVE_MMX2
 189 #undef HAVE_3DNOW
 190 #undef HAVE_SSE2
 191 #define RENAME(a) a ## _MMX2
 192 #include "rgb2rgb_template.c"
 193
 194 //3DNOW versions
 195 #undef RENAME
 196 #define HAVE_MMX
 197 #undef HAVE_MMX2
 198 #define HAVE_3DNOW
 199 #undef HAVE_SSE2
 200 #define RENAME(a) a ## _3DNOW
 201 #include "rgb2rgb_template.c"
 202
 203 #endif //ARCH_X86 || ARCH_X86_64
 204
 205 /*
 206  rgb15->rgb16 Original by Strepto/Astral
 207  ported to gcc & bugfixed : A'rpi
 208  MMX2, 3DNOW optimization by Nick Kurshev
 209  32bit c version, and and&add trick by Michael Niedermayer
 210 */
 211
 212 void sws_rgb2rgb_init(int flags){
 213 #if (defined(HAVE_MMX2) || defined(HAVE_3DNOW) || defined(HAVE_MMX))  && defined(CONFIG_GPL)
 214     if (flags & SWS_CPU_CAPS_MMX2)
 215         rgb2rgb_init_MMX2();
 216     else if (flags & SWS_CPU_CAPS_3DNOW)
 217         rgb2rgb_init_3DNOW();
 218     else if (flags & SWS_CPU_CAPS_MMX)
 219         rgb2rgb_init_MMX();
 220     else
 221 #endif /* defined(HAVE_MMX2) || defined(HAVE_3DNOW) || defined(HAVE_MMX) */
 222         rgb2rgb_init_C();
 223 }
 224
 225 /**
 226  * Palette is assumed to contain BGR32.
 227  */
 228 void palette8torgb32(const uint8_t *src, uint8_t *dst, long num_pixels, const uint8_t *palette)
 229 {
 230     long i;
 231
 232 /*
 233     for (i=0; i<num_pixels; i++)
 234         ((unsigned *)dst)[i] = ((unsigned *)palette)[ src[i] ];
 235 */
 236
 237     for (i=0; i<num_pixels; i++)
 238     {
 239         #ifdef WORDS_BIGENDIAN
 240             dst[3]= palette[ src[i]*4+2 ];
 241             dst[2]= palette[ src[i]*4+1 ];
 242             dst[1]= palette[ src[i]*4+0 ];
 243         #else
 244         //FIXME slow?
 245             dst[0]= palette[ src[i]*4+2 ];
 246             dst[1]= palette[ src[i]*4+1 ];
 247             dst[2]= palette[ src[i]*4+0 ];
 248             //dst[3]= 0; /* do we need this cleansing? */
 249         #endif
 250         dst+= 4;
 251     }
 252 }
 253
 254 void palette8tobgr32(const uint8_t *src, uint8_t *dst, long num_pixels, const uint8_t *palette)
 255 {
 256     long i;
 257     for (i=0; i<num_pixels; i++)
 258     {
 259         #ifdef WORDS_BIGENDIAN
 260             dst[3]= palette[ src[i]*4+0 ];
 261             dst[2]= palette[ src[i]*4+1 ];
 262             dst[1]= palette[ src[i]*4+2 ];
 263         #else
 264             //FIXME slow?
 265             dst[0]= palette[ src[i]*4+0 ];
 266             dst[1]= palette[ src[i]*4+1 ];
 267             dst[2]= palette[ src[i]*4+2 ];
 268             //dst[3]= 0; /* do we need this cleansing? */
 269         #endif
 270
 271         dst+= 4;
 272     }
 273 }
 274
 275 /**
 276  * Palette is assumed to contain BGR32.
 277  */
 278 void palette8torgb24(const uint8_t *src, uint8_t *dst, long num_pixels, const uint8_t *palette)
 279 {
 280     long i;
 281 /*
 282     writes 1 byte o much and might cause alignment issues on some architectures?
 283     for (i=0; i<num_pixels; i++)
 284         ((unsigned *)(&dst[i*3])) = ((unsigned *)palette)[ src[i] ];
 285 */
 286     for (i=0; i<num_pixels; i++)
 287     {
 288         //FIXME slow?
 289         dst[0]= palette[ src[i]*4+2 ];
 290         dst[1]= palette[ src[i]*4+1 ];
 291         dst[2]= palette[ src[i]*4+0 ];
 292         dst+= 3;
 293     }
 294 }
 295
 296 void palette8tobgr24(const uint8_t *src, uint8_t *dst, long num_pixels, const uint8_t *palette)
 297 {
 298     long i;
 299 /*
 300     writes 1 byte o much and might cause alignment issues on some architectures?
 301     for (i=0; i<num_pixels; i++)
 302         ((unsigned *)(&dst[i*3])) = ((unsigned *)palette)[ src[i] ];
 303 */
 304     for (i=0; i<num_pixels; i++)
 305     {
 306         //FIXME slow?
 307         dst[0]= palette[ src[i]*4+0 ];
 308         dst[1]= palette[ src[i]*4+1 ];
 309         dst[2]= palette[ src[i]*4+2 ];
 310         dst+= 3;
 311     }
 312 }
 313
 314 /**
 315  * Palette is assumed to contain bgr16, see rgb32to16 to convert the palette
 316  */
 317 void palette8torgb16(const uint8_t *src, uint8_t *dst, long num_pixels, const uint8_t *palette)
 318 {
 319     long i;
 320     for (i=0; i<num_pixels; i++)
 321         ((uint16_t *)dst)[i] = ((uint16_t *)palette)[ src[i] ];
 322 }
 323 void palette8tobgr16(const uint8_t *src, uint8_t *dst, long num_pixels, const uint8_t *palette)
 324 {
 325     long i;
 326     for (i=0; i<num_pixels; i++)
 327         ((uint16_t *)dst)[i] = bswap_16(((uint16_t *)palette)[ src[i] ]);
 328 }
 329
 330 /**
 331  * Palette is assumed to contain BGR15, see rgb32to15 to convert the palette.
 332  */
 333 void palette8torgb15(const uint8_t *src, uint8_t *dst, long num_pixels, const uint8_t *palette)
 334 {
 335     long i;
 336     for (i=0; i<num_pixels; i++)
 337         ((uint16_t *)dst)[i] = ((uint16_t *)palette)[ src[i] ];
 338 }
 339 void palette8tobgr15(const uint8_t *src, uint8_t *dst, long num_pixels, const uint8_t *palette)
 340 {
 341     long i;
 342     for (i=0; i<num_pixels; i++)
 343         ((uint16_t *)dst)[i] = bswap_16(((uint16_t *)palette)[ src[i] ]);
 344 }
 345
 346 void rgb32tobgr24(const uint8_t *src, uint8_t *dst, long src_size)
 347 {
 348     long i;
 349     long num_pixels = src_size >> 2;
 350     for (i=0; i<num_pixels; i++)
 351     {
 352         #ifdef WORDS_BIGENDIAN
 353             /* RGB32 (= A,B,G,R) -> BGR24 (= B,G,R) */
 354             dst[3*i + 0] = src[4*i + 1];
 355             dst[3*i + 1] = src[4*i + 2];
 356             dst[3*i + 2] = src[4*i + 3];
 357         #else
 358             dst[3*i + 0] = src[4*i + 2];
 359             dst[3*i + 1] = src[4*i + 1];
 360             dst[3*i + 2] = src[4*i + 0];
 361         #endif
 362     }
 363 }
 364
 365 void rgb24tobgr32(const uint8_t *src, uint8_t *dst, long src_size)
 366 {
 367     long i;
 368     for (i=0; 3*i<src_size; i++)
 369     {
 370         #ifdef WORDS_BIGENDIAN
 371             /* RGB24 (= R,G,B) -> BGR32 (= A,R,G,B) */
 372             dst[4*i + 0] = 0;
 373             dst[4*i + 1] = src[3*i + 0];
 374             dst[4*i + 2] = src[3*i + 1];
 375             dst[4*i + 3] = src[3*i + 2];
 376         #else
 377             dst[4*i + 0] = src[3*i + 2];
 378             dst[4*i + 1] = src[3*i + 1];
 379             dst[4*i + 2] = src[3*i + 0];
 380             dst[4*i + 3] = 0;
 381         #endif
 382     }
 383 }
 384
 385 void rgb16tobgr32(const uint8_t *src, uint8_t *dst, long src_size)
 386 {
 387     const uint16_t *end;
 388     uint8_t *d = (uint8_t *)dst;
 389     const uint16_t *s = (uint16_t *)src;
 390     end = s + src_size/2;
 391     while (s < end)
 392     {
 393         register uint16_t bgr;
 394         bgr = *s++;
 395         #ifdef WORDS_BIGENDIAN
 396             *d++ = 0;
 397             *d++ = (bgr&0x1F)<<3;
 398             *d++ = (bgr&0x7E0)>>3;
 399             *d++ = (bgr&0xF800)>>8;
 400         #else
 401             *d++ = (bgr&0xF800)>>8;
 402             *d++ = (bgr&0x7E0)>>3;
 403             *d++ = (bgr&0x1F)<<3;
 404             *d++ = 0;
 405         #endif
 406     }
 407 }
 408
 409 void rgb16tobgr24(const uint8_t *src, uint8_t *dst, long src_size)
 410 {
 411     const uint16_t *end;
 412     uint8_t *d = (uint8_t *)dst;
 413     const uint16_t *s = (const uint16_t *)src;
 414     end = s + src_size/2;
 415     while (s < end)
 416     {
 417         register uint16_t bgr;
 418         bgr = *s++;
 419         *d++ = (bgr&0xF800)>>8;
 420         *d++ = (bgr&0x7E0)>>3;
 421         *d++ = (bgr&0x1F)<<3;
 422     }
 423 }
 424
 425 void rgb16tobgr16(const uint8_t *src, uint8_t *dst, long src_size)
 426 {
 427     long i;
 428     long num_pixels = src_size >> 1;
 429
 430     for (i=0; i<num_pixels; i++)
 431     {
 432         unsigned b,g,r;
 433         register uint16_t rgb;
 434         rgb = src[2*i];
 435         r = rgb&0x1F;
 436         g = (rgb&0x7E0)>>5;
 437         b = (rgb&0xF800)>>11;
 438         dst[2*i] = (b&0x1F) | ((g&0x3F)<<5) | ((r&0x1F)<<11);
 439     }
 440 }
 441
 442 void rgb16tobgr15(const uint8_t *src, uint8_t *dst, long src_size)
 443 {
 444     long i;
 445     long num_pixels = src_size >> 1;
 446
 447     for (i=0; i<num_pixels; i++)
 448     {
 449         unsigned b,g,r;
 450         register uint16_t rgb;
 451         rgb = src[2*i];
 452         r = rgb&0x1F;
 453         g = (rgb&0x7E0)>>5;
 454         b = (rgb&0xF800)>>11;
 455         dst[2*i] = (b&0x1F) | ((g&0x1F)<<5) | ((r&0x1F)<<10);
 456     }
 457 }
 458
 459 void rgb15tobgr32(const uint8_t *src, uint8_t *dst, long src_size)
 460 {
 461     const uint16_t *end;
 462     uint8_t *d = (uint8_t *)dst;
 463     const uint16_t *s = (const uint16_t *)src;
 464     end = s + src_size/2;
 465     while (s < end)
 466     {
 467         register uint16_t bgr;
 468         bgr = *s++;
 469         #ifdef WORDS_BIGENDIAN
 470             *d++ = 0;
 471             *d++ = (bgr&0x1F)<<3;
 472             *d++ = (bgr&0x3E0)>>2;
 473             *d++ = (bgr&0x7C00)>>7;
 474         #else
 475             *d++ = (bgr&0x7C00)>>7;
 476             *d++ = (bgr&0x3E0)>>2;
 477             *d++ = (bgr&0x1F)<<3;
 478             *d++ = 0;
 479         #endif
 480     }
 481 }
 482
 483 void rgb15tobgr24(const uint8_t *src, uint8_t *dst, long src_size)
 484 {
 485     const uint16_t *end;
 486     uint8_t *d = (uint8_t *)dst;
 487     const uint16_t *s = (uint16_t *)src;
 488     end = s + src_size/2;
 489     while (s < end)
 490     {
 491         register uint16_t bgr;
 492         bgr = *s++;
 493         *d++ = (bgr&0x7C00)>>7;
 494         *d++ = (bgr&0x3E0)>>2;
 495         *d++ = (bgr&0x1F)<<3;
 496     }
 497 }
 498
 499 void rgb15tobgr16(const uint8_t *src, uint8_t *dst, long src_size)
 500 {
 501     long i;
 502     long num_pixels = src_size >> 1;
 503
 504     for (i=0; i<num_pixels; i++)
 505     {
 506         unsigned b,g,r;
 507         register uint16_t rgb;
 508         rgb = src[2*i];
 509         r = rgb&0x1F;
 510         g = (rgb&0x3E0)>>5;
 511         b = (rgb&0x7C00)>>10;
 512         dst[2*i] = (b&0x1F) | ((g&0x3F)<<5) | ((r&0x1F)<<11);
 513     }
 514 }
 515
 516 void rgb15tobgr15(const uint8_t *src, uint8_t *dst, long src_size)
 517 {
 518     long i;
 519     long num_pixels = src_size >> 1;
 520
 521     for (i=0; i<num_pixels; i++)
 522     {
 523         unsigned b,g,r;
 524         register uint16_t rgb;
 525         rgb = src[2*i];
 526         r = rgb&0x1F;
 527         g = (rgb&0x3E0)>>5;
 528         b = (rgb&0x7C00)>>10;
 529         dst[2*i] = (b&0x1F) | ((g&0x1F)<<5) | ((r&0x1F)<<10);
 530     }
 531 }
 532
 533 void rgb8tobgr8(const uint8_t *src, uint8_t *dst, long src_size)
 534 {
 535     long i;
 536     long num_pixels = src_size;
 537     for (i=0; i<num_pixels; i++)
 538     {
 539         unsigned b,g,r;
 540         register uint8_t rgb;
 541         rgb = src[i];
 542         r = (rgb&0x07);
 543         g = (rgb&0x38)>>3;
 544         b = (rgb&0xC0)>>6;
 545         dst[i] = ((b<<1)&0x07) | ((g&0x07)<<3) | ((r&0x03)<<6);
 546     }
 547 }