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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
rgb2rgb.c
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：98k
源码类别：

Symbian

开发平台：

Visual C++

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