Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.     SDL - Simple DirectMedia Layer
  3.     Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
  4.  
  5.     This library is free software; you can redistribute it and/or
  6.     modify it under the terms of the GNU Library General Public
  7.     License as published by the Free Software Foundation; either
  8.     version 2 of the License, or (at your option) any later version.
  9.  
  10.     This library is distributed in the hope that it will be useful,
  11.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.     Library General Public License for more details.
  14.  
  15.     You should have received a copy of the GNU Library General Public
  16.     License along with this library; if not, write to the Free
  17.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18.  
  19.     Sam Lantinga
  20.     slouken@devolution.com
  21. */
  22.  
  23.  
  24. #include <stdio.h>
  25.  
  26. #include "SDL_types.h"
  27. #include "SDL_video.h"
  28. #include "SDL_blit.h"
  29. #include "SDL_byteorder.h"
  30.  
  31. /* Function to check the CPU flags */
  32. #define MMX_CPU         0x800000
  33. #ifdef USE_ASMBLIT
  34. #define CPU_Flags()     Hermes_X86_CPU()
  35. #else
  36. #define CPU_Flags()     0L
  37. #endif
  38.  
  39. /* Functions to blit from N-bit surfaces to other surfaces */
  40.  
  41. #ifdef USE_ASMBLIT
  42.  
  43. /* Heheheh, we coerce Hermes into using SDL blit information */
  44. #define X86_ASSEMBLER
  45. #define HermesConverterInterface        SDL_BlitInfo
  46. #define HermesClearInterface            void
  47. #define STACKCALL
  48. typedef Uint32 int32;
  49.  
  50. #include "HeadMMX.h"
  51. #include "HeadX86.h"
  52.  
  53. #else
  54.  
  55. /* This is now endian dependent */
  56. #if ( SDL_BYTEORDER == SDL_LIL_ENDIAN )
  57. #define HI      1
  58. #define LO      0
  59. #else /* ( SDL_BYTEORDER == SDL_BIG_ENDIAN ) */
  60. #define HI      0
  61. #define LO      1
  62. #endif
  63.  
  64. /* Special optimized blit for RGB 8-8-8 --> RGB 3-3-2 */
  65. #define RGB888_RGB332(dst, src) { \
  66.         dst = (((src)&0x00E00000)>>16)| \
  67.               (((src)&0x0000E000)>>11)| \
  68.               (((src)&0x000000C0)>>6); \
  69. }
  70. static void Blit_RGB888_index8(SDL_BlitInfo *info)
  71. {
  72. #ifndef USE_DUFFS_LOOP
  73.         int c;
  74. #endif
  75.         int width, height;
  76.         Uint32 *src;
  77.         const Uint8 *map;
  78.         Uint8 *dst;
  79.         int srcskip, dstskip;
  80.  
  81.         /* Set up some basic variables */
  82.         width = info->d_width;
  83.         height = info->d_height;
  84.         src = (Uint32 *)info->s_pixels;
  85.         srcskip = info->s_skip/4;
  86.         dst = info->d_pixels;
  87.         dstskip = info->d_skip;
  88.         map = info->table;
  89.  
  90.         if ( map == NULL ) {
  91.                 while ( height-- ) {
  92. #ifdef USE_DUFFS_LOOP
  93.                         DUFFS_LOOP(
  94.                                 RGB888_RGB332(*dst++, *src);
  95.                         , width);
  96. #else
  97.                         for ( c=width/4; c; --c ) {
  98.                                 /* Pack RGB into 8bit pixel */
  99.                                 ++src;
  100.                                 RGB888_RGB332(*dst++, *src);
  101.                                 ++src;
  102.                                 RGB888_RGB332(*dst++, *src);
  103.                                 ++src;
  104.                                 RGB888_RGB332(*dst++, *src);
  105.                                 ++src;
  106.                         }
  107.                         switch ( width & 3 ) {
  108.                                 case 3:
  109.                                         RGB888_RGB332(*dst++, *src);
  110.                                         ++src;
  111.                                 case 2:
  112.                                         RGB888_RGB332(*dst++, *src);
  113.                                         ++src;
  114.                                 case 1:
  115.                                         RGB888_RGB332(*dst++, *src);
  116.                                         ++src;
  117.                         }
  118. #endif /* USE_DUFFS_LOOP */
  119.                         src += srcskip;
  120.                         dst += dstskip;
  121.                 }
  122.         } else {
  123.                 int pixel;
  124.  
  125.                 while ( height-- ) {
  126. #ifdef USE_DUFFS_LOOP
  127.                         DUFFS_LOOP(
  128.                                 RGB888_RGB332(pixel, *src);
  129.                                 *dst++ = map[pixel];
  130.                                 ++src;
  131.                         , width);
  132. #else
  133.                         for ( c=width/4; c; --c ) {
  134.                                 /* Pack RGB into 8bit pixel */
  135.                                 RGB888_RGB332(pixel, *src);
  136.                                 *dst++ = map[pixel];
  137.                                 ++src;
  138.                                 RGB888_RGB332(pixel, *src);
  139.                                 *dst++ = map[pixel];
  140.                                 ++src;
  141.                                 RGB888_RGB332(pixel, *src);
  142.                                 *dst++ = map[pixel];
  143.                                 ++src;
  144.                                 RGB888_RGB332(pixel, *src);
  145.                                 *dst++ = map[pixel];
  146.                                 ++src;
  147.                         }
  148.                         switch ( width & 3 ) {
  149.                                 case 3:
  150.                                         RGB888_RGB332(pixel, *src);
  151.                                         *dst++ = map[pixel];
  152.                                         ++src;
  153.                                 case 2:
  154.                                         RGB888_RGB332(pixel, *src);
  155.                                         *dst++ = map[pixel];
  156.                                         ++src;
  157.                                 case 1:
  158.                                         RGB888_RGB332(pixel, *src);
  159.                                         *dst++ = map[pixel];
  160.                                         ++src;
  161.                         }
  162. #endif /* USE_DUFFS_LOOP */
  163.                         src += srcskip;
  164.                         dst += dstskip;
  165.                 }
  166.         }
  167. }
  168. /* Special optimized blit for RGB 8-8-8 --> RGB 5-5-5 */
  169. #define RGB888_RGB555(dst, src) { \
  170.         *(Uint16 *)(dst) = (((*src)&0x00F80000)>>9)| \
  171.                            (((*src)&0x0000F800)>>6)| \
  172.                            (((*src)&0x000000F8)>>3); \
  173. }
  174. #define RGB888_RGB555_TWO(dst, src) { \
  175.         *(Uint32 *)(dst) = (((((src[HI])&0x00F80000)>>9)| \
  176.                              (((src[HI])&0x0000F800)>>6)| \
  177.                              (((src[HI])&0x000000F8)>>3))<<16)| \
  178.                              (((src[LO])&0x00F80000)>>9)| \
  179.                              (((src[LO])&0x0000F800)>>6)| \
  180.                              (((src[LO])&0x000000F8)>>3); \
  181. }
  182. static void Blit_RGB888_RGB555(SDL_BlitInfo *info)
  183. {
  184. #ifndef USE_DUFFS_LOOP
  185.         int c;
  186. #endif
  187.         int width, height;
  188.         Uint32 *src;
  189.         Uint16 *dst;
  190.         int srcskip, dstskip;
  191.  
  192.         /* Set up some basic variables */
  193.         width = info->d_width;
  194.         height = info->d_height;
  195.         src = (Uint32 *)info->s_pixels;
  196.         srcskip = info->s_skip/4;
  197.         dst = (Uint16 *)info->d_pixels;
  198.         dstskip = info->d_skip/2;
  199.  
  200. #ifdef USE_DUFFS_LOOP
  201.         while ( height-- ) {
  202.                 DUFFS_LOOP(
  203.                         RGB888_RGB555(dst, src);
  204.                         ++src;
  205.                         ++dst;
  206.                 , width);
  207.                 src += srcskip;
  208.                 dst += dstskip;
  209.         }
  210. #else
  211.         /* Memory align at 4-byte boundary, if necessary */
  212.         if ( (long)dst & 0x03 ) {
  213.                 /* Don't do anything if width is 0 */
  214.                 if ( width == 0 ) {
  215.                         return;
  216.                 }
  217.                 --width;
  218.  
  219.                 while ( height-- ) {
  220.                         /* Perform copy alignment */
  221.                         RGB888_RGB555(dst, src);
  222.                         ++src;
  223.                         ++dst;
  224.  
  225.                         /* Copy in 4 pixel chunks */
  226.                         for ( c=width/4; c; --c ) {
  227.                                 RGB888_RGB555_TWO(dst, src);
  228.                                 src += 2;
  229.                                 dst += 2;
  230.                                 RGB888_RGB555_TWO(dst, src);
  231.                                 src += 2;
  232.                                 dst += 2;
  233.                         }
  234.                         /* Get any leftovers */
  235.                         switch (width & 3) {
  236.                                 case 3:
  237.                                         RGB888_RGB555(dst, src);
  238.                                         ++src;
  239.                                         ++dst;
  240.                                 case 2:
  241.                                         RGB888_RGB555_TWO(dst, src);
  242.                                         src += 2;
  243.                                         dst += 2;
  244.                                         break;
  245.                                 case 1:
  246.                                         RGB888_RGB555(dst, src);
  247.                                         ++src;
  248.                                         ++dst;
  249.                                         break;
  250.                         }
  251.                         src += srcskip;
  252.                         dst += dstskip;
  253.                 }
  254.         } else {
  255.                 while ( height-- ) {
  256.                         /* Copy in 4 pixel chunks */
  257.                         for ( c=width/4; c; --c ) {
  258.                                 RGB888_RGB555_TWO(dst, src);
  259.                                 src += 2;
  260.                                 dst += 2;
  261.                                 RGB888_RGB555_TWO(dst, src);
  262.                                 src += 2;
  263.                                 dst += 2;
  264.                         }
  265.                         /* Get any leftovers */
  266.                         switch (width & 3) {
  267.                                 case 3:
  268.                                         RGB888_RGB555(dst, src);
  269.                                         ++src;
  270.                                         ++dst;
  271.                                 case 2:
  272.                                         RGB888_RGB555_TWO(dst, src);
  273.                                         src += 2;
  274.                                         dst += 2;
  275.                                         break;
  276.                                 case 1:
  277.                                         RGB888_RGB555(dst, src);
  278.                                         ++src;
  279.                                         ++dst;
  280.                                         break;
  281.                         }
  282.                         src += srcskip;
  283.                         dst += dstskip;
  284.                 }
  285.         }
  286. #endif /* USE_DUFFS_LOOP */
  287. }
  288. /* Special optimized blit for RGB 8-8-8 --> RGB 5-6-5 */
  289. #define RGB888_RGB565(dst, src) { \
  290.         *(Uint16 *)(dst) = (((*src)&0x00F80000)>>8)| \
  291.                            (((*src)&0x0000FC00)>>5)| \
  292.                            (((*src)&0x000000F8)>>3); \
  293. }
  294. #define RGB888_RGB565_TWO(dst, src) { \
  295.         *(Uint32 *)(dst) = (((((src[HI])&0x00F80000)>>8)| \
  296.                              (((src[HI])&0x0000FC00)>>5)| \
  297.                              (((src[HI])&0x000000F8)>>3))<<16)| \
  298.                              (((src[LO])&0x00F80000)>>8)| \
  299.                              (((src[LO])&0x0000FC00)>>5)| \
  300.                              (((src[LO])&0x000000F8)>>3); \
  301. }
  302. static void Blit_RGB888_RGB565(SDL_BlitInfo *info)
  303. {
  304. #ifndef USE_DUFFS_LOOP
  305.         int c;
  306. #endif
  307.         int width, height;
  308.         Uint32 *src;
  309.         Uint16 *dst;
  310.         int srcskip, dstskip;
  311.  
  312.         /* Set up some basic variables */
  313.         width = info->d_width;
  314.         height = info->d_height;
  315.         src = (Uint32 *)info->s_pixels;
  316.         srcskip = info->s_skip/4;
  317.         dst = (Uint16 *)info->d_pixels;
  318.         dstskip = info->d_skip/2;
  319.  
  320. #ifdef USE_DUFFS_LOOP
  321.         while ( height-- ) {
  322.                 DUFFS_LOOP(
  323.                         RGB888_RGB565(dst, src);
  324.                         ++src;
  325.                         ++dst;
  326.                 , width);
  327.                 src += srcskip;
  328.                 dst += dstskip;
  329.         }
  330. #else
  331.         /* Memory align at 4-byte boundary, if necessary */
  332.         if ( (long)dst & 0x03 ) {
  333.                 /* Don't do anything if width is 0 */
  334.                 if ( width == 0 ) {
  335.                         return;
  336.                 }
  337.                 --width;
  338.  
  339.                 while ( height-- ) {
  340.                         /* Perform copy alignment */
  341.                         RGB888_RGB565(dst, src);
  342.                         ++src;
  343.                         ++dst;
  344.  
  345.                         /* Copy in 4 pixel chunks */
  346.                         for ( c=width/4; c; --c ) {
  347.                                 RGB888_RGB565_TWO(dst, src);
  348.                                 src += 2;
  349.                                 dst += 2;
  350.                                 RGB888_RGB565_TWO(dst, src);
  351.                                 src += 2;
  352.                                 dst += 2;
  353.                         }
  354.                         /* Get any leftovers */
  355.                         switch (width & 3) {
  356.                                 case 3:
  357.                                         RGB888_RGB565(dst, src);
  358.                                         ++src;
  359.                                         ++dst;
  360.                                 case 2:
  361.                                         RGB888_RGB565_TWO(dst, src);
  362.                                         src += 2;
  363.                                         dst += 2;
  364.                                         break;
  365.                                 case 1:
  366.                                         RGB888_RGB565(dst, src);
  367.                                         ++src;
  368.                                         ++dst;
  369.                                         break;
  370.                         }
  371.                         src += srcskip;
  372.                         dst += dstskip;
  373.                 }
  374.         } else {
  375.                 while ( height-- ) {
  376.                         /* Copy in 4 pixel chunks */
  377.                         for ( c=width/4; c; --c ) {
  378.                                 RGB888_RGB565_TWO(dst, src);
  379.                                 src += 2;
  380.                                 dst += 2;
  381.                                 RGB888_RGB565_TWO(dst, src);
  382.                                 src += 2;
  383.                                 dst += 2;
  384.                         }
  385.                         /* Get any leftovers */
  386.                         switch (width & 3) {
  387.                                 case 3:
  388.                                         RGB888_RGB565(dst, src);
  389.                                         ++src;
  390.                                         ++dst;
  391.                                 case 2:
  392.                                         RGB888_RGB565_TWO(dst, src);
  393.                                         src += 2;
  394.                                         dst += 2;
  395.                                         break;
  396.                                 case 1:
  397.                                         RGB888_RGB565(dst, src);
  398.                                         ++src;
  399.                                         ++dst;
  400.                                         break;
  401.                         }
  402.                         src += srcskip;
  403.                         dst += dstskip;
  404.                 }
  405.         }
  406. #endif /* USE_DUFFS_LOOP */
  407. }
  408.  
  409. #endif /* USE_ASMBLIT */
  410.  
  411.  
  412. /* Special optimized blit for RGB 5-6-5 --> 32-bit RGB surfaces */
  413. #if ( SDL_BYTEORDER == SDL_LIL_ENDIAN )
  414. #define RGB565_32(dst, src, map) (map[src[0]*2] + map[src[1]*2+1])
  415. #else /* ( SDL_BYTEORDER == SDL_BIG_ENDIAN ) */
  416. #define RGB565_32(dst, src, map) (map[src[1]*2] + map[src[0]*2+1])
  417. #endif
  418. static void Blit_RGB565_32(SDL_BlitInfo *info, const Uint32 *map)
  419. {
  420. #ifndef USE_DUFFS_LOOP
  421.         int c;
  422. #endif
  423.         int width, height;
  424.         Uint8 *src;
  425.         Uint32 *dst;
  426.         int srcskip, dstskip;
  427.  
  428.         /* Set up some basic variables */
  429.         width = info->d_width;
  430.         height = info->d_height;
  431.         src = (Uint8 *)info->s_pixels;
  432.         srcskip = info->s_skip;
  433.         dst = (Uint32 *)info->d_pixels;
  434.         dstskip = info->d_skip/4;
  435.  
  436. #ifdef USE_DUFFS_LOOP
  437.         while ( height-- ) {
  438.                 DUFFS_LOOP(
  439.                 {
  440.                         *dst++ = RGB565_32(dst, src, map);
  441.                         src += 2;
  442.                 },
  443.                 width);
  444.                 src += srcskip;
  445.                 dst += dstskip;
  446.         }
  447. #else
  448.         while ( height-- ) {
  449.                 /* Copy in 4 pixel chunks */
  450.                 for ( c=width/4; c; --c ) {
  451.                         *dst++ = RGB565_32(dst, src, map);
  452.                         src += 2;
  453.                         *dst++ = RGB565_32(dst, src, map);
  454.                         src += 2;
  455.                         *dst++ = RGB565_32(dst, src, map);
  456.                         src += 2;
  457.                         *dst++ = RGB565_32(dst, src, map);
  458.                         src += 2;
  459.                 }
  460.                 /* Get any leftovers */
  461.                 switch (width & 3) {
  462.                         case 3:
  463.                                 *dst++ = RGB565_32(dst, src, map);
  464.                                 src += 2;
  465.                         case 2:
  466.                                 *dst++ = RGB565_32(dst, src, map);
  467.                                 src += 2;
  468.                         case 1:
  469.                                 *dst++ = RGB565_32(dst, src, map);
  470.                                 src += 2;
  471.                                 break;
  472.                 }
  473.                 src += srcskip;
  474.                 dst += dstskip;
  475.         }
  476. #endif /* USE_DUFFS_LOOP */
  477. }
  478.  
  479. /* Special optimized blit for RGB 5-6-5 --> ARGB 8-8-8-8 */
  480. static const Uint32 RGB565_ARGB8888_LUT[512] = {
  481.                 0x00000000, 0xff000000, 0x00000008, 0xff002000,
  482.                 0x00000010, 0xff004000, 0x00000018, 0xff006100,
  483.                 0x00000020, 0xff008100, 0x00000029, 0xff00a100,
  484.                 0x00000031, 0xff00c200, 0x00000039, 0xff00e200,
  485.                 0x00000041, 0xff080000, 0x0000004a, 0xff082000,
  486.                 0x00000052, 0xff084000, 0x0000005a, 0xff086100,
  487.                 0x00000062, 0xff088100, 0x0000006a, 0xff08a100,
  488.                 0x00000073, 0xff08c200, 0x0000007b, 0xff08e200,
  489.                 0x00000083, 0xff100000, 0x0000008b, 0xff102000,
  490.                 0x00000094, 0xff104000, 0x0000009c, 0xff106100,
  491.                 0x000000a4, 0xff108100, 0x000000ac, 0xff10a100,
  492.                 0x000000b4, 0xff10c200, 0x000000bd, 0xff10e200,
  493.                 0x000000c5, 0xff180000, 0x000000cd, 0xff182000,
  494.                 0x000000d5, 0xff184000, 0x000000de, 0xff186100,
  495.                 0x000000e6, 0xff188100, 0x000000ee, 0xff18a100,
  496.                 0x000000f6, 0xff18c200, 0x000000ff, 0xff18e200,
  497.                 0x00000400, 0xff200000, 0x00000408, 0xff202000,
  498.                 0x00000410, 0xff204000, 0x00000418, 0xff206100,
  499.                 0x00000420, 0xff208100, 0x00000429, 0xff20a100,
  500.                 0x00000431, 0xff20c200, 0x00000439, 0xff20e200,
  501.                 0x00000441, 0xff290000, 0x0000044a, 0xff292000,
  502.                 0x00000452, 0xff294000, 0x0000045a, 0xff296100,
  503.                 0x00000462, 0xff298100, 0x0000046a, 0xff29a100,
  504.                 0x00000473, 0xff29c200, 0x0000047b, 0xff29e200,
  505.                 0x00000483, 0xff310000, 0x0000048b, 0xff312000,
  506.                 0x00000494, 0xff314000, 0x0000049c, 0xff316100,
  507.                 0x000004a4, 0xff318100, 0x000004ac, 0xff31a100,
  508.                 0x000004b4, 0xff31c200, 0x000004bd, 0xff31e200,
  509.                 0x000004c5, 0xff390000, 0x000004cd, 0xff392000,
  510.                 0x000004d5, 0xff394000, 0x000004de, 0xff396100,
  511.                 0x000004e6, 0xff398100, 0x000004ee, 0xff39a100,
  512.                 0x000004f6, 0xff39c200, 0x000004ff, 0xff39e200,
  513.                 0x00000800, 0xff410000, 0x00000808, 0xff412000,
  514.                 0x00000810, 0xff414000, 0x00000818, 0xff416100,
  515.                 0x00000820, 0xff418100, 0x00000829, 0xff41a100,
  516.                 0x00000831, 0xff41c200, 0x00000839, 0xff41e200,
  517.                 0x00000841, 0xff4a0000, 0x0000084a, 0xff4a2000,
  518.                 0x00000852, 0xff4a4000, 0x0000085a, 0xff4a6100,
  519.                 0x00000862, 0xff4a8100, 0x0000086a, 0xff4aa100,
  520.                 0x00000873, 0xff4ac200, 0x0000087b, 0xff4ae200,
  521.                 0x00000883, 0xff520000, 0x0000088b, 0xff522000,
  522.                 0x00000894, 0xff524000, 0x0000089c, 0xff526100,
  523.                 0x000008a4, 0xff528100, 0x000008ac, 0xff52a100,
  524.                 0x000008b4, 0xff52c200, 0x000008bd, 0xff52e200,
  525.                 0x000008c5, 0xff5a0000, 0x000008cd, 0xff5a2000,
  526.                 0x000008d5, 0xff5a4000, 0x000008de, 0xff5a6100,
  527.                 0x000008e6, 0xff5a8100, 0x000008ee, 0xff5aa100,
  528.                 0x000008f6, 0xff5ac200, 0x000008ff, 0xff5ae200,
  529.                 0x00000c00, 0xff620000, 0x00000c08, 0xff622000,
  530.                 0x00000c10, 0xff624000, 0x00000c18, 0xff626100,
  531.                 0x00000c20, 0xff628100, 0x00000c29, 0xff62a100,
  532.                 0x00000c31, 0xff62c200, 0x00000c39, 0xff62e200,
  533.                 0x00000c41, 0xff6a0000, 0x00000c4a, 0xff6a2000,
  534.                 0x00000c52, 0xff6a4000, 0x00000c5a, 0xff6a6100,
  535.                 0x00000c62, 0xff6a8100, 0x00000c6a, 0xff6aa100,
  536.                 0x00000c73, 0xff6ac200, 0x00000c7b, 0xff6ae200,
  537.                 0x00000c83, 0xff730000, 0x00000c8b, 0xff732000,
  538.                 0x00000c94, 0xff734000, 0x00000c9c, 0xff736100,
  539.                 0x00000ca4, 0xff738100, 0x00000cac, 0xff73a100,
  540.                 0x00000cb4, 0xff73c200, 0x00000cbd, 0xff73e200,
  541.                 0x00000cc5, 0xff7b0000, 0x00000ccd, 0xff7b2000,
  542.                 0x00000cd5, 0xff7b4000, 0x00000cde, 0xff7b6100,
  543.                 0x00000ce6, 0xff7b8100, 0x00000cee, 0xff7ba100,
  544.                 0x00000cf6, 0xff7bc200, 0x00000cff, 0xff7be200,
  545.                 0x00001000, 0xff830000, 0x00001008, 0xff832000,
  546.                 0x00001010, 0xff834000, 0x00001018, 0xff836100,
  547.                 0x00001020, 0xff838100, 0x00001029, 0xff83a100,
  548.                 0x00001031, 0xff83c200, 0x00001039, 0xff83e200,
  549.                 0x00001041, 0xff8b0000, 0x0000104a, 0xff8b2000,
  550.                 0x00001052, 0xff8b4000, 0x0000105a, 0xff8b6100,
  551.                 0x00001062, 0xff8b8100, 0x0000106a, 0xff8ba100,
  552.                 0x00001073, 0xff8bc200, 0x0000107b, 0xff8be200,
  553.                 0x00001083, 0xff940000, 0x0000108b, 0xff942000,
  554.                 0x00001094, 0xff944000, 0x0000109c, 0xff946100,
  555.                 0x000010a4, 0xff948100, 0x000010ac, 0xff94a100,
  556.                 0x000010b4, 0xff94c200, 0x000010bd, 0xff94e200,
  557.                 0x000010c5, 0xff9c0000, 0x000010cd, 0xff9c2000,
  558.                 0x000010d5, 0xff9c4000, 0x000010de, 0xff9c6100,
  559.                 0x000010e6, 0xff9c8100, 0x000010ee, 0xff9ca100,
  560.                 0x000010f6, 0xff9cc200, 0x000010ff, 0xff9ce200,
  561.                 0x00001400, 0xffa40000, 0x00001408, 0xffa42000,
  562.                 0x00001410, 0xffa44000, 0x00001418, 0xffa46100,
  563.                 0x00001420, 0xffa48100, 0x00001429, 0xffa4a100,
  564.                 0x00001431, 0xffa4c200, 0x00001439, 0xffa4e200,
  565.                 0x00001441, 0xffac0000, 0x0000144a, 0xffac2000,
  566.                 0x00001452, 0xffac4000, 0x0000145a, 0xffac6100,
  567.                 0x00001462, 0xffac8100, 0x0000146a, 0xffaca100,
  568.                 0x00001473, 0xffacc200, 0x0000147b, 0xfface200,
  569.                 0x00001483, 0xffb40000, 0x0000148b, 0xffb42000,
  570.                 0x00001494, 0xffb44000, 0x0000149c, 0xffb46100,
  571.                 0x000014a4, 0xffb48100, 0x000014ac, 0xffb4a100,
  572.                 0x000014b4, 0xffb4c200, 0x000014bd, 0xffb4e200,
  573.                 0x000014c5, 0xffbd0000, 0x000014cd, 0xffbd2000,
  574.                 0x000014d5, 0xffbd4000, 0x000014de, 0xffbd6100,
  575.                 0x000014e6, 0xffbd8100, 0x000014ee, 0xffbda100,
  576.                 0x000014f6, 0xffbdc200, 0x000014ff, 0xffbde200,
  577.                 0x00001800, 0xffc50000, 0x00001808, 0xffc52000,
  578.                 0x00001810, 0xffc54000, 0x00001818, 0xffc56100,
  579.                 0x00001820, 0xffc58100, 0x00001829, 0xffc5a100,
  580.                 0x00001831, 0xffc5c200, 0x00001839, 0xffc5e200,
  581.                 0x00001841, 0xffcd0000, 0x0000184a, 0xffcd2000,
  582.                 0x00001852, 0xffcd4000, 0x0000185a, 0xffcd6100,
  583.                 0x00001862, 0xffcd8100, 0x0000186a, 0xffcda100,
  584.                 0x00001873, 0xffcdc200, 0x0000187b, 0xffcde200,
  585.                 0x00001883, 0xffd50000, 0x0000188b, 0xffd52000,
  586.                 0x00001894, 0xffd54000, 0x0000189c, 0xffd56100,
  587.                 0x000018a4, 0xffd58100, 0x000018ac, 0xffd5a100,
  588.                 0x000018b4, 0xffd5c200, 0x000018bd, 0xffd5e200,
  589.                 0x000018c5, 0xffde0000, 0x000018cd, 0xffde2000,
  590.                 0x000018d5, 0xffde4000, 0x000018de, 0xffde6100,
  591.                 0x000018e6, 0xffde8100, 0x000018ee, 0xffdea100,
  592.                 0x000018f6, 0xffdec200, 0x000018ff, 0xffdee200,
  593.                 0x00001c00, 0xffe60000, 0x00001c08, 0xffe62000,
  594.                 0x00001c10, 0xffe64000, 0x00001c18, 0xffe66100,
  595.                 0x00001c20, 0xffe68100, 0x00001c29, 0xffe6a100,
  596.                 0x00001c31, 0xffe6c200, 0x00001c39, 0xffe6e200,
  597.                 0x00001c41, 0xffee0000, 0x00001c4a, 0xffee2000,
  598.                 0x00001c52, 0xffee4000, 0x00001c5a, 0xffee6100,
  599.                 0x00001c62, 0xffee8100, 0x00001c6a, 0xffeea100,
  600.                 0x00001c73, 0xffeec200, 0x00001c7b, 0xffeee200,
  601.                 0x00001c83, 0xfff60000, 0x00001c8b, 0xfff62000,
  602.                 0x00001c94, 0xfff64000, 0x00001c9c, 0xfff66100,
  603.                 0x00001ca4, 0xfff68100, 0x00001cac, 0xfff6a100,
  604.                 0x00001cb4, 0xfff6c200, 0x00001cbd, 0xfff6e200,
  605.                 0x00001cc5, 0xffff0000, 0x00001ccd, 0xffff2000,
  606.                 0x00001cd5, 0xffff4000, 0x00001cde, 0xffff6100,
  607.                 0x00001ce6, 0xffff8100, 0x00001cee, 0xffffa100,
  608.                 0x00001cf6, 0xffffc200, 0x00001cff, 0xffffe200
  609. };
  610. static void Blit_RGB565_ARGB8888(SDL_BlitInfo *info)
  611. {
  612.     Blit_RGB565_32(info, RGB565_ARGB8888_LUT);
  613. }
  614.  
  615. /* Special optimized blit for RGB 5-6-5 --> ABGR 8-8-8-8 */
  616. static const Uint32 RGB565_ABGR8888_LUT[512] = {
  617.                 0xff000000, 0x00000000, 0xff080000, 0x00002000,
  618.                 0xff100000, 0x00004000, 0xff180000, 0x00006100,
  619.                 0xff200000, 0x00008100, 0xff290000, 0x0000a100,
  620.                 0xff310000, 0x0000c200, 0xff390000, 0x0000e200,
  621.                 0xff410000, 0x00000008, 0xff4a0000, 0x00002008,
  622.                 0xff520000, 0x00004008, 0xff5a0000, 0x00006108,
  623.                 0xff620000, 0x00008108, 0xff6a0000, 0x0000a108,
  624.                 0xff730000, 0x0000c208, 0xff7b0000, 0x0000e208,
  625.                 0xff830000, 0x00000010, 0xff8b0000, 0x00002010,
  626.                 0xff940000, 0x00004010, 0xff9c0000, 0x00006110,
  627.                 0xffa40000, 0x00008110, 0xffac0000, 0x0000a110,
  628.                 0xffb40000, 0x0000c210, 0xffbd0000, 0x0000e210,
  629.                 0xffc50000, 0x00000018, 0xffcd0000, 0x00002018,
  630.                 0xffd50000, 0x00004018, 0xffde0000, 0x00006118,
  631.                 0xffe60000, 0x00008118, 0xffee0000, 0x0000a118,
  632.                 0xfff60000, 0x0000c218, 0xffff0000, 0x0000e218,
  633.                 0xff000400, 0x00000020, 0xff080400, 0x00002020,
  634.                 0xff100400, 0x00004020, 0xff180400, 0x00006120,
  635.                 0xff200400, 0x00008120, 0xff290400, 0x0000a120,
  636.                 0xff310400, 0x0000c220, 0xff390400, 0x0000e220,
  637.                 0xff410400, 0x00000029, 0xff4a0400, 0x00002029,
  638.                 0xff520400, 0x00004029, 0xff5a0400, 0x00006129,
  639.                 0xff620400, 0x00008129, 0xff6a0400, 0x0000a129,
  640.                 0xff730400, 0x0000c229, 0xff7b0400, 0x0000e229,
  641.                 0xff830400, 0x00000031, 0xff8b0400, 0x00002031,
  642.                 0xff940400, 0x00004031, 0xff9c0400, 0x00006131,
  643.                 0xffa40400, 0x00008131, 0xffac0400, 0x0000a131,
  644.                 0xffb40400, 0x0000c231, 0xffbd0400, 0x0000e231,
  645.                 0xffc50400, 0x00000039, 0xffcd0400, 0x00002039,
  646.                 0xffd50400, 0x00004039, 0xffde0400, 0x00006139,
  647.                 0xffe60400, 0x00008139, 0xffee0400, 0x0000a139,
  648.                 0xfff60400, 0x0000c239, 0xffff0400, 0x0000e239,
  649.                 0xff000800, 0x00000041, 0xff080800, 0x00002041,
  650.                 0xff100800, 0x00004041, 0xff180800, 0x00006141,
  651.                 0xff200800, 0x00008141, 0xff290800, 0x0000a141,
  652.                 0xff310800, 0x0000c241, 0xff390800, 0x0000e241,
  653.                 0xff410800, 0x0000004a, 0xff4a0800, 0x0000204a,
  654.                 0xff520800, 0x0000404a, 0xff5a0800, 0x0000614a,
  655.                 0xff620800, 0x0000814a, 0xff6a0800, 0x0000a14a,
  656.                 0xff730800, 0x0000c24a, 0xff7b0800, 0x0000e24a,
  657.                 0xff830800, 0x00000052, 0xff8b0800, 0x00002052,
  658.                 0xff940800, 0x00004052, 0xff9c0800, 0x00006152,
  659.                 0xffa40800, 0x00008152, 0xffac0800, 0x0000a152,
  660.                 0xffb40800, 0x0000c252, 0xffbd0800, 0x0000e252,
  661.                 0xffc50800, 0x0000005a, 0xffcd0800, 0x0000205a,
  662.                 0xffd50800, 0x0000405a, 0xffde0800, 0x0000615a,
  663.                 0xffe60800, 0x0000815a, 0xffee0800, 0x0000a15a,
  664.                 0xfff60800, 0x0000c25a, 0xffff0800, 0x0000e25a,
  665.                 0xff000c00, 0x00000062, 0xff080c00, 0x00002062,
  666.                 0xff100c00, 0x00004062, 0xff180c00, 0x00006162,
  667.                 0xff200c00, 0x00008162, 0xff290c00, 0x0000a162,
  668.                 0xff310c00, 0x0000c262, 0xff390c00, 0x0000e262,
  669.                 0xff410c00, 0x0000006a, 0xff4a0c00, 0x0000206a,
  670.                 0xff520c00, 0x0000406a, 0xff5a0c00, 0x0000616a,
  671.                 0xff620c00, 0x0000816a, 0xff6a0c00, 0x0000a16a,
  672.                 0xff730c00, 0x0000c26a, 0xff7b0c00, 0x0000e26a,
  673.                 0xff830c00, 0x00000073, 0xff8b0c00, 0x00002073,
  674.                 0xff940c00, 0x00004073, 0xff9c0c00, 0x00006173,
  675.                 0xffa40c00, 0x00008173, 0xffac0c00, 0x0000a173,
  676.                 0xffb40c00, 0x0000c273, 0xffbd0c00, 0x0000e273,
  677.                 0xffc50c00, 0x0000007b, 0xffcd0c00, 0x0000207b,
  678.                 0xffd50c00, 0x0000407b, 0xffde0c00, 0x0000617b,
  679.                 0xffe60c00, 0x0000817b, 0xffee0c00, 0x0000a17b,
  680.                 0xfff60c00, 0x0000c27b, 0xffff0c00, 0x0000e27b,
  681.                 0xff001000, 0x00000083, 0xff081000, 0x00002083,
  682.                 0xff101000, 0x00004083, 0xff181000, 0x00006183,
  683.                 0xff201000, 0x00008183, 0xff291000, 0x0000a183,
  684.                 0xff311000, 0x0000c283, 0xff391000, 0x0000e283,
  685.                 0xff411000, 0x0000008b, 0xff4a1000, 0x0000208b,
  686.                 0xff521000, 0x0000408b, 0xff5a1000, 0x0000618b,
  687.                 0xff621000, 0x0000818b, 0xff6a1000, 0x0000a18b,
  688.                 0xff731000, 0x0000c28b, 0xff7b1000, 0x0000e28b,
  689.                 0xff831000, 0x00000094, 0xff8b1000, 0x00002094,
  690.                 0xff941000, 0x00004094, 0xff9c1000, 0x00006194,
  691.                 0xffa41000, 0x00008194, 0xffac1000, 0x0000a194,
  692.                 0xffb41000, 0x0000c294, 0xffbd1000, 0x0000e294,
  693.                 0xffc51000, 0x0000009c, 0xffcd1000, 0x0000209c,
  694.                 0xffd51000, 0x0000409c, 0xffde1000, 0x0000619c,
  695.                 0xffe61000, 0x0000819c, 0xffee1000, 0x0000a19c,
  696.                 0xfff61000, 0x0000c29c, 0xffff1000, 0x0000e29c,
  697.                 0xff001400, 0x000000a4, 0xff081400, 0x000020a4,
  698.                 0xff101400, 0x000040a4, 0xff181400, 0x000061a4,
  699.                 0xff201400, 0x000081a4, 0xff291400, 0x0000a1a4,
  700.                 0xff311400, 0x0000c2a4, 0xff391400, 0x0000e2a4,
  701.                 0xff411400, 0x000000ac, 0xff4a1400, 0x000020ac,
  702.                 0xff521400, 0x000040ac, 0xff5a1400, 0x000061ac,
  703.                 0xff621400, 0x000081ac, 0xff6a1400, 0x0000a1ac,
  704.                 0xff731400, 0x0000c2ac, 0xff7b1400, 0x0000e2ac,
  705.                 0xff831400, 0x000000b4, 0xff8b1400, 0x000020b4,
  706.                 0xff941400, 0x000040b4, 0xff9c1400, 0x000061b4,
  707.                 0xffa41400, 0x000081b4, 0xffac1400, 0x0000a1b4,
  708.                 0xffb41400, 0x0000c2b4, 0xffbd1400, 0x0000e2b4,
  709.                 0xffc51400, 0x000000bd, 0xffcd1400, 0x000020bd,
  710.                 0xffd51400, 0x000040bd, 0xffde1400, 0x000061bd,
  711.                 0xffe61400, 0x000081bd, 0xffee1400, 0x0000a1bd,
  712.                 0xfff61400, 0x0000c2bd, 0xffff1400, 0x0000e2bd,
  713.                 0xff001800, 0x000000c5, 0xff081800, 0x000020c5,
  714.                 0xff101800, 0x000040c5, 0xff181800, 0x000061c5,
  715.                 0xff201800, 0x000081c5, 0xff291800, 0x0000a1c5,
  716.                 0xff311800, 0x0000c2c5, 0xff391800, 0x0000e2c5,
  717.                 0xff411800, 0x000000cd, 0xff4a1800, 0x000020cd,
  718.                 0xff521800, 0x000040cd, 0xff5a1800, 0x000061cd,
  719.                 0xff621800, 0x000081cd, 0xff6a1800, 0x0000a1cd,
  720.                 0xff731800, 0x0000c2cd, 0xff7b1800, 0x0000e2cd,
  721.                 0xff831800, 0x000000d5, 0xff8b1800, 0x000020d5,
  722.                 0xff941800, 0x000040d5, 0xff9c1800, 0x000061d5,
  723.                 0xffa41800, 0x000081d5, 0xffac1800, 0x0000a1d5,
  724.                 0xffb41800, 0x0000c2d5, 0xffbd1800, 0x0000e2d5,
  725.                 0xffc51800, 0x000000de, 0xffcd1800, 0x000020de,
  726.                 0xffd51800, 0x000040de, 0xffde1800, 0x000061de,
  727.                 0xffe61800, 0x000081de, 0xffee1800, 0x0000a1de,
  728.                 0xfff61800, 0x0000c2de, 0xffff1800, 0x0000e2de,
  729.                 0xff001c00, 0x000000e6, 0xff081c00, 0x000020e6,
  730.                 0xff101c00, 0x000040e6, 0xff181c00, 0x000061e6,
  731.                 0xff201c00, 0x000081e6, 0xff291c00, 0x0000a1e6,
  732.                 0xff311c00, 0x0000c2e6, 0xff391c00, 0x0000e2e6,
  733.                 0xff411c00, 0x000000ee, 0xff4a1c00, 0x000020ee,
  734.                 0xff521c00, 0x000040ee, 0xff5a1c00, 0x000061ee,
  735.                 0xff621c00, 0x000081ee, 0xff6a1c00, 0x0000a1ee,
  736.                 0xff731c00, 0x0000c2ee, 0xff7b1c00, 0x0000e2ee,
  737.                 0xff831c00, 0x000000f6, 0xff8b1c00, 0x000020f6,
  738.                 0xff941c00, 0x000040f6, 0xff9c1c00, 0x000061f6,
  739.                 0xffa41c00, 0x000081f6, 0xffac1c00, 0x0000a1f6,
  740.                 0xffb41c00, 0x0000c2f6, 0xffbd1c00, 0x0000e2f6,
  741.                 0xffc51c00, 0x000000ff, 0xffcd1c00, 0x000020ff,
  742.                 0xffd51c00, 0x000040ff, 0xffde1c00, 0x000061ff,
  743.                 0xffe61c00, 0x000081ff, 0xffee1c00, 0x0000a1ff,
  744.                 0xfff61c00, 0x0000c2ff, 0xffff1c00, 0x0000e2ff
  745. };
  746. static void Blit_RGB565_ABGR8888(SDL_BlitInfo *info)
  747. {
  748.     Blit_RGB565_32(info, RGB565_ABGR8888_LUT);
  749. }
  750.  
  751. /* Special optimized blit for RGB 5-6-5 --> RGBA 8-8-8-8 */
  752. static const Uint32 RGB565_RGBA8888_LUT[512] = {
  753.                 0x000000ff, 0x00000000, 0x000008ff, 0x00200000,
  754.                 0x000010ff, 0x00400000, 0x000018ff, 0x00610000,
  755.                 0x000020ff, 0x00810000, 0x000029ff, 0x00a10000,
  756.                 0x000031ff, 0x00c20000, 0x000039ff, 0x00e20000,
  757.                 0x000041ff, 0x08000000, 0x00004aff, 0x08200000,
  758.                 0x000052ff, 0x08400000, 0x00005aff, 0x08610000,
  759.                 0x000062ff, 0x08810000, 0x00006aff, 0x08a10000,
  760.                 0x000073ff, 0x08c20000, 0x00007bff, 0x08e20000,
  761.                 0x000083ff, 0x10000000, 0x00008bff, 0x10200000,
  762.                 0x000094ff, 0x10400000, 0x00009cff, 0x10610000,
  763.                 0x0000a4ff, 0x10810000, 0x0000acff, 0x10a10000,
  764.                 0x0000b4ff, 0x10c20000, 0x0000bdff, 0x10e20000,
  765.                 0x0000c5ff, 0x18000000, 0x0000cdff, 0x18200000,
  766.                 0x0000d5ff, 0x18400000, 0x0000deff, 0x18610000,
  767.                 0x0000e6ff, 0x18810000, 0x0000eeff, 0x18a10000,
  768.                 0x0000f6ff, 0x18c20000, 0x0000ffff, 0x18e20000,
  769.                 0x000400ff, 0x20000000, 0x000408ff, 0x20200000,
  770.                 0x000410ff, 0x20400000, 0x000418ff, 0x20610000,
  771.                 0x000420ff, 0x20810000, 0x000429ff, 0x20a10000,
  772.                 0x000431ff, 0x20c20000, 0x000439ff, 0x20e20000,
  773.                 0x000441ff, 0x29000000, 0x00044aff, 0x29200000,
  774.                 0x000452ff, 0x29400000, 0x00045aff, 0x29610000,
  775.                 0x000462ff, 0x29810000, 0x00046aff, 0x29a10000,
  776.                 0x000473ff, 0x29c20000, 0x00047bff, 0x29e20000,
  777.                 0x000483ff, 0x31000000, 0x00048bff, 0x31200000,
  778.                 0x000494ff, 0x31400000, 0x00049cff, 0x31610000,
  779.                 0x0004a4ff, 0x31810000, 0x0004acff, 0x31a10000,
  780.                 0x0004b4ff, 0x31c20000, 0x0004bdff, 0x31e20000,
  781.                 0x0004c5ff, 0x39000000, 0x0004cdff, 0x39200000,
  782.                 0x0004d5ff, 0x39400000, 0x0004deff, 0x39610000,
  783.                 0x0004e6ff, 0x39810000, 0x0004eeff, 0x39a10000,
  784.                 0x0004f6ff, 0x39c20000, 0x0004ffff, 0x39e20000,
  785.                 0x000800ff, 0x41000000, 0x000808ff, 0x41200000,
  786.                 0x000810ff, 0x41400000, 0x000818ff, 0x41610000,
  787.                 0x000820ff, 0x41810000, 0x000829ff, 0x41a10000,
  788.                 0x000831ff, 0x41c20000, 0x000839ff, 0x41e20000,
  789.                 0x000841ff, 0x4a000000, 0x00084aff, 0x4a200000,
  790.                 0x000852ff, 0x4a400000, 0x00085aff, 0x4a610000,
  791.                 0x000862ff, 0x4a810000, 0x00086aff, 0x4aa10000,
  792.                 0x000873ff, 0x4ac20000, 0x00087bff, 0x4ae20000,
  793.                 0x000883ff, 0x52000000, 0x00088bff, 0x52200000,
  794.                 0x000894ff, 0x52400000, 0x00089cff, 0x52610000,
  795.                 0x0008a4ff, 0x52810000, 0x0008acff, 0x52a10000,
  796.                 0x0008b4ff, 0x52c20000, 0x0008bdff, 0x52e20000,
  797.                 0x0008c5ff, 0x5a000000, 0x0008cdff, 0x5a200000,
  798.                 0x0008d5ff, 0x5a400000, 0x0008deff, 0x5a610000,
  799.                 0x0008e6ff, 0x5a810000, 0x0008eeff, 0x5aa10000,
  800.                 0x0008f6ff, 0x5ac20000, 0x0008ffff, 0x5ae20000,
  801.                 0x000c00ff, 0x62000000, 0x000c08ff, 0x62200000,
  802.                 0x000c10ff, 0x62400000, 0x000c18ff, 0x62610000,
  803.                 0x000c20ff, 0x62810000, 0x000c29ff, 0x62a10000,
  804.                 0x000c31ff, 0x62c20000, 0x000c39ff, 0x62e20000,
  805.                 0x000c41ff, 0x6a000000, 0x000c4aff, 0x6a200000,
  806.                 0x000c52ff, 0x6a400000, 0x000c5aff, 0x6a610000,
  807.                 0x000c62ff, 0x6a810000, 0x000c6aff, 0x6aa10000,
  808.                 0x000c73ff, 0x6ac20000, 0x000c7bff, 0x6ae20000,
  809.                 0x000c83ff, 0x73000000, 0x000c8bff, 0x73200000,
  810.                 0x000c94ff, 0x73400000, 0x000c9cff, 0x73610000,
  811.                 0x000ca4ff, 0x73810000, 0x000cacff, 0x73a10000,
  812.                 0x000cb4ff, 0x73c20000, 0x000cbdff, 0x73e20000,
  813.                 0x000cc5ff, 0x7b000000, 0x000ccdff, 0x7b200000,
  814.                 0x000cd5ff, 0x7b400000, 0x000cdeff, 0x7b610000,
  815.                 0x000ce6ff, 0x7b810000, 0x000ceeff, 0x7ba10000,
  816.                 0x000cf6ff, 0x7bc20000, 0x000cffff, 0x7be20000,
  817.                 0x001000ff, 0x83000000, 0x001008ff, 0x83200000,
  818.                 0x001010ff, 0x83400000, 0x001018ff, 0x83610000,
  819.                 0x001020ff, 0x83810000, 0x001029ff, 0x83a10000,
  820.                 0x001031ff, 0x83c20000, 0x001039ff, 0x83e20000,
  821.                 0x001041ff, 0x8b000000, 0x00104aff, 0x8b200000,
  822.                 0x001052ff, 0x8b400000, 0x00105aff, 0x8b610000,
  823.                 0x001062ff, 0x8b810000, 0x00106aff, 0x8ba10000,
  824.                 0x001073ff, 0x8bc20000, 0x00107bff, 0x8be20000,
  825.                 0x001083ff, 0x94000000, 0x00108bff, 0x94200000,
  826.                 0x001094ff, 0x94400000, 0x00109cff, 0x94610000,
  827.                 0x0010a4ff, 0x94810000, 0x0010acff, 0x94a10000,
  828.                 0x0010b4ff, 0x94c20000, 0x0010bdff, 0x94e20000,
  829.                 0x0010c5ff, 0x9c000000, 0x0010cdff, 0x9c200000,
  830.                 0x0010d5ff, 0x9c400000, 0x0010deff, 0x9c610000,
  831.                 0x0010e6ff, 0x9c810000, 0x0010eeff, 0x9ca10000,
  832.                 0x0010f6ff, 0x9cc20000, 0x0010ffff, 0x9ce20000,
  833.                 0x001400ff, 0xa4000000, 0x001408ff, 0xa4200000,
  834.                 0x001410ff, 0xa4400000, 0x001418ff, 0xa4610000,
  835.                 0x001420ff, 0xa4810000, 0x001429ff, 0xa4a10000,
  836.                 0x001431ff, 0xa4c20000, 0x001439ff, 0xa4e20000,
  837.                 0x001441ff, 0xac000000, 0x00144aff, 0xac200000,
  838.                 0x001452ff, 0xac400000, 0x00145aff, 0xac610000,
  839.                 0x001462ff, 0xac810000, 0x00146aff, 0xaca10000,
  840.                 0x001473ff, 0xacc20000, 0x00147bff, 0xace20000,
  841.                 0x001483ff, 0xb4000000, 0x00148bff, 0xb4200000,
  842.                 0x001494ff, 0xb4400000, 0x00149cff, 0xb4610000,
  843.                 0x0014a4ff, 0xb4810000, 0x0014acff, 0xb4a10000,
  844.                 0x0014b4ff, 0xb4c20000, 0x0014bdff, 0xb4e20000,
  845.                 0x0014c5ff, 0xbd000000, 0x0014cdff, 0xbd200000,
  846.                 0x0014d5ff, 0xbd400000, 0x0014deff, 0xbd610000,
  847.                 0x0014e6ff, 0xbd810000, 0x0014eeff, 0xbda10000,
  848.                 0x0014f6ff, 0xbdc20000, 0x0014ffff, 0xbde20000,
  849.                 0x001800ff, 0xc5000000, 0x001808ff, 0xc5200000,
  850.                 0x001810ff, 0xc5400000, 0x001818ff, 0xc5610000,
  851.                 0x001820ff, 0xc5810000, 0x001829ff, 0xc5a10000,
  852.                 0x001831ff, 0xc5c20000, 0x001839ff, 0xc5e20000,
  853.                 0x001841ff, 0xcd000000, 0x00184aff, 0xcd200000,
  854.                 0x001852ff, 0xcd400000, 0x00185aff, 0xcd610000,
  855.                 0x001862ff, 0xcd810000, 0x00186aff, 0xcda10000,
  856.                 0x001873ff, 0xcdc20000, 0x00187bff, 0xcde20000,
  857.                 0x001883ff, 0xd5000000, 0x00188bff, 0xd5200000,
  858.                 0x001894ff, 0xd5400000, 0x00189cff, 0xd5610000,
  859.                 0x0018a4ff, 0xd5810000, 0x0018acff, 0xd5a10000,
  860.                 0x0018b4ff, 0xd5c20000, 0x0018bdff, 0xd5e20000,
  861.                 0x0018c5ff, 0xde000000, 0x0018cdff, 0xde200000,
  862.                 0x0018d5ff, 0xde400000, 0x0018deff, 0xde610000,
  863.                 0x0018e6ff, 0xde810000, 0x0018eeff, 0xdea10000,
  864.                 0x0018f6ff, 0xdec20000, 0x0018ffff, 0xdee20000,
  865.                 0x001c00ff, 0xe6000000, 0x001c08ff, 0xe6200000,
  866.                 0x001c10ff, 0xe6400000, 0x001c18ff, 0xe6610000,
  867.                 0x001c20ff, 0xe6810000, 0x001c29ff, 0xe6a10000,
  868.                 0x001c31ff, 0xe6c20000, 0x001c39ff, 0xe6e20000,
  869.                 0x001c41ff, 0xee000000, 0x001c4aff, 0xee200000,
  870.                 0x001c52ff, 0xee400000, 0x001c5aff, 0xee610000,
  871.                 0x001c62ff, 0xee810000, 0x001c6aff, 0xeea10000,
  872.                 0x001c73ff, 0xeec20000, 0x001c7bff, 0xeee20000,
  873.                 0x001c83ff, 0xf6000000, 0x001c8bff, 0xf6200000,
  874.                 0x001c94ff, 0xf6400000, 0x001c9cff, 0xf6610000,
  875.                 0x001ca4ff, 0xf6810000, 0x001cacff, 0xf6a10000,
  876.                 0x001cb4ff, 0xf6c20000, 0x001cbdff, 0xf6e20000,
  877.                 0x001cc5ff, 0xff000000, 0x001ccdff, 0xff200000,
  878.                 0x001cd5ff, 0xff400000, 0x001cdeff, 0xff610000,
  879.                 0x001ce6ff, 0xff810000, 0x001ceeff, 0xffa10000,
  880.                 0x001cf6ff, 0xffc20000, 0x001cffff, 0xffe20000,
  881. };
  882. static void Blit_RGB565_RGBA8888(SDL_BlitInfo *info)
  883. {
  884.     Blit_RGB565_32(info, RGB565_RGBA8888_LUT);
  885. }
  886.  
  887. /* Special optimized blit for RGB 5-6-5 --> BGRA 8-8-8-8 */
  888. static const Uint32 RGB565_BGRA8888_LUT[512] = {
  889.                 0x00000000, 0x000000ff, 0x08000000, 0x002000ff,
  890.                 0x10000000, 0x004000ff, 0x18000000, 0x006100ff,
  891.                 0x20000000, 0x008100ff, 0x29000000, 0x00a100ff,
  892.                 0x31000000, 0x00c200ff, 0x39000000, 0x00e200ff,
  893.                 0x41000000, 0x000008ff, 0x4a000000, 0x002008ff,
  894.                 0x52000000, 0x004008ff, 0x5a000000, 0x006108ff,
  895.                 0x62000000, 0x008108ff, 0x6a000000, 0x00a108ff,
  896.                 0x73000000, 0x00c208ff, 0x7b000000, 0x00e208ff,
  897.                 0x83000000, 0x000010ff, 0x8b000000, 0x002010ff,
  898.                 0x94000000, 0x004010ff, 0x9c000000, 0x006110ff,
  899.                 0xa4000000, 0x008110ff, 0xac000000, 0x00a110ff,
  900.                 0xb4000000, 0x00c210ff, 0xbd000000, 0x00e210ff,
  901.                 0xc5000000, 0x000018ff, 0xcd000000, 0x002018ff,
  902.                 0xd5000000, 0x004018ff, 0xde000000, 0x006118ff,
  903.                 0xe6000000, 0x008118ff, 0xee000000, 0x00a118ff,
  904.                 0xf6000000, 0x00c218ff, 0xff000000, 0x00e218ff,
  905.                 0x00040000, 0x000020ff, 0x08040000, 0x002020ff,
  906.                 0x10040000, 0x004020ff, 0x18040000, 0x006120ff,
  907.                 0x20040000, 0x008120ff, 0x29040000, 0x00a120ff,
  908.                 0x31040000, 0x00c220ff, 0x39040000, 0x00e220ff,
  909.                 0x41040000, 0x000029ff, 0x4a040000, 0x002029ff,
  910.                 0x52040000, 0x004029ff, 0x5a040000, 0x006129ff,
  911.                 0x62040000, 0x008129ff, 0x6a040000, 0x00a129ff,
  912.                 0x73040000, 0x00c229ff, 0x7b040000, 0x00e229ff,
  913.                 0x83040000, 0x000031ff, 0x8b040000, 0x002031ff,
  914.                 0x94040000, 0x004031ff, 0x9c040000, 0x006131ff,
  915.                 0xa4040000, 0x008131ff, 0xac040000, 0x00a131ff,
  916.                 0xb4040000, 0x00c231ff, 0xbd040000, 0x00e231ff,
  917.                 0xc5040000, 0x000039ff, 0xcd040000, 0x002039ff,
  918.                 0xd5040000, 0x004039ff, 0xde040000, 0x006139ff,
  919.                 0xe6040000, 0x008139ff, 0xee040000, 0x00a139ff,
  920.                 0xf6040000, 0x00c239ff, 0xff040000, 0x00e239ff,
  921.                 0x00080000, 0x000041ff, 0x08080000, 0x002041ff,
  922.                 0x10080000, 0x004041ff, 0x18080000, 0x006141ff,
  923.                 0x20080000, 0x008141ff, 0x29080000, 0x00a141ff,
  924.                 0x31080000, 0x00c241ff, 0x39080000, 0x00e241ff,
  925.                 0x41080000, 0x00004aff, 0x4a080000, 0x00204aff,
  926.                 0x52080000, 0x00404aff, 0x5a080000, 0x00614aff,
  927.                 0x62080000, 0x00814aff, 0x6a080000, 0x00a14aff,
  928.                 0x73080000, 0x00c24aff, 0x7b080000, 0x00e24aff,
  929.                 0x83080000, 0x000052ff, 0x8b080000, 0x002052ff,
  930.                 0x94080000, 0x004052ff, 0x9c080000, 0x006152ff,
  931.                 0xa4080000, 0x008152ff, 0xac080000, 0x00a152ff,
  932.                 0xb4080000, 0x00c252ff, 0xbd080000, 0x00e252ff,
  933.                 0xc5080000, 0x00005aff, 0xcd080000, 0x00205aff,
  934.                 0xd5080000, 0x00405aff, 0xde080000, 0x00615aff,
  935.                 0xe6080000, 0x00815aff, 0xee080000, 0x00a15aff,
  936.                 0xf6080000, 0x00c25aff, 0xff080000, 0x00e25aff,
  937.                 0x000c0000, 0x000062ff, 0x080c0000, 0x002062ff,
  938.                 0x100c0000, 0x004062ff, 0x180c0000, 0x006162ff,
  939.                 0x200c0000, 0x008162ff, 0x290c0000, 0x00a162ff,
  940.                 0x310c0000, 0x00c262ff, 0x390c0000, 0x00e262ff,
  941.                 0x410c0000, 0x00006aff, 0x4a0c0000, 0x00206aff,
  942.                 0x520c0000, 0x00406aff, 0x5a0c0000, 0x00616aff,
  943.                 0x620c0000, 0x00816aff, 0x6a0c0000, 0x00a16aff,
  944.                 0x730c0000, 0x00c26aff, 0x7b0c0000, 0x00e26aff,
  945.                 0x830c0000, 0x000073ff, 0x8b0c0000, 0x002073ff,
  946.                 0x940c0000, 0x004073ff, 0x9c0c0000, 0x006173ff,
  947.                 0xa40c0000, 0x008173ff, 0xac0c0000, 0x00a173ff,
  948.                 0xb40c0000, 0x00c273ff, 0xbd0c0000, 0x00e273ff,
  949.                 0xc50c0000, 0x00007bff, 0xcd0c0000, 0x00207bff,
  950.                 0xd50c0000, 0x00407bff, 0xde0c0000, 0x00617bff,
  951.                 0xe60c0000, 0x00817bff, 0xee0c0000, 0x00a17bff,
  952.                 0xf60c0000, 0x00c27bff, 0xff0c0000, 0x00e27bff,
  953.                 0x00100000, 0x000083ff, 0x08100000, 0x002083ff,
  954.                 0x10100000, 0x004083ff, 0x18100000, 0x006183ff,
  955.                 0x20100000, 0x008183ff, 0x29100000, 0x00a183ff,
  956.                 0x31100000, 0x00c283ff, 0x39100000, 0x00e283ff,
  957.                 0x41100000, 0x00008bff, 0x4a100000, 0x00208bff,
  958.                 0x52100000, 0x00408bff, 0x5a100000, 0x00618bff,
  959.                 0x62100000, 0x00818bff, 0x6a100000, 0x00a18bff,
  960.                 0x73100000, 0x00c28bff, 0x7b100000, 0x00e28bff,
  961.                 0x83100000, 0x000094ff, 0x8b100000, 0x002094ff,
  962.                 0x94100000, 0x004094ff, 0x9c100000, 0x006194ff,
  963.                 0xa4100000, 0x008194ff, 0xac100000, 0x00a194ff,
  964.                 0xb4100000, 0x00c294ff, 0xbd100000, 0x00e294ff,
  965.                 0xc5100000, 0x00009cff, 0xcd100000, 0x00209cff,
  966.                 0xd5100000, 0x00409cff, 0xde100000, 0x00619cff,
  967.                 0xe6100000, 0x00819cff, 0xee100000, 0x00a19cff,
  968.                 0xf6100000, 0x00c29cff, 0xff100000, 0x00e29cff,
  969.                 0x00140000, 0x0000a4ff, 0x08140000, 0x0020a4ff,
  970.                 0x10140000, 0x0040a4ff, 0x18140000, 0x0061a4ff,
  971.                 0x20140000, 0x0081a4ff, 0x29140000, 0x00a1a4ff,
  972.                 0x31140000, 0x00c2a4ff, 0x39140000, 0x00e2a4ff,
  973.                 0x41140000, 0x0000acff, 0x4a140000, 0x0020acff,
  974.                 0x52140000, 0x0040acff, 0x5a140000, 0x0061acff,
  975.                 0x62140000, 0x0081acff, 0x6a140000, 0x00a1acff,
  976.                 0x73140000, 0x00c2acff, 0x7b140000, 0x00e2acff,
  977.                 0x83140000, 0x0000b4ff, 0x8b140000, 0x0020b4ff,
  978.                 0x94140000, 0x0040b4ff, 0x9c140000, 0x0061b4ff,
  979.                 0xa4140000, 0x0081b4ff, 0xac140000, 0x00a1b4ff,
  980.                 0xb4140000, 0x00c2b4ff, 0xbd140000, 0x00e2b4ff,
  981.                 0xc5140000, 0x0000bdff, 0xcd140000, 0x0020bdff,
  982.                 0xd5140000, 0x0040bdff, 0xde140000, 0x0061bdff,
  983.                 0xe6140000, 0x0081bdff, 0xee140000, 0x00a1bdff,
  984.                 0xf6140000, 0x00c2bdff, 0xff140000, 0x00e2bdff,
  985.                 0x00180000, 0x0000c5ff, 0x08180000, 0x0020c5ff,
  986.                 0x10180000, 0x0040c5ff, 0x18180000, 0x0061c5ff,
  987.                 0x20180000, 0x0081c5ff, 0x29180000, 0x00a1c5ff,
  988.                 0x31180000, 0x00c2c5ff, 0x39180000, 0x00e2c5ff,
  989.                 0x41180000, 0x0000cdff, 0x4a180000, 0x0020cdff,
  990.                 0x52180000, 0x0040cdff, 0x5a180000, 0x0061cdff,
  991.                 0x62180000, 0x0081cdff, 0x6a180000, 0x00a1cdff,
  992.                 0x73180000, 0x00c2cdff, 0x7b180000, 0x00e2cdff,
  993.                 0x83180000, 0x0000d5ff, 0x8b180000, 0x0020d5ff,
  994.                 0x94180000, 0x0040d5ff, 0x9c180000, 0x0061d5ff,
  995.                 0xa4180000, 0x0081d5ff, 0xac180000, 0x00a1d5ff,
  996.                 0xb4180000, 0x00c2d5ff, 0xbd180000, 0x00e2d5ff,
  997.                 0xc5180000, 0x0000deff, 0xcd180000, 0x0020deff,
  998.                 0xd5180000, 0x0040deff, 0xde180000, 0x0061deff,
  999.                 0xe6180000, 0x0081deff, 0xee180000, 0x00a1deff,
  1000.                 0xf6180000, 0x00c2deff, 0xff180000, 0x00e2deff,
  1001.                 0x001c0000, 0x0000e6ff, 0x081c0000, 0x0020e6ff,
  1002.                 0x101c0000, 0x0040e6ff, 0x181c0000, 0x0061e6ff,
  1003.                 0x201c0000, 0x0081e6ff, 0x291c0000, 0x00a1e6ff,
  1004.                 0x311c0000, 0x00c2e6ff, 0x391c0000, 0x00e2e6ff,
  1005.                 0x411c0000, 0x0000eeff, 0x4a1c0000, 0x0020eeff,
  1006.                 0x521c0000, 0x0040eeff, 0x5a1c0000, 0x0061eeff,
  1007.                 0x621c0000, 0x0081eeff, 0x6a1c0000, 0x00a1eeff,
  1008.                 0x731c0000, 0x00c2eeff, 0x7b1c0000, 0x00e2eeff,
  1009.                 0x831c0000, 0x0000f6ff, 0x8b1c0000, 0x0020f6ff,
  1010.                 0x941c0000, 0x0040f6ff, 0x9c1c0000, 0x0061f6ff,
  1011.                 0xa41c0000, 0x0081f6ff, 0xac1c0000, 0x00a1f6ff,
  1012.                 0xb41c0000, 0x00c2f6ff, 0xbd1c0000, 0x00e2f6ff,
  1013.                 0xc51c0000, 0x0000ffff, 0xcd1c0000, 0x0020ffff,
  1014.                 0xd51c0000, 0x0040ffff, 0xde1c0000, 0x0061ffff,
  1015.                 0xe61c0000, 0x0081ffff, 0xee1c0000, 0x00a1ffff,
  1016.                 0xf61c0000, 0x00c2ffff, 0xff1c0000, 0x00e2ffff
  1017. };
  1018. static void Blit_RGB565_BGRA8888(SDL_BlitInfo *info)
  1019. {
  1020.     Blit_RGB565_32(info, RGB565_BGRA8888_LUT);
  1021. }
  1022.  
  1023. /* Special optimized blit for RGB 8-8-8 --> RGB 3-3-2 */
  1024. #ifndef RGB888_RGB332
  1025. #define RGB888_RGB332(dst, src) { \
  1026.         dst = (((src)&0x00E00000)>>16)| \
  1027.               (((src)&0x0000E000)>>11)| \
  1028.               (((src)&0x000000C0)>>6); \
  1029. }
  1030. #endif
  1031. static void Blit_RGB888_index8_map(SDL_BlitInfo *info)
  1032. {
  1033. #ifndef USE_DUFFS_LOOP
  1034.         int c;
  1035. #endif
  1036.         int pixel;
  1037.         int width, height;
  1038.         Uint32 *src;
  1039.         const Uint8 *map;
  1040.         Uint8 *dst;
  1041.         int srcskip, dstskip;
  1042.  
  1043.         /* Set up some basic variables */
  1044.         width = info->d_width;
  1045.         height = info->d_height;
  1046.         src = (Uint32 *)info->s_pixels;
  1047.         srcskip = info->s_skip/4;
  1048.         dst = info->d_pixels;
  1049.         dstskip = info->d_skip;
  1050.         map = info->table;
  1051.  
  1052. #ifdef USE_DUFFS_LOOP
  1053.         while ( height-- ) {
  1054.                 DUFFS_LOOP(
  1055.                         RGB888_RGB332(pixel, *src);
  1056.                         *dst++ = map[pixel];
  1057.                         ++src;
  1058.                 , width);
  1059.                 src += srcskip;
  1060.                 dst += dstskip;
  1061.         }
  1062. #else
  1063.         while ( height-- ) {
  1064.                 for ( c=width/4; c; --c ) {
  1065.                         /* Pack RGB into 8bit pixel */
  1066.                         RGB888_RGB332(pixel, *src);
  1067.                         *dst++ = map[pixel];
  1068.                         ++src;
  1069.                         RGB888_RGB332(pixel, *src);
  1070.                         *dst++ = map[pixel];
  1071.                         ++src;
  1072.                         RGB888_RGB332(pixel, *src);
  1073.                         *dst++ = map[pixel];
  1074.                         ++src;
  1075.                         RGB888_RGB332(pixel, *src);
  1076.                         *dst++ = map[pixel];
  1077.                         ++src;
  1078.                 }
  1079.                 switch ( width & 3 ) {
  1080.                         case 3:
  1081.                                 RGB888_RGB332(pixel, *src);
  1082.                                 *dst++ = map[pixel];
  1083.                                 ++src;
  1084.                         case 2:
  1085.                                 RGB888_RGB332(pixel, *src);
  1086.                                 *dst++ = map[pixel];
  1087.                                 ++src;
  1088.                         case 1:
  1089.                                 RGB888_RGB332(pixel, *src);
  1090.                                 *dst++ = map[pixel];
  1091.                                 ++src;
  1092.                 }
  1093.                 src += srcskip;
  1094.                 dst += dstskip;
  1095.         }
  1096. #endif /* USE_DUFFS_LOOP */
  1097. }
  1098. static void BlitNto1(SDL_BlitInfo *info)
  1099. {
  1100. #ifndef USE_DUFFS_LOOP
  1101.         int c;
  1102. #endif
  1103.         int width, height;
  1104.         Uint8 *src;
  1105.         const Uint8 *map;
  1106.         Uint8 *dst;
  1107.         int srcskip, dstskip;
  1108.         int srcbpp;
  1109.         Uint32 pixel;
  1110.         int  sR, sG, sB;
  1111.         SDL_PixelFormat *srcfmt;
  1112.  
  1113.         /* Set up some basic variables */
  1114.         width = info->d_width;
  1115.         height = info->d_height;
  1116.         src = info->s_pixels;
  1117.         srcskip = info->s_skip;
  1118.         dst = info->d_pixels;
  1119.         dstskip = info->d_skip;
  1120.         map = info->table;
  1121.         srcfmt = info->src;
  1122.         srcbpp = srcfmt->BytesPerPixel;
  1123.  
  1124.         if ( map == NULL ) {
  1125.                 while ( height-- ) {
  1126. #ifdef USE_DUFFS_LOOP
  1127.                         DUFFS_LOOP(
  1128.                                 DISEMBLE_RGB(src, srcbpp, srcfmt, pixel,
  1129.                                                                 sR, sG, sB);
  1130.                                 if ( 1 ) {
  1131.                                         /* Pack RGB into 8bit pixel */
  1132.                                         *dst = ((sR>>5)<<(3+2))|
  1133.                                                 ((sG>>5)<<(2)) |
  1134.                                                 ((sB>>6)<<(0)) ;
  1135.                                 }
  1136.                                 dst++;
  1137.                                 src += srcbpp;
  1138.                         , width);
  1139. #else
  1140.                         for ( c=width; c; --c ) {
  1141.                                 DISEMBLE_RGB(src, srcbpp, srcfmt, pixel,
  1142.                                                                 sR, sG, sB);
  1143.                                 if ( 1 ) {
  1144.                                         /* Pack RGB into 8bit pixel */
  1145.                                         *dst = ((sR>>5)<<(3+2))|
  1146.                                                 ((sG>>5)<<(2)) |
  1147.                                                 ((sB>>6)<<(0)) ;
  1148.                                 }
  1149.                                 dst++;
  1150.                                 src += srcbpp;
  1151.                         }
  1152. #endif
  1153.                         src += srcskip;
  1154.                         dst += dstskip;
  1155.                 }
  1156.         } else {
  1157.                 while ( height-- ) {
  1158. #ifdef USE_DUFFS_LOOP
  1159.                         DUFFS_LOOP(
  1160.                                 DISEMBLE_RGB(src, srcbpp, srcfmt, pixel,
  1161.                                                                 sR, sG, sB);
  1162.                                 if ( 1 ) {
  1163.                                         /* Pack RGB into 8bit pixel */
  1164.                                         *dst = map[((sR>>5)<<(3+2))|
  1165.                                                    ((sG>>5)<<(2))  |
  1166.                                                    ((sB>>6)<<(0))  ];
  1167.                                 }
  1168.                                 dst++;
  1169.                                 src += srcbpp;
  1170.                         , width);
  1171. #else
  1172.                         for ( c=width; c; --c ) {
  1173.                                 DISEMBLE_RGB(src, srcbpp, srcfmt, pixel,
  1174.                                                                 sR, sG, sB);
  1175.                                 if ( 1 ) {
  1176.                                         /* Pack RGB into 8bit pixel */
  1177.                                         *dst = map[((sR>>5)<<(3+2))|
  1178.                                                    ((sG>>5)<<(2))  |
  1179.                                                    ((sB>>6)<<(0))  ];
  1180.                                 }
  1181.                                 dst++;
  1182.                                 src += srcbpp;
  1183.                         }
  1184. #endif /* USE_DUFFS_LOOP */
  1185.                         src += srcskip;
  1186.                         dst += dstskip;
  1187.                 }
  1188.         }
  1189. }
  1190. static void BlitNtoN(SDL_BlitInfo *info)
  1191. {
  1192.         int width = info->d_width;
  1193.         int height = info->d_height;
  1194.         Uint8 *src = info->s_pixels;
  1195.         int srcskip = info->s_skip;
  1196.         Uint8 *dst = info->d_pixels;
  1197.         int dstskip = info->d_skip;
  1198.         SDL_PixelFormat *srcfmt = info->src;
  1199.         int srcbpp = srcfmt->BytesPerPixel;
  1200.         SDL_PixelFormat *dstfmt = info->dst;
  1201.         int dstbpp = dstfmt->BytesPerPixel;
  1202.         unsigned alpha = dstfmt->Amask ? SDL_ALPHA_OPAQUE : 0;
  1203.  
  1204.         while ( height-- ) {
  1205.                 DUFFS_LOOP(
  1206.                 {
  1207.                         Uint32 pixel;
  1208.                         unsigned sR;
  1209.                         unsigned sG;
  1210.                         unsigned sB;
  1211.                         DISEMBLE_RGB(src, srcbpp, srcfmt, pixel, sR, sG, sB);
  1212.                         ASSEMBLE_RGBA(dst, dstbpp, dstfmt, sR, sG, sB, alpha);
  1213.                         dst += dstbpp;
  1214.                         src += srcbpp;
  1215.                 },
  1216.                 width);
  1217.                 src += srcskip;
  1218.                 dst += dstskip;
  1219.         }
  1220. }
  1221.  
  1222. static void BlitNtoNCopyAlpha(SDL_BlitInfo *info)
  1223. {
  1224.         int width = info->d_width;
  1225.         int height = info->d_height;
  1226.         Uint8 *src = info->s_pixels;
  1227.         int srcskip = info->s_skip;
  1228.         Uint8 *dst = info->d_pixels;
  1229.         int dstskip = info->d_skip;
  1230.         SDL_PixelFormat *srcfmt = info->src;
  1231.         int srcbpp = srcfmt->BytesPerPixel;
  1232.         SDL_PixelFormat *dstfmt = info->dst;
  1233.         int dstbpp = dstfmt->BytesPerPixel;
  1234.         int c;
  1235.  
  1236.         /* FIXME: should map alpha to [0..255] correctly! */
  1237.         while ( height-- ) {
  1238.                 for ( c=width; c; --c ) {
  1239.                         Uint32 pixel;
  1240.                         unsigned sR, sG, sB, sA;
  1241.                         DISEMBLE_RGBA(src, srcbpp, srcfmt, pixel,
  1242.                                       sR, sG, sB, sA);
  1243.                         ASSEMBLE_RGBA(dst, dstbpp, dstfmt,
  1244.                                       sR, sG, sB, sA);
  1245.                         dst += dstbpp;
  1246.                         src += srcbpp;
  1247.                 }
  1248.                 src += srcskip;
  1249.                 dst += dstskip;
  1250.         }
  1251. }
  1252.  
  1253. static void BlitNto1Key(SDL_BlitInfo *info)
  1254. {
  1255.         int width = info->d_width;
  1256.         int height = info->d_height;
  1257.         Uint8 *src = info->s_pixels;
  1258.         int srcskip = info->s_skip;
  1259.         Uint8 *dst = info->d_pixels;
  1260.         int dstskip = info->d_skip;
  1261.         SDL_PixelFormat *srcfmt = info->src;
  1262.         const Uint8 *palmap = info->table;
  1263.         Uint32 ckey = srcfmt->colorkey;
  1264.         Uint32 rgbmask = ~srcfmt->Amask;
  1265.         int srcbpp;
  1266.         Uint32 pixel;
  1267.         Uint8  sR, sG, sB;
  1268.  
  1269.         /* Set up some basic variables */
  1270.         srcbpp = srcfmt->BytesPerPixel;
  1271.         ckey &= rgbmask;
  1272.  
  1273.         if ( palmap == NULL ) {
  1274.                 while ( height-- ) {
  1275.                         DUFFS_LOOP(
  1276.                         {
  1277.                                 DISEMBLE_RGB(src, srcbpp, srcfmt, pixel,
  1278.                                                                 sR, sG, sB);
  1279.                                 if ( (pixel & rgbmask) != ckey ) {
  1280.                                         /* Pack RGB into 8bit pixel */
  1281.                                         *dst = ((sR>>5)<<(3+2))|
  1282.                                                 ((sG>>5)<<(2)) |
  1283.                                                 ((sB>>6)<<(0)) ;
  1284.                                 }
  1285.                                 dst++;
  1286.                                 src += srcbpp;
  1287.                         },
  1288.                         width);
  1289.                         src += srcskip;
  1290.                         dst += dstskip;
  1291.                 }
  1292.         } else {
  1293.                 while ( height-- ) {
  1294.                         DUFFS_LOOP(
  1295.                         {
  1296.                                 DISEMBLE_RGB(src, srcbpp, srcfmt, pixel,
  1297.                                                                 sR, sG, sB);
  1298.                                 if ( (pixel & rgbmask) != ckey ) {
  1299.                                         /* Pack RGB into 8bit pixel */
  1300.                                         *dst = palmap[((sR>>5)<<(3+2))|
  1301.                                                         ((sG>>5)<<(2))  |
  1302.                                                         ((sB>>6)<<(0))  ];
  1303.                                 }
  1304.                                 dst++;
  1305.                                 src += srcbpp;
  1306.                         },
  1307.                         width);
  1308.                         src += srcskip;
  1309.                         dst += dstskip;
  1310.                 }
  1311.         }
  1312. }
  1313.  
  1314. static void Blit2to2Key(SDL_BlitInfo *info)
  1315. {
  1316.         int width = info->d_width;
  1317.         int height = info->d_height;
  1318.         Uint16 *srcp = (Uint16 *)info->s_pixels;
  1319.         int srcskip = info->s_skip;
  1320.         Uint16 *dstp = (Uint16 *)info->d_pixels;
  1321.         int dstskip = info->d_skip;
  1322.         Uint32 ckey = info->src->colorkey;
  1323.         Uint32 rgbmask = ~info->src->Amask;
  1324.  
  1325.         /* Set up some basic variables */
  1326.         srcskip /= 2;
  1327.         dstskip /= 2;
  1328.         ckey &= rgbmask;
  1329.  
  1330.         while ( height-- ) {
  1331.                 DUFFS_LOOP(
  1332.                 {
  1333.                         if ( (*srcp & rgbmask) != ckey ) {
  1334.                                 *dstp = *srcp;
  1335.                         }
  1336.                         dstp++;
  1337.                         srcp++;
  1338.                 },
  1339.                 width);
  1340.                 srcp += srcskip;
  1341.                 dstp += dstskip;
  1342.         }
  1343. }
  1344.  
  1345. static void BlitNtoNKey(SDL_BlitInfo *info)
  1346. {
  1347.         int width = info->d_width;
  1348.         int height = info->d_height;
  1349.         Uint8 *src = info->s_pixels;
  1350.         int srcskip = info->s_skip;
  1351.         Uint8 *dst = info->d_pixels;
  1352.         int dstskip = info->d_skip;
  1353.         Uint32 ckey = info->src->colorkey;
  1354.         SDL_PixelFormat *srcfmt = info->src;
  1355.         SDL_PixelFormat *dstfmt = info->dst;
  1356.         int srcbpp = srcfmt->BytesPerPixel;
  1357.         int dstbpp = dstfmt->BytesPerPixel;
  1358.         unsigned alpha = dstfmt->Amask ? SDL_ALPHA_OPAQUE : 0;
  1359.  
  1360.         while ( height-- ) {
  1361.                 DUFFS_LOOP(
  1362.                 {
  1363.                         Uint32 pixel;
  1364.                         unsigned sR;
  1365.                         unsigned sG;
  1366.                         unsigned sB;
  1367.                         RETRIEVE_RGB_PIXEL(src, srcbpp, pixel);
  1368.                         if ( pixel != ckey ) {
  1369.                                 RGB_FROM_PIXEL(pixel, srcfmt, sR, sG, sB);
  1370.                                 ASSEMBLE_RGBA(dst, dstbpp, dstfmt,
  1371.                                               sR, sG, sB, alpha);
  1372.                         }
  1373.                         dst += dstbpp;
  1374.                         src += srcbpp;
  1375.                 },
  1376.                 width);
  1377.                 src += srcskip;
  1378.                 dst += dstskip;
  1379.         }
  1380. }
  1381.  
  1382. static void BlitNtoNKeyCopyAlpha(SDL_BlitInfo *info)
  1383. {
  1384.         int width = info->d_width;
  1385.         int height = info->d_height;
  1386.         Uint8 *src = info->s_pixels;
  1387.         int srcskip = info->s_skip;
  1388.         Uint8 *dst = info->d_pixels;
  1389.         int dstskip = info->d_skip;
  1390.         Uint32 ckey = info->src->colorkey;
  1391.         SDL_PixelFormat *srcfmt = info->src;
  1392.         SDL_PixelFormat *dstfmt = info->dst;
  1393.         Uint32 rgbmask = ~srcfmt->Amask;
  1394.  
  1395.         Uint8 srcbpp;
  1396.         Uint8 dstbpp;
  1397.         Uint32 pixel;
  1398.         Uint8  sR, sG, sB, sA;
  1399.  
  1400.         /* Set up some basic variables */
  1401.         srcbpp = srcfmt->BytesPerPixel;
  1402.         dstbpp = dstfmt->BytesPerPixel;
  1403.         ckey &= rgbmask;
  1404.  
  1405.         /* FIXME: should map alpha to [0..255] correctly! */
  1406.         while ( height-- ) {
  1407.                 DUFFS_LOOP(
  1408.                 {
  1409.                         DISEMBLE_RGBA(src, srcbpp, srcfmt, pixel,
  1410.                                       sR, sG, sB, sA);
  1411.                         if ( (pixel & rgbmask) != ckey ) {
  1412.                                   ASSEMBLE_RGBA(dst, dstbpp, dstfmt,
  1413.                                                 sR, sG, sB, sA);
  1414.                         }
  1415.                         dst += dstbpp;
  1416.                         src += srcbpp;
  1417.                 },
  1418.                 width);
  1419.                 src += srcskip;
  1420.                 dst += dstskip;
  1421.         }
  1422. }
  1423.  
  1424. /* Normal N to N optimized blitters */
  1425. struct blit_table {
  1426.         Uint32 srcR, srcG, srcB;
  1427.         int dstbpp;
  1428.         Uint32 dstR, dstG, dstB;
  1429.         Uint32 cpu_flags;
  1430.         void *aux_data;
  1431.         SDL_loblit blitfunc;
  1432.         enum { NO_ALPHA, SET_ALPHA, COPY_ALPHA } alpha;
  1433. };
  1434. static const struct blit_table normal_blit_1[] = {
  1435.         /* Default for 8-bit RGB source, an invalid combination */
  1436.         { 0,0,0, 0, 0,0,0, 0, NULL, NULL },
  1437. };
  1438. static const struct blit_table normal_blit_2[] = {
  1439. #ifdef USE_ASMBLIT
  1440.     { 0x0000F800,0x000007E0,0x0000001F, 2, 0x0000001F,0x000007E0,0x0000F800,
  1441.       0, ConvertX86p16_16BGR565, ConvertX86, NO_ALPHA },
  1442.     { 0x0000F800,0x000007E0,0x0000001F, 2, 0x00007C00,0x000003E0,0x0000001F,
  1443.       0, ConvertX86p16_16RGB555, ConvertX86, NO_ALPHA },
  1444.     { 0x0000F800,0x000007E0,0x0000001F, 2, 0x0000001F,0x000003E0,0x00007C00,
  1445.       0, ConvertX86p16_16BGR555, ConvertX86, NO_ALPHA },
  1446. #endif
  1447.     { 0x0000F800,0x000007E0,0x0000001F, 4, 0x00FF0000,0x0000FF00,0x000000FF,
  1448.       0, NULL, Blit_RGB565_ARGB8888, SET_ALPHA },
  1449.     { 0x0000F800,0x000007E0,0x0000001F, 4, 0x000000FF,0x0000FF00,0x00FF0000,
  1450.       0, NULL, Blit_RGB565_ABGR8888, SET_ALPHA },
  1451.     { 0x0000F800,0x000007E0,0x0000001F, 4, 0xFF000000,0x00FF0000,0x0000FF00,
  1452.       0, NULL, Blit_RGB565_RGBA8888, SET_ALPHA },
  1453.     { 0x0000F800,0x000007E0,0x0000001F, 4, 0x0000FF00,0x00FF0000,0xFF000000,
  1454.       0, NULL, Blit_RGB565_BGRA8888, SET_ALPHA },
  1455.  
  1456.     /* Default for 16-bit RGB source, used if no other blitter matches */
  1457.     { 0,0,0, 0, 0,0,0, 0, NULL, BlitNtoN, 0 }
  1458. };
  1459. static const struct blit_table normal_blit_3[] = {
  1460.         /* Default for 24-bit RGB source, never optimized */
  1461.     { 0,0,0, 0, 0,0,0, 0, NULL, BlitNtoN, 0 }
  1462. };
  1463. static const struct blit_table normal_blit_4[] = {
  1464. #ifdef USE_ASMBLIT
  1465.     { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000F800,0x000007E0,0x0000001F,
  1466.       MMX_CPU, ConvertMMXpII32_16RGB565, ConvertMMX, NO_ALPHA },
  1467.     { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000F800,0x000007E0,0x0000001F,
  1468.       0, ConvertX86p32_16RGB565, ConvertX86, NO_ALPHA },
  1469.     { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000001F,0x000007E0,0x0000F800,
  1470.       MMX_CPU, ConvertMMXpII32_16BGR565, ConvertMMX, NO_ALPHA },
  1471.     { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000001F,0x000007E0,0x0000F800,
  1472.       0, ConvertX86p32_16BGR565, ConvertX86, NO_ALPHA },
  1473.     { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x00007C00,0x000003E0,0x0000001F,
  1474.       MMX_CPU, ConvertMMXpII32_16RGB555, ConvertMMX, NO_ALPHA },
  1475.     { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x00007C00,0x000003E0,0x0000001F,
  1476.       0, ConvertX86p32_16RGB555, ConvertX86, NO_ALPHA },
  1477.     { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000001F,0x000003E0,0x00007C00,
  1478.       MMX_CPU, ConvertMMXpII32_16BGR555, ConvertMMX, NO_ALPHA },
  1479.     { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000001F,0x000003E0,0x00007C00,
  1480.       0, ConvertX86p32_16BGR555, ConvertX86, NO_ALPHA },
  1481.     { 0x00FF0000,0x0000FF00,0x000000FF, 3, 0x00FF0000,0x0000FF00,0x000000FF,
  1482.       0, ConvertX86p32_24RGB888, ConvertX86, NO_ALPHA },
  1483.     { 0x00FF0000,0x0000FF00,0x000000FF, 3, 0x000000FF,0x0000FF00,0x00FF0000,
  1484.       0, ConvertX86p32_24BGR888, ConvertX86, NO_ALPHA },
  1485.     { 0x00FF0000,0x0000FF00,0x000000FF, 4, 0x000000FF,0x0000FF00,0x00FF0000,
  1486.       0, ConvertX86p32_32BGR888, ConvertX86, NO_ALPHA },
  1487.     { 0x00FF0000,0x0000FF00,0x000000FF, 4, 0xFF000000,0x00FF0000,0x0000FF00,
  1488.       0, ConvertX86p32_32RGBA888, ConvertX86, NO_ALPHA },
  1489.     { 0x00FF0000,0x0000FF00,0x000000FF, 4, 0x0000FF00,0x00FF0000,0xFF000000,
  1490.       0, ConvertX86p32_32BGRA888, ConvertX86, NO_ALPHA },
  1491. #else
  1492.     { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000F800,0x000007E0,0x0000001F,
  1493.       0, NULL, Blit_RGB888_RGB565, NO_ALPHA },
  1494.     { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x00007C00,0x000003E0,0x0000001F,
  1495.       0, NULL, Blit_RGB888_RGB555, NO_ALPHA },
  1496. #endif
  1497.         /* Default for 32-bit RGB source, used if no other blitter matches */
  1498.         { 0,0,0, 0, 0,0,0, 0, NULL, BlitNtoN, 0 }
  1499. };
  1500. static const struct blit_table *normal_blit[] = {
  1501.         normal_blit_1, normal_blit_2, normal_blit_3, normal_blit_4
  1502. };
  1503.  
  1504. SDL_loblit SDL_CalculateBlitN(SDL_Surface *surface, int blit_index)
  1505. {
  1506.         struct private_swaccel *sdata;
  1507.         SDL_PixelFormat *srcfmt;
  1508.         SDL_PixelFormat *dstfmt;
  1509.         const struct blit_table *table;
  1510.         int which;
  1511.         SDL_loblit blitfun;
  1512.  
  1513.         /* Set up data for choosing the blit */
  1514.         sdata = surface->map->sw_data;
  1515.         srcfmt = surface->format;
  1516.         dstfmt = surface->map->dst->format;
  1517.  
  1518.         if ( blit_index & 2 ) {
  1519.                 /* alpha or alpha+colorkey */
  1520.                 return SDL_CalculateAlphaBlit(surface, blit_index);
  1521.         }
  1522.  
  1523.         /* We don't support destinations less than 8-bits */
  1524.         if ( dstfmt->BitsPerPixel < 8 ) {
  1525.                 return(NULL);
  1526.         }
  1527.        
  1528.         if(blit_index == 1) {
  1529.             /* colorkey blit: Here we don't have too many options, mostly
  1530.                because RLE is the preferred fast way to deal with this.
  1531.                If a particular case turns out to be useful we'll add it. */
  1532.  
  1533.             if(srcfmt->BytesPerPixel == 2
  1534.                && surface->map->identity)
  1535.                 return Blit2to2Key;
  1536.             else if(dstfmt->BytesPerPixel == 1)
  1537.                 return BlitNto1Key;
  1538.             else {
  1539.                 if(srcfmt->Amask && dstfmt->Amask)
  1540.                     return BlitNtoNKeyCopyAlpha;
  1541.                 else
  1542.                     return BlitNtoNKey;
  1543.             }
  1544.         }
  1545.  
  1546.         blitfun = NULL;
  1547.         if ( dstfmt->BitsPerPixel == 8 ) {
  1548.                 /* We assume 8-bit destinations are palettized */
  1549.                 if ( (srcfmt->BytesPerPixel == 4) &&
  1550.                      (srcfmt->Rmask == 0x00FF0000) &&
  1551.                      (srcfmt->Gmask == 0x0000FF00) &&
  1552.                      (srcfmt->Bmask == 0x000000FF) ) {
  1553.                         if ( surface->map->table ) {
  1554.                                 blitfun = Blit_RGB888_index8_map;
  1555.                         } else {
  1556. #ifdef USE_ASMBLIT
  1557.                                 sdata->aux_data = ConvertX86p32_8RGB332;
  1558.                                 blitfun = ConvertX86;
  1559. #else
  1560.                                 blitfun = Blit_RGB888_index8;
  1561. #endif
  1562.                         }
  1563.                 } else {
  1564.                         blitfun = BlitNto1;
  1565.                 }
  1566.         } else {
  1567.                 /* Now the meat, choose the blitter we want */
  1568.                 int a_need = 0;
  1569.                 if(dstfmt->Amask)
  1570.                     a_need = srcfmt->Amask ? COPY_ALPHA : SET_ALPHA;
  1571.                 table = normal_blit[srcfmt->BytesPerPixel-1];
  1572.                 for ( which=0; table[which].srcR; ++which ) {
  1573.                         if ( srcfmt->Rmask == table[which].srcR &&
  1574.                              srcfmt->Gmask == table[which].srcG &&
  1575.                              srcfmt->Bmask == table[which].srcB &&
  1576.                              dstfmt->BytesPerPixel == table[which].dstbpp &&
  1577.                              dstfmt->Rmask == table[which].dstR &&
  1578.                              dstfmt->Gmask == table[which].dstG &&
  1579.                              dstfmt->Bmask == table[which].dstB &&
  1580.                              (a_need & table[which].alpha) == a_need &&
  1581.                              (CPU_Flags()&table[which].cpu_flags) ==
  1582.                              table[which].cpu_flags )
  1583.                                 break;
  1584.                 }
  1585.                 sdata->aux_data = table[which].aux_data;
  1586.                 blitfun = table[which].blitfunc;
  1587.                 if(a_need == COPY_ALPHA && blitfun == BlitNtoN)
  1588.                     blitfun = BlitNtoNCopyAlpha;
  1589.         }
  1590.  
  1591. #ifdef DEBUG_ASM
  1592. #ifdef USE_ASMBLIT
  1593.         if ( blitfun == ConvertMMX )
  1594.                 SDL_printf("Using mmx blit\n");
  1595.         else
  1596.         if ( blitfun == ConvertX86 )
  1597.                 SDL_printf("Using asm blit\n");
  1598.         else
  1599. #endif
  1600.         if ( (blitfun == SDL_BlitNtoN) || (blitfun == SDL_BlitNto1) )
  1601.                 fprintf(stderr, "Using C blit\n");
  1602.         else
  1603.                 fprintf(stderr, "Using optimized C blit\n");
  1604. #endif /* DEBUG_ASM */
  1605.  
  1606.         return(blitfun);
  1607. }
  1608.