home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / mint / mgr / sparcmgr / src.zoo / src / port / bitmap.c next >
Encoding:
C/C++ Source or Header  |  1989-09-26  |  6.1 KB  |  228 lines
  1. /*  SUN version of portable bit-blt code.  (S. A. Uhler) 
  2.  *  The data on each line is padded to (BITS+1) bits
  3.  */
  4.  
  5. #ifdef sun
  6. #  include <sys/ioctl.h>
  7. #  include <sun/fbio.h>
  8. #  include <sys/file.h>
  9. #  include <sys/mman.h>
  10. #endif
  11. #include <stdio.h>
  12. #include "bitmap.h"
  13.  
  14. #define dprintf    if(bit_debug)fprintf
  15. int bit_debug;
  16. static int _s_start;        /* for our "vfree" */
  17. static _s_len;
  18.  
  19. /* open the display; it looks like memory */
  20.  
  21. BITMAP *
  22. bit_open(name)
  23. char *name;            /* name of frame buffer */
  24. {
  25.    BITMAP *result = BIT_NULL;
  26. #ifdef sun
  27.    int fd;                    /* file descriptor of frame buffer */
  28.    register DATA *addr;    /* address of frame buffer */
  29.    struct fbtype buff;    /* frame buffer parameters */
  30.    int pagesize;    
  31.    char *malloc();
  32.  
  33.    /* open the SUN display */
  34.  
  35.    if ((fd = open(name, O_RDWR)) < 0)
  36.       return (BIT_NULL);
  37.  
  38.    /* get the frame buffer size */
  39.  
  40.    if (ioctl(fd, FBIOGTYPE, &buff) < 0)
  41.       return (BIT_NULL);
  42.  
  43.    /* malloc space for frame buffer */
  44.  
  45.    pagesize = getpagesize();
  46.    if ((_s_start = (int) malloc(buff.fb_size + pagesize)) == 0)
  47.       return (BIT_NULL);
  48.  
  49.    /* align space (and fb size) on a page boundary */
  50.  
  51.    buff.fb_size = (buff.fb_size+pagesize-1) &~ (pagesize-1);
  52.    addr = (DATA *) ((_s_start + pagesize - 1) & ~(pagesize - 1));
  53.  
  54.    /* map the frame buffer into malloc'd space */
  55.  
  56. #ifdef _MAP_NEW      /* New semantics for mmap in Sun release 4.0 */
  57.    addr = (DATA) mmap(addr, _s_len=buff.fb_size,
  58.                    PROT_READ|PROT_WRITE, _MAP_NEW|MAP_SHARED, fd, 0);
  59.    if ((int)addr == -1)
  60.       return (BIT_NULL);
  61. #else
  62.    if (mmap(addr, _s_len = buff.fb_size, PROT_WRITE, MAP_SHARED, fd, 0) < 0)
  63.       return (BIT_NULL);
  64. #endif
  65.  
  66.    if ((result = (BITMAP *) malloc(sizeof(BITMAP))) == (BITMAP *) 0)
  67.       return (BIT_NULL);
  68.  
  69.    result->primary = result;
  70.    result->data = addr;
  71.    result->x0 = 0,
  72.    result->y0 = 0,
  73.    result->wide = buff.fb_width;
  74.    result->high = buff.fb_height;
  75.    result->type = _SCREEN;
  76. #endif sun
  77.    return (result);
  78. }
  79.  
  80. /* destroy a bitmap, free up space */
  81.  
  82. int
  83. bit_destroy(bitmap)
  84. BITMAP *bitmap;
  85. {
  86.    if (bitmap == (BITMAP *) 0)
  87.       return (-1);
  88.    if (IS_MEMORY(bitmap) && IS_PRIMARY(bitmap))
  89.       free(bitmap->data);
  90.    else if (IS_SCREEN(bitmap) && IS_PRIMARY(bitmap)) {
  91.       munmap(BIT_DATA(bitmap), _s_len);
  92.       free(_s_start);
  93.         }
  94.    free(bitmap);
  95.    return (0);
  96. }
  97.  
  98. /* create a bitmap as a sub-rectangle of another bitmap */
  99.  
  100. BITMAP *
  101. bit_create(map, x, y, wide, high)
  102. BITMAP *map;
  103. int x, y, wide, high;
  104. {
  105.    char *malloc();
  106.    register BITMAP *result;
  107.  
  108.    if (x + wide > map->wide)
  109.       wide = map->wide - x;
  110.    if (y + high > map->high)
  111.       high = map->high - y;
  112.    if (wide < 1 || high < 1)
  113.       return (BIT_NULL);
  114.  
  115.    if ((result = (BITMAP *) malloc(sizeof(BITMAP))) == (BITMAP *) 0)
  116.       return (BIT_NULL);
  117.  
  118.    result->data = map->data;
  119.    result->x0 = map->x0 + x;
  120.    result->y0 = map->y0 + y;
  121.    result->wide = wide;
  122.    result->high = high;
  123.    result->primary = map->primary;
  124.    result->type = map->type;
  125.    return (result);
  126. }
  127.  
  128. /* allocate space for, and create a memory bitmap */
  129.  
  130. BITMAP *
  131. bit_alloc(wide, high, data, bits)
  132. unsigned short wide, high;
  133. DATA *data;
  134. int bits;    /* in preparation for color */
  135. {
  136.    char *malloc();
  137.    register BITMAP *result;
  138.    register int size;
  139.  
  140.    if ((result = (BITMAP *) malloc(sizeof(BITMAP))) == (BITMAP *) 0)
  141.       return (result);
  142.  
  143.    result->x0 = 0;
  144.    result->y0 = 0;
  145.    result->high = high;
  146.    result->wide = wide;
  147.  
  148.    size = ((wide+BITS)/8) * high;
  149.  
  150.    if (data != (DATA *) 0) {        /* point to user supplied data */
  151.       result->data = data;
  152.  
  153.         /* convert from external to internal format (if required) */
  154.  
  155.       if (DOFLIP) {
  156.          flip(data,size/sizeof(DATA));
  157.          }
  158.         }
  159.    else {                    /* malloc space: better be DATA aligned */
  160.         if ((result->data = (DATA *) malloc(size)) == (DATA *) 0) {
  161.           free(result);
  162.           return ((BITMAP *) 0);
  163.            }
  164.         bzero(result->data,size);
  165.         }
  166.  
  167.     if ((int) result->data &3)
  168.       fprintf(stderr,"bit_alloc(): boundary alignment error\n");
  169.    result->primary = result;
  170.    result->type = _MEMORY;
  171.    return (result);
  172.     }
  173.  
  174. /* flip the bit order on count elements of s */
  175.  
  176. static unsigned char flp[256] = {
  177.     0x00,    0x80,    0x40,    0xc0,    0x20,    0xa0,    0x60,    0xe0,
  178.     0x10,    0x90,    0x50,    0xd0,    0x30,    0xb0,    0x70,    0xf0,
  179.     0x08,    0x88,    0x48,    0xc8,    0x28,    0xa8,    0x68,    0xe8,
  180.     0x18,    0x98,    0x58,    0xd8,    0x38,    0xb8,    0x78,    0xf8,
  181.     0x04,    0x84,    0x44,    0xc4,    0x24,    0xa4,    0x64,    0xe4,
  182.     0x14,    0x94,    0x54,    0xd4,    0x34,    0xb4,    0x74,    0xf4,
  183.     0x0c,    0x8c,    0x4c,    0xcc,    0x2c,    0xac,    0x6c,    0xec,
  184.     0x1c,    0x9c,    0x5c,    0xdc,    0x3c,    0xbc,    0x7c,    0xfc,
  185.     0x02,    0x82,    0x42,    0xc2,    0x22,    0xa2,    0x62,    0xe2,
  186.     0x12,    0x92,    0x52,    0xd2,    0x32,    0xb2,    0x72,    0xf2,
  187.     0x0a,    0x8a,    0x4a,    0xca,    0x2a,    0xaa,    0x6a,    0xea,
  188.     0x1a,    0x9a,    0x5a,    0xda,    0x3a,    0xba,    0x7a,    0xfa,
  189.     0x06,    0x86,    0x46,    0xc6,    0x26,    0xa6,    0x66,    0xe6,
  190.     0x16,    0x96,    0x56,    0xd6,    0x36,    0xb6,    0x76,    0xf6,
  191.     0x0e,    0x8e,    0x4e,    0xce,    0x2e,    0xae,    0x6e,    0xee,
  192.     0x1e,    0x9e,    0x5e,    0xde,    0x3e,    0xbe,    0x7e,    0xfe,
  193.     0x01,    0x81,    0x41,    0xc1,    0x21,    0xa1,    0x61,    0xe1,
  194.     0x11,    0x91,    0x51,    0xd1,    0x31,    0xb1,    0x71,    0xf1,
  195.     0x09,    0x89,    0x49,    0xc9,    0x29,    0xa9,    0x69,    0xe9,
  196.     0x19,    0x99,    0x59,    0xd9,    0x39,    0xb9,    0x79,    0xf9,
  197.     0x05,    0x85,    0x45,    0xc5,    0x25,    0xa5,    0x65,    0xe5,
  198.     0x15,    0x95,    0x55,    0xd5,    0x35,    0xb5,    0x75,    0xf5,
  199.     0x0d,    0x8d,    0x4d,    0xcd,    0x2d,    0xad,    0x6d,    0xed,
  200.     0x1d,    0x9d,    0x5d,    0xdd,    0x3d,    0xbd,    0x7d,    0xfd,
  201.     0x03,    0x83,    0x43,    0xc3,    0x23,    0xa3,    0x63,    0xe3,
  202.     0x13,    0x93,    0x53,    0xd3,    0x33,    0xb3,    0x73,    0xf3,
  203.     0x0b,    0x8b,    0x4b,    0xcb,    0x2b,    0xab,    0x6b,    0xeb,
  204.     0x1b,    0x9b,    0x5b,    0xdb,    0x3b,    0xbb,    0x7b,    0xfb,
  205.     0x07,    0x87,    0x47,    0xc7,    0x27,    0xa7,    0x67,    0xe7,
  206.     0x17,    0x97,    0x57,    0xd7,    0x37,    0xb7,    0x77,    0xf7,
  207.     0x0f,    0x8f,    0x4f,    0xcf,    0x2f,    0xaf,    0x6f,    0xef,
  208.     0x1f,    0x9f,    0x5f,    0xdf,    0x3f,    0xbf,    0x7f,    0xff,
  209.     };
  210.  
  211. /*
  212.  * Convert from external to internal bitmap format.  Internal format
  213.  * is SUN-3 bit order, 1=black, 0=white.  This sample flip routine is
  214.  * for the DEC3100, where 1=white, 0=black, and the bits in every byte
  215.  * are revered
  216.  */
  217.  
  218. int
  219. flip(s,count,how)
  220. register DATA *s;
  221. register int count;
  222. int how;                        /* not used */
  223.     {
  224.     while (count-- > 0) 
  225.         *s++ = ~((flp[*s&0xff]) | (flp[*s>>8&0xff]<<8) |
  226.                  (flp[*s>>16&0xff]<<16) | (flp[*s>>24&0xff]<<24));
  227.     }
  228.