home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / rexx / library2 / gbmrexx / gbm / gbmmir.c < prev    next >
C/C++ Source or Header  |  1992-11-12  |  7KB  |  349 lines
  1. /*
  2.  
  3. GBMMIR.C  Produce Mirror Image of General Bitmap
  4.  
  5. */
  6.  
  7. /*...sincludes:0:*/
  8. #include <stdio.h>
  9. #include <string.h>
  10. #include <stddef.h>
  11. #include <stdlib.h>
  12. #include <memory.h>
  13. #include <malloc.h>
  14. #include "standard.h"
  15. #include "gbm.h"
  16.  
  17. /*...vgbm\46\h:0:*/
  18. /*...e*/
  19.  
  20. /*...sgbm_ref_vert:0:*/
  21. BOOLEAN gbm_ref_vert(GBM *gbm, byte *data)
  22.     {
  23.     int    stride = ( ((gbm -> w * gbm -> bpp + 31)/32) * 4 );
  24.     byte    *p1 = data;
  25.     byte    *p2 = data + (gbm -> h - 1) * stride;
  26.     byte    *p3;
  27.  
  28.     if ( (p3 = malloc(stride)) == NULL )
  29.         return ( FALSE );
  30.  
  31.     for ( ; p1 < p2; p1 += stride, p2 -= stride )
  32.         {
  33.         memcpy(p3, p1, stride);
  34.         memcpy(p1, p2, stride);
  35.         memcpy(p2, p3, stride);
  36.         }
  37.  
  38.     free(p3);
  39.  
  40.     return ( TRUE );
  41.     }
  42. /*...e*/
  43. /*...sgbm_ref_horz:0:*/
  44. /*...sref_horz_24:0:*/
  45. static void ref_horz_24(byte *dst, byte *src, int n)
  46.     {
  47.     dst += n * 3;
  48.     while ( n-- )
  49.         {
  50.         dst -= 3;
  51.         dst [0] = *src++;
  52.         dst [1] = *src++;
  53.         dst [2] = *src++;
  54.         }
  55.     }
  56. /*...e*/
  57. /*...sref_horz_8:0:*/
  58. static void ref_horz_8(byte *dst, byte *src, int n)
  59.     {
  60.     dst += n;
  61.     while ( n-- )
  62.         *(--dst) = *src++;
  63.     }
  64. /*...e*/
  65. /*...sref_horz_4:0:*/
  66. static byte rev4 [0x100];
  67.  
  68. static void table_4(void)
  69.     {
  70.     int    i;
  71.  
  72.     for ( i = 0; i < 0x100; i++ )
  73.         rev4 [i] = (byte) ( ((i & 0x0f) << 4) | ((i & 0xf0) >> 4) );
  74.     }
  75.  
  76. static void ref_horz_4(byte *dst, byte *src, int n)
  77.     {
  78.     if ( (n & 1) == 0 )
  79.         {
  80.         n /= 2;
  81.         dst += n;
  82.         while ( n-- )
  83.             *(--dst) = rev4 [*src++];
  84.         }
  85.     else
  86.         {
  87.         n /= 2;
  88.         src += n;
  89.         while ( n-- )
  90.             {
  91.             *dst    = (byte) (*(src--) & 0xf0);
  92.             *dst++ |= (byte) (* src    & 0x0f);
  93.             }
  94.         *dst = (byte) (*src & 0xf0);
  95.         }
  96.     }
  97. /*...e*/
  98. /*...sref_horz_1:0:*/
  99. static byte rev [0x100]; /* Reverses all bits in a byte */
  100. static byte rev_top [7][0x100]; /* Reverses top N bits of a byte */
  101. static byte rev_bot [7][0x100]; /* Reverses bottom N bits of a byte */
  102. static byte lmask [8] = { 0, 0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe };
  103.  
  104. static void table_1(void)
  105.     {
  106.     int i;
  107.  
  108.     for ( i = 0; i < 0x100; i++ )
  109.         {
  110.         int j, p, q, b = 0;
  111.  
  112.         for ( p = 0x01, q = 0x80; p < 0x100; p <<= 1, q >>= 1 )
  113.             if ( i & p )
  114.                 b |= q;
  115.         rev [i] = b;
  116.  
  117.         for ( j = 1; j < 8; j++ )
  118.             {
  119.             byte l = 0, r = 0;
  120.             byte lm = 0x80, lmr = (byte) (0x80 >> (j - 1));
  121.             byte rm = 0x01, rmr = (byte) (0x01 << (j - 1));
  122.             int k;
  123.  
  124.             for ( k = 0; k < j; k++ )
  125.                 {
  126.                 if ( i & (lm >> k) ) l |= (lmr << k);
  127.                 if ( i & (rm << k) ) r |= (rmr >> k);
  128.                 }
  129.             rev_top [j-1][i] = l;
  130.             rev_bot [j-1][i] = r;
  131.             }
  132.         }
  133.     }
  134.  
  135. static void ref_horz_1(byte *dst, byte *src, int n)
  136.     {
  137.     int    last = ( n & 7 );
  138.  
  139.     n >>= 3;
  140.     if ( last == 0 )
  141.         {
  142.         dst += n;
  143.         while ( n-- )
  144.             *(--dst) = rev [*src++];
  145.         }
  146.     else
  147.         {
  148.         byte    *lrev = rev_top [   last -1];
  149.         byte    *rrev = rev_bot [(8-last)-1];
  150.         byte    lm = lmask [last], rm = 0xff - lm;
  151.  
  152.         src += n;
  153.         while ( n-- )
  154.             {
  155.             *dst    = lrev [*(src--) & lm];
  156.             *dst++ |= rrev [* src    & rm];
  157.             }
  158.         *dst = lrev [*src & lm];
  159.         }
  160.     }
  161. /*...e*/
  162.  
  163. BOOLEAN gbm_ref_horz(GBM *gbm, byte *data)
  164.     {
  165.     int    stride = ( ((gbm -> w * gbm -> bpp + 31)/32) * 4 );
  166.     int    y;
  167.     byte    *p = data;
  168.     byte    *tmp;
  169.  
  170.     if ( (tmp = malloc(stride)) == NULL )
  171.         return ( FALSE );
  172.  
  173.     switch ( gbm -> bpp )
  174.         {
  175.         case 24:
  176.             for ( y = 0; y < gbm -> h; y++, p += stride )
  177.                 {
  178.                 ref_horz_24(tmp, p, gbm -> w);
  179.                 memcpy(p, tmp, stride);
  180.                 }
  181.             break;
  182.         case 8:
  183.             for ( y = 0; y < gbm -> h; y++, p += stride )
  184.                 {
  185.                 ref_horz_8(tmp, p, gbm -> w);
  186.                 memcpy(p, tmp, stride);
  187.                 }
  188.             break;
  189.         case 4:
  190.             table_4();
  191.             for ( y = 0; y < gbm -> h; y++, p += stride )
  192.                 {
  193.                 ref_horz_4(tmp, p, gbm -> w);
  194.                 memcpy(p, tmp, stride);
  195.                 }
  196.             break;
  197.         case 1:
  198.             table_1();
  199.             for ( y = 0; y < gbm -> h; y++, p += stride )
  200.                 {
  201.                 ref_horz_1(tmp, p, gbm -> w);
  202.                 memcpy(p, tmp, stride);
  203.                 }
  204.             break;
  205.         }
  206.  
  207.     free(tmp);
  208.  
  209.     return ( TRUE );
  210.     }
  211. /*...e*/
  212. /*...sgbm_transpose:0:*/
  213. void gbm_transpose(GBM *gbm, byte *data, byte *data_t)
  214.     {
  215.     int stride   = ((gbm -> w * gbm -> bpp + 31) / 32) * 4;
  216.     int stride_t = ((gbm -> h * gbm -> bpp + 31) / 32) * 4;
  217.  
  218.     switch ( gbm -> bpp )
  219.         {
  220. /*...s24:16:*/
  221. case 24:
  222.     {
  223.     int data_step = stride - gbm -> w * 3;
  224.     int p_step = stride_t - 2;
  225.     int x, y;
  226.  
  227.     for ( y = 0; y < gbm -> h; y++ )
  228.         {
  229.         byte *p = data_t; data_t += 3;
  230.  
  231.         for ( x = 0; x < gbm -> w; x++ )
  232.             {
  233.             *p++ = *data++;
  234.             *p++ = *data++;
  235.             *p   = *data++;
  236.             p += p_step;
  237.             }
  238.         data += data_step;
  239.         }
  240.     }
  241.     break;
  242. /*...e*/
  243. /*...s8:16:*/
  244. case 8:
  245.     {
  246.     int data_step = stride - gbm -> w;
  247.     int x, y;
  248.  
  249.     for ( y = 0; y < gbm -> h; y++ )
  250.         {
  251.         byte *p = data_t++;
  252.  
  253.         for ( x = 0; x < gbm -> w; x++ )
  254.             {
  255.             *p = *data++;
  256.             p += stride_t;
  257.             }
  258.         data += data_step;
  259.         }
  260.     }
  261.     break;
  262. /*...e*/
  263. /*...s4:16:*/
  264. case 4:
  265.     {
  266.     int x, y;
  267.  
  268.     for ( y = 0; y < gbm -> h; y += 2 )
  269.         {
  270.         for ( x = 0; x < gbm -> w; x += 2 )
  271. /*...s2x2 transpose to 2x2:40:*/
  272. {
  273. byte *src      = data + y * stride + (x >> 1);
  274. byte ab        = src [0     ];
  275. byte cd        = src [stride];
  276. byte *dst      = data_t + x * stride_t + (y >> 1);
  277. dst [0       ] = (byte) ((ab & 0xf0) | (cd >> 4));
  278. dst [stride_t] = (byte) ((ab << 4) | (cd & 0x0f));
  279. }
  280. /*...e*/
  281.         if ( x < gbm -> w )
  282. /*...s1x2 transpose to 2x1:40:*/
  283. {
  284. byte *src    = data + y * stride + (x >> 1);
  285. byte a0      = src [0     ];
  286. byte b0      = src [stride];
  287. byte *dst    = data_t + x * stride_t + (y >> 1);
  288. dst [0     ] = (byte) ((a0 & 0xf0) | (b0 >> 4));
  289. }
  290. /*...e*/
  291.         }
  292.     if ( y < gbm -> h )
  293.         {
  294.         for ( x = 0; x < gbm -> w; x += 2 )
  295. /*...s2x1 transpose to 1x2:40:*/
  296. {
  297. byte *src      = data + y * stride + (x >> 1);
  298. byte ab        = src [0     ];
  299. byte *dst      = data_t + x * stride_t + (y >> 1);
  300. dst [0       ] = (byte) (ab & 0xf0);
  301. dst [stride_t] = (byte) (ab << 4);
  302. }
  303. /*...e*/
  304.         if ( x < gbm -> w )
  305. /*...s1x1 transpose to 1x1:40:*/
  306. {
  307. byte *src    = data + y * stride + (x >> 1);
  308. byte a0      = src [0     ];
  309. byte *dst    = data_t + x * stride_t + (y >> 1);
  310. dst [0     ] = (byte) (a0 & 0xf0);
  311. }
  312. /*...e*/
  313.         }
  314.     }
  315.     break;
  316. /*...e*/
  317. /*...s1:16:*/
  318. case 1:
  319.     {
  320.     int x, y;
  321.     byte xbit, ybit;
  322.  
  323.     memset(data_t, 0, gbm -> w * stride_t);
  324.  
  325.     ybit = 0x80;
  326.     for ( y = 0; y < gbm -> h; y++ )
  327.         {
  328.         xbit = 0x80;
  329.         for ( x = 0; x < gbm -> w; x++ )
  330.             {
  331.             byte *src = data   + y * stride   + (x >> 3);
  332.             byte *dst = data_t + x * stride_t + (y >> 3); 
  333.  
  334.             if ( *src & xbit )
  335.                 *dst |= ybit;
  336.  
  337.             if ( (xbit >>= 1) == 0 )
  338.                 xbit = 0x80;
  339.             }
  340.         if ( (ybit >>= 1) == 0 )
  341.             ybit = 0x80;
  342.         }
  343.     }
  344.     break;
  345. /*...e*/
  346.         }
  347.     }
  348. /*...e*/
  349.