开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
rgb2rgb.c
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：97k
源码类别：

Symbian

开发平台：

C/C++

rgb2rgb.c：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. #ifdef _MACINTOSH
  37. #pragma require_prototypes off
  38. #endif
  40. /*** #includes: ********************************************/
  42. #include "env.h"
  43. #include "rgb.h"    /* basic RGB-data definitions & macros */
  44. #include "scale.h"  /* scale algorithms */
  45. #include "colorlib.h" /* ensure that prototypes get extern C'ed */
  46. /*** Additional pixel-level macros: ************************/
  48. /*
  49.  * Generic pixel load-convert-store macro:
  50.  */
  51. #define LOAD_CONVERT_STORE(df,d,sf,s)       
  52.     {                                       
  53.         PIXEL(df,da);                       
  54.         LOAD_CONVERT(df,da,sf,s);           
  55.         s+=BPP(sf);                         
  56.         STORE(df,d,da);                     
  57.         d+=BPP(df);                         
  58.     }
  60. /*
  61.  * Generic 4-pixels load-convert-store macro
  62.  * (XXX: this is just a lazy implementation of
  63.  *  4-times unrolled load-convert-store;
  64.  *  later, we should rewrite it for better
  65.  *  efficiency !!!)
  66.  */
  67. #define LOAD_CONVERT_STORE_4(df,d,sf,s)     
  68.     {                                       
  69.         PIXEL(df,da);                       
  70.         LOAD_CONVERT(df,da,sf,s);           
  71.         STORE(df,d,da);                     
  72.         LOAD_CONVERT(df,da,sf,s+BPP(sf));   
  73.         STORE(df,d+BPP(df),da);             
  74.         LOAD_CONVERT(df,da,sf,s+2*BPP(sf)); 
  75.         STORE(df,d+2*BPP(df),da);           
  76.         LOAD_CONVERT(df,da,sf,s+3*BPP(sf)); 
  77.         STORE(df,d+3*BPP(df),da);           
  78.         s+=4*BPP(sf);                       
  79.         d+=4*BPP(df);                       
  80.     }
  82. /*
  83.  * Generic pixel load-convert-average-store macro:
  84.  * ([d2] = convert([s]); [d12] = ([d1]+[d2])/2)
  85.  */
  86. #define LOAD_CONVERT_AVERAGE_STORE(df,d1,d12,d2,sf,s) 
  87.     {                                       
  88.         PIXEL(df,da);                       
  89.         LOAD_CONVERT(df,da,sf,s);           
  90.         s+=BPP(sf);                         
  91.         STORE(df,d2,da);                    
  92.         d2+=BPP(df);                        
  93.         LOAD_AVERAGE(df,da,da,d1);          
  94.         d1+=BPP(df);                        
  95.         STORE(df,d12,da);                   
  96.         d12+=BPP(df);                       
  97.     }
  99. /*
  100.  * Generic 4-pixels load-convert-average-store macro:
  101.  * (again, very lazy implementation; ultimately it should
  102.  *  be rewritten for all possible combinations of pixel formats !!)
  103.  */
  104. #define LOAD_CONVERT_AVERAGE_STORE_4(df,d1,d12,d2,sf,s) 
  105.     {                                       
  106.         PIXEL(df,da);                       
  107.         /* first column: */                 
  108.         LOAD_CONVERT(df,da,sf,s);           
  109.         STORE(df,d2,da);                    
  110.         LOAD_AVERAGE(df,da,da,d1);          
  111.         STORE(df,d12,da);                   
  112.         /* second column: */                
  113.         LOAD_CONVERT(df,da,sf,s+BPP(sf));   
  114.         STORE(df,d2+BPP(df),da);            
  115.         LOAD_AVERAGE(df,da,da,d1+BPP(df));  
  116.         STORE(df,d12+BPP(df),da);           
  117.         /* third column: */                 
  118.         LOAD_CONVERT(df,da,sf,s+2*BPP(sf)); 
  119.         STORE(df,d2+2*BPP(df),da);          
  120.         LOAD_AVERAGE(df,da,da,d1+2*BPP(df));
  121.         STORE(df,d12+2*BPP(df),da);         
  122.         /* fourth column: */                
  123.         LOAD_CONVERT(df,da,sf,s+3*BPP(sf)); 
  124.         STORE(df,d2+3*BPP(df),da);          
  125.         LOAD_AVERAGE(df,da,da,d1+3*BPP(df));
  126.         STORE(df,d12+3*BPP(df),da);         
  127.         /* update pointers: */              
  128.         s +=4*BPP(sf);                      
  129.         d1+=4*BPP(df);                      
  130.         d2+=4*BPP(df);                      
  131.         d12+=4*BPP(df);                     
  132.     }
  135. /*** Generic RGB single-row converters: ********************/
  137. /*
  138.  * Generic row shrinking converter:
  139.  */
  140. #define ROW_SHRINK(df,dest_ptr,dest_dx,sf,src_ptr,src_dx)   
  141.     {                                                       
  142.         /* initialize local variables: */                   
  143.         register unsigned char *d = dest_ptr;               
  144.         register unsigned char *s = src_ptr;                
  145.         register int count = dest_dx;                       
  146.         register int limit = src_dx >> 1; /* -1 */          
  147.         register int step = dest_dx;                        
  148.         /* check row length: */                             
  149.         if (count) {                                        
  150.             do {                                            
  151.                 /* convert and copy a nearest pixel: */     
  152.                 PIXEL(df,da);                               
  153.                 LOAD_CONVERT(df,da,sf,s);                   
  154.                 STORE(df,d,da);                             
  155.                 d+=BPP(df);                                 
  156.                 /* inverted Bresenham stepping: */          
  157.                 do {                                        
  158.                     /* skip source pixel: */                
  159.                     s+=BPP(sf);                             
  160.                 } while ((limit -= step) >= 0);             
  161.                 limit += src_dx;                            
  162.             } while (--count);                              
  163.         }                                                   
  164.     }
  166. /*
  167.  * Generic row copy converter:
  168.  */
  169. #define ROW_COPY(df,dest_ptr,dest_dx,sf,src_ptr,src_dx)     
  170.     {                                                       
  171.         /* do we have the same format? */                   
  172.         if (ID(df) == ID(sf)) {                             
  173.             /* just use memcopy: */                         
  174.             memcpy(dest_ptr, src_ptr, dest_dx*BPP(df)); /* Flawfinder: ignore */    
  175.         } else {                                            
  176.             /* initialize local variables: */               
  177.             register unsigned char *d = dest_ptr;           
  178.             register unsigned char *s = src_ptr;            
  179.             register int count = dest_dx;                   
  180.             /* convert misaligned pixels first: */          
  181.             while (((unsigned int)d & 3)                    
  182.                 && ((unsigned int)s & 3) && count) {        
  183.                 LOAD_CONVERT_STORE(df,d,sf,s);              
  184.                 count --;                                   
  185.             }                                               
  186.             /* the main loop (convert 4 pixels a time): */  
  187.             while (count >= 4) {                            
  188.                 LOAD_CONVERT_STORE_4(df,d,sf,s);            
  189.                 count -= 4;                                 
  190.             }                                               
  191.             /* convert the remaining pixels: */             
  192.             while (count) {                                 
  193.                 LOAD_CONVERT_STORE(df,d,sf,s);              
  194.                 count --;                                   
  195.             }                                               
  196.         }                                                   
  197.     }
  199. /*
  200.  * Generic row stretching converter:
  201.  *  (shall not be used when dest_dx/2 >= src_dx!!!)
  202.  */
  203. #define ROW_STRETCH(df,dest_ptr,dest_dx,sf,src_ptr,src_dx)  
  204.     {                                                       
  205.         /* initialize local variables: */                   
  206.         register unsigned char *d = dest_ptr;               
  207.         register unsigned char *s = src_ptr;                
  208.         register int count = dest_dx;                       
  209.         register int limit = dest_dx >> 1; /* !!! */        
  210.         register int step = src_dx;                         
  211.         /* check row length: */                             
  212.         if (count) {                                        
  213.             goto start;                                     
  214.             /* the main loop: */                            
  215.             do {                                            
  216.                 PIXEL(df,da);                               
  217.                 /* Bresenham stepping: */                   
  218.                 if ((limit -= step) < 0) {                  
  219.                     limit += dest_dx;                       
  220.                     /* load & convert pixel: */             
  221.     start:          LOAD_CONVERT(df,da,sf,s);               
  222.                     s+=BPP(sf);                             
  223.                 }                                           
  224.                 /* replicate pixel: */                      
  225.                 STORE(df,d,da);                             
  226.                 d+=BPP(df);                                 
  227.             } while (--count);                              
  228.         }                                                   
  229.     }
  231. /*
  232.  * Generic row 2x-stretching converter:
  233.  */
  234. #define ROW_STRETCH2X(df,dest_ptr,dest_dx,sf,src_ptr,src_dx) 
  235.     {                                                       
  236.         /* initialize local variables: */                   
  237.         register unsigned char *d = dest_ptr;               
  238.         register unsigned char *s = src_ptr;                
  239.         register int count = src_dx;                        
  240.         /* check row length: */                             
  241.         if (count) {                                        
  242.             /* process first integral pixel: */             
  243.             PIXEL(df,da);                                   
  244.             LOAD_CONVERT(df,da,sf,s);                       
  245.             s+=BPP(sf);                                     
  246.             count --;                                       
  247.             STORE(df,d,da);                                 
  248.             d+=BPP(df);                                     
  249.             /* main loop (process 2 pixels a time): */      
  250.             while (count >= 2) {                            
  251.                 /* load & convert second integral pixel: */ 
  252.                 PIXEL(df,db);                               
  253.                 LOAD_CONVERT(df,db,sf,s);                   
  254.                 /* calculate first half-pixel: */           
  255.                 AVERAGE(df,da,da,db);                       
  256.                 /* store both pixels: */                    
  257.                 STORE(df,d,da);                             
  258.                 STORE(df,d+BPP(df),db);                     
  259.                 /* load & convert third integral pixel: */  
  260.                 LOAD_CONVERT(df,da,sf,s+BPP(sf));           
  261.                 /* calculate second half-pixel: */          
  262.                 AVERAGE(df,db,db,da);                       
  263.                 /* store both pixels: */                    
  264.                 STORE(df,d+2*BPP(df),db);                   
  265.                 STORE(df,d+3*BPP(df),da);                   
  266.                 /* shift pointers: */                       
  267.                 s+=2*BPP(sf);                               
  268.                 d+=4*BPP(df);                               
  269.                 count -= 2;                                 
  270.             }                                               
  271.             /* is there any more pixels to convert? */      
  272.             if (count) {                                    
  273.                 /* load & convert last integral pixel: */   
  274.                 PIXEL(df,db);                               
  275.                 LOAD_CONVERT(df,db,sf,s);                   
  276.                 /* calculate last half-pixel: */            
  277.                 AVERAGE(df,da,da,db);                       
  278.                 /* store pixels: */                         
  279.                 STORE(df,d,da);                             
  280.                 STORE(df,d+BPP(df),db);                     
  281.                 STORE(df,d+2*BPP(df),db);                   
  282.             } else {                                        
  283.                 /* replicate last pixel: */                 
  284.                 STORE(df,d,da);                             
  285.             }                                               
  286.         }                                                   
  287.     }
  289. /*
  290.  * Generic row 2x+ stretching converter:
  291.  */
  292. #define ROW_STRETCH2XPLUS(df,dest_ptr,dest_dx,sf,src_ptr,src_dx) 
  293.     {                                                       
  294.         /* initialize local variables: */                   
  295.         register unsigned char *d = dest_ptr;               
  296.         register unsigned char *s = src_ptr;                
  297.         register int count = dest_dx;                       
  298.         register int limit = dest_dx >> 1; /* !!! */        
  299.         register int step = src_dx << 1;  /* !!! */         
  300.         /* # of pixels mapped outside source image: */      
  301.         register int remainder = (2*dest_dx - limit) / step;
  302.         /* check row length: */                             
  303.         if (count) {                                        
  304.             /* load & convert first pixel: */               
  305.             PIXEL(df,da); PIXEL(df,db);                     
  306.             LOAD_CONVERT(df,da,sf,s);                       
  307.             s+=BPP(sf);                                     
  308.             /* update counter: */                           
  309.             if (!(count -= remainder))                      
  310.                 goto end_of_row;                            
  311.             /* main loop: */                                
  312.             while (1) {                                     
  313.                 /* replicate first integral pixel: */       
  314.                 do {                                        
  315.                     STORE(df,d,da);                         
  316.                     d+=BPP(df);                             
  317.                     if (!(--count))                         
  318.                         goto end_of_row;                    
  319.                 } while ((limit -= step) >= 0);             
  320.                 limit += dest_dx;                           
  321.                 /* load & convert second pixel: */          
  322.                 LOAD_CONVERT(df,db,sf,s);                   
  323.                 /* calc & replicate first half-pixel: */    
  324.                 AVERAGE(df,da,da,db);                       
  325.                 do {                                        
  326.                     STORE(df,d,da);                         
  327.                     d+=BPP(df);                             
  328.                     if (!(--count))                         
  329.                         goto end_of_row;                    
  330.                 } while ((limit -= step) >= 0);             
  331.                 limit += dest_dx;                           
  332.                 /* replicate second integral pixel: */      
  333.                 do {                                        
  334.                     STORE(df,d,db);                         
  335.                     d+=BPP(df);                             
  336.                     if (!(--count))                         
  337.                         goto end_of_row_2;                  
  338.                 } while ((limit -= step) >= 0);             
  339.                 limit += dest_dx;                           
  340.                 /* load & convert third pixel: */           
  341.                 LOAD_CONVERT(df,da,sf,s+BPP(sf));           
  342.                 s+=2*BPP(sf);                               
  343.                 /* calc & replicate second half-pixel: */   
  344.                 AVERAGE(df,db,db,da);                       
  345.                 do {                                        
  346.                     STORE(df,d,db);                         
  347.                     d+=BPP(df);                             
  348.                     if (!(--count))                         
  349.                         goto end_of_row_2;                  
  350.                 } while ((limit -= step) >= 0);             
  351.                 limit += dest_dx;                           
  352.             }                                               
  353.             /* replicate the remaining pixels: */           
  354. end_of_row_2: COPY(df,da,db);                               
  355. end_of_row: while (remainder--) {                           
  356.                 STORE(df,d,da);                             
  357.                 d+=BPP(df);                                 
  358.             }                                               
  359.         }                                                   
  360.     }
  362. /*** Generic RGB 1.5-row converters: ***********************/
  364. /*
  365.  * Generic 1.5-row shrinking converter:
  366.  *  dest_ptr_1  - a previously converted row in destination image
  367.  *  dest_ptr_12 - an area to store half-pixel average row
  368.  *  dest_ptr_2  - an area to store next converted row from source image
  369.  */
  370. #define ROW2X_SHRINK(df,dest_ptr_1,dest_ptr_12,dest_ptr_2,dest_dx,sf,src_ptr,src_dx)   
  371.     {                                                       
  372.         /* initialize local variables: */                   
  373.         register unsigned char *d1 = dest_ptr_1;            
  374.         register unsigned char *d12 = dest_ptr_12;          
  375.         register unsigned char *d2 = dest_ptr_2;            
  376.         register unsigned char *s = src_ptr;                
  377.         register int count = dest_dx;                       
  378.         register int limit = src_dx >> 1; /* -1 */          
  379.         register int step = dest_dx;                        
  380.         /* check row length: */                             
  381.         if (count) {                                        
  382.             do {                                            
  383.                 /* load & convert pixel from second row: */ 
  384.                 PIXEL(df,da);                               
  385.                 LOAD_CONVERT(df,da,sf,s);                   
  386.                 STORE(df,d2,da);                            
  387.                 d2+=BPP(df);                                
  388.                 /* average it with pixel from first row: */ 
  389.                 LOAD_AVERAGE(df,da,da,d1);                  
  390.                 d1+=BPP(df);                                
  391.                 STORE(df,d12,da);                           
  392.                 d12+=BPP(df);                               
  393.                 /* inverted Bresenham stepping: */          
  394.                 do {                                        
  395.                     /* skip source pixel: */                
  396.                     s+=BPP(sf);                             
  397.                 } while ((limit -= step) >= 0);             
  398.                 limit += src_dx;                            
  399.             } while (--count);                              
  400.         }                                                   
  401.     }
  403. /*
  404.  * Generic 1.5-row copy converter:
  405.  */
  406. #define ROW2X_COPY(df,dest_ptr_1,dest_ptr_12,dest_ptr_2,dest_dx,sf,src_ptr,src_dx)     
  407.     {                                                       
  408.         /* initialize local variables: */                   
  409.         register unsigned char *d1 = dest_ptr_1;            
  410.         register unsigned char *d12 = dest_ptr_12;          
  411.         register unsigned char *d2 = dest_ptr_2;            
  412.         register unsigned char *s = src_ptr;                
  413.         register int count = dest_dx;                       
  414.         /* convert misaligned pixels first: */              
  415.         while (((unsigned int)d2 & 3)                       
  416.             && ((unsigned int)s & 3) && count) {            
  417.             LOAD_CONVERT_AVERAGE_STORE(df,d1,d12,d2,sf,s);  
  418.             count --;                                       
  419.         }                                                   
  420.         /* the main loop (convert 4 pixels a time): */      
  421.         while (count >= 4) {                                
  422.             LOAD_CONVERT_AVERAGE_STORE_4(df,d1,d12,d2,sf,s);
  423.             count -= 4;                                     
  424.         }                                                   
  425.         /* convert the remaining pixels: */                 
  426.         while (count) {                                     
  427.             LOAD_CONVERT_AVERAGE_STORE(df,d1,d12,d2,sf,s);  
  428.             count --;                                       
  429.         }                                                   
  430.     }
  432. /*
  433.  * Generic 1.5-row stretching converter:
  434.  *  (shall not be used when dest_dx/2 >= src_dx!!!)
  435.  */
  436. #define ROW2X_STRETCH(df,dest_ptr_1,dest_ptr_12,dest_ptr_2,dest_dx,sf,src_ptr,src_dx)  
  437.     {                                                       
  438.         /* initialize local variables: */                   
  439.         register unsigned char *d1 = dest_ptr_1;            
  440.         register unsigned char *d12 = dest_ptr_12;          
  441.         register unsigned char *d2 = dest_ptr_2;            
  442.         register unsigned char *s = src_ptr;                
  443.         register int count = dest_dx;                       
  444.         register int limit = dest_dx >> 1; /* !!! */        
  445.         register int step = src_dx;                         
  446.         /* check row length: */                             
  447.         if (count) {                                        
  448.             goto start;                                     
  449.             /* the main loop: */                            
  450.             do {                                            
  451.                 PIXEL(df,da); PIXEL(df,dc);                 
  452.                 /* Bresenham stepping: */                   
  453.                 if ((limit -= step) < 0) {                  
  454.                     limit += dest_dx;                       
  455.                     /* load & convert pixel: */             
  456.     start:          LOAD_CONVERT(df,da,sf,s);               
  457.                     s+=BPP(sf);                             
  458.                     /* calculate a half-pixel above: */     
  459.                     LOAD_AVERAGE(df,dc,da,d1);              
  460.                 }                                           
  461.                 /* replicate pixels: */                     
  462.                 d1+=BPP(df);                                
  463.                 STORE(df,d2,da);                            
  464.                 d2+=BPP(df);                                
  465.                 STORE(df,d12,dc);                           
  466.                 d12+=BPP(df);                               
  467.             } while (--count);                              
  468.         }                                                   
  469.     }
  471. /*
  472.  * Generic 1.5-row 2x-stretching converter:
  473.  */
  474. #define ROW2X_STRETCH2X(df,dest_ptr_1,dest_ptr_12,dest_ptr_2,dest_dx,sf,src_ptr,src_dx) 
  475.     {                                                       
  476.         /* initialize local variables: */                   
  477.         register unsigned char *d1 = dest_ptr_1;            
  478.         register unsigned char *d12 = dest_ptr_12;          
  479.         register unsigned char *d2 = dest_ptr_2;            
  480.         register unsigned char *s = src_ptr;                
  481.         register int count = src_dx;                        
  482.         /* check row length: */                             
  483.         if (count) {                                        
  484.             /* load and convert first pixel: */             
  485.             PIXEL(df,da); PIXEL(df,dc);                     
  486.             LOAD_CONVERT(df,da,sf,s);                       
  487.             s+=BPP(sf);                                     
  488.             /* calculate a half-pixel above it: */          
  489.             LOAD_AVERAGE(df,dc,da,d1);                      
  490.             d1+=2*BPP(df);                                  
  491.             count --;                                       
  492.             /* store both: */                               
  493.             STORE(df,d2,da);                                
  494.             d2+=BPP(df);                                    
  495.             STORE(df,d12,dc);                               
  496.             d12+=BPP(df);                                   
  497.             /* main loop (process 2 pixels a time): */      
  498.             while (count >= 2) {                            
  499.                 /* load & convert second integral pixel: */ 
  500.                 PIXEL(df,db); PIXEL(df,dd);                 
  501.                 LOAD_CONVERT(df,db,sf,s);                   
  502.                 /* calculate a half-pixel on the left: */   
  503.                 AVERAGE(df,da,da,db);                       
  504.                 /* store both pixels: */                    
  505.                 STORE(df,d2,da);                            
  506.                 STORE(df,d2+BPP(df),db);                    
  507.                 /* calculate a half-pixel above: */         
  508.                 LOAD_AVERAGE(df,dd,db,d1);                  
  509.                 /* calculate a half-pixel above and left: */
  510.                 AVERAGE(df,dc,dc,dd);                       
  511.                 /* store both: */                           
  512.                 STORE(df,d12,dc);                           
  513.                 STORE(df,d12+BPP(df),dd);                   
  514.                 /* load & convert third integral pixel: */  
  515.                 LOAD_CONVERT(df,da,sf,s+BPP(sf));           
  516.                 /* calculate a half-pixel on the left: */   
  517.                 AVERAGE(df,db,db,da);                       
  518.                 /* store both pixels: */                    
  519.                 STORE(df,d2+2*BPP(df),db);                  
  520.                 STORE(df,d2+3*BPP(df),da);                  
  521.                 /* calculate a half-pixel above: */         
  522.                 LOAD_AVERAGE(df,dc,da,d1+2*BPP(df));        
  523.                 /* calculate a half-pixel above and left: */
  524.                 AVERAGE(df,dd,dd,dc);                       
  525.                 /* store both: */                           
  526.                 STORE(df,d12+2*BPP(df),dd);                 
  527.                 STORE(df,d12+3*BPP(df),dc);                 
  528.                 /* shift pointers: */                       
  529.                 s+=2*BPP(sf);                               
  530.                 d1+=4*BPP(df);                              
  531.                 d2+=4*BPP(df);                              
  532.                 d12+=4*BPP(df);                             
  533.                 count -= 2;                                 
  534.             }                                               
  535.             /* is there any more pixels to convert? */      
  536.             if (count) {                                    
  537.                 /* load & convert last integral pixel: */   
  538.                 PIXEL(df,db); PIXEL(df,dd);                 
  539.                 LOAD_CONVERT(df,db,sf,s);                   
  540.                 /* calculate a half-pixel on the left: */   
  541.                 AVERAGE(df,da,da,db);                       
  542.                 /* store pixels: */                         
  543.                 STORE(df,d2,da);                            
  544.                 STORE(df,d2+BPP(df),db);                    
  545.                 STORE(df,d2+2*BPP(df),db);                  
  546.                 /* calculate a half-pixel above: */         
  547.                 LOAD_AVERAGE(df,dd,db,d1);                  
  548.                 /* calculate a half-pixel above and left: */
  549.                 AVERAGE(df,dc,dc,dd);                       
  550.                 /* store pixels: */                         
  551.                 STORE(df,d12,dc);                           
  552.                 STORE(df,d12+BPP(df),dd);                   
  553.                 STORE(df,d12+2*BPP(df),dd);                 
  554.             } else {                                        
  555.                 /* replicate last pixels: */                
  556.                 STORE(df,d2,da);                            
  557.                 STORE(df,d12,dc);                           
  558.             }                                               
  559.         }                                                   
  560.     }
  562. /*
  563.  * Generic 1.5-row 2x+ stretching converter:
  564.  */
  565. #define ROW2X_STRETCH2XPLUS(df,dest_ptr_1,dest_ptr_12,dest_ptr_2,dest_dx,sf,src_ptr,src_dx) 
  566.     {                                                       
  567.         /* initialize local variables: */                   
  568.         register unsigned char *d1 = dest_ptr_1;            
  569.         register unsigned char *d12 = dest_ptr_12;          
  570.         register unsigned char *d2 = dest_ptr_2;            
  571.         register unsigned char *s = src_ptr;                
  572.         register int count = dest_dx;                       
  573.         register int limit = dest_dx >> 1; /* !!! */        
  574.         register int step = src_dx << 1;  /* !!! */         
  575.         /* # of pixels mapped outside source image: */      
  576.         register int remainder = (2*dest_dx - limit) / step;
  577.         /* check row length: */                             
  578.         if (count) {                                        
  579.             /* load & convert first pixel: */               
  580.             PIXEL(df,da); PIXEL(df,db);                     
  581.             PIXEL(df,dc); PIXEL(df,dd);                     
  582.             LOAD_CONVERT(df,da,sf,s);                       
  583.             s+=BPP(sf);                                     
  584.             /* update counter: */                           
  585.             if (!(count -= remainder))                      
  586.                 goto end_of_row;                            
  587.             /* main loop: */                                
  588.             while (1) {                                     
  589.                 /* calculate a half-pixel above: */         
  590.                 LOAD_AVERAGE(df,dc,da,d1);                  
  591.                 /* replicate first pair of pixels: */       
  592.                 do {                                        
  593.                     d1+=BPP(df);                            
  594.                     STORE(df,d2,da);                        
  595.                     d2+=BPP(df);                            
  596.                     STORE(df,d12,dc);                       
  597.                     d12+=BPP(df);                           
  598.                     if (!(--count))                         
  599.                         goto end_of_row;                    
  600.                 } while ((limit -= step) >= 0);             
  601.                 limit += dest_dx;                           
  602.                 /* load & convert second pixel: */          
  603.                 LOAD_CONVERT(df,db,sf,s);                   
  604.                 /* calculate half-pixel on the left: */     
  605.                 AVERAGE(df,da,da,db);                       
  606.                 /* calculate half-pixel above and left: */  
  607.                 LOAD_AVERAGE(df,dc,da,d1);                  
  608.                 /* replicate first pair of half-pixels: */  
  609.                 do {                                        
  610.                     d1+=BPP(df);                            
  611.                     STORE(df,d2,da);                        
  612.                     d2+=BPP(df);                            
  613.                     STORE(df,d12,dc);                       
  614.                     d12+=BPP(df);                           
  615.                     if (!(--count))                         
  616.                         goto end_of_row;                    
  617.                 } while ((limit -= step) >= 0);             
  618.                 limit += dest_dx;                           
  619.                 /* calculate half-pixel above: */           
  620.                 LOAD_AVERAGE(df,dd,db,d1);                  
  621.                 /* replicate second pair of pixels: */      
  622.                 do {                                        
  623.                     d1+=BPP(df);                            
  624.                     STORE(df,d2,db);                        
  625.                     d2+=BPP(df);                            
  626.                     STORE(df,d12,dd);                       
  627.                     d12+=BPP(df);                           
  628.                     if (!(--count))                         
  629.                         goto end_of_row_2;                  
  630.                 } while ((limit -= step) >= 0);             
  631.                 limit += dest_dx;                           
  632.                 /* load & convert third pixel: */           
  633.                 LOAD_CONVERT(df,da,sf,s+BPP(sf));           
  634.                 s+=2*BPP(sf);                               
  635.                 /* calculate half-pixel on the left: */     
  636.                 AVERAGE(df,db,db,da);                       
  637.                 /* calculate half-pixel above and left: */  
  638.                 LOAD_AVERAGE(df,dd,db,d1);                  
  639.                 /* replicate second pair of half-pixels: */ 
  640.                 do {                                        
  641.                     d1+=BPP(df);                            
  642.                     STORE(df,d2,db);                        
  643.                     d2+=BPP(df);                            
  644.                     STORE(df,d12,dd);                       
  645.                     d12+=BPP(df);                           
  646.                     if (!(--count))                         
  647.                         goto end_of_row_2;                  
  648.                 } while ((limit -= step) >= 0);             
  649.                 limit += dest_dx;                           
  650.             }                                               
  651.             /* replicate the remaining pixels: */           
  652. end_of_row_2:                                               
  653.             COPY(df,da,db);                                 
  654.             COPY(df,dc,dd);                                 
  655. end_of_row: while (remainder--) {                           
  656.                 STORE(df,d2,da);                            
  657.                 d2+=BPP(df);                                
  658.                 STORE(df,d12,dc);                           
  659.                 d12+=BPP(df);                               
  660.             }                                               
  661.         }                                                   
  662.     }
  664. /***********************************************************/
  666. /*
  667.  * Function names:
  668.  */
  669. #define FN(df,sf)           sf##to##df
  670. #define ROW_FN(df,sf,t)     sf##to##df##_ROW_##t
  671. #define ROW2X_FN(df,sf,t)   sf##to##df##_ROW2X_##t
  673. /*
  674.  * Function replication macros:
  675.  *  (row- and 1.5 row- converters)
  676.  */
  677. #define ROW_FUNC(df,sf,t)   
  678.     void ROW_FN(df,sf,t) (unsigned char *dest_ptr,          
  679.         int dest_dx, unsigned char *src_ptr, int src_dx)    
  680.         ROW_##t(df,dest_ptr,dest_dx,sf,src_ptr,src_dx)
  682. #define ROW2X_FUNC(df,sf,t) 
  683.     void ROW2X_FN(df,sf,t) (unsigned char *dest_ptr_1,      
  684.         unsigned char *dest_ptr_12, unsigned char *dest_ptr_2,
  685.         int dest_dx, unsigned char *src_ptr, int src_dx)    
  686.         ROW2X_##t(df,dest_ptr_1,dest_ptr_12,dest_ptr_2,dest_dx,sf,src_ptr,src_dx)
  689. /***********************************************************/
  691. /*
  692.  * Actual row functions:
  693.  */
  695. ROW_FUNC(RGB32 ,RGB32 ,SHRINK)
  696. ROW_FUNC(RGB32 ,RGB32 ,COPY)
  697. ROW_FUNC(RGB32 ,RGB32 ,STRETCH)
  698. ROW_FUNC(RGB32 ,RGB32 ,STRETCH2X)
  699. ROW_FUNC(RGB32 ,RGB32 ,STRETCH2XPLUS)
  701. ROW_FUNC(RGB32 ,BGR32 ,SHRINK)
  702. ROW_FUNC(RGB32 ,BGR32 ,COPY)
  703. ROW_FUNC(RGB32 ,BGR32 ,STRETCH)
  704. ROW_FUNC(RGB32 ,BGR32 ,STRETCH2X)
  705. ROW_FUNC(RGB32 ,BGR32 ,STRETCH2XPLUS)
  707. ROW_FUNC(RGB32 ,RGB24 ,SHRINK)
  708. ROW_FUNC(RGB32 ,RGB24 ,COPY)
  709. ROW_FUNC(RGB32 ,RGB24 ,STRETCH)
  710. ROW_FUNC(RGB32 ,RGB24 ,STRETCH2X)
  711. ROW_FUNC(RGB32 ,RGB24 ,STRETCH2XPLUS)
  713. ROW_FUNC(RGB32 ,RGB565,SHRINK)
  714. ROW_FUNC(RGB32 ,RGB565,COPY)
  715. ROW_FUNC(RGB32 ,RGB565,STRETCH)
  716. ROW_FUNC(RGB32 ,RGB565,STRETCH2X)
  717. ROW_FUNC(RGB32 ,RGB565,STRETCH2XPLUS)
  719. ROW_FUNC(RGB32 ,RGB555,SHRINK)
  720. ROW_FUNC(RGB32 ,RGB555,COPY)
  721. ROW_FUNC(RGB32 ,RGB555,STRETCH)
  722. ROW_FUNC(RGB32 ,RGB555,STRETCH2X)
  723. ROW_FUNC(RGB32 ,RGB555,STRETCH2XPLUS)
  725. ROW_FUNC(RGB32 ,RGB8  ,SHRINK)
  726. ROW_FUNC(RGB32 ,RGB8  ,COPY)
  727. ROW_FUNC(RGB32 ,RGB8  ,STRETCH)
  728. ROW_FUNC(RGB32 ,RGB8  ,STRETCH2X)
  729. ROW_FUNC(RGB32 ,RGB8  ,STRETCH2XPLUS)
  732. ROW_FUNC(BGR32 ,RGB32 ,SHRINK)
  733. ROW_FUNC(BGR32 ,RGB32 ,COPY)
  734. ROW_FUNC(BGR32 ,RGB32 ,STRETCH)
  735. ROW_FUNC(BGR32 ,RGB32 ,STRETCH2X)
  736. ROW_FUNC(BGR32 ,RGB32 ,STRETCH2XPLUS)
  738. ROW_FUNC(BGR32 ,BGR32 ,SHRINK)
  739. ROW_FUNC(BGR32 ,BGR32 ,COPY)
  740. ROW_FUNC(BGR32 ,BGR32 ,STRETCH)
  741. ROW_FUNC(BGR32 ,BGR32 ,STRETCH2X)
  742. ROW_FUNC(BGR32 ,BGR32 ,STRETCH2XPLUS)
  744. ROW_FUNC(BGR32 ,RGB24 ,SHRINK)
  745. ROW_FUNC(BGR32 ,RGB24 ,COPY)
  746. ROW_FUNC(BGR32 ,RGB24 ,STRETCH)
  747. ROW_FUNC(BGR32 ,RGB24 ,STRETCH2X)
  748. ROW_FUNC(BGR32 ,RGB24 ,STRETCH2XPLUS)
  750. ROW_FUNC(BGR32 ,RGB565,SHRINK)
  751. ROW_FUNC(BGR32 ,RGB565,COPY)
  752. ROW_FUNC(BGR32 ,RGB565,STRETCH)
  753. ROW_FUNC(BGR32 ,RGB565,STRETCH2X)
  754. ROW_FUNC(BGR32 ,RGB565,STRETCH2XPLUS)
  756. ROW_FUNC(BGR32 ,RGB555,SHRINK)
  757. ROW_FUNC(BGR32 ,RGB555,COPY)
  758. ROW_FUNC(BGR32 ,RGB555,STRETCH)
  759. ROW_FUNC(BGR32 ,RGB555,STRETCH2X)
  760. ROW_FUNC(BGR32 ,RGB555,STRETCH2XPLUS)
  762. ROW_FUNC(BGR32 ,RGB8  ,SHRINK)
  763. ROW_FUNC(BGR32 ,RGB8  ,COPY)
  764. ROW_FUNC(BGR32 ,RGB8  ,STRETCH)
  765. ROW_FUNC(BGR32 ,RGB8  ,STRETCH2X)
  766. ROW_FUNC(BGR32 ,RGB8  ,STRETCH2XPLUS)
  769. ROW_FUNC(RGB24 ,RGB32 ,SHRINK)
  770. ROW_FUNC(RGB24 ,RGB32 ,COPY)
  771. ROW_FUNC(RGB24 ,RGB32 ,STRETCH)
  772. ROW_FUNC(RGB24 ,RGB32 ,STRETCH2X)
  773. ROW_FUNC(RGB24 ,RGB32 ,STRETCH2XPLUS)
  775. ROW_FUNC(RGB24 ,BGR32 ,SHRINK)
  776. ROW_FUNC(RGB24 ,BGR32 ,COPY)
  777. ROW_FUNC(RGB24 ,BGR32 ,STRETCH)
  778. ROW_FUNC(RGB24 ,BGR32 ,STRETCH2X)
  779. ROW_FUNC(RGB24 ,BGR32 ,STRETCH2XPLUS)
  781. ROW_FUNC(RGB24 ,RGB24 ,SHRINK)
  782. ROW_FUNC(RGB24 ,RGB24 ,COPY)
  783. ROW_FUNC(RGB24 ,RGB24 ,STRETCH)
  784. ROW_FUNC(RGB24 ,RGB24 ,STRETCH2X)
  785. ROW_FUNC(RGB24 ,RGB24 ,STRETCH2XPLUS)
  787. ROW_FUNC(RGB24 ,RGB565,SHRINK)
  788. ROW_FUNC(RGB24 ,RGB565,COPY)
  789. ROW_FUNC(RGB24 ,RGB565,STRETCH)
  790. ROW_FUNC(RGB24 ,RGB565,STRETCH2X)
  791. ROW_FUNC(RGB24 ,RGB565,STRETCH2XPLUS)
  793. ROW_FUNC(RGB24 ,RGB555,SHRINK)
  794. ROW_FUNC(RGB24 ,RGB555,COPY)
  795. ROW_FUNC(RGB24 ,RGB555,STRETCH)
  796. ROW_FUNC(RGB24 ,RGB555,STRETCH2X)
  797. ROW_FUNC(RGB24 ,RGB555,STRETCH2XPLUS)
  799. ROW_FUNC(RGB24 ,RGB8  ,SHRINK)
  800. ROW_FUNC(RGB24 ,RGB8  ,COPY)
  801. ROW_FUNC(RGB24 ,RGB8  ,STRETCH)
  802. ROW_FUNC(RGB24 ,RGB8  ,STRETCH2X)
  803. ROW_FUNC(RGB24 ,RGB8  ,STRETCH2XPLUS)
  806. ROW_FUNC(RGB565,RGB32 ,SHRINK)
  807. ROW_FUNC(RGB565,RGB32 ,COPY)
  808. ROW_FUNC(RGB565,RGB32 ,STRETCH)
  809. ROW_FUNC(RGB565,RGB32 ,STRETCH2X)
  810. ROW_FUNC(RGB565,RGB32 ,STRETCH2XPLUS)
  812. ROW_FUNC(RGB565,BGR32 ,SHRINK)
  813. ROW_FUNC(RGB565,BGR32 ,COPY)
  814. ROW_FUNC(RGB565,BGR32 ,STRETCH)
  815. ROW_FUNC(RGB565,BGR32 ,STRETCH2X)
  816. ROW_FUNC(RGB565,BGR32 ,STRETCH2XPLUS)
  818. ROW_FUNC(RGB565,RGB24 ,SHRINK)
  819. ROW_FUNC(RGB565,RGB24 ,COPY)
  820. ROW_FUNC(RGB565,RGB24 ,STRETCH)
  821. ROW_FUNC(RGB565,RGB24 ,STRETCH2X)
  822. ROW_FUNC(RGB565,RGB24 ,STRETCH2XPLUS)
  824. ROW_FUNC(RGB565,RGB565,SHRINK)
  825. ROW_FUNC(RGB565,RGB565,COPY)
  826. ROW_FUNC(RGB565,RGB565,STRETCH)
  827. ROW_FUNC(RGB565,RGB565,STRETCH2X)
  828. ROW_FUNC(RGB565,RGB565,STRETCH2XPLUS)
  830. ROW_FUNC(RGB565,RGB555,SHRINK)
  831. ROW_FUNC(RGB565,RGB555,COPY)
  832. ROW_FUNC(RGB565,RGB555,STRETCH)
  833. ROW_FUNC(RGB565,RGB555,STRETCH2X)
  834. ROW_FUNC(RGB565,RGB555,STRETCH2XPLUS)
  836. ROW_FUNC(RGB565,RGB8  ,SHRINK)
  837. ROW_FUNC(RGB565,RGB8  ,COPY)
  838. ROW_FUNC(RGB565,RGB8  ,STRETCH)
  839. ROW_FUNC(RGB565,RGB8  ,STRETCH2X)
  840. ROW_FUNC(RGB565,RGB8  ,STRETCH2XPLUS)
  843. ROW_FUNC(RGB555,RGB32 ,SHRINK)
  844. ROW_FUNC(RGB555,RGB32 ,COPY)
  845. ROW_FUNC(RGB555,RGB32 ,STRETCH)
  846. ROW_FUNC(RGB555,RGB32 ,STRETCH2X)
  847. ROW_FUNC(RGB555,RGB32 ,STRETCH2XPLUS)
  849. ROW_FUNC(RGB555,BGR32 ,SHRINK)
  850. ROW_FUNC(RGB555,BGR32 ,COPY)
  851. ROW_FUNC(RGB555,BGR32 ,STRETCH)
  852. ROW_FUNC(RGB555,BGR32 ,STRETCH2X)
  853. ROW_FUNC(RGB555,BGR32 ,STRETCH2XPLUS)
  855. ROW_FUNC(RGB555,RGB24 ,SHRINK)
  856. ROW_FUNC(RGB555,RGB24 ,COPY)
  857. ROW_FUNC(RGB555,RGB24 ,STRETCH)
  858. ROW_FUNC(RGB555,RGB24 ,STRETCH2X)
  859. ROW_FUNC(RGB555,RGB24 ,STRETCH2XPLUS)
  861. ROW_FUNC(RGB555,RGB565,SHRINK)
  862. ROW_FUNC(RGB555,RGB565,COPY)
  863. ROW_FUNC(RGB555,RGB565,STRETCH)
  864. ROW_FUNC(RGB555,RGB565,STRETCH2X)
  865. ROW_FUNC(RGB555,RGB565,STRETCH2XPLUS)
  867. ROW_FUNC(RGB555,RGB555,SHRINK)
  868. ROW_FUNC(RGB555,RGB555,COPY)
  869. ROW_FUNC(RGB555,RGB555,STRETCH)
  870. ROW_FUNC(RGB555,RGB555,STRETCH2X)
  871. ROW_FUNC(RGB555,RGB555,STRETCH2XPLUS)
  873. ROW_FUNC(RGB555,RGB8  ,SHRINK)
  874. ROW_FUNC(RGB555,RGB8  ,COPY)
  875. ROW_FUNC(RGB555,RGB8  ,STRETCH)
  876. ROW_FUNC(RGB555,RGB8  ,STRETCH2X)
  877. ROW_FUNC(RGB555,RGB8  ,STRETCH2XPLUS)
  880. ROW_FUNC(RGB8  ,RGB32 ,SHRINK)
  881. ROW_FUNC(RGB8  ,RGB32 ,COPY)
  882. ROW_FUNC(RGB8  ,RGB32 ,STRETCH)
  883. ROW_FUNC(RGB8  ,RGB32 ,STRETCH2X)
  884. ROW_FUNC(RGB8  ,RGB32 ,STRETCH2XPLUS)
  886. ROW_FUNC(RGB8  ,BGR32 ,SHRINK)
  887. ROW_FUNC(RGB8  ,BGR32 ,COPY)
  888. ROW_FUNC(RGB8  ,BGR32 ,STRETCH)
  889. ROW_FUNC(RGB8  ,BGR32 ,STRETCH2X)
  890. ROW_FUNC(RGB8  ,BGR32 ,STRETCH2XPLUS)
  892. ROW_FUNC(RGB8  ,RGB24 ,SHRINK)
  893. ROW_FUNC(RGB8  ,RGB24 ,COPY)
  894. ROW_FUNC(RGB8  ,RGB24 ,STRETCH)
  895. ROW_FUNC(RGB8  ,RGB24 ,STRETCH2X)
  896. ROW_FUNC(RGB8  ,RGB24 ,STRETCH2XPLUS)
  898. ROW_FUNC(RGB8  ,RGB565,SHRINK)
  899. ROW_FUNC(RGB8  ,RGB565,COPY)
  900. ROW_FUNC(RGB8  ,RGB565,STRETCH)
  901. ROW_FUNC(RGB8  ,RGB565,STRETCH2X)
  902. ROW_FUNC(RGB8  ,RGB565,STRETCH2XPLUS)
  904. ROW_FUNC(RGB8  ,RGB555,SHRINK)
  905. ROW_FUNC(RGB8  ,RGB555,COPY)
  906. ROW_FUNC(RGB8  ,RGB555,STRETCH)
  907. ROW_FUNC(RGB8  ,RGB555,STRETCH2X)
  908. ROW_FUNC(RGB8  ,RGB555,STRETCH2XPLUS)
  910. ROW_FUNC(RGB8  ,RGB8  ,SHRINK)
  911. ROW_FUNC(RGB8  ,RGB8  ,COPY)
  912. ROW_FUNC(RGB8  ,RGB8  ,STRETCH)
  913. ROW_FUNC(RGB8  ,RGB8  ,STRETCH2X)
  914. ROW_FUNC(RGB8  ,RGB8  ,STRETCH2XPLUS)
  917. /*
  918.  * Actual 1.5-row conversion functions:
  919.  */
  921. ROW2X_FUNC(RGB32 ,RGB32 ,SHRINK)
  922. ROW2X_FUNC(RGB32 ,RGB32 ,COPY)
  923. ROW2X_FUNC(RGB32 ,RGB32 ,STRETCH)
  924. ROW2X_FUNC(RGB32 ,RGB32 ,STRETCH2X)
  925. ROW2X_FUNC(RGB32 ,RGB32 ,STRETCH2XPLUS)
  927. ROW2X_FUNC(RGB32 ,BGR32 ,SHRINK)
  928. ROW2X_FUNC(RGB32 ,BGR32 ,COPY)
  929. ROW2X_FUNC(RGB32 ,BGR32 ,STRETCH)
  930. ROW2X_FUNC(RGB32 ,BGR32 ,STRETCH2X)
  931. ROW2X_FUNC(RGB32 ,BGR32 ,STRETCH2XPLUS)
  933. ROW2X_FUNC(RGB32 ,RGB24 ,SHRINK)
  934. ROW2X_FUNC(RGB32 ,RGB24 ,COPY)
  935. ROW2X_FUNC(RGB32 ,RGB24 ,STRETCH)
  936. ROW2X_FUNC(RGB32 ,RGB24 ,STRETCH2X)
  937. ROW2X_FUNC(RGB32 ,RGB24 ,STRETCH2XPLUS)
  939. ROW2X_FUNC(RGB32 ,RGB565,SHRINK)
  940. ROW2X_FUNC(RGB32 ,RGB565,COPY)
  941. ROW2X_FUNC(RGB32 ,RGB565,STRETCH)
  942. ROW2X_FUNC(RGB32 ,RGB565,STRETCH2X)
  943. ROW2X_FUNC(RGB32 ,RGB565,STRETCH2XPLUS)
  945. ROW2X_FUNC(RGB32 ,RGB555,SHRINK)
  946. ROW2X_FUNC(RGB32 ,RGB555,COPY)
  947. ROW2X_FUNC(RGB32 ,RGB555,STRETCH)
  948. ROW2X_FUNC(RGB32 ,RGB555,STRETCH2X)
  949. ROW2X_FUNC(RGB32 ,RGB555,STRETCH2XPLUS)
  951. ROW2X_FUNC(RGB32 ,RGB8  ,SHRINK)
  952. ROW2X_FUNC(RGB32 ,RGB8  ,COPY)
  953. ROW2X_FUNC(RGB32 ,RGB8  ,STRETCH)
  954. ROW2X_FUNC(RGB32 ,RGB8  ,STRETCH2X)
  955. ROW2X_FUNC(RGB32 ,RGB8  ,STRETCH2XPLUS)
  958. ROW2X_FUNC(BGR32 ,RGB32 ,SHRINK)
  959. ROW2X_FUNC(BGR32 ,RGB32 ,COPY)
  960. ROW2X_FUNC(BGR32 ,RGB32 ,STRETCH)
  961. ROW2X_FUNC(BGR32 ,RGB32 ,STRETCH2X)
  962. ROW2X_FUNC(BGR32 ,RGB32 ,STRETCH2XPLUS)
  964. ROW2X_FUNC(BGR32 ,BGR32 ,SHRINK)
  965. ROW2X_FUNC(BGR32 ,BGR32 ,COPY)
  966. ROW2X_FUNC(BGR32 ,BGR32 ,STRETCH)
  967. ROW2X_FUNC(BGR32 ,BGR32 ,STRETCH2X)
  968. ROW2X_FUNC(BGR32 ,BGR32 ,STRETCH2XPLUS)
  970. ROW2X_FUNC(BGR32 ,RGB24 ,SHRINK)
  971. ROW2X_FUNC(BGR32 ,RGB24 ,COPY)
  972. ROW2X_FUNC(BGR32 ,RGB24 ,STRETCH)
  973. ROW2X_FUNC(BGR32 ,RGB24 ,STRETCH2X)
  974. ROW2X_FUNC(BGR32 ,RGB24 ,STRETCH2XPLUS)
  976. ROW2X_FUNC(BGR32 ,RGB565,SHRINK)
  977. ROW2X_FUNC(BGR32 ,RGB565,COPY)
  978. ROW2X_FUNC(BGR32 ,RGB565,STRETCH)
  979. ROW2X_FUNC(BGR32 ,RGB565,STRETCH2X)
  980. ROW2X_FUNC(BGR32 ,RGB565,STRETCH2XPLUS)
  982. ROW2X_FUNC(BGR32 ,RGB555,SHRINK)
  983. ROW2X_FUNC(BGR32 ,RGB555,COPY)
  984. ROW2X_FUNC(BGR32 ,RGB555,STRETCH)
  985. ROW2X_FUNC(BGR32 ,RGB555,STRETCH2X)
  986. ROW2X_FUNC(BGR32 ,RGB555,STRETCH2XPLUS)
  988. ROW2X_FUNC(BGR32 ,RGB8  ,SHRINK)
  989. ROW2X_FUNC(BGR32 ,RGB8  ,COPY)
  990. ROW2X_FUNC(BGR32 ,RGB8  ,STRETCH)
  991. ROW2X_FUNC(BGR32 ,RGB8  ,STRETCH2X)
  992. ROW2X_FUNC(BGR32 ,RGB8  ,STRETCH2XPLUS)
  995. ROW2X_FUNC(RGB24 ,RGB32 ,SHRINK)
  996. ROW2X_FUNC(RGB24 ,RGB32 ,COPY)
  997. ROW2X_FUNC(RGB24 ,RGB32 ,STRETCH)
  998. ROW2X_FUNC(RGB24 ,RGB32 ,STRETCH2X)
  999. ROW2X_FUNC(RGB24 ,RGB32 ,STRETCH2XPLUS)
  1001. ROW2X_FUNC(RGB24 ,BGR32 ,SHRINK)
  1002. ROW2X_FUNC(RGB24 ,BGR32 ,COPY)
  1003. ROW2X_FUNC(RGB24 ,BGR32 ,STRETCH)
  1004. ROW2X_FUNC(RGB24 ,BGR32 ,STRETCH2X)
  1005. ROW2X_FUNC(RGB24 ,BGR32 ,STRETCH2XPLUS)
  1007. ROW2X_FUNC(RGB24 ,RGB24 ,SHRINK)
  1008. ROW2X_FUNC(RGB24 ,RGB24 ,COPY)
  1009. ROW2X_FUNC(RGB24 ,RGB24 ,STRETCH)
  1010. ROW2X_FUNC(RGB24 ,RGB24 ,STRETCH2X)
  1011. ROW2X_FUNC(RGB24 ,RGB24 ,STRETCH2XPLUS)
  1013. ROW2X_FUNC(RGB24 ,RGB565,SHRINK)
  1014. ROW2X_FUNC(RGB24 ,RGB565,COPY)
  1015. ROW2X_FUNC(RGB24 ,RGB565,STRETCH)
  1016. ROW2X_FUNC(RGB24 ,RGB565,STRETCH2X)
  1017. ROW2X_FUNC(RGB24 ,RGB565,STRETCH2XPLUS)
  1019. ROW2X_FUNC(RGB24 ,RGB555,SHRINK)
  1020. ROW2X_FUNC(RGB24 ,RGB555,COPY)
  1021. ROW2X_FUNC(RGB24 ,RGB555,STRETCH)
  1022. ROW2X_FUNC(RGB24 ,RGB555,STRETCH2X)
  1023. ROW2X_FUNC(RGB24 ,RGB555,STRETCH2XPLUS)
  1025. ROW2X_FUNC(RGB24 ,RGB8  ,SHRINK)
  1026. ROW2X_FUNC(RGB24 ,RGB8  ,COPY)
  1027. ROW2X_FUNC(RGB24 ,RGB8  ,STRETCH)
  1028. ROW2X_FUNC(RGB24 ,RGB8  ,STRETCH2X)
  1029. ROW2X_FUNC(RGB24 ,RGB8  ,STRETCH2XPLUS)
  1032. ROW2X_FUNC(RGB565,RGB32 ,SHRINK)
  1033. ROW2X_FUNC(RGB565,RGB32 ,COPY)
  1034. ROW2X_FUNC(RGB565,RGB32 ,STRETCH)
  1035. ROW2X_FUNC(RGB565,RGB32 ,STRETCH2X)
  1036. ROW2X_FUNC(RGB565,RGB32 ,STRETCH2XPLUS)
  1038. ROW2X_FUNC(RGB565,BGR32 ,SHRINK)
  1039. ROW2X_FUNC(RGB565,BGR32 ,COPY)
  1040. ROW2X_FUNC(RGB565,BGR32 ,STRETCH)
  1041. ROW2X_FUNC(RGB565,BGR32 ,STRETCH2X)
  1042. ROW2X_FUNC(RGB565,BGR32 ,STRETCH2XPLUS)
  1044. ROW2X_FUNC(RGB565,RGB24 ,SHRINK)
  1045. ROW2X_FUNC(RGB565,RGB24 ,COPY)
  1046. ROW2X_FUNC(RGB565,RGB24 ,STRETCH)
  1047. ROW2X_FUNC(RGB565,RGB24 ,STRETCH2X)
  1048. ROW2X_FUNC(RGB565,RGB24 ,STRETCH2XPLUS)
  1050. ROW2X_FUNC(RGB565,RGB565,SHRINK)
  1051. ROW2X_FUNC(RGB565,RGB565,COPY)
  1052. ROW2X_FUNC(RGB565,RGB565,STRETCH)
  1053. ROW2X_FUNC(RGB565,RGB565,STRETCH2X)
  1054. ROW2X_FUNC(RGB565,RGB565,STRETCH2XPLUS)
  1056. ROW2X_FUNC(RGB565,RGB555,SHRINK)
  1057. ROW2X_FUNC(RGB565,RGB555,COPY)
  1058. ROW2X_FUNC(RGB565,RGB555,STRETCH)
  1059. ROW2X_FUNC(RGB565,RGB555,STRETCH2X)
  1060. ROW2X_FUNC(RGB565,RGB555,STRETCH2XPLUS)
  1062. ROW2X_FUNC(RGB565,RGB8  ,SHRINK)
  1063. ROW2X_FUNC(RGB565,RGB8  ,COPY)
  1064. ROW2X_FUNC(RGB565,RGB8  ,STRETCH)
  1065. ROW2X_FUNC(RGB565,RGB8  ,STRETCH2X)
  1066. ROW2X_FUNC(RGB565,RGB8  ,STRETCH2XPLUS)
  1069. ROW2X_FUNC(RGB555,RGB32 ,SHRINK)
  1070. ROW2X_FUNC(RGB555,RGB32 ,COPY)
  1071. ROW2X_FUNC(RGB555,RGB32 ,STRETCH)
  1072. ROW2X_FUNC(RGB555,RGB32 ,STRETCH2X)
  1073. ROW2X_FUNC(RGB555,RGB32 ,STRETCH2XPLUS)
  1075. ROW2X_FUNC(RGB555,BGR32 ,SHRINK)
  1076. ROW2X_FUNC(RGB555,BGR32 ,COPY)
  1077. ROW2X_FUNC(RGB555,BGR32 ,STRETCH)
  1078. ROW2X_FUNC(RGB555,BGR32 ,STRETCH2X)
  1079. ROW2X_FUNC(RGB555,BGR32 ,STRETCH2XPLUS)
  1081. ROW2X_FUNC(RGB555,RGB24 ,SHRINK)
  1082. ROW2X_FUNC(RGB555,RGB24 ,COPY)
  1083. ROW2X_FUNC(RGB555,RGB24 ,STRETCH)
  1084. ROW2X_FUNC(RGB555,RGB24 ,STRETCH2X)
  1085. ROW2X_FUNC(RGB555,RGB24 ,STRETCH2XPLUS)
  1087. ROW2X_FUNC(RGB555,RGB565,SHRINK)
  1088. ROW2X_FUNC(RGB555,RGB565,COPY)
  1089. ROW2X_FUNC(RGB555,RGB565,STRETCH)
  1090. ROW2X_FUNC(RGB555,RGB565,STRETCH2X)
  1091. ROW2X_FUNC(RGB555,RGB565,STRETCH2XPLUS)
  1093. ROW2X_FUNC(RGB555,RGB555,SHRINK)
  1094. ROW2X_FUNC(RGB555,RGB555,COPY)
  1095. ROW2X_FUNC(RGB555,RGB555,STRETCH)
  1096. ROW2X_FUNC(RGB555,RGB555,STRETCH2X)
  1097. ROW2X_FUNC(RGB555,RGB555,STRETCH2XPLUS)
  1099. ROW2X_FUNC(RGB555,RGB8  ,SHRINK)
  1100. ROW2X_FUNC(RGB555,RGB8  ,COPY)
  1101. ROW2X_FUNC(RGB555,RGB8  ,STRETCH)
  1102. ROW2X_FUNC(RGB555,RGB8  ,STRETCH2X)
  1103. ROW2X_FUNC(RGB555,RGB8  ,STRETCH2XPLUS)
  1106. ROW2X_FUNC(RGB8  ,RGB32 ,SHRINK)
  1107. ROW2X_FUNC(RGB8  ,RGB32 ,COPY)
  1108. ROW2X_FUNC(RGB8  ,RGB32 ,STRETCH)
  1109. ROW2X_FUNC(RGB8  ,RGB32 ,STRETCH2X)
  1110. ROW2X_FUNC(RGB8  ,RGB32 ,STRETCH2XPLUS)
  1112. ROW2X_FUNC(RGB8  ,BGR32 ,SHRINK)
  1113. ROW2X_FUNC(RGB8  ,BGR32 ,COPY)
  1114. ROW2X_FUNC(RGB8  ,BGR32 ,STRETCH)
  1115. ROW2X_FUNC(RGB8  ,BGR32 ,STRETCH2X)
  1116. ROW2X_FUNC(RGB8  ,BGR32 ,STRETCH2XPLUS)
  1118. ROW2X_FUNC(RGB8  ,RGB24 ,SHRINK)
  1119. ROW2X_FUNC(RGB8  ,RGB24 ,COPY)
  1120. ROW2X_FUNC(RGB8  ,RGB24 ,STRETCH)
  1121. ROW2X_FUNC(RGB8  ,RGB24 ,STRETCH2X)
  1122. ROW2X_FUNC(RGB8  ,RGB24 ,STRETCH2XPLUS)
  1124. ROW2X_FUNC(RGB8  ,RGB565,SHRINK)
  1125. ROW2X_FUNC(RGB8  ,RGB565,COPY)
  1126. ROW2X_FUNC(RGB8  ,RGB565,STRETCH)
  1127. ROW2X_FUNC(RGB8  ,RGB565,STRETCH2X)
  1128. ROW2X_FUNC(RGB8  ,RGB565,STRETCH2XPLUS)
  1130. ROW2X_FUNC(RGB8  ,RGB555,SHRINK)
  1131. ROW2X_FUNC(RGB8  ,RGB555,COPY)
  1132. ROW2X_FUNC(RGB8  ,RGB555,STRETCH)
  1133. ROW2X_FUNC(RGB8  ,RGB555,STRETCH2X)
  1134. ROW2X_FUNC(RGB8  ,RGB555,STRETCH2XPLUS)
  1136. ROW2X_FUNC(RGB8  ,RGB8  ,SHRINK)
  1137. ROW2X_FUNC(RGB8  ,RGB8  ,COPY)
  1138. ROW2X_FUNC(RGB8  ,RGB8  ,STRETCH)
  1139. ROW2X_FUNC(RGB8  ,RGB8  ,STRETCH2X)
  1140. ROW2X_FUNC(RGB8  ,RGB8  ,STRETCH2XPLUS)
  1143. /*
  1144.  * Row scale function selection tables:
  1145.  *  [destination format][source format][row scale type]
  1146.  */
  1147. void (* RowFuncs [RGB_FORMATS][RGB_FORMATS][SCALE_FUNCS]) (
  1148.     unsigned char *dest_ptr, int dest_dx, unsigned char *src_ptr, int src_dx) =
  1149. {
  1150.     {   {
  1151.             ROW_FN(RGB32 ,RGB32 ,SHRINK),
  1152.             ROW_FN(RGB32 ,RGB32 ,COPY),
  1153.             ROW_FN(RGB32 ,RGB32 ,STRETCH),
  1154.             ROW_FN(RGB32 ,RGB32 ,STRETCH2X),
  1155.             ROW_FN(RGB32 ,RGB32 ,STRETCH2XPLUS)
  1156.         },{
  1157. #ifdef _FAT_HXCOLOR
  1158.             ROW_FN(RGB32 ,BGR32 ,SHRINK),
  1159.             ROW_FN(RGB32 ,BGR32 ,COPY),
  1160.             ROW_FN(RGB32 ,BGR32 ,STRETCH),
  1161.             ROW_FN(RGB32 ,BGR32 ,STRETCH2X),
  1162.             ROW_FN(RGB32 ,BGR32 ,STRETCH2XPLUS)
  1163. #else
  1164.     0,
  1165.     0,
  1166.     0,
  1167.             0,
  1168.             0
  1169. #endif
  1170.         },{
  1171. #ifdef _FAT_HXCOLOR
  1172.             ROW_FN(RGB32 ,RGB24 ,SHRINK),
  1173.             ROW_FN(RGB32 ,RGB24 ,COPY),
  1174.             ROW_FN(RGB32 ,RGB24 ,STRETCH),
  1175.             ROW_FN(RGB32 ,RGB24 ,STRETCH2X),
  1176.             ROW_FN(RGB32 ,RGB24 ,STRETCH2XPLUS)
  1177. #else
  1178.     0,
  1179.     0,
  1180.             0,
  1181.             0,
  1182.     0
  1183. #endif
  1184.         },{
  1185. #ifdef _FAT_HXCOLOR
  1186.             ROW_FN(RGB32 ,RGB565,SHRINK),
  1187.             ROW_FN(RGB32 ,RGB565,COPY),
  1188.             ROW_FN(RGB32 ,RGB565,STRETCH),
  1189.             ROW_FN(RGB32 ,RGB565,STRETCH2X),
  1190.             ROW_FN(RGB32 ,RGB565,STRETCH2XPLUS)
  1191. #else
  1192.     0,
  1193.     0,
  1194.     0,
  1195.             0,
  1196.             0
  1197. #endif
  1198.         },{
  1199. #ifdef _FAT_HXCOLOR
  1200.             ROW_FN(RGB32 ,RGB555,SHRINK),
  1201.             ROW_FN(RGB32 ,RGB555,COPY),
  1202.             ROW_FN(RGB32 ,RGB555,STRETCH),
  1203.             ROW_FN(RGB32 ,RGB555,STRETCH2X),
  1204.             ROW_FN(RGB32 ,RGB555,STRETCH2XPLUS)
  1205. #else
  1206.     0,
  1207.     0,
  1208.     0,
  1209.             0,
  1210.             0
  1211. #endif
  1212.         },{ /* rgb444 stub */
  1213.             0,
  1214.             0,
  1215.             0,
  1216.             0,
  1217.             0
  1218.         },{
  1219. #ifdef _8_BIT_SUPPORT
  1220.             ROW_FN(RGB32 ,RGB8  ,SHRINK),
  1221.             ROW_FN(RGB32 ,RGB8  ,COPY),
  1222.             ROW_FN(RGB32 ,RGB8  ,STRETCH),
  1223.             ROW_FN(RGB32 ,RGB8  ,STRETCH2X),
  1224.             ROW_FN(RGB32 ,RGB8  ,STRETCH2XPLUS)
  1225. #else
  1226.     0,
  1227.     0,
  1228.     0,
  1229.             0,
  1230.             0
  1231. #endif
  1232.         }
  1233.     },{ {
  1234.             ROW_FN(BGR32 ,RGB32 ,SHRINK),
  1235.             ROW_FN(BGR32 ,RGB32 ,COPY),
  1236.             ROW_FN(BGR32 ,RGB32 ,STRETCH),
  1237.             ROW_FN(BGR32 ,RGB32 ,STRETCH2X),
  1238.             ROW_FN(BGR32 ,RGB32 ,STRETCH2XPLUS)
  1239.         },{
  1240. #ifdef _FAT_HXCOLOR
  1241.             ROW_FN(BGR32 ,BGR32 ,SHRINK),
  1242.             ROW_FN(BGR32 ,BGR32 ,COPY),
  1243.             ROW_FN(BGR32 ,BGR32 ,STRETCH),
  1244.             ROW_FN(BGR32 ,BGR32 ,STRETCH2X),
  1245.             ROW_FN(BGR32 ,BGR32 ,STRETCH2XPLUS)
  1246. #else
  1247.     0,
  1248.     0,
  1249.     0,
  1250.             0,
  1251.             0
  1252. #endif
  1253.         },{
  1254. #ifdef _FAT_HXCOLOR
  1255.             ROW_FN(BGR32 ,RGB24 ,SHRINK),
  1256.             ROW_FN(BGR32 ,RGB24 ,COPY),
  1257.             ROW_FN(BGR32 ,RGB24 ,STRETCH),
  1258.             ROW_FN(BGR32 ,RGB24 ,STRETCH2X),
  1259.             ROW_FN(BGR32 ,RGB24 ,STRETCH2XPLUS)
  1260. #else
  1261.     0,
  1262.     0,
  1263.     0,
  1264.             0,
  1265.             0
  1266. #endif
  1267.         },{
  1268. #ifdef _FAT_HXCOLOR
  1269.             ROW_FN(BGR32 ,RGB565,SHRINK),
  1270.             ROW_FN(BGR32 ,RGB565,COPY),
  1271.             ROW_FN(BGR32 ,RGB565,STRETCH),
  1272.             ROW_FN(BGR32 ,RGB565,STRETCH2X),
  1273.             ROW_FN(BGR32 ,RGB565,STRETCH2XPLUS)
  1274. #else
  1275.     0,
  1276.     0,
  1277.     0,
  1278.             0,
  1279.             0
  1280. #endif
  1281.         },{
  1282. #ifdef _FAT_HXCOLOR
  1283.             ROW_FN(BGR32 ,RGB555,SHRINK),
  1284.             ROW_FN(BGR32 ,RGB555,COPY),
  1285.             ROW_FN(BGR32 ,RGB555,STRETCH),
  1286.             ROW_FN(BGR32 ,RGB555,STRETCH2X),
  1287.             ROW_FN(BGR32 ,RGB555,STRETCH2XPLUS)
  1288. #else
  1289.     0,
  1290.     0,
  1291.     0,
  1292.             0,
  1293.             0
  1294. #endif
  1295.         },{ /* rgb444 stub */
  1296.             0,
  1297.             0,
  1298.             0,
  1299.             0,
  1300.             0
  1301.         },{
  1302. #ifdef _8_BIT_SUPPORT
  1303.     ROW_FN(BGR32 ,RGB8  ,SHRINK),
  1304.             ROW_FN(BGR32 ,RGB8  ,COPY),
  1305.             ROW_FN(BGR32 ,RGB8  ,STRETCH),
  1306.             ROW_FN(BGR32 ,RGB8  ,STRETCH2X),
  1307.             ROW_FN(BGR32 ,RGB8  ,STRETCH2XPLUS)
  1308. #else
  1309.     0,
  1310.     0,
  1311.     0,
  1312.             0,
  1313.             0
  1314. #endif
  1315.         }
  1316.     },{ {
  1317.             ROW_FN(RGB24 ,RGB32 ,SHRINK),
  1318.             ROW_FN(RGB24 ,RGB32 ,COPY),
  1319.             ROW_FN(RGB24 ,RGB32 ,STRETCH),
  1320.             ROW_FN(RGB24 ,RGB32 ,STRETCH2X),
  1321.             ROW_FN(RGB24 ,RGB32 ,STRETCH2XPLUS)
  1322.         },{
  1323. #ifdef _FAT_HXCOLOR
  1324.             ROW_FN(RGB24 ,BGR32 ,SHRINK),
  1325.             ROW_FN(RGB24 ,BGR32 ,COPY),
  1326.             ROW_FN(RGB24 ,BGR32 ,STRETCH),
  1327.             ROW_FN(RGB24 ,BGR32 ,STRETCH2X),
  1328.             ROW_FN(RGB24 ,BGR32 ,STRETCH2XPLUS)
  1329. #else
  1330.     0,
  1331.     0,
  1332.     0,
  1333.     0,
  1334.     0
  1335. #endif
  1336.         },{
  1337. #ifdef _FAT_HXCOLOR
  1338.             ROW_FN(RGB24 ,RGB24 ,SHRINK),
  1339.             ROW_FN(RGB24 ,RGB24 ,COPY),
  1340.             ROW_FN(RGB24 ,RGB24 ,STRETCH),
  1341.             ROW_FN(RGB24 ,RGB24 ,STRETCH2X),
  1342.             ROW_FN(RGB24 ,RGB24 ,STRETCH2XPLUS)
  1343. #else
  1344.     0,
  1345.     0,
  1346.     0,
  1347.     0,
  1348.     0
  1349. #endif
  1350.         },{
  1351. #ifdef _FAT_HXCOLOR
  1352.             ROW_FN(RGB24 ,RGB565,SHRINK),
  1353.             ROW_FN(RGB24 ,RGB565,COPY),
  1354.             ROW_FN(RGB24 ,RGB565,STRETCH),
  1355.             ROW_FN(RGB24 ,RGB565,STRETCH2X),
  1356.             ROW_FN(RGB24 ,RGB565,STRETCH2XPLUS)
  1357. #else
  1358.     0,
  1359.     0,
  1360.     0,
  1361.     0,
  1362.     0
  1363. #endif
  1364.         },{
  1365. #ifdef _FAT_HXCOLOR
  1366.             ROW_FN(RGB24 ,RGB555,SHRINK),
  1367.             ROW_FN(RGB24 ,RGB555,COPY),
  1368.             ROW_FN(RGB24 ,RGB555,STRETCH),
  1369.             ROW_FN(RGB24 ,RGB555,STRETCH2X),
  1370.             ROW_FN(RGB24 ,RGB555,STRETCH2XPLUS)
  1371. #else
  1372.     0,
  1373.     0,
  1374.     0,
  1375.     0,
  1376.     0
  1377. #endif
  1378.         },{ /* rgb444 stub */
  1379.             0,
  1380.             0,
  1381.             0,
  1382.             0,
  1383.             0
  1384.         },{
  1385. #ifdef _8_BIT_SUPPORT
  1386.             ROW_FN(RGB24 ,RGB8  ,SHRINK),
  1387.             ROW_FN(RGB24 ,RGB8  ,COPY),
  1388.             ROW_FN(RGB24 ,RGB8  ,STRETCH),
  1389.             ROW_FN(RGB24 ,RGB8  ,STRETCH2X),
  1390.             ROW_FN(RGB24 ,RGB8  ,STRETCH2XPLUS)
  1391. #else
  1392.     0,
  1393.     0,
  1394.     0,
  1395.     0,
  1396.     0
  1397. #endif
  1398.         }
  1399.     },{ {
  1400.             ROW_FN(RGB565,RGB32 ,SHRINK),
  1401.             ROW_FN(RGB565,RGB32 ,COPY),
  1402.             ROW_FN(RGB565,RGB32 ,STRETCH),
  1403.             ROW_FN(RGB565,RGB32 ,STRETCH2X),
  1404.             ROW_FN(RGB565,RGB32 ,STRETCH2XPLUS)
  1405.         },{
  1406. #ifdef _FAT_HXCOLOR
  1407.             ROW_FN(RGB565,BGR32 ,SHRINK),
  1408.             ROW_FN(RGB565,BGR32 ,COPY),
  1409.             ROW_FN(RGB565,BGR32 ,STRETCH),
  1410.             ROW_FN(RGB565,BGR32 ,STRETCH2X),
  1411.             ROW_FN(RGB565,BGR32 ,STRETCH2XPLUS)
  1412. #else
  1413.     0,
  1414.     0,
  1415.     0,
  1416.     0,
  1417.     0
  1418. #endif
  1419.         },{
  1420. #ifdef _FAT_HXCOLOR
  1421.             ROW_FN(RGB565,RGB24 ,SHRINK),
  1422.             ROW_FN(RGB565,RGB24 ,COPY),
  1423.             ROW_FN(RGB565,RGB24 ,STRETCH),
  1424.             ROW_FN(RGB565,RGB24 ,STRETCH2X),
  1425.             ROW_FN(RGB565,RGB24 ,STRETCH2XPLUS)
  1426. #else
  1427.     0,
  1428.     0,
  1429.     0,
  1430.     0,
  1431.     0
  1432. #endif
  1433.         },{
  1434. #ifdef _FAT_HXCOLOR
  1435.             ROW_FN(RGB565,RGB565,SHRINK),
  1436.             ROW_FN(RGB565,RGB565,COPY),
  1437.             ROW_FN(RGB565,RGB565,STRETCH),
  1438.             ROW_FN(RGB565,RGB565,STRETCH2X),
  1439.             ROW_FN(RGB565,RGB565,STRETCH2XPLUS)
  1440. #else
  1441.     0,
  1442.     0,
  1443.     0,
  1444.     0,
  1445.     0
  1446. #endif
  1447.         },{
  1448. #ifdef _FAT_HXCOLOR
  1449.             ROW_FN(RGB565,RGB555,SHRINK),
  1450.             ROW_FN(RGB565,RGB555,COPY),
  1451.             ROW_FN(RGB565,RGB555,STRETCH),
  1452.             ROW_FN(RGB565,RGB555,STRETCH2X),
  1453.             ROW_FN(RGB565,RGB555,STRETCH2XPLUS)
  1454. #else
  1455.     0,
  1456.     0,
  1457.     0,
  1458.     0,
  1459.     0
  1460. #endif
  1461.         },{ /* rgb444 stub */
  1462.             0,
  1463.             0,
  1464.             0,
  1465.             0,
  1466.             0
  1467.         },{
  1468. #ifdef _8_BIT_SUPPORT
  1469.             ROW_FN(RGB565,RGB8  ,SHRINK),
  1470.             ROW_FN(RGB565,RGB8  ,COPY),
  1471.             ROW_FN(RGB565,RGB8  ,STRETCH),
  1472.             ROW_FN(RGB565,RGB8  ,STRETCH2X),
  1473.             ROW_FN(RGB565,RGB8  ,STRETCH2XPLUS)
  1474. #else
  1475.     0,
  1476.     0,
  1477.     0,
  1478.             0,
  1479.             0
  1480. #endif
  1481.         }
  1482.     },{ {
  1483.             ROW_FN(RGB555,RGB32 ,SHRINK),
  1484.             ROW_FN(RGB555,RGB32 ,COPY),
  1485.             ROW_FN(RGB555,RGB32 ,STRETCH),
  1486.             ROW_FN(RGB555,RGB32 ,STRETCH2X),
  1487.             ROW_FN(RGB555,RGB32 ,STRETCH2XPLUS)
  1488.         },{
  1489. #ifdef _FAT_HXCOLOR
  1490.             ROW_FN(RGB555,BGR32 ,SHRINK),
  1491.             ROW_FN(RGB555,BGR32 ,COPY),
  1492.             ROW_FN(RGB555,BGR32 ,STRETCH),
  1493.             ROW_FN(RGB555,BGR32 ,STRETCH2X),
  1494.             ROW_FN(RGB555,BGR32 ,STRETCH2XPLUS)
  1495. #else
  1496.     0,
  1497.     0,
  1498.     0,
  1499.             0,
  1500.             0
  1501. #endif
  1502.         },{
  1503. #ifdef _FAT_HXCOLOR
  1504.             ROW_FN(RGB555,RGB24 ,SHRINK),
  1505.             ROW_FN(RGB555,RGB24 ,COPY),
  1506.             ROW_FN(RGB555,RGB24 ,STRETCH),
  1507.             ROW_FN(RGB555,RGB24 ,STRETCH2X),
  1508.             ROW_FN(RGB555,RGB24 ,STRETCH2XPLUS)
  1509. #else
  1510.     0,
  1511.     0,
  1512.     0,
  1513.             0,
  1514.             0
  1515. #endif
  1516.         },{
  1517. #ifdef _FAT_HXCOLOR
  1518.             ROW_FN(RGB555,RGB565,SHRINK),
  1519.             ROW_FN(RGB555,RGB565,COPY),
  1520.             ROW_FN(RGB555,RGB565,STRETCH),
  1521.             ROW_FN(RGB555,RGB565,STRETCH2X),
  1522.             ROW_FN(RGB555,RGB565,STRETCH2XPLUS)
  1523. #else
  1524.     0,
  1525.     0,
  1526.     0,
  1527.             0,
  1528.             0
  1529. #endif
  1530.         },{
  1531. #ifdef _FAT_HXCOLOR
  1532.             ROW_FN(RGB555,RGB555,SHRINK),
  1533.             ROW_FN(RGB555,RGB555,COPY),
  1534.             ROW_FN(RGB555,RGB555,STRETCH),
  1535.             ROW_FN(RGB555,RGB555,STRETCH2X),
  1536.             ROW_FN(RGB555,RGB555,STRETCH2XPLUS)
  1537. #else
  1538.     0,
  1539.     0,
  1540.     0,
  1541.             0,
  1542.             0
  1543. #endif
  1544.         },{ /* rgb444 stub */
  1545.             0,
  1546.             0,
  1547.             0,
  1548.             0,
  1549.             0
  1550.         },{
  1551. #ifdef _8_BIT_SUPPORT
  1552.             ROW_FN(RGB555,RGB8  ,SHRINK),
  1553.             ROW_FN(RGB555,RGB8  ,COPY),
  1554.             ROW_FN(RGB555,RGB8  ,STRETCH),
  1555.             ROW_FN(RGB555,RGB8  ,STRETCH2X),
  1556.             ROW_FN(RGB555,RGB8  ,STRETCH2XPLUS)
  1557. #else
  1558.     0,
  1559.     0,
  1560.     0,
  1561.             0,
  1562.             0
  1563. #endif
  1564.         }
  1565.     },{ {
  1566. #ifdef _8_BIT_SUPPORT
  1567.             ROW_FN(RGB8  ,RGB32 ,SHRINK),
  1568.             ROW_FN(RGB8  ,RGB32 ,COPY),
  1569.             ROW_FN(RGB8  ,RGB32 ,STRETCH),
  1570.             ROW_FN(RGB8  ,RGB32 ,STRETCH2X),
  1571.             ROW_FN(RGB8  ,RGB32 ,STRETCH2XPLUS)
  1572. #else
  1573.     0,
  1574.     0,
  1575.     0,
  1576.             0,
  1577.             0
  1578. #endif
  1579.         },{
  1580. #ifdef _8_BIT_SUPPORT
  1581.             ROW_FN(RGB8  ,BGR32 ,SHRINK),
  1582.             ROW_FN(RGB8  ,BGR32 ,COPY),
  1583.             ROW_FN(RGB8  ,BGR32 ,STRETCH),
  1584.             ROW_FN(RGB8  ,BGR32 ,STRETCH2X),
  1585.             ROW_FN(RGB8  ,BGR32 ,STRETCH2XPLUS)
  1586. #else
  1587.     0,
  1588.     0,
  1589.     0,
  1590.             0,
  1591.             0
  1592. #endif
  1593.         },{
  1594. #ifdef _8_BIT_SUPPORT
  1595.             ROW_FN(RGB8  ,RGB24 ,SHRINK),
  1596.             ROW_FN(RGB8  ,RGB24 ,COPY),
  1597.             ROW_FN(RGB8  ,RGB24 ,STRETCH),
  1598.             ROW_FN(RGB8  ,RGB24 ,STRETCH2X),
  1599.             ROW_FN(RGB8  ,RGB24 ,STRETCH2XPLUS)
  1600. #else
  1601.     0,
  1602.     0,
  1603.     0,
  1604.             0,
  1605.             0
  1606. #endif
  1607.         },{
  1608. #ifdef _8_BIT_SUPPORT
  1609.             ROW_FN(RGB8  ,RGB565,SHRINK),
  1610.             ROW_FN(RGB8  ,RGB565,COPY),
  1611.             ROW_FN(RGB8  ,RGB565,STRETCH),
  1612.             ROW_FN(RGB8  ,RGB565,STRETCH2X),
  1613.             ROW_FN(RGB8  ,RGB565,STRETCH2XPLUS)
  1614. #else
  1615.     0,
  1616.     0,
  1617.     0,
  1618.             0,
  1619.             0
  1620. #endif
  1621.         },{
  1622. #ifdef _8_BIT_SUPPORT
  1623.             ROW_FN(RGB8  ,RGB555,SHRINK),
  1624.             ROW_FN(RGB8  ,RGB555,COPY),
  1625.             ROW_FN(RGB8  ,RGB555,STRETCH),
  1626.             ROW_FN(RGB8  ,RGB555,STRETCH2X),
  1627.             ROW_FN(RGB8  ,RGB555,STRETCH2XPLUS)
  1628. #else
  1629.     0,
  1630.     0,
  1631.     0,
  1632.             0,
  1633.             0
  1634. #endif
  1635.         },{ /* rgb444 stub */
  1636.             0,
  1637.             0,
  1638.             0,
  1639.             0,
  1640.             0
  1641.         },{
  1642. #ifdef _8_BIT_SUPPORT
  1643.             ROW_FN(RGB8  ,RGB8  ,SHRINK),
  1644.             ROW_FN(RGB8  ,RGB8  ,COPY),
  1645.             ROW_FN(RGB8  ,RGB8  ,STRETCH),
  1646.             ROW_FN(RGB8  ,RGB8  ,STRETCH2X),
  1647.             ROW_FN(RGB8  ,RGB8  ,STRETCH2XPLUS)
  1648. #else
  1649.     0,
  1650.     0,
  1651.     0,
  1652.             0,
  1653.             0
  1654. #endif
  1655.         }
  1656.     }
  1657. };
  1659. /*
  1660.  * 1.5-row scale function selection tables:
  1661.  *  [destination format][source format][row scale type]
  1662.  */
  1663. void (* Row2xFuncs [RGB_FORMATS][RGB_FORMATS][SCALE_FUNCS]) (
  1664.     unsigned char *dest_ptr_1, unsigned char *dest_ptr_12,
  1665.     unsigned char *dest_ptr_2, int dest_dx, unsigned char *src_ptr, int src_dx) =
  1666. {
  1667.     {   {
  1668.             ROW2X_FN(RGB32 ,RGB32 ,SHRINK),
  1669.             ROW2X_FN(RGB32 ,RGB32 ,COPY),
  1670.             ROW2X_FN(RGB32 ,RGB32 ,STRETCH),
  1671.             ROW2X_FN(RGB32 ,RGB32 ,STRETCH2X),
  1672.             ROW2X_FN(RGB32 ,RGB32 ,STRETCH2XPLUS)
  1673.         },{
  1674. #ifdef _FAT_HXCOLOR
  1675.             ROW2X_FN(RGB32 ,BGR32 ,SHRINK),
  1676.             ROW2X_FN(RGB32 ,BGR32 ,COPY),
  1677.             ROW2X_FN(RGB32 ,BGR32 ,STRETCH),
  1678.             ROW2X_FN(RGB32 ,BGR32 ,STRETCH2X),
  1679.             ROW2X_FN(RGB32 ,BGR32 ,STRETCH2XPLUS)
  1680. #else
  1681.     0,
  1682.     0,
  1683.     0,
  1684.             0,
  1685.             0
  1686. #endif
  1687.         },{
  1688. #ifdef _FAT_HXCOLOR
  1689.             ROW2X_FN(RGB32 ,RGB24 ,SHRINK),
  1690.             ROW2X_FN(RGB32 ,RGB24 ,COPY),
  1691.             ROW2X_FN(RGB32 ,RGB24 ,STRETCH),
  1692.             ROW2X_FN(RGB32 ,RGB24 ,STRETCH2X),
  1693.             ROW2X_FN(RGB32 ,RGB24 ,STRETCH2XPLUS)
  1694. #else
  1695.     0,
  1696.     0,
  1697.     0,
  1698.             0,
  1699.             0
  1700. #endif
  1701.         },{
  1702. #ifdef _FAT_HXCOLOR
  1703.             ROW2X_FN(RGB32 ,RGB565,SHRINK),
  1704.             ROW2X_FN(RGB32 ,RGB565,COPY),
  1705.             ROW2X_FN(RGB32 ,RGB565,STRETCH),
  1706.             ROW2X_FN(RGB32 ,RGB565,STRETCH2X),
  1707.             ROW2X_FN(RGB32 ,RGB565,STRETCH2XPLUS)
  1708. #else
  1709.     0,
  1710.     0,
  1711.     0,
  1712.             0,
  1713.             0
  1714. #endif
  1715.         },{
  1716. #ifdef _FAT_HXCOLOR
  1717.             ROW2X_FN(RGB32 ,RGB555,SHRINK),
  1718.             ROW2X_FN(RGB32 ,RGB555,COPY),
  1719.             ROW2X_FN(RGB32 ,RGB555,STRETCH),
  1720.             ROW2X_FN(RGB32 ,RGB555,STRETCH2X),
  1721.             ROW2X_FN(RGB32 ,RGB555,STRETCH2XPLUS)
  1722. #else
  1723.     0,
  1724.     0,
  1725.     0,
  1726.             0,
  1727.             0
  1728. #endif
  1729.         },{ /* rgb444 stub */
  1730.             0,
  1731.             0,
  1732.             0,
  1733.             0,
  1734.             0
  1735.         },{
  1736. #ifdef _8_BIT_SUPPORT
  1738.             ROW2X_FN(RGB32 ,RGB8  ,SHRINK),
  1739.             ROW2X_FN(RGB32 ,RGB8  ,COPY),
  1740.             ROW2X_FN(RGB32 ,RGB8  ,STRETCH),
  1741.             ROW2X_FN(RGB32 ,RGB8  ,STRETCH2X),
  1742.             ROW2X_FN(RGB32 ,RGB8  ,STRETCH2XPLUS)
  1743. #else
  1744.     0,
  1745.     0,
  1746.     0,
  1747.             0,
  1748.             0
  1749. #endif
  1750.         }
  1751.     },{ {
  1752.             ROW2X_FN(BGR32 ,RGB32 ,SHRINK),
  1753.             ROW2X_FN(BGR32 ,RGB32 ,COPY),
  1754.             ROW2X_FN(BGR32 ,RGB32 ,STRETCH),
  1755.             ROW2X_FN(BGR32 ,RGB32 ,STRETCH2X),
  1756.             ROW2X_FN(BGR32 ,RGB32 ,STRETCH2XPLUS)
  1757.         },{
  1758. #ifdef _FAT_HXCOLOR
  1759.             ROW2X_FN(BGR32 ,BGR32 ,SHRINK),
  1760.             ROW2X_FN(BGR32 ,BGR32 ,COPY),
  1761.             ROW2X_FN(BGR32 ,BGR32 ,STRETCH),
  1762.             ROW2X_FN(BGR32 ,BGR32 ,STRETCH2X),
  1763.             ROW2X_FN(BGR32 ,BGR32 ,STRETCH2XPLUS)
  1764. #else
  1765.     0,
  1766.     0,
  1767.     0,
  1768.             0,
  1769.             0
  1770. #endif
  1771.         },{
  1772. #ifdef _FAT_HXCOLOR
  1773.             ROW2X_FN(BGR32 ,RGB24 ,SHRINK),
  1774.             ROW2X_FN(BGR32 ,RGB24 ,COPY),
  1775.             ROW2X_FN(BGR32 ,RGB24 ,STRETCH),
  1776.             ROW2X_FN(BGR32 ,RGB24 ,STRETCH2X),
  1777.             ROW2X_FN(BGR32 ,RGB24 ,STRETCH2XPLUS)
  1778. #else
  1779.     0,
  1780.     0,
  1781.     0,
  1782.             0,
  1783.             0
  1784. #endif
  1785.         },{
  1786. #ifdef _FAT_HXCOLOR
  1787.             ROW2X_FN(BGR32 ,RGB565,SHRINK),
  1788.             ROW2X_FN(BGR32 ,RGB565,COPY),
  1789.             ROW2X_FN(BGR32 ,RGB565,STRETCH),
  1790.             ROW2X_FN(BGR32 ,RGB565,STRETCH2X),
  1791.             ROW2X_FN(BGR32 ,RGB565,STRETCH2XPLUS)
  1792. #else
  1793.     0,
  1794.     0,
  1795.     0,
  1796.             0,
  1797.             0
  1798. #endif
  1799.         },{
  1800. #ifdef _FAT_HXCOLOR
  1801.             ROW2X_FN(BGR32 ,RGB555,SHRINK),
  1802.             ROW2X_FN(BGR32 ,RGB555,COPY),
  1803.             ROW2X_FN(BGR32 ,RGB555,STRETCH),
  1804.             ROW2X_FN(BGR32 ,RGB555,STRETCH2X),
  1805.             ROW2X_FN(BGR32 ,RGB555,STRETCH2XPLUS)
  1806. #else
  1807.     0,
  1808.     0,
  1809.     0,
  1810.             0,
  1811.             0
  1812. #endif
  1813.         },{ /* rgb444 stub */
  1814.             0,
  1815.             0,
  1816.             0,
  1817.             0,
  1818.             0
  1819.         },{
  1820. #ifdef _8_BIT_SUPPORT
  1821.             ROW2X_FN(BGR32 ,RGB8  ,SHRINK),
  1822.             ROW2X_FN(BGR32 ,RGB8  ,COPY),
  1823.             ROW2X_FN(BGR32 ,RGB8  ,STRETCH),
  1824.             ROW2X_FN(BGR32 ,RGB8  ,STRETCH2X),
  1825.             ROW2X_FN(BGR32 ,RGB8  ,STRETCH2XPLUS)
  1826. #else
  1827.     0,
  1828.     0,
  1829.     0,
  1830.             0,
  1831.             0
  1832. #endif
  1833.         }
  1834.     },{ {
  1835.             ROW2X_FN(RGB24 ,RGB32 ,SHRINK),
  1836.             ROW2X_FN(RGB24 ,RGB32 ,COPY),
  1837.             ROW2X_FN(RGB24 ,RGB32 ,STRETCH),
  1838.             ROW2X_FN(RGB24 ,RGB32 ,STRETCH2X),
  1839.             ROW2X_FN(RGB24 ,RGB32 ,STRETCH2XPLUS)
  1840.         },{
  1841. #ifdef _FAT_HXCOLOR
  1842.             ROW2X_FN(RGB24 ,BGR32 ,SHRINK),
  1843.             ROW2X_FN(RGB24 ,BGR32 ,COPY),
  1844.             ROW2X_FN(RGB24 ,BGR32 ,STRETCH),
  1845.             ROW2X_FN(RGB24 ,BGR32 ,STRETCH2X),
  1846.             ROW2X_FN(RGB24 ,BGR32 ,STRETCH2XPLUS)
  1847. #else
  1848.     0,
  1849.     0,
  1850.     0,
  1851.             0,
  1852.             0
  1853. #endif
  1854.         },{
  1855. #ifdef _FAT_HXCOLOR
  1856.             ROW2X_FN(RGB24 ,RGB24 ,SHRINK),
  1857.             ROW2X_FN(RGB24 ,RGB24 ,COPY),
  1858.             ROW2X_FN(RGB24 ,RGB24 ,STRETCH),
  1859.             ROW2X_FN(RGB24 ,RGB24 ,STRETCH2X),
  1860.             ROW2X_FN(RGB24 ,RGB24 ,STRETCH2XPLUS)
  1861. #else
  1862.     0,
  1863.     0,
  1864.     0,
  1865.             0,
  1866.             0
  1867. #endif
  1868.         },{
  1869. #ifdef _FAT_HXCOLOR
  1870.             ROW2X_FN(RGB24 ,RGB565,SHRINK),
  1871.             ROW2X_FN(RGB24 ,RGB565,COPY),
  1872.             ROW2X_FN(RGB24 ,RGB565,STRETCH),
  1873.             ROW2X_FN(RGB24 ,RGB565,STRETCH2X),
  1874.             ROW2X_FN(RGB24 ,RGB565,STRETCH2XPLUS)
  1875. #else
  1876.     0,
  1877.     0,
  1878.     0,
  1879.             0,
  1880.             0
  1881. #endif
  1882.         },{
  1883. #ifdef _FAT_HXCOLOR
  1884.             ROW2X_FN(RGB24 ,RGB555,SHRINK),
  1885.             ROW2X_FN(RGB24 ,RGB555,COPY),
  1886.             ROW2X_FN(RGB24 ,RGB555,STRETCH),
  1887.             ROW2X_FN(RGB24 ,RGB555,STRETCH2X),
  1888.             ROW2X_FN(RGB24 ,RGB555,STRETCH2XPLUS)
  1889. #else
  1890.     0,
  1891.     0,
  1892.     0,
  1893.             0,
  1894.             0
  1895. #endif
  1896.         },{ /* rgb444 stub */
  1897.             0,
  1898.             0,
  1899.             0,
  1900.             0,
  1901.             0
  1902.         },{
  1903. #ifdef _8_BIT_SUPPORT
  1904.             ROW2X_FN(RGB24 ,RGB8  ,SHRINK),
  1905.             ROW2X_FN(RGB24 ,RGB8  ,COPY),
  1906.             ROW2X_FN(RGB24 ,RGB8  ,STRETCH),
  1907.             ROW2X_FN(RGB24 ,RGB8  ,STRETCH2X),
  1908.             ROW2X_FN(RGB24 ,RGB8  ,STRETCH2XPLUS)
  1909. #else
  1910.     0,
  1911.     0,
  1912.     0,
  1913.             0,
  1914.             0
  1915. #endif
  1916.         }
  1917.     },{ {
  1918.             ROW2X_FN(RGB565,RGB32 ,SHRINK),
  1919.             ROW2X_FN(RGB565,RGB32 ,COPY),
  1920.             ROW2X_FN(RGB565,RGB32 ,STRETCH),
  1921.             ROW2X_FN(RGB565,RGB32 ,STRETCH2X),
  1922.             ROW2X_FN(RGB565,RGB32 ,STRETCH2XPLUS)
  1923.         },{
  1924. #ifdef _FAT_HXCOLOR
  1925.             ROW2X_FN(RGB565,BGR32 ,SHRINK),
  1926.             ROW2X_FN(RGB565,BGR32 ,COPY),
  1927.             ROW2X_FN(RGB565,BGR32 ,STRETCH),
  1928.             ROW2X_FN(RGB565,BGR32 ,STRETCH2X),
  1929.             ROW2X_FN(RGB565,BGR32 ,STRETCH2XPLUS)
  1930. #else
  1931.     0,
  1932.     0,
  1933.     0,
  1934.             0,
  1935.             0
  1936. #endif
  1937.         },{
  1938. #ifdef _FAT_HXCOLOR
  1939.             ROW2X_FN(RGB565,RGB24 ,SHRINK),
  1940.             ROW2X_FN(RGB565,RGB24 ,COPY),
  1941.             ROW2X_FN(RGB565,RGB24 ,STRETCH),
  1942.             ROW2X_FN(RGB565,RGB24 ,STRETCH2X),
  1943.             ROW2X_FN(RGB565,RGB24 ,STRETCH2XPLUS)
  1944. #else
  1945.     0,
  1946.     0,
  1947.     0,
  1948.             0,
  1949.             0
  1950. #endif
  1951.         },{
  1952. #ifdef _FAT_HXCOLOR
  1953.             ROW2X_FN(RGB565,RGB565,SHRINK),
  1954.             ROW2X_FN(RGB565,RGB565,COPY),
  1955.             ROW2X_FN(RGB565,RGB565,STRETCH),
  1956.             ROW2X_FN(RGB565,RGB565,STRETCH2X),
  1957.             ROW2X_FN(RGB565,RGB565,STRETCH2XPLUS)
  1958. #else
  1959.     0,
  1960.     0,
  1961.     0,
  1962.             0,
  1963.             0
  1964. #endif
  1965.         },{
  1966. #ifdef _FAT_HXCOLOR
  1967.             ROW2X_FN(RGB565,RGB555,SHRINK),
  1968.             ROW2X_FN(RGB565,RGB555,COPY),
  1969.             ROW2X_FN(RGB565,RGB555,STRETCH),
  1970.             ROW2X_FN(RGB565,RGB555,STRETCH2X),
  1971.             ROW2X_FN(RGB565,RGB555,STRETCH2XPLUS)
  1972. #else
  1973.     0,
  1974.     0,
  1975.     0,
  1976.             0,
  1977.             0
  1978. #endif
  1979.         },{ /* rgb444 stub */
  1980.             0,
  1981.             0,
  1982.             0,
  1983.             0,
  1984.             0
  1985.         },{
  1986. #ifdef _8_BIT_SUPPORT
  1987.             ROW2X_FN(RGB565,RGB8  ,SHRINK),
  1988.             ROW2X_FN(RGB565,RGB8  ,COPY),
  1989.             ROW2X_FN(RGB565,RGB8  ,STRETCH),
  1990.             ROW2X_FN(RGB565,RGB8  ,STRETCH2X),
  1991.             ROW2X_FN(RGB565,RGB8  ,STRETCH2XPLUS)
  1992. #else
  1993.     0,
  1994.     0,
  1995.     0,
  1996.             0,
  1997.             0
  1998. #endif
  1999.         }
  2000.     },{ {
  2001.             ROW2X_FN(RGB555,RGB32 ,SHRINK),
  2002.             ROW2X_FN(RGB555,RGB32 ,COPY),
  2003.             ROW2X_FN(RGB555,RGB32 ,STRETCH),
  2004.             ROW2X_FN(RGB555,RGB32 ,STRETCH2X),
  2005.             ROW2X_FN(RGB555,RGB32 ,STRETCH2XPLUS)
  2006.         },{
  2007. #ifdef _FAT_HXCOLOR
  2008.             ROW2X_FN(RGB555,BGR32 ,SHRINK),
  2009.             ROW2X_FN(RGB555,BGR32 ,COPY),
  2010.             ROW2X_FN(RGB555,BGR32 ,STRETCH),
  2011.             ROW2X_FN(RGB555,BGR32 ,STRETCH2X),
  2012.             ROW2X_FN(RGB555,BGR32 ,STRETCH2XPLUS)
  2013. #else
  2014.     0,
  2015.     0,
  2016.     0,
  2017.             0,
  2018.             0
  2019. #endif
  2020.         },{
  2021. #ifdef _FAT_HXCOLOR
  2022.             ROW2X_FN(RGB555,RGB24 ,SHRINK),
  2023.             ROW2X_FN(RGB555,RGB24 ,COPY),
  2024.             ROW2X_FN(RGB555,RGB24 ,STRETCH),
  2025.             ROW2X_FN(RGB555,RGB24 ,STRETCH2X),
  2026.             ROW2X_FN(RGB555,RGB24 ,STRETCH2XPLUS)
  2027. #else
  2028.     0,
  2029.     0,
  2030.     0,
  2031.             0,
  2032.             0
  2033. #endif
  2034.         },{
  2035. #ifdef _FAT_HXCOLOR
  2036.             ROW2X_FN(RGB555,RGB565,SHRINK),
  2037.             ROW2X_FN(RGB555,RGB565,COPY),
  2038.             ROW2X_FN(RGB555,RGB565,STRETCH),
  2039.             ROW2X_FN(RGB555,RGB565,STRETCH2X),
  2040.             ROW2X_FN(RGB555,RGB565,STRETCH2XPLUS)
  2041. #else
  2042.     0,
  2043.     0,
  2044.     0,
  2045.             0,
  2046.             0
  2047. #endif
  2048.         },{
  2049. #ifdef _FAT_HXCOLOR
  2050.             ROW2X_FN(RGB555,RGB555,SHRINK),
  2051.             ROW2X_FN(RGB555,RGB555,COPY),
  2052.             ROW2X_FN(RGB555,RGB555,STRETCH),
  2053.             ROW2X_FN(RGB555,RGB555,STRETCH2X),
  2054.             ROW2X_FN(RGB555,RGB555,STRETCH2XPLUS)
  2055. #else
  2056.     0,
  2057.     0,
  2058.     0,
  2059.             0,
  2060.             0
  2061. #endif
  2062.         },{ /* rgb444 stub */
  2063.             0,
  2064.             0,
  2065.             0,
  2066.             0,
  2067.             0
  2068.         },{
  2069. #ifdef _8_BIT_SUPPORT
  2070.             ROW2X_FN(RGB555,RGB8  ,SHRINK),
  2071.             ROW2X_FN(RGB555,RGB8  ,COPY),
  2072.             ROW2X_FN(RGB555,RGB8  ,STRETCH),
  2073.             ROW2X_FN(RGB555,RGB8  ,STRETCH2X),
  2074.             ROW2X_FN(RGB555,RGB8  ,STRETCH2XPLUS)
  2075. #else
  2076.     0,
  2077.     0,
  2078.     0,
  2079.             0,
  2080.             0
  2081. #endif
  2082.         }
  2083.     },{ {
  2084. #ifdef _8_BIT_SUPPORT
  2085.             ROW2X_FN(RGB8  ,RGB32 ,SHRINK),
  2086.             ROW2X_FN(RGB8  ,RGB32 ,COPY),
  2087.             ROW2X_FN(RGB8  ,RGB32 ,STRETCH),
  2088.             ROW2X_FN(RGB8  ,RGB32 ,STRETCH2X),
  2089.             ROW2X_FN(RGB8  ,RGB32 ,STRETCH2XPLUS)
  2090. #else
  2091.     0,
  2092.     0,
  2093.     0,
  2094.             0,
  2095.             0
  2096. #endif
  2097.         },{
  2098. #ifdef _8_BIT_SUPPORT
  2099.             ROW2X_FN(RGB8  ,BGR32 ,SHRINK),
  2100.             ROW2X_FN(RGB8  ,BGR32 ,COPY),
  2101.             ROW2X_FN(RGB8  ,BGR32 ,STRETCH),
  2102.             ROW2X_FN(RGB8  ,BGR32 ,STRETCH2X),
  2103.             ROW2X_FN(RGB8  ,BGR32 ,STRETCH2XPLUS)
  2104. #else
  2105.     0,
  2106.     0,
  2107.     0,
  2108.             0,
  2109.             0
  2110. #endif
  2111.         },{
  2112. #ifdef _8_BIT_SUPPORT
  2113.             ROW2X_FN(RGB8  ,RGB24 ,SHRINK),
  2114.             ROW2X_FN(RGB8  ,RGB24 ,COPY),
  2115.             ROW2X_FN(RGB8  ,RGB24 ,STRETCH),
  2116.             ROW2X_FN(RGB8  ,RGB24 ,STRETCH2X),
  2117.             ROW2X_FN(RGB8  ,RGB24 ,STRETCH2XPLUS)
  2118. #else
  2119.     0,
  2120.     0,
  2121.     0,
  2122.             0,
  2123.             0
  2124. #endif
  2125.         },{
  2126. #ifdef _8_BIT_SUPPORT
  2127.             ROW2X_FN(RGB8  ,RGB565,SHRINK),
  2128.             ROW2X_FN(RGB8  ,RGB565,COPY),
  2129.             ROW2X_FN(RGB8  ,RGB565,STRETCH),
  2130.             ROW2X_FN(RGB8  ,RGB565,STRETCH2X),
  2131.             ROW2X_FN(RGB8  ,RGB565,STRETCH2XPLUS)
  2132. #else
  2133.     0,
  2134.     0,
  2135.     0,
  2136.             0,
  2137.             0
  2138. #endif
  2139.         },{
  2140. #ifdef _8_BIT_SUPPORT
  2141.             ROW2X_FN(RGB8  ,RGB555,SHRINK),
  2142.             ROW2X_FN(RGB8  ,RGB555,COPY),
  2143.             ROW2X_FN(RGB8  ,RGB555,STRETCH),
  2144.             ROW2X_FN(RGB8  ,RGB555,STRETCH2X),
  2145.             ROW2X_FN(RGB8  ,RGB555,STRETCH2XPLUS)
  2146. #else
  2147.     0,
  2148.     0,
  2149.     0,
  2150.             0,
  2151.             0
  2152. #endif
  2153.         },{ /* rgb444 stub */
  2154.             0,
  2155.             0,
  2156.             0,
  2157.             0,
  2158.             0
  2159.         },{
  2160. #ifdef _8_BIT_SUPPORT
  2161.             ROW2X_FN(RGB8  ,RGB8  ,SHRINK),
  2162.             ROW2X_FN(RGB8  ,RGB8  ,COPY),
  2163.             ROW2X_FN(RGB8  ,RGB8  ,STRETCH),
  2164.             ROW2X_FN(RGB8  ,RGB8  ,STRETCH2X),
  2165.             ROW2X_FN(RGB8  ,RGB8  ,STRETCH2XPLUS)
  2166. #else
  2167.     0,
  2168.     0,
  2169.     0,
  2170.             0,
  2171.             0
  2172. #endif
  2173.         }
  2174.     }
  2175. };
  2178. /*** RGB image converters: *********************************/
  2180. /*
  2181.  * Image shrink converter:
  2182.  */
  2183. void IMAGE_SHRINK (
  2184.     unsigned char *dest_ptr, int dest_dx, int dest_dy, int dest_pitch, int dest_bpp,
  2185.     unsigned char *src_ptr, int src_dx, int src_dy, int src_pitch, int src_bpp,
  2186.     void (*row_func) (unsigned char *, int, unsigned char *, int),
  2187.     void (*row2x_func) (unsigned char *, unsigned char *, unsigned char *,
  2188.         int, unsigned char *, int))
  2189. {
  2190.     /* initialize local variables: */
  2191.     register unsigned char *d = dest_ptr;
  2192.     register unsigned char *s = src_ptr;
  2193.     register int count = dest_dy;
  2194.     register int limit = src_dy >> 1; /* -1 */
  2195.     register int step = dest_dy;
  2196.     /* check image height: */
  2197.     if (count) {
  2198.         /* the main loop: */
  2199.         do {
  2200.             /* call row-converter: */
  2201.             (* row_func) (d, dest_dx, s, src_dx);
  2202.             d += dest_pitch;
  2203.             /* inverted Bresenham stepping: */
  2204.             do {
  2205.                 /* skip rows: */
  2206.                 s += src_pitch;
  2207.             } while ((limit -= step) >= 0);
  2208.             limit += src_dy;
  2209.         } while (--count);
  2210.     }
  2211. }
  2213. /*
  2214.  * Image copy converter:
  2215.  */
  2216. void IMAGE_COPY (
  2217.     unsigned char *dest_ptr, int dest_dx, int dest_dy, int dest_pitch, int dest_bpp,
  2218.     unsigned char *src_ptr, int src_dx, int src_dy, int src_pitch, int src_bpp,
  2219.     void (*row_func) (unsigned char *, int, unsigned char *, int),
  2220.     void (*row2x_func) (unsigned char *, unsigned char *, unsigned char *,
  2221.         int, unsigned char *, int))
  2222. {
  2223.     /* initialize local variables: */
  2224.     register unsigned char *d = dest_ptr;
  2225.     register unsigned char *s = src_ptr;
  2226.     register int count = dest_dy;
  2227.     /* check image height: */
  2228.     if (count) {
  2229.         /* the main loop: */
  2230.         do {
  2231.             /* call row-converter: */
  2232.             (* row_func) (d, dest_dx, s, src_dx);
  2233.             /* shift pointers: */
  2234.             s += src_pitch;
  2235.             d += dest_pitch;
  2236.         } while (--count);
  2237.     }
  2238. }
  2240. /*
  2241.  * Image stretching converter:
  2242.  *  (shall not be used when dest_dy/2 >= src_dy!!!)
  2243.  */
  2244. void IMAGE_STRETCH (
  2245.     unsigned char *dest_ptr, int dest_dx, int dest_dy, int dest_pitch, int dest_bpp,
  2246.     unsigned char *src_ptr, int src_dx, int src_dy, int src_pitch, int src_bpp,
  2247.     void (*row_func) (unsigned char *, int, unsigned char *, int),
  2248.     void (*row2x_func) (unsigned char *, unsigned char *, unsigned char *,
  2249.         int, unsigned char *, int))
  2250. {
  2251.     /* initialize local variables: */
  2252.     register unsigned char *d = dest_ptr;
  2253.     register unsigned char *s = src_ptr;
  2254.     register int dest_dx_bytes = dest_dx * dest_bpp;
  2255.     register int count = dest_dy;
  2256.     register int limit = dest_dy >> 1; /* !!! */
  2257.     register int step = src_dy;
  2258.     /* check image height: */
  2259.     if (count) {
  2260.         goto start;
  2261.         /* the main loop: */
  2262.         do {
  2263.             /* Bresenham stepping: */
  2264.             if ((limit -= step) < 0) {
  2265.                 limit += dest_dy;
  2266.                 /* convert a new row: */
  2267.     start:      (* row_func) (d, dest_dx, s, src_dx);
  2268.                 s += src_pitch;
  2269.                 d += dest_pitch;
  2270.             } else {
  2271.                 /* replicate last row: */
  2272.                 memcpy(d, d - dest_pitch, dest_dx_bytes); /* Flawfinder: ignore */
  2273.                 d += dest_pitch;
  2274.             }
  2275.         } while (--count);
  2276.     }
  2277. }
  2280. /*
  2281.  * Image 2x-stretching converter:
  2282.  */
  2283. void IMAGE_STRETCH2X (
  2284.     unsigned char *dest_ptr, int dest_dx, int dest_dy, int dest_pitch, int dest_bpp,
  2285.     unsigned char *src_ptr, int src_dx, int src_dy, int src_pitch, int src_bpp,
  2286.     void (*row_func) (unsigned char *, int, unsigned char *, int),
  2287.     void (*row2x_func) (unsigned char *, unsigned char *, unsigned char *,
  2288.         int, unsigned char *, int))
  2289. {
  2290.     /* initialize local variables: */
  2291.     register unsigned char *d1 = dest_ptr;
  2292.     register unsigned char *d12 = dest_ptr + dest_pitch;
  2293.     register unsigned char *d2 = dest_ptr + dest_pitch * 2;
  2294.     register unsigned char *s = src_ptr;
  2295.     register int dest_dx_bytes = dest_dx * dest_bpp;
  2296.     register int count = src_dy;
  2297.     /* check image height: */
  2298.     if (count) {
  2299.         /* convert first row: */
  2300.         (* row_func) (d1, dest_dx, s, src_dx);
  2301.         s += src_pitch;
  2302.         /* the main loop: */
  2303.         while (--count) {
  2304.             /* process second & half-pixel rows: */
  2305.             (* row2x_func) (d1, d12, d2, dest_dx, s, src_dx);
  2306.             d1 += 2 * dest_pitch;
  2307.             d12 += 2 * dest_pitch;
  2308.             d2 += 2 * dest_pitch;
  2309.             s += src_pitch;
  2310.         }
  2311.         /* replicate the last converted row: */
  2312.         memcpy (d12, d1, dest_dx_bytes); /* Flawfinder: ignore */
  2313.     }
  2314. }
  2316. /*
  2317.  * Image 2x+ stretching converter:
  2318.  */
  2319. void IMAGE_STRETCH2XPLUS (
  2320.     unsigned char *dest_ptr, int dest_dx, int dest_dy, int dest_pitch, int dest_bpp,
  2321.     unsigned char *src_ptr, int src_dx, int src_dy, int src_pitch, int src_bpp,
  2322.     void (*row_func) (unsigned char *, int, unsigned char *, int),
  2323.     void (*row2x_func) (unsigned char *, unsigned char *, unsigned char *,
  2324.         int, unsigned char *, int))
  2325. {
  2326.     /* initialize local variables: */
  2327.     register unsigned char *d = dest_ptr, *d1;
  2328.     register unsigned char *s = src_ptr;
  2329.     register int dest_dx_bytes = dest_dx * dest_bpp;
  2330.     register int count = dest_dy;
  2331.     register int limit = dest_dy >> 1; /* !!! */
  2332.     register int step = src_dy << 1;   /* !!! */
  2333.     /* # of rows mapped outside source image: */
  2334.     register int remainder = (2*dest_dy - limit) / step;
  2335.     /* check destination image height: */
  2336.     if (count) {
  2337.         /* convert first row: */
  2338.         (* row_func) (d, dest_dx, s, src_dx);
  2339.         s += src_pitch;
  2340.         /* update count: */
  2341.         if (!(count -= remainder)) {
  2342.             remainder --;
  2343.             goto end;
  2344.         }
  2345.         /* main loop: */
  2346.         while (1) {
  2347.             /* replicate last converted integral row: */
  2348.             goto start;
  2349.             do {
  2350.                 /* replicate a row: */
  2351.                 memcpy(d + dest_pitch, d, dest_dx_bytes); /* Flawfinder: ignore */
  2352.                 d += dest_pitch;
  2353. start:
  2354.                 /* check if all rows are filled up: */
  2355.                 if (!(--count))
  2356.                     goto end;
  2357.             } while ((limit -= step) >= 0);
  2358.             limit += dest_dy;
  2359.             /* store current location, and scan until next integral row: */
  2360.             d1 = d;
  2361.             do {
  2362.                 /* just shift a pointer: */
  2363.                 d += dest_pitch;
  2364.                 /* check if all rows are filled up: */
  2365.                 if (!(--count))
  2366.                     goto end_2;
  2367.             } while ((limit -= step) >= 0);
  2368.             limit += dest_dy;
  2369.             /* convert next integral & previous half-pixel rows: */
  2370.             (* row2x_func) (d1, d1 + dest_pitch, d + dest_pitch, dest_dx, s, src_dx);
  2371.             d1 += dest_pitch;
  2372.             s += src_pitch;
  2373.             /* replicate half-pixel row: */
  2374.             while (d1 != d) {   /* can't use < pitch can be negative!!! */
  2375.                 /* now, we can copy it: */
  2376.                 memcpy(d1 + dest_pitch, d1, dest_dx_bytes); /* Flawfinder: ignore */
  2377.                 d1 += dest_pitch;
  2378.             }
  2379.             /* select last converted row: */
  2380.             d += dest_pitch;
  2381.         }
  2382.         /* fill space reserved for half-pixel row: */
  2383. end_2:
  2384.         while (d1 != d) {   /* can't use < pitch can be negative!!! */
  2385.             memcpy(d1 + dest_pitch, d1, dest_dx_bytes); /* Flawfinder: ignore */
  2386.             d1 += dest_pitch;
  2387.         }
  2388.         /* copy the remaining rows: */
  2389. end:
  2390.         while (remainder--) {
  2391.             memcpy(d + dest_pitch, d, dest_dx_bytes); /* Flawfinder: ignore */
  2392.             d += dest_pitch;
  2393.         }
  2394.     }
  2395. }
  2397. /*
  2398.  * Image scale functions table:
  2399.  *  [vertical scale type]
  2400.  */
  2401. void (* ImageFuncs [SCALE_FUNCS]) (
  2402.     unsigned char *dest_ptr, int dest_dx, int dest_dy, int dest_pitch, int dest_bpp,
  2403.     unsigned char *src_ptr, int src_dx, int src_dy, int src_pitch, int src_bpp,
  2404.     void (*row_func) (unsigned char *, int, unsigned char *, int),
  2405.     void (*row2x_func) (unsigned char *, unsigned char *, unsigned char *,
  2406.         int, unsigned char *, int)) =
  2407. {
  2408.     IMAGE_SHRINK,
  2409.     IMAGE_COPY,
  2410.     IMAGE_STRETCH,
  2411.     IMAGE_STRETCH2X,
  2412.     IMAGE_STRETCH2XPLUS
  2413. };
  2415. /*
  2416.  * Bytes per pixel (bpp) table:
  2417.  */
  2418. int bpp [RGB_FORMATS] =
  2419. {
  2420.     BPP(RGB32),
  2421.     BPP(BGR32),
  2422.     BPP(RGB24),
  2423.     BPP(RGB565),
  2424.     BPP(RGB555),
  2425.     BPP(RGB444),
  2426.     BPP(RGB8)
  2427. };
  2429. /*
  2430.  * The main RGBtoRGB converter:
  2431.  */
  2432. int RGBtoRGB (
  2433.     /* destination image parameters: */
  2434.     int dest_format, unsigned char *dest_ptr, int dest_width, int dest_height,
  2435.     int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  2436.     /* source image parameters: */
  2437.     int src_format, unsigned char *src_ptr, int src_width, int src_height,
  2438.     int src_pitch, int src_x, int src_y, int src_dx, int src_dy)
  2439. {
  2440.     /* pointers to low-level converters to use: */
  2441.     void (*row_proc) (unsigned char *, int, unsigned char *, int);
  2442.     void (*row2x_proc) (unsigned char *, unsigned char *, unsigned char *, int,
  2443.         unsigned char *, int);
  2444.     void (*image_proc) (unsigned char *, int, int, int, int,
  2445.         unsigned char *, int, int, int, int,
  2446.         void (*) (unsigned char *, int, unsigned char *, int),
  2447.         void (*) (unsigned char *, unsigned char *, unsigned char *, int,
  2448.             unsigned char *, int));
  2449.     /* scale types: */
  2450.     register int scale_x, scale_y;
  2452.     /* pointers and pixel depths: */
  2453.     register int dest_bpp, src_bpp;
  2454.     register unsigned char *d, *s;
  2456.     /* check arguments: */
  2457.     if (
  2458.         /* alignments: */
  2459.         ((unsigned)dest_ptr & 3) || (dest_pitch & 3) ||
  2460.         ((unsigned)src_ptr  & 3) || (src_pitch  & 3) ||
  2461.         /* image sizes: */
  2462.         dest_width <= 0 || dest_height <= 0 ||
  2463.         src_width  <= 0 || src_height  <= 0 ||
  2464.         /* rectangles: */
  2465.         dest_x < 0 || dest_y < 0 || dest_dx <= 0 || dest_dy <= 0 ||
  2466.         src_x  < 0 || src_y  < 0 || src_dx  <= 0 || src_dy  <= 0 ||
  2467.         /* overlaps: */
  2468.         dest_width < dest_x + dest_dx || dest_height < dest_y + dest_dy ||
  2469.         src_width  < src_x  + src_dx  || src_height  < src_y  + src_dy)
  2470.     {
  2471.         /* fail: */
  2472.         return -1;
  2473.     }
  2475.     /* get scale types: */
  2476.     GET_SCALE_TYPE(dest_dx, src_dx, scale_x);
  2477.     GET_SCALE_TYPE(dest_dy, src_dy, scale_y);
  2479.     /* select row and image converters: */
  2480.     row_proc   = RowFuncs [dest_format][src_format][scale_x];
  2481.     row2x_proc = Row2xFuncs [dest_format][src_format][scale_x];
  2482.     image_proc = ImageFuncs [scale_y];
  2484.     if (!row_proc  || !row2x_proc || !image_proc)
  2485.     {
  2486.         return 1;
  2487.     }
  2489.     /* get pixel depths: */
  2490.     dest_bpp = bpp [dest_format];
  2491.     src_bpp = bpp [src_format];
  2493.     /* check if bottom-up bitmaps: */
  2494.     if (dest_pitch < 0) dest_ptr -= (dest_height-1) * dest_pitch;
  2495.     if (src_pitch < 0)  src_ptr -= (src_height-1) * src_pitch;
  2497.     /* get pointers: */
  2498.     d = dest_ptr + dest_x * dest_bpp + dest_y * dest_pitch;
  2499.     s = src_ptr + src_x * src_bpp + src_y * src_pitch;
  2501.     /* pass control to appropriate lower-level converters: */
  2502.     (* image_proc) (d, dest_dx, dest_dy, dest_pitch, dest_bpp,
  2503.         s, src_dx, src_dy, src_pitch, src_bpp, row_proc, row2x_proc);
  2505.     /* success: */
  2506.     return 0;
  2507. }
  2510. /*
  2511.  * Public format-conversion routines.
  2512.  * Use:
  2513.  *  int XXXXtoYYYY (unsigned char *dest_ptr, int dest_width, int dest_height,
  2514.  *      int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  2515.  *      unsigned char *src_ptr, int src_width, int src_height, int src_pitch,
  2516.  *      int src_x, int src_y, int src_dx, int src_dy);
  2517.  * Input:
  2518.  *  dest_ptr - pointer to a destination buffer
  2519.  *  dest_width, dest_height - width/height of the destination image (pixels)
  2520.  *  dest_pitch - pitch of the dest. buffer (in bytes; <0 - if bottom up image)
  2521.  *  dest_x, dest_y, dest_dx, dest_dy - destination rectangle (pixels)
  2522.  *  src_ptr - pointer to an input image
  2523.  *  src_width, src_height - width/height of the input image (pixels)
  2524.  *  src_pitch - pitch of the source buffer (in bytes; <0 - if bottom up image)
  2525.  *  src_x, src_y, src_dx, src_dy - source rectangle (pixels)
  2526.  * Returns:
  2527.  *  0 - if success; -1 if failure.
  2528.  * Note:
  2529.  *  Both source and destination buffers must be 4-bytes aligned,
  2530.  *  and their pitches (#of bytes in row) shall be multiple of 4!!!
  2531.  */
  2533. #define RGBTORGB_FUNC(df,sf)                                
  2534.     int FN(df,sf) (unsigned char *dest_ptr,                 
  2535.         int dest_width, int dest_height, int dest_pitch,    
  2536.         int dest_x, int dest_y, int dest_dx, int dest_dy,   
  2537.         unsigned char *src_ptr,                             
  2538.         int src_width, int src_height, int src_pitch,       
  2539.         int src_x, int src_y, int src_dx, int src_dy)       
  2540.     {                                                       
  2541.         return RGBtoRGB(                                    
  2542.             ID(df), dest_ptr, dest_width, dest_height,      
  2543.             dest_pitch, dest_x, dest_y, dest_dx, dest_dy,   
  2544.             ID(sf), src_ptr, src_width, src_height,         
  2545.             src_pitch, src_x, src_y, src_dx, src_dy);       
  2546.     }
  2549. RGBTORGB_FUNC(RGB32 ,RGB32 )
  2550. RGBTORGB_FUNC(RGB32 ,BGR32 )
  2551. RGBTORGB_FUNC(RGB32 ,RGB24 )
  2552. RGBTORGB_FUNC(RGB32 ,RGB565)
  2553. RGBTORGB_FUNC(RGB32 ,RGB555)
  2554. RGBTORGB_FUNC(RGB32 ,RGB8  )
  2556. RGBTORGB_FUNC(BGR32 ,RGB32 )
  2557. RGBTORGB_FUNC(BGR32 ,BGR32 )
  2558. RGBTORGB_FUNC(BGR32 ,RGB24 )
  2559. RGBTORGB_FUNC(BGR32 ,RGB565)
  2560. RGBTORGB_FUNC(BGR32 ,RGB555)
  2561. RGBTORGB_FUNC(BGR32 ,RGB8  )
  2563. RGBTORGB_FUNC(RGB24 ,RGB32 )
  2564. RGBTORGB_FUNC(RGB24 ,BGR32 )
  2565. RGBTORGB_FUNC(RGB24 ,RGB24 )
  2566. RGBTORGB_FUNC(RGB24 ,RGB565)
  2567. RGBTORGB_FUNC(RGB24 ,RGB555)
  2568. RGBTORGB_FUNC(RGB24 ,RGB8  )
  2570. RGBTORGB_FUNC(RGB565,RGB32 )
  2571. RGBTORGB_FUNC(RGB565,BGR32 )
  2572. RGBTORGB_FUNC(RGB565,RGB24 )
  2573. RGBTORGB_FUNC(RGB565,RGB565)
  2574. RGBTORGB_FUNC(RGB565,RGB555)
  2575. RGBTORGB_FUNC(RGB565,RGB8  )
  2577. RGBTORGB_FUNC(RGB555,RGB32 )
  2578. RGBTORGB_FUNC(RGB555,BGR32 )
  2579. RGBTORGB_FUNC(RGB555,RGB24 )
  2580. RGBTORGB_FUNC(RGB555,RGB565)
  2581. RGBTORGB_FUNC(RGB555,RGB555)
  2582. RGBTORGB_FUNC(RGB555,RGB8  )
  2584. RGBTORGB_FUNC(RGB8  ,RGB32 )
  2585. RGBTORGB_FUNC(RGB8  ,BGR32 )
  2586. RGBTORGB_FUNC(RGB8  ,RGB24 )
  2587. RGBTORGB_FUNC(RGB8  ,RGB565)
  2588. RGBTORGB_FUNC(RGB8  ,RGB555)
  2589. RGBTORGB_FUNC(RGB8  ,RGB8  )
  2592. /***********************************************************/
  2593. #ifdef TESTALL
  2595. /*
  2596.  * Enumerates all possible formats/sizes and checks
  2597.  * if conversion is performed correctly.
  2598.  */
  2600. /* C RunTime Header Files */
  2601. #include <stdio.h>
  2602. #include <stdlib.h>
  2603. #include <string.h>
  2605. /* image buffers: */
  2606. #define MAX_WIDTH   176
  2607. #define MAX_PITCH   ((MAX_WIDTH + 1) * 4)
  2608. #define MAX_HEIGHT  144
  2610. static char src_image [(MAX_HEIGHT+1) * MAX_PITCH]; /* Flawfinder: ignore */
  2611. static char dest_image [(MAX_HEIGHT+1) * MAX_PITCH]; /* Flawfinder: ignore */
  2613. /*
  2614.  * Unified Set/Get pixel functions:
  2615.  */
  2616. static void GetPixel (int format, unsigned char *ptr, int *pr, int *pg, int *pb)
  2617. {
  2618. #   define  GET_PIXEL(f,s,r,g,b)    
  2619.         {                           
  2620.             PIXEL(f,a);             
  2621.             LOAD(f,s,a);            
  2622.             r = GET_R(f,a);         
  2623.             g = GET_G(f,a);         
  2624.             b = GET_B(f,a);         
  2625.         }
  2627.     switch (format) {
  2628.         case ID(RGB32) : GET_PIXEL(RGB32 ,ptr,*pr,*pg,*pb); break;
  2629.         case ID(BGR32) : GET_PIXEL(BGR32 ,ptr,*pr,*pg,*pb); break;
  2630.         case ID(RGB24) : GET_PIXEL(RGB24 ,ptr,*pr,*pg,*pb); break;
  2631.         case ID(RGB565): GET_PIXEL(RGB565,ptr,*pr,*pg,*pb); break;
  2632.         case ID(RGB555): GET_PIXEL(RGB555,ptr,*pr,*pg,*pb); break;
  2633.         case ID(RGB8)  : GET_PIXEL(RGB8  ,ptr,*pr,*pg,*pb); break;
  2634.     }
  2635. }
  2637. static void SetPixel (int format, unsigned char *ptr, int r, int g, int b)
  2638. {
  2639. #   define  SET_PIXEL(f,d,r,g,b)    
  2640.         {                           
  2641.             PIXEL(f,a);             
  2642.             SET(f,a,r,g,b);         
  2643.             STORE(f,d,a);           
  2644.         }
  2646.     switch (format) {
  2647.         case ID(RGB32) : SET_PIXEL(RGB32 ,ptr,r,g,b); break;
  2648.         case ID(BGR32) : SET_PIXEL(BGR32 ,ptr,r,g,b); break;
  2649.         case ID(RGB24) : SET_PIXEL(RGB24 ,ptr,r,g,b); break;
  2650.         case ID(RGB565): SET_PIXEL(RGB565,ptr,r,g,b); break;
  2651.         case ID(RGB555): SET_PIXEL(RGB555,ptr,r,g,b); break;
  2652.         case ID(RGB8)  : SET_PIXEL(RGB8  ,ptr,r,g,b); break;
  2653.     }
  2654. }
  2656. /*
  2657.  * Test pixel value:
  2658.  */
  2659. #define TEST_R    0x80
  2660. #define TEST_G    0x80
  2661. #define TEST_B    0x80
  2663. /*
  2664.  * The test program:
  2665.  */
  2666. int main (int argc, char *argv[])
  2667. {
  2668.     int src_format, src_width, src_height;
  2669.     int dest_format, dest_width, dest_height;
  2671. /* register color in the palette: */
  2672. PAL_SET(1,TEST_R,TEST_G,TEST_B);
  2673.     PMAP_SET(1,TEST_R,TEST_G,TEST_B);
  2675.     /* the main loop: */
  2676.     for (src_format=0; src_format<RGB_FORMATS; src_format++)
  2677.     for (dest_format=1; dest_format<RGB_FORMATS; dest_format++)
  2678.     for (src_width=1; src_width<=MAX_WIDTH; src_width++)
  2679.     for (src_height=1; src_height<=MAX_HEIGHT; src_height++)
  2680.     for (dest_width=1; dest_width<=MAX_WIDTH; dest_width++)
  2681.     for (dest_height=1; dest_height<=MAX_HEIGHT; dest_height++)
  2682.     {
  2683.         register unsigned char *s, *d ;
  2684.         register int i, j;
  2686.         /* print diagnostic message: */
  2687.         printf ("testing conversion: (%d,%d,%d) -> (%d,%d,%d)... ",
  2688.             src_format, src_height, src_width, dest_format, dest_height, dest_width);
  2690.         /* clear buffers: */
  2691.         memset (src_image, 0, sizeof(src_image));
  2692.         memset (dest_image, 0, sizeof(dest_image));
  2694.         /* create source image: */
  2695.         s = src_image;
  2696.         for (i=0; i<src_height; i++) {
  2697.             for (j=0; j<src_width; j++) {
  2698.                 SetPixel(src_format, s, TEST_R, TEST_G, TEST_B);
  2699.                 s += bpp[src_format];
  2700.             }
  2701.             s += MAX_PITCH - src_width * bpp[src_format];
  2702.         }
  2704.         /* call color converter: */
  2705.         if (RGBtoRGB (dest_format, dest_image, dest_width, dest_height,
  2706.             MAX_PITCH, 0, 0, dest_width, dest_height, src_format, src_image,
  2707.             src_width, src_height, MAX_PITCH, 0, 0, src_width, src_height)) {
  2708.             printf ("RGBtoRGb error!!");
  2709.             getch();
  2710.         }
  2712.         /* test converted image: */
  2713.         d = dest_image;
  2714.         for (i=0; i<dest_height; i++) {
  2715.             int r,g,b;
  2716.             for (j=0; j<dest_width; j++) {
  2717.                 GetPixel(dest_format, d, &r, &g, &b);
  2718.                 if (r != TEST_R || g != TEST_G || b != TEST_B) {
  2719.                     printf ("{%d,%d}",i,j);
  2720.                     getch();
  2721.                 }
  2722.                 d += bpp[dest_format];
  2723.             }
  2724.             /* check pixels outside the frame !!!*/
  2725.             GetPixel(dest_format, d, &r, &g, &b);
  2726.             if (r != 0 || g != 0 || b != 0) {
  2727.                 printf ("!!!}%d,%d{",i,j);
  2728.                 getch();
  2729.             }
  2730.             d += MAX_PITCH - dest_width * bpp[dest_format];
  2731.         }
  2732.         printf ("done.n");
  2733.     }
  2734. }
  2735. #endif
  2737. /***********************************************************/
  2738. #ifdef TEST
  2739. /*
  2740.  * Test program.
  2741.  * Use:
  2742.  *  RGB2RGB <output file> <input file> [<new width> <new height>] [<new format>]
  2743.  */
  2745. /* Note: use /Zp1 (no structure alignments) to compile it !!! */
  2747. /* Windows Header Files: */
  2748. #include <windows.h>
  2750. /* C RunTime Header Files */
  2751. #include <stdio.h>
  2752. #include <stdlib.h>
  2753. #include <string.h>
  2755. /* Main program: */
  2756. int main (int argc, char *argv[])
  2757. {
  2758.     /* local variables: */
  2759.     FILE *ifp, *ofp;
  2760.     int width = 0, height = 0, format = 0;
  2761.     static struct BMPHDR {
  2762.         BITMAPFILEHEADER hdr;               /* bitmap file-header */
  2763.         BITMAPINFOHEADER bihdr;             /* bitmap info-header */
  2764.     } src_bmphdr, dest_bmphdr;
  2765.     int src_image_size, dest_image_size;
  2766.     unsigned char *src_image, *dest_image;
  2767. register int i;
  2769.     int (* func) (unsigned char *dest_ptr, int dest_width, int dest_height,
  2770.         int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  2771.         unsigned char *src_ptr, int src_width, int src_height, int src_pitch,       
  2772.         int src_x, int src_y, int src_dx, int src_dy);
  2774.     /* process program arguments: */
  2775.     if (argc < 3) {
  2776.         fprintf (stderr, "Use:ntRGB2RGB <output file> <input file> [width] [height] [format]n");
  2777. exit (EXIT_FAILURE);
  2778. }
  2779.     /* open work files: */
  2780.     if ((ofp = fopen (argv[1], "wb+")) == NULL) { /* Flawfinder: ignore */
  2781.         fprintf (stderr, "Cannot open output file.n");
  2782. exit (EXIT_FAILURE);
  2783. }
  2784. if ((ifp = fopen (argv[2], "rb")) == NULL) { /* Flawfinder: ignore */
  2785.         fprintf (stderr, "Cannot open input file.n");
  2786. exit (EXIT_FAILURE);
  2787. }
  2788.     /* retrieve optional arguments: */
  2789.     if ((argc >= 4)
  2790.      && (width = atoi(argv[3])) == 0) {
  2791.         fprintf (stderr, "Invalid image width.n");
  2792. exit (EXIT_FAILURE);
  2793.     }
  2794.     if ((argc >= 5)
  2795.      && (height = atoi(argv[4])) == 0) {
  2796.         fprintf (stderr, "Invalid image height.n");
  2797. exit (EXIT_FAILURE);
  2798.     }
  2799.     if ((argc >= 6)
  2800.      && (format = atoi(argv[5])) == 0) {
  2801.         fprintf (stderr, "Invalid image format.n");
  2802. exit (EXIT_FAILURE);
  2803.      }
  2805.     /* read input file header: */
  2806. i = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
  2807.     if (fread ((void *)&src_bmphdr, 1, i, ifp) != i) {
  2808. fprintf (stderr, "Cannot read input file.n");
  2809. exit (EXIT_FAILURE);
  2810. }
  2812.     /* here we will deal with simplest BMPs only: */
  2813.     if (src_bmphdr.bihdr.biCompression != BI_RGB
  2814.      || src_bmphdr.hdr.bfOffBits != i) {
  2815.         fprintf (stderr, "Sorry, I cannot understand this type of bitmap.n");
  2816. exit (EXIT_FAILURE);
  2817.     }
  2819.     /* prepare output file header: */
  2820.     memcpy((void *)&dest_bmphdr, (void *)&src_bmphdr, i); /* Flawfinder: ignore */
  2821.     if (width)
  2822.         dest_bmphdr.bihdr.biWidth = width;
  2823.     if (height)
  2824.         dest_bmphdr.bihdr.biHeight = height;
  2826.     /* allocate memory for source/dest. images: */
  2827.     src_image_size = src_bmphdr.bihdr.biWidth * src_bmphdr.bihdr.biHeight * src_bmphdr.bihdr.biBitCount / 8;
  2828.     dest_image_size = dest_bmphdr.bihdr.biWidth * dest_bmphdr.bihdr.biHeight * dest_bmphdr.bihdr.biBitCount / 8;
  2829.     if ((src_image = (unsigned char *)malloc(src_image_size)) == NULL ||
  2830.         (dest_image = (unsigned char *)malloc(dest_image_size)) == NULL) {
  2831.         fprintf (stderr, "Out of memory.n");
  2832. exit (EXIT_FAILURE);
  2833.     }
  2835.     /* read input frame: */
  2836.     if (fread (src_image, 1, src_image_size, ifp) != src_image_size) {
  2837. fprintf (stderr, "Cannot read input file.n");
  2838.         goto free_exit;
  2839.     }
  2841.     /* select color converter to use: */
  2842.     switch (src_bmphdr.bihdr.biBitCount)
  2843.     {
  2844.         case 32: func = RGB32toRGB32;   break;
  2845.         case 24: func = RGB24toRGB24;   break;
  2846.         case 16: func = RGB555toRGB555; break;
  2847.         case 8:  func = RGB8toRGB8;     break;
  2848.         default:
  2849.             fprintf (stderr, "Unsupported pixel depth.n");
  2850.             goto free_exit;
  2851.     }
  2853.     /* call it: */
  2854.     if ((* func)
  2855.         (dest_image, dest_bmphdr.bihdr.biWidth, dest_bmphdr.bihdr.biHeight,
  2856.         dest_bmphdr.bihdr.biWidth * dest_bmphdr.bihdr.biBitCount / 8,
  2857.         0, 0, dest_bmphdr.bihdr.biWidth, dest_bmphdr.bihdr.biHeight,
  2858.         src_image, src_bmphdr.bihdr.biWidth, src_bmphdr.bihdr.biHeight,
  2859.         src_bmphdr.bihdr.biWidth * src_bmphdr.bihdr.biBitCount / 8,
  2860.         0, 0, src_bmphdr.bihdr.biWidth, src_bmphdr.bihdr.biHeight))
  2861.     {
  2862.         fprintf (stderr, "Format conversion error.n");
  2863.         goto free_exit;
  2864.     }
  2866.     /* save converted image: */
  2867.     if (fwrite ((void *)&dest_bmphdr, 1, i, ofp) != i
  2868.      || fwrite (dest_image, 1, dest_image_size, ofp) != dest_image_size) {
  2869.         fprintf (stderr, "Cannot save file.n");
  2870.     }
  2872. free_exit:
  2873.     /* free memory: */
  2874.     free (src_image);
  2875.     free (dest_image);
  2877. /* close files & exit: */
  2878. fclose (ifp);
  2879. fclose (ofp);
  2881.     return EXIT_SUCCESS;
  2882. }
  2883. #endif
  2885. /* rgb2rgb.c -- end of file */