lib/libvgl/simple.c

   1 /*-
   2  * Copyright (c) 1991-1997 Søren Schmidt
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer
  10  *    in this position and unchanged.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. The name of the author may not be used to endorse or promote products
  15  *    derived from this software without specific prior written permission
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <signal.h>
  33 #include <sys/fbio.h>
  34 #include "vgl.h"
  35
  36 static byte VGLSavePaletteRed[256];
  37 static byte VGLSavePaletteGreen[256];
  38 static byte VGLSavePaletteBlue[256];
  39
  40 #define ABS(a)          (((a)<0) ? -(a) : (a))
  41 #define SGN(a)          (((a)<0) ? -1 : 1)
  42 #define min(x, y)       (((x) < (y)) ? (x) : (y))
  43 #define max(x, y)       (((x) > (y)) ? (x) : (y))
  44
  45 static void
  46 color2mem(u_long color, byte *b, int len)
  47 {
  48   switch (len) {
  49   case 4:
  50     b[3] = (color >> 24) & 0xff;
  51     /* fallthrough */
  52   case 3:
  53     b[2] = (color >> 16) & 0xff;
  54     /* fallthrough */
  55   case 2:
  56     b[1] = (color >> 8) & 0xff;
  57     /* fallthrough */
  58   case 1:
  59   default:
  60     b[0] = color & 0xff;
  61     break;
  62   }
  63
  64   return;
  65 }
  66
  67 static u_long
  68 mem2color(byte *b, int len)
  69 {
  70   u_long color = 0;
  71
  72   switch (len) {
  73   case 4:
  74     color |= (b[3] & 0xff) << 24;
  75     /* fallthrough */
  76   case 3:
  77     color |= (b[2] & 0xff) << 16;
  78     /* fallthrough */
  79   case 2:
  80     color |= (b[1] & 0xff) << 8;
  81     /* fallthrough */
  82   case 1:
  83   default:
  84     color |= (b[0] & 0xff);
  85     break;
  86   }
  87
  88   return color;
  89 }
  90
  91 void
  92 VGLSetXY(VGLBitmap *object, int x, int y, u_long color)
  93 {
  94   int offset;
  95   byte b[4];
  96
  97   VGLCheckSwitch();
  98   if (x>=0 && x<object->VXsize && y>=0 && y<object->VYsize) {
  99     if (!VGLMouseFreeze(x, y, 1, 1, color)) {
 100       switch (object->Type) {
 101       case MEMBUF:
 102       case VIDBUF8:
 103         object->Bitmap[y*object->VXsize+x]=((byte)color);
 104         break;
 105       case VIDBUF8S:
 106         object->Bitmap[VGLSetSegment(y*object->VXsize+x)]=((byte)color);
 107         break;
 108       case VIDBUF16:
 109       case VIDBUF24:
 110       case VIDBUF32:
 111         color2mem(color, b, object->PixelBytes);
 112         bcopy(b, &object->Bitmap[(y*object->VXsize+x) * object->PixelBytes],
 113                 object->PixelBytes);
 114         break;
 115       case VIDBUF16S:
 116       case VIDBUF24S:
 117       case VIDBUF32S:
 118         color2mem(color, b, object->PixelBytes);
 119         offset = VGLSetSegment((y*object->VXsize+x) * object->PixelBytes);
 120         bcopy(b, &object->Bitmap[offset], object->PixelBytes);
 121         break;
 122       case VIDBUF8X:
 123         outb(0x3c4, 0x02);
 124         outb(0x3c5, 0x01 << (x&0x3));
 125         object->Bitmap[(unsigned)(VGLAdpInfo.va_line_width*y)+(x/4)] = ((byte)color);
 126         break;
 127       case VIDBUF4S:
 128         offset = VGLSetSegment(y*VGLAdpInfo.va_line_width + x/8);
 129         goto set_planar;
 130       case VIDBUF4:
 131         offset = y*VGLAdpInfo.va_line_width + x/8;
 132 set_planar:
 133         outb(0x3c4, 0x02); outb(0x3c5, 0x0f);
 134         outb(0x3ce, 0x00); outb(0x3cf, (byte)color & 0x0f);     /* set/reset */
 135         outb(0x3ce, 0x01); outb(0x3cf, 0x0f);           /* set/reset enable */
 136         outb(0x3ce, 0x08); outb(0x3cf, 0x80 >> (x%8));  /* bit mask */
 137         object->Bitmap[offset] |= (byte)color;
 138       }
 139     }
 140     VGLMouseUnFreeze();
 141   }
 142 }
 143
 144 u_long
 145 VGLGetXY(VGLBitmap *object, int x, int y)
 146 {
 147   int offset;
 148   byte b[4];
 149 #if 0
 150   int i;
 151   u_long color;
 152   byte mask;
 153 #endif
 154
 155   VGLCheckSwitch();
 156   if (x<0 || x>=object->VXsize || y<0 || y>=object->VYsize)
 157     return 0;
 158   switch (object->Type) {
 159     case MEMBUF:
 160     case VIDBUF8:
 161       return object->Bitmap[((y*object->VXsize)+x)];
 162     case VIDBUF8S:
 163       return object->Bitmap[VGLSetSegment(y*object->VXsize+x)];
 164     case VIDBUF16:
 165     case VIDBUF24:
 166     case VIDBUF32:
 167       bcopy(&object->Bitmap[(y*object->VXsize+x) * object->PixelBytes],
 168                 b, object->PixelBytes);
 169       return (mem2color(b, object->PixelBytes));
 170     case VIDBUF16S:
 171     case VIDBUF24S:
 172     case VIDBUF32S:
 173         offset = VGLSetSegment((y*object->VXsize+x) * object->PixelBytes);
 174         bcopy(&object->Bitmap[offset], b, object->PixelBytes);
 175
 176       return (mem2color(b, object->PixelBytes));
 177     case VIDBUF8X:
 178       outb(0x3ce, 0x04); outb(0x3cf, x & 0x3);
 179       return object->Bitmap[(unsigned)(VGLAdpInfo.va_line_width*y)+(x/4)];
 180     case VIDBUF4S:
 181       offset = VGLSetSegment(y*VGLAdpInfo.va_line_width + x/8);
 182       goto get_planar;
 183     case VIDBUF4:
 184       offset = y*VGLAdpInfo.va_line_width + x/8;
 185 get_planar:
 186 #if 1
 187       return (object->Bitmap[offset]&(0x80>>(x%8))) ? 1 : 0;    /* XXX */
 188 #else
 189       color = 0;
 190       mask = 0x80 >> (x%8);
 191       for (i = 0; i < VGLModeInfo.vi_planes; i++) {
 192         outb(0x3ce, 0x04); outb(0x3cf, i);
 193         color |= (object->Bitmap[offset] & mask) ? (1 << i) : 0;
 194       }
 195       return color;
 196 #endif
 197   }
 198   return 0;             /* XXX black? */
 199 }
 200
 201 void
 202 VGLLine(VGLBitmap *object, int x1, int y1, int x2, int y2, u_long color)
 203 {
 204   int d, x, y, ax, ay, sx, sy, dx, dy;
 205
 206   dx = x2-x1; ax = ABS(dx)<<1; sx = SGN(dx); x = x1;
 207   dy = y2-y1; ay = ABS(dy)<<1; sy = SGN(dy); y = y1;
 208
 209   if (ax>ay) {                                  /* x dominant */
 210     d = ay-(ax>>1);
 211     for (;;) {
 212       VGLSetXY(object, x, y, color);
 213       if (x==x2)
 214         break;
 215       if (d>=0) {
 216         y += sy; d -= ax;
 217       }
 218       x += sx; d += ay;
 219     }
 220   }
 221   else {                                        /* y dominant */
 222     d = ax-(ay>>1);
 223     for (;;) {
 224       VGLSetXY(object, x, y, color);
 225       if (y==y2)
 226         break;
 227       if (d>=0) {
 228         x += sx; d -= ay;
 229       }
 230       y += sy; d += ax;
 231     }
 232   }
 233 }
 234
 235 void
 236 VGLBox(VGLBitmap *object, int x1, int y1, int x2, int y2, u_long color)
 237 {
 238   VGLLine(object, x1, y1, x2, y1, color);
 239   VGLLine(object, x2, y1, x2, y2, color);
 240   VGLLine(object, x2, y2, x1, y2, color);
 241   VGLLine(object, x1, y2, x1, y1, color);
 242 }
 243
 244 void
 245 VGLFilledBox(VGLBitmap *object, int x1, int y1, int x2, int y2, u_long color)
 246 {
 247   int y;
 248
 249   for (y=y1; y<=y2; y++) VGLLine(object, x1, y, x2, y, color);
 250 }
 251
 252 void
 253 inline set4pixels(VGLBitmap *object, int x, int y, int xc, int yc, u_long color)
 254 {
 255   if (x!=0) {
 256     VGLSetXY(object, xc+x, yc+y, color);
 257     VGLSetXY(object, xc-x, yc+y, color);
 258     if (y!=0) {
 259       VGLSetXY(object, xc+x, yc-y, color);
 260       VGLSetXY(object, xc-x, yc-y, color);
 261     }
 262   }
 263   else {
 264     VGLSetXY(object, xc, yc+y, color);
 265     if (y!=0)
 266       VGLSetXY(object, xc, yc-y, color);
 267   }
 268 }
 269
 270 void
 271 VGLEllipse(VGLBitmap *object, int xc, int yc, int a, int b, u_long color)
 272 {
 273   int x = 0, y = b, asq = a*a, asq2 = a*a*2, bsq = b*b;
 274   int bsq2 = b*b*2, d = bsq-asq*b+asq/4, dx = 0, dy = asq2*b;
 275
 276   while (dx<dy) {
 277     set4pixels(object, x, y, xc, yc, color);
 278     if (d>0) {
 279       y--; dy-=asq2; d-=dy;
 280     }
 281     x++; dx+=bsq2; d+=bsq+dx;
 282   }
 283   d+=(3*(asq-bsq)/2-(dx+dy))/2;
 284   while (y>=0) {
 285     set4pixels(object, x, y, xc, yc, color);
 286     if (d<0) {
 287       x++; dx+=bsq2; d+=dx;
 288     }
 289     y--; dy-=asq2; d+=asq-dy;
 290   }
 291 }
 292
 293 void
 294 inline set2lines(VGLBitmap *object, int x, int y, int xc, int yc, u_long color)
 295 {
 296   if (x!=0) {
 297     VGLLine(object, xc+x, yc+y, xc-x, yc+y, color);
 298     if (y!=0)
 299       VGLLine(object, xc+x, yc-y, xc-x, yc-y, color);
 300   }
 301   else {
 302     VGLLine(object, xc, yc+y, xc, yc-y, color);
 303   }
 304 }
 305
 306 void
 307 VGLFilledEllipse(VGLBitmap *object, int xc, int yc, int a, int b, u_long color)
 308 {
 309   int x = 0, y = b, asq = a*a, asq2 = a*a*2, bsq = b*b;
 310   int bsq2 = b*b*2, d = bsq-asq*b+asq/4, dx = 0, dy = asq2*b;
 311
 312   while (dx<dy) {
 313     set2lines(object, x, y, xc, yc, color);
 314     if (d>0) {
 315       y--; dy-=asq2; d-=dy;
 316     }
 317     x++; dx+=bsq2; d+=bsq+dx;
 318   }
 319   d+=(3*(asq-bsq)/2-(dx+dy))/2;
 320   while (y>=0) {
 321     set2lines(object, x, y, xc, yc, color);
 322     if (d<0) {
 323       x++; dx+=bsq2; d+=dx;
 324     }
 325     y--; dy-=asq2; d+=asq-dy;
 326   }
 327 }
 328
 329 void
 330 VGLClear(VGLBitmap *object, u_long color)
 331 {
 332   int offset;
 333   int len;
 334   int i, total = 0;
 335   byte b[4];
 336
 337   VGLCheckSwitch();
 338   VGLMouseFreeze(0, 0, object->Xsize, object->Ysize, color); /* XXX */
 339   switch (object->Type) {
 340   case MEMBUF:
 341   case VIDBUF8:
 342     memset(object->Bitmap, (byte)color, object->VXsize*object->VYsize);
 343     break;
 344
 345   case VIDBUF8S:
 346     for (offset = 0; offset < object->VXsize*object->VYsize; ) {
 347       VGLSetSegment(offset);
 348       len = min(object->VXsize*object->VYsize - offset,
 349                 VGLAdpInfo.va_window_size);
 350       memset(object->Bitmap, (byte)color, len);
 351       offset += len;
 352     }
 353     break;
 354   case VIDBUF16:
 355   case VIDBUF24:
 356   case VIDBUF32:
 357     color2mem(color, b, object->PixelBytes);
 358     total = object->VXsize*object->VYsize*object->PixelBytes;
 359     for (i = 0; i < total; i += object->PixelBytes)
 360       bcopy(b, object->Bitmap + i, object->PixelBytes);
 361     break;
 362
 363   case VIDBUF16S:
 364   case VIDBUF24S:
 365   case VIDBUF32S:
 366     color2mem(color, b, object->PixelBytes);
 367     total = object->VXsize*object->VYsize*object->PixelBytes;
 368     for (offset = 0; offset < total; ) {
 369       VGLSetSegment(offset);
 370       len = min(total - offset, VGLAdpInfo.va_window_size);
 371       for (i = 0; i < len; i += object->PixelBytes)
 372         bcopy(b, object->Bitmap + offset + i, object->PixelBytes);
 373       offset += len;
 374     }
 375     break;
 376
 377   case VIDBUF8X:
 378     /* XXX works only for Xsize % 4 = 0 */
 379     outb(0x3c6, 0xff);
 380     outb(0x3c4, 0x02); outb(0x3c5, 0x0f);
 381     memset(object->Bitmap, (byte)color, VGLAdpInfo.va_line_width*object->VYsize);
 382     break;
 383
 384   case VIDBUF4:
 385   case VIDBUF4S:
 386     /* XXX works only for Xsize % 8 = 0 */
 387     outb(0x3c4, 0x02); outb(0x3c5, 0x0f);
 388     outb(0x3ce, 0x05); outb(0x3cf, 0x02);               /* mode 2 */
 389     outb(0x3ce, 0x01); outb(0x3cf, 0x00);               /* set/reset enable */
 390     outb(0x3ce, 0x08); outb(0x3cf, 0xff);               /* bit mask */
 391     for (offset = 0; offset < VGLAdpInfo.va_line_width*object->VYsize; ) {
 392       VGLSetSegment(offset);
 393       len = min(object->VXsize*object->VYsize - offset,
 394                 VGLAdpInfo.va_window_size);
 395       memset(object->Bitmap, (byte)color, len);
 396       offset += len;
 397     }
 398     outb(0x3ce, 0x05); outb(0x3cf, 0x00);
 399     break;
 400   }
 401   VGLMouseUnFreeze();
 402 }
 403
 404 void
 405 VGLRestorePalette()
 406 {
 407   int i;
 408
 409   outb(0x3C6, 0xFF);
 410   inb(0x3DA);
 411   outb(0x3C8, 0x00);
 412   for (i=0; i<256; i++) {
 413     outb(0x3C9, VGLSavePaletteRed[i]);
 414     inb(0x84);
 415     outb(0x3C9, VGLSavePaletteGreen[i]);
 416     inb(0x84);
 417     outb(0x3C9, VGLSavePaletteBlue[i]);
 418     inb(0x84);
 419   }
 420   inb(0x3DA);
 421   outb(0x3C0, 0x20);
 422 }
 423
 424 void
 425 VGLSavePalette()
 426 {
 427   int i;
 428
 429   outb(0x3C6, 0xFF);
 430   inb(0x3DA);
 431   outb(0x3C7, 0x00);
 432   for (i=0; i<256; i++) {
 433     VGLSavePaletteRed[i] = inb(0x3C9);
 434     inb(0x84);
 435     VGLSavePaletteGreen[i] = inb(0x3C9);
 436     inb(0x84);
 437     VGLSavePaletteBlue[i] = inb(0x3C9);
 438     inb(0x84);
 439   }
 440   inb(0x3DA);
 441   outb(0x3C0, 0x20);
 442 }
 443
 444 void
 445 VGLSetPalette(byte *red, byte *green, byte *blue)
 446 {
 447   int i;
 448
 449   for (i=0; i<256; i++) {
 450     VGLSavePaletteRed[i] = red[i];
 451     VGLSavePaletteGreen[i] = green[i];
 452     VGLSavePaletteBlue[i] = blue[i];
 453   }
 454   VGLCheckSwitch();
 455   outb(0x3C6, 0xFF);
 456   inb(0x3DA);
 457   outb(0x3C8, 0x00);
 458   for (i=0; i<256; i++) {
 459     outb(0x3C9, VGLSavePaletteRed[i]);
 460     inb(0x84);
 461     outb(0x3C9, VGLSavePaletteGreen[i]);
 462     inb(0x84);
 463     outb(0x3C9, VGLSavePaletteBlue[i]);
 464     inb(0x84);
 465   }
 466   inb(0x3DA);
 467   outb(0x3C0, 0x20);
 468 }
 469
 470 void
 471 VGLSetPaletteIndex(byte color, byte red, byte green, byte blue)
 472 {
 473   VGLSavePaletteRed[color] = red;
 474   VGLSavePaletteGreen[color] = green;
 475   VGLSavePaletteBlue[color] = blue;
 476   VGLCheckSwitch();
 477   outb(0x3C6, 0xFF);
 478   inb(0x3DA);
 479   outb(0x3C8, color);
 480   outb(0x3C9, red); outb(0x3C9, green); outb(0x3C9, blue);
 481   inb(0x3DA);
 482   outb(0x3C0, 0x20);
 483 }
 484
 485 void
 486 VGLSetBorder(byte color)
 487 {
 488   VGLCheckSwitch();
 489   inb(0x3DA);
 490   outb(0x3C0,0x11); outb(0x3C0, color);
 491   inb(0x3DA);
 492   outb(0x3C0, 0x20);
 493 }
 494
 495 void
 496 VGLBlankDisplay(int blank)
 497 {
 498   byte val;
 499
 500   VGLCheckSwitch();
 501   outb(0x3C4, 0x01); val = inb(0x3C5); outb(0x3C4, 0x01);
 502   outb(0x3C5, ((blank) ? (val |= 0x20) : (val &= 0xDF)));
 503 }