system/freebsd-src
system/freebsd-src
1
0
Fork 0
mirror of https://github.com/freebsd/freebsd-src synced 2024-07-08 20:26:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add Truecolor 16 and 32bits support. Note that 24bits modes are not

Browse Source 
supported since it's not easy to put 3 bytes accross 64Kb windows
of memory. This should not be such a problem with linear framebuffers.

There is no major interface modification except that the color type
becomes u_long instead of byte. So one just need to recompile his
application.

Approved by:	Soren Schmidt <sos@freebsd.dk>
This commit is contained in:
Nicolas Souchu 2001-01-13 11:30:17 +00:00
parent ea0187039a
commit 933d455fac
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=70991
4 changed files with 251 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
lib/libvgl/bitmap.c
View File

@ -143,12 +143,31 @@ WriteVerticalLine(VGLBitmap *dst, int x, int y, int width, byte *line)
width -= i;
}
break;
case VIDBUF16S:
case VIDBUF24S:
case VIDBUF32S:
width = width * dst->PixelBytes;
pos = (dst->VXsize * y + x) * dst->PixelBytes;
while (width > 0) {
offset = VGLSetSegment(pos);
i = min(VGLAdpInfo.va_window_size - offset, width);
bcopy(line, dst->Bitmap + offset, i);
line += i;
pos += i;
width -= i;
}
break;
case VIDBUF8:
case MEMBUF:
address = dst->Bitmap + dst->VXsize * y + x;
bcopy(line, address, width);
break;
case VIDBUF16:
case VIDBUF24:
case VIDBUF32:
address = dst->Bitmap + (dst->VXsize * y + x) * dst->PixelBytes;
bcopy(line, address, width * dst->PixelBytes);
break;
default:
}
}
@ -238,11 +257,31 @@ ReadVerticalLine(VGLBitmap *src, int x, int y, int width, byte *line)
width -= i;
}
break;
case VIDBUF16S:
case VIDBUF24S:
case VIDBUF32S:
width = width * src->PixelBytes;
pos = (src->VXsize * y + x) * src->PixelBytes;
while (width > 0) {
offset = VGLSetSegment(pos);
i = min(VGLAdpInfo.va_window_size - offset, width);
bcopy(src->Bitmap + offset, line, i);
line += i;
pos += i;
width -= i;
}
break;
case VIDBUF8:
case MEMBUF:
address = src->Bitmap + src->VXsize * y + x;
bcopy(address, line, width);
break;
case VIDBUF16:
case VIDBUF24:
case VIDBUF32:
address = src->Bitmap + (src->VXsize * y + x) * src->PixelBytes;
bcopy(address, line, width * src->PixelBytes);
break;
default:
}
}

79
lib/libvgl/main.c
View File

@ -39,6 +39,8 @@
#include <sys/consio.h>
#include "vgl.h"
/* XXX Direct Color 24bits modes unsupported */
#define min(x, y) (((x) < (y)) ? (x) : (y))
#define max(x, y) (((x) > (y)) ? (x) : (y))
@ -178,6 +180,25 @@ VGLInit(int mode)
case V_INFO_MM_VGAX:
VGLDisplay->Type = VIDBUF8X;
break;
case V_INFO_MM_DIRECT:
VGLDisplay->PixelBytes = VGLModeInfo.vi_pixel_size;
switch (VGLDisplay->PixelBytes) {
case 2:
VGLDisplay->Type = VIDBUF16;
break;
#if notyet
case 3:
VGLDisplay->Type = VIDBUF24;
break;
#endif
case 4:
VGLDisplay->Type = VIDBUF32;
break;
default:
VGLEnd();
return -4;
}
break;
default:
VGLEnd();
return -4;
@ -224,10 +245,26 @@ VGLInit(int mode)
/* see if we are in the windowed buffer mode or in the linear buffer mode */
if (VGLBufSize/VGLModeInfo.vi_planes > VGLAdpInfo.va_window_size) {
if (VGLDisplay->Type == VIDBUF4)
switch (VGLDisplay->Type) {
case VIDBUF4:
VGLDisplay->Type = VIDBUF4S;
else if (VGLDisplay->Type == VIDBUF8)
break;
case VIDBUF8:
VGLDisplay->Type = VIDBUF8S;
break;
case VIDBUF16:
VGLDisplay->Type = VIDBUF16S;
break;
case VIDBUF24:
VGLDisplay->Type = VIDBUF24S;
break;
case VIDBUF32:
VGLDisplay->Type = VIDBUF32S;
break;
default:
VGLEnd();
return -8;
}
}
VGLMode = mode;
@ -308,13 +345,35 @@ VGLCheckSwitch()
VGLDisplay->Type = VIDBUF8S;
else
VGLDisplay->Type = VIDBUF8;
} else {
/* shouldn't be happening */
}
break;
case V_INFO_MM_VGAX:
VGLDisplay->Type = VIDBUF8X;
break;
case V_INFO_MM_DIRECT:
switch (VGLModeInfo.vi_pixel_size) {
case 2:
if (VGLBufSize/VGLModeInfo.vi_planes > VGLAdpInfo.va_window_size)
VGLDisplay->Type = VIDBUF16S;
else
VGLDisplay->Type = VIDBUF16;
break;
case 3:
if (VGLBufSize/VGLModeInfo.vi_planes > VGLAdpInfo.va_window_size)
VGLDisplay->Type = VIDBUF24S;
else
VGLDisplay->Type = VIDBUF24;
break;
case 4:
if (VGLBufSize/VGLModeInfo.vi_planes > VGLAdpInfo.va_window_size)
VGLDisplay->Type = VIDBUF32S;
else
VGLDisplay->Type = VIDBUF32;
break;
default:
/* shouldn't be happening */
break;
}
default:
/* shouldn't be happening */
break;
@ -357,6 +416,12 @@ VGLCheckSwitch()
break;
case VIDBUF8:
case VIDBUF8S:
case VIDBUF16:
case VIDBUF16S:
case VIDBUF24:
case VIDBUF24S:
case VIDBUF32:
case VIDBUF32S:
for (offset = 0; offset < VGLBufSize; offset += len) {
VGLSetSegment(offset);
len = min(VGLBufSize - offset, VGLAdpInfo.va_window_size);
@ -398,6 +463,12 @@ VGLCheckSwitch()
break;
case VIDBUF8:
case VIDBUF8S:
case VIDBUF16:
case VIDBUF16S:
case VIDBUF24:
case VIDBUF24S:
case VIDBUF32:
case VIDBUF32S:
for (offset = 0; offset < VGLBufSize; offset += len) {
VGLSetSegment(offset);
len = min(VGLBufSize - offset, VGLAdpInfo.va_window_size);

143
lib/libvgl/simple.c
View File

@ -41,10 +41,57 @@ static byte VGLSavePaletteBlue[256];
#define min(x, y) (((x) < (y)) ? (x) : (y))
#define max(x, y) (((x) > (y)) ? (x) : (y))
static void
color2mem(u_long color, byte *b, int len)
{
switch (len) {
case 4:
b[3] = (color >> 24) & 0xff;
/* fallthrough */
case 3:
b[2] = (color >> 16) & 0xff;
/* fallthrough */
case 2:
b[1] = (color >> 8) & 0xff;
/* fallthrough */
case 1:
default:
b[0] = color & 0xff;
break;
}
return;
}
static u_long
mem2color(byte *b, int len)
{
u_long color = 0;
switch (len) {
case 4:
color |= (b[3] & 0xff) << 24;
/* fallthrough */
case 3:
color |= (b[2] & 0xff) << 16;
/* fallthrough */
case 2:
color |= (b[1] & 0xff) << 8;
/* fallthrough */
case 1:
default:
color |= (b[0] & 0xff);
break;
}
return color;
}
void
VGLSetXY(VGLBitmap *object, int x, int y, byte color)
VGLSetXY(VGLBitmap *object, int x, int y, u_long color)
{
int offset;
byte b[4];
VGLCheckSwitch();
if (x>=0 && x<object->VXsize && y>=0 && y<object->VYsize) {
@ -52,15 +99,29 @@ VGLSetXY(VGLBitmap *object, int x, int y, byte color)
switch (object->Type) {
case MEMBUF:
case VIDBUF8:
object->Bitmap[y*object->VXsize+x]=(color);
object->Bitmap[y*object->VXsize+x]=((byte)color);
break;
case VIDBUF8S:
object->Bitmap[VGLSetSegment(y*object->VXsize+x)]=(color);
object->Bitmap[VGLSetSegment(y*object->VXsize+x)]=((byte)color);
break;
case VIDBUF16:
case VIDBUF24:
case VIDBUF32:
color2mem(color, b, object->PixelBytes);
bcopy(b, &object->Bitmap[(y*object->VXsize+x) * object->PixelBytes],
object->PixelBytes);
break;
case VIDBUF16S:
case VIDBUF24S:
case VIDBUF32S:
color2mem(color, b, object->PixelBytes);
offset = VGLSetSegment((y*object->VXsize+x) * object->PixelBytes);
bcopy(b, &object->Bitmap[offset], object->PixelBytes);
break;
case VIDBUF8X:
outb(0x3c4, 0x02);
outb(0x3c5, 0x01 << (x&0x3));
object->Bitmap[(unsigned)(VGLAdpInfo.va_line_width*y)+(x/4)] = (color);
object->Bitmap[(unsigned)(VGLAdpInfo.va_line_width*y)+(x/4)] = ((byte)color);
break;
case VIDBUF4S:
offset = VGLSetSegment(y*VGLAdpInfo.va_line_width + x/8);
@ -69,23 +130,24 @@ VGLSetXY(VGLBitmap *object, int x, int y, byte color)
offset = y*VGLAdpInfo.va_line_width + x/8;
set_planar:
outb(0x3c4, 0x02); outb(0x3c5, 0x0f);
outb(0x3ce, 0x00); outb(0x3cf, color & 0x0f); /* set/reset */
outb(0x3ce, 0x00); outb(0x3cf, (byte)color & 0x0f); /* set/reset */
outb(0x3ce, 0x01); outb(0x3cf, 0x0f); /* set/reset enable */
outb(0x3ce, 0x08); outb(0x3cf, 0x80 >> (x%8)); /* bit mask */
object->Bitmap[offset] |= color;
object->Bitmap[offset] |= (byte)color;
}
}
VGLMouseUnFreeze();
}
}
byte
u_long
VGLGetXY(VGLBitmap *object, int x, int y)
{
int offset;
byte b[4];
#if 0
int i;
byte color;
u_long color;
byte mask;
#endif
@ -98,6 +160,19 @@ VGLGetXY(VGLBitmap *object, int x, int y)
return object->Bitmap[((y*object->VXsize)+x)];
case VIDBUF8S:
return object->Bitmap[VGLSetSegment(y*object->VXsize+x)];
case VIDBUF16:
case VIDBUF24:
case VIDBUF32:
bcopy(&object->Bitmap[(y*object->VXsize+x) * object->PixelBytes],
b, object->PixelBytes);
return (mem2color(b, object->PixelBytes));
case VIDBUF16S:
case VIDBUF24S:
case VIDBUF32S:
offset = VGLSetSegment((y*object->VXsize+x) * object->PixelBytes);
bcopy(&object->Bitmap[offset], b, object->PixelBytes);
return (mem2color(b, object->PixelBytes));
case VIDBUF8X:
outb(0x3ce, 0x04); outb(0x3cf, x & 0x3);
return object->Bitmap[(unsigned)(VGLAdpInfo.va_line_width*y)+(x/4)];
@ -119,11 +194,11 @@ VGLGetXY(VGLBitmap *object, int x, int y)
return color;
#endif
}
return 0;
return 0; /* XXX black? */
}
void
VGLLine(VGLBitmap *object, int x1, int y1, int x2, int y2, byte color)
VGLLine(VGLBitmap *object, int x1, int y1, int x2, int y2, u_long color)
{
int d, x, y, ax, ay, sx, sy, dx, dy;
@ -157,7 +232,7 @@ VGLLine(VGLBitmap *object, int x1, int y1, int x2, int y2, byte color)
}
void
VGLBox(VGLBitmap *object, int x1, int y1, int x2, int y2, byte color)
VGLBox(VGLBitmap *object, int x1, int y1, int x2, int y2, u_long color)
{
VGLLine(object, x1, y1, x2, y1, color);
VGLLine(object, x2, y1, x2, y2, color);
@ -166,7 +241,7 @@ VGLBox(VGLBitmap *object, int x1, int y1, int x2, int y2, byte color)
}
void
VGLFilledBox(VGLBitmap *object, int x1, int y1, int x2, int y2, byte color)
VGLFilledBox(VGLBitmap *object, int x1, int y1, int x2, int y2, u_long color)
{
int y;
@ -174,7 +249,7 @@ VGLFilledBox(VGLBitmap *object, int x1, int y1, int x2, int y2, byte color)
}
void
inline set4pixels(VGLBitmap *object, int x, int y, int xc, int yc, byte color)
inline set4pixels(VGLBitmap *object, int x, int y, int xc, int yc, u_long color)
{
if (x!=0) {
VGLSetXY(object, xc+x, yc+y, color);
@ -192,7 +267,7 @@ inline set4pixels(VGLBitmap *object, int x, int y, int xc, int yc, byte color)
}
void
VGLEllipse(VGLBitmap *object, int xc, int yc, int a, int b, byte color)
VGLEllipse(VGLBitmap *object, int xc, int yc, int a, int b, u_long color)
{
int x = 0, y = b, asq = a*a, asq2 = a*a*2, bsq = b*b;
int bsq2 = b*b*2, d = bsq-asq*b+asq/4, dx = 0, dy = asq2*b;
@ -215,7 +290,7 @@ VGLEllipse(VGLBitmap *object, int xc, int yc, int a, int b, byte color)
}
void
inline set2lines(VGLBitmap *object, int x, int y, int xc, int yc, byte color)
inline set2lines(VGLBitmap *object, int x, int y, int xc, int yc, u_long color)
{
if (x!=0) {
VGLLine(object, xc+x, yc+y, xc-x, yc+y, color);
@ -228,7 +303,7 @@ inline set2lines(VGLBitmap *object, int x, int y, int xc, int yc, byte color)
}
void
VGLFilledEllipse(VGLBitmap *object, int xc, int yc, int a, int b, byte color)
VGLFilledEllipse(VGLBitmap *object, int xc, int yc, int a, int b, u_long color)
{
int x = 0, y = b, asq = a*a, asq2 = a*a*2, bsq = b*b;
int bsq2 = b*b*2, d = bsq-asq*b+asq/4, dx = 0, dy = asq2*b;
@ -251,17 +326,19 @@ VGLFilledEllipse(VGLBitmap *object, int xc, int yc, int a, int b, byte color)
}
void
VGLClear(VGLBitmap *object, byte color)
VGLClear(VGLBitmap *object, u_long color)
{
int offset;
int len;
int i, total = 0;
byte b[4];
VGLCheckSwitch();
VGLMouseFreeze(0, 0, object->Xsize, object->Ysize, color);
VGLMouseFreeze(0, 0, object->Xsize, object->Ysize, color); /* XXX */
switch (object->Type) {
case MEMBUF:
case VIDBUF8:
memset(object->Bitmap, color, object->VXsize*object->VYsize);
memset(object->Bitmap, (byte)color, object->VXsize*object->VYsize);
break;
case VIDBUF8S:
@ -269,7 +346,29 @@ VGLClear(VGLBitmap *object, byte color)
VGLSetSegment(offset);
len = min(object->VXsize*object->VYsize - offset,
VGLAdpInfo.va_window_size);
memset(object->Bitmap, color, len);
memset(object->Bitmap, (byte)color, len);
offset += len;
}
break;
case VIDBUF16:
case VIDBUF24:
case VIDBUF32:
color2mem(color, b, object->PixelBytes);
total = object->VXsize*object->VYsize*object->PixelBytes;
for (i = 0; i < total; i += object->PixelBytes)
bcopy(b, object->Bitmap + i, object->PixelBytes);
break;
case VIDBUF16S:
case VIDBUF24S:
case VIDBUF32S:
color2mem(color, b, object->PixelBytes);
total = object->VXsize*object->VYsize*object->PixelBytes;
for (offset = 0; offset < total; ) {
VGLSetSegment(offset);
len = min(total - offset, VGLAdpInfo.va_window_size);
for (i = 0; i < len; i += object->PixelBytes)
bcopy(b, object->Bitmap + offset + i, object->PixelBytes);
offset += len;
}
break;
@ -278,7 +377,7 @@ VGLClear(VGLBitmap *object, byte color)
/* XXX works only for Xsize % 4 = 0 */
outb(0x3c6, 0xff);
outb(0x3c4, 0x02); outb(0x3c5, 0x0f);
memset(object->Bitmap, color, VGLAdpInfo.va_line_width*object->VYsize);
memset(object->Bitmap, (byte)color, VGLAdpInfo.va_line_width*object->VYsize);
break;
case VIDBUF4:
@ -292,7 +391,7 @@ VGLClear(VGLBitmap *object, byte color)
VGLSetSegment(offset);
len = min(object->VXsize*object->VYsize - offset,
VGLAdpInfo.va_window_size);
memset(object->Bitmap, color, len);
memset(object->Bitmap, (byte)color, len);
offset += len;
}
outb(0x3ce, 0x05); outb(0x3cf, 0x00);

23
lib/libvgl/vgl.h
View File

@ -40,6 +40,7 @@ typedef struct {
int VXsize, VYsize;
int Xorigin, Yorigin;
byte *Bitmap;
int PixelBytes;
} VGLBitmap;
#define VGLBITMAP_INITIALIZER(t, x, y, bits) \
@ -54,6 +55,12 @@ typedef struct {
#define VIDBUF8X 3
#define VIDBUF8S 4
#define VIDBUF4S 5
#define VIDBUF16 6 /* Direct Color linear buffer */
#define VIDBUF24 7 /* Direct Color linear buffer */
#define VIDBUF32 8 /* Direct Color linear buffer */
#define VIDBUF16S 9 /* Direct Color segmented buffer */
#define VIDBUF24S 10 /* Direct Color segmented buffer */
#define VIDBUF32S 11 /* Direct Color segmented buffer */
#define NOBUF 255
typedef struct VGLText {
@ -122,14 +129,14 @@ int VGLMouseStatus(int *x, int *y, char *buttons);
int VGLMouseFreeze(int x, int y, int width, int hight, byte color);
void VGLMouseUnFreeze(void);
/* simple.c */
void VGLSetXY(VGLBitmap *object, int x, int y, byte color);
byte VGLGetXY(VGLBitmap *object, int x, int y);
void VGLLine(VGLBitmap *object, int x1, int y1, int x2, int y2, byte color);
void VGLBox(VGLBitmap *object, int x1, int y1, int x2, int y2, byte color);
void VGLFilledBox(VGLBitmap *object, int x1, int y1, int x2, int y2, byte color);
void VGLEllipse(VGLBitmap *object, int xc, int yc, int a, int b, byte color);
void VGLFilledEllipse(VGLBitmap *object, int xc, int yc, int a, int b, byte color);
void VGLClear(VGLBitmap *object, byte color);
void VGLSetXY(VGLBitmap *object, int x, int y, u_long color);
u_long VGLGetXY(VGLBitmap *object, int x, int y);
void VGLLine(VGLBitmap *object, int x1, int y1, int x2, int y2, u_long color);
void VGLBox(VGLBitmap *object, int x1, int y1, int x2, int y2, u_long color);
void VGLFilledBox(VGLBitmap *object, int x1, int y1, int x2, int y2, u_long color);
void VGLEllipse(VGLBitmap *object, int xc, int yc, int a, int b, u_long color);
void VGLFilledEllipse(VGLBitmap *object, int xc, int yc, int a, int b, u_long color);
void VGLClear(VGLBitmap *object, u_long color);
void VGLRestorePalette(void);
void VGLSavePalette(void);
void VGLSetPalette(byte *red, byte *green, byte *blue);