falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
10479 Commits
32 Branches
821MB
Tree: 0809b51e52
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0809b51e52'
${ noResults }
FFmpeg/libswscale/rgb2rgb.c

548 lines
19KB
Raw Blame History 

  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. }