home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / D / SVGALIB / SVGALIB1.TAR / svgalib / src / vgadraw.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-08  |  5.9 KB  |  238 lines
  1. /* VGAlib version 1.2 - (c) 1993 Tommy Frandsen            */
  2. /*                                   */
  3. /* This library is free software; you can redistribute it and/or   */
  4. /* modify it without any restrictions. This library is distributed */
  5. /* in the hope that it will be useful, but without any warranty.   */
  6.  
  7. /* Multi-chipset support Copyright 1993 Harm Hanemaayer */
  8. /* partially copyrighted (C) 1993 by Hartmut Schirmer */
  9.  
  10. #include <stdio.h>
  11. #include "vga.h"
  12. #include "libvga.h"
  13.  
  14.  
  15. /* used to decompose color value into bits (for fast scanline drawing) */
  16. union bits {
  17.     struct {
  18.         unsigned char bit3;
  19.         unsigned char bit2;
  20.         unsigned char bit1;
  21.         unsigned char bit0;
  22.     } b;
  23.     unsigned int i;
  24. };
  25.  
  26. /* color decompositions */
  27. static union bits color16[16] = {{0,0,0,0},
  28.                      {0,0,0,1},
  29.                        {0,0,1,0},
  30.                      {0,0,1,1},
  31.                      {0,1,0,0},
  32.                      {0,1,0,1},
  33.                      {0,1,1,0},
  34.                      {0,1,1,1},
  35.                      {1,0,0,0},
  36.                      {1,0,0,1},
  37.                      {1,0,1,0},
  38.                      {1,0,1,1},
  39.                      {1,1,0,0},
  40.                      {1,1,0,1},
  41.                      {1,1,1,0},
  42.                      {1,1,1,1}};
  43.  
  44. /* display plane buffers (for fast scanline drawing) */
  45. /* 256 bytes -> max 2048 pixel per line (2/16 colors)*/
  46. static unsigned char plane0[256];
  47. static unsigned char plane1[256];
  48. static unsigned char plane2[256];
  49. static unsigned char plane3[256];
  50.  
  51.  
  52. int vga_drawscanline(int line, unsigned char* colors)
  53. {
  54.     if ((CI.colors == 2) || (CI.colors > 256))
  55.     return vga_drawscansegment(colors, 0, line, CI.xbytes);
  56.     else
  57.     return vga_drawscansegment(colors, 0, line, CI.xdim);
  58. } 
  59.  
  60.  
  61. int vga_drawscansegment(unsigned char* colors, int x, int y, int length)
  62. {
  63.     /* both length and x must divide with 8 */
  64.  
  65.     if (MODEX) goto modeX;
  66.     switch (CI.colors) {
  67.         case 16:
  68.             {
  69.                int i, j, k, first, last, page, l1, l2;
  70.                 int offset;
  71.         union bits bytes;
  72.                 unsigned char* address;
  73.  
  74.                 k = 0;
  75.                 for(i = 0; i < length; i += 8) {
  76.                     bytes.i = 0;
  77.                     first = i;
  78.                     last  = i+8;
  79.                     for(j = first; j < last; j++)
  80.                        bytes.i = (bytes.i<<1) | color16[colors[j]].i;
  81.             plane0[k]   = bytes.b.bit0;
  82.             plane1[k]   = bytes.b.bit1;
  83.             plane2[k]   = bytes.b.bit2;
  84.             plane3[k++] = bytes.b.bit3;
  85.                 }
  86.  
  87.                 offset = (y*CI.xdim + x)/8;
  88.         vga_setpage((page = offset>>16));
  89.         l1 = 0x10000 - (offset &= 0xffff);
  90.         length /= 8;
  91.         if (l1 > length) l1 = length;
  92.         l2 = length - l1; 
  93.         
  94.                 address = GM + offset;
  95.  
  96.         /* disable Set/Reset Register */
  97.             port_out(0x01, GRA_I ); 
  98.             port_out(0x00, GRA_D ); 
  99.  
  100.         /* write to all bits */
  101.             port_out(0x08, GRA_I ); 
  102.             port_out(0xFF, GRA_D );   
  103.  
  104.         /* select map mask register */
  105.             port_out(0x02, SEQ_I ); 
  106.  
  107.                 /* write plane 0 */
  108.             port_out(0x01, SEQ_D ); 
  109.             memcpy(address, plane0, l1);
  110.  
  111.                 /* write plane 1 */
  112.             port_out(0x02, SEQ_D ); 
  113.             memcpy(address, plane1, l1);
  114.  
  115.                 /* write plane 2 */
  116.             port_out(0x04, SEQ_D ); 
  117.             memcpy(address, plane2, l1);
  118.  
  119.                 /* write plane 3 */
  120.             port_out(0x08, SEQ_D ); 
  121.             memcpy(address, plane3, l1);
  122.  
  123.         if (l2 > 0) {
  124.             vga_setpage(page+1);
  125.  
  126.                     /* write plane 0 */
  127.                 port_out(0x01, SEQ_D ); 
  128.                 memcpy( GM, &plane0[l1], l2);
  129.  
  130.                     /* write plane 1 */
  131.                 port_out(0x02, SEQ_D ); 
  132.                 memcpy( GM, &plane1[l1], l2);
  133.  
  134.                     /* write plane 2 */
  135.                 port_out(0x04, SEQ_D ); 
  136.                 memcpy( GM, &plane2[l1], l2);
  137.  
  138.                     /* write plane 3 */
  139.                 port_out(0x08, SEQ_D ); 
  140.                 memcpy( GM, &plane3[l1], l2);
  141.         }
  142.  
  143.                 /* restore map mask register */
  144.             port_out(0x0F, SEQ_D ); 
  145.   
  146.         /* enable Set/Reset Register */
  147.             port_out(0x01, GRA_I );
  148.                 port_out(0x0F, GRA_D );
  149.         }
  150.             break;
  151.         case 2 :
  152.         {
  153.         /* disable Set/Reset Register */
  154.             port_out(0x01, GRA_I ); 
  155.             port_out(0x00, GRA_D );
  156.  
  157.         /* write to all bits */
  158.             port_out(0x08, GRA_I ); 
  159.             port_out(0xFF, GRA_D );   
  160.  
  161.         /* write to all planes */
  162.             port_out(0x02, SEQ_I ); 
  163.             port_out(0x0F, SEQ_D ); 
  164.  
  165.             memcpy( GM + (y*CI.xdim + x)/8, colors, length);
  166.  
  167.                 /* restore map mask register */
  168.             port_out(0x0F, SEQ_D ); 
  169.   
  170.         /* enable Set/Reset Register */
  171.             port_out(0x01, GRA_I ); 
  172.             port_out(0x0F, GRA_D );   
  173.           }
  174.             break;
  175.     case 256:
  176.             {
  177.           switch (CM) {
  178.           case G320x200x256: /* linear addressing - easy and fast */
  179.                              memcpy(GM+y*CI.xdim+x,colors,length);
  180.                      return 0;
  181.               case G320x240x256:
  182.               case G320x400x256:
  183.               case G360x480x256:
  184. modeX:
  185.                      {
  186.                        int first, last, offset, pixel, plane;
  187.  
  188.                        /* select map mask register */ 
  189.                        port_out(0x02, SEQ_I); 
  190.  
  191.                        for(plane = 0; plane < 4; plane++) {
  192.                      /* select plane */
  193.                      port_out(1 << plane, SEQ_D);   
  194.  
  195.                      pixel = plane;
  196.                      first = (y*CI.xdim + x)/4;
  197.                      last  = (y*CI.xdim + x + length)/4;
  198.                      for(offset = first; offset < last; offset++) {
  199.                        GM[offset] = colors[pixel];  
  200.                        pixel += 4;
  201.                      }
  202.                        }
  203.                      }
  204.                      return 0;
  205.           }
  206.           {
  207.         unsigned long offset;
  208.         int segment, free;
  209.  
  210.   SegmentedCopy:
  211.         offset  = y*CI.xbytes+x;
  212.         segment = offset >> 16;
  213.         free    = ((segment+1)<<16)-offset;
  214.         offset  &= 0xFFFF;
  215.  
  216.         if (free < length) {
  217.             vga_setpage(segment);
  218.             memcpy(GM + offset, colors, free);
  219.                    vga_setpage(segment + 1);
  220.             memcpy(GM, colors+free, length-free);
  221.         } else {
  222.             vga_setpage(segment);
  223.             memcpy(GM + offset, colors, length);
  224.         }
  225.           }
  226.         }  
  227.             break;
  228.         case 32768:
  229.     case 65536: x *= 2;
  230.                 goto SegmentedCopy;
  231.     case 1<<24: x*=3;
  232.                 goto SegmentedCopy;
  233.     }    
  234.  
  235.     return 0;
  236. }
  237.  
  238.