src/video/ggi/SDL_ggivideo.c - third_party/sdl - Git at Google

 /*
     SDL - Simple DirectMedia Layer
     Copyright (C) 1997-2009 Sam Lantinga

     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
     License as published by the Free Software Foundation; either
     version 2.1 of the License, or (at your option) any later version.

     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Lesser General Public License for more details.

     You should have received a copy of the GNU Lesser General Public
     License along with this library; if not, write to the Free Software
     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

     Sam Lantinga
     slouken@libsdl.org
 */
 #include "SDL_config.h"

 /* GGI-based SDL video driver implementation.
 */

 #include <fcntl.h>
 #include <unistd.h>
 #include <sys/mman.h>

 #include <ggi/ggi.h>
 #include <ggi/gii.h>

 #include "SDL_video.h"
 #include "SDL_mouse.h"
 #include "../SDL_sysvideo.h"
 #include "../SDL_pixels_c.h"
 #include "../../events/SDL_events_c.h"
 #include "SDL_ggivideo.h"
 #include "SDL_ggimouse_c.h"
 #include "SDL_ggievents_c.h"


 struct private_hwdata
 {
 	ggi_visual_t vis;
 };

 ggi_visual_t VIS;

 /* Initialization/Query functions */
 static int GGI_VideoInit(_THIS, SDL_PixelFormat *vformat);
 static SDL_Rect **GGI_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);
 static SDL_Surface *GGI_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
 static int GGI_SetColors(_THIS, int firstcolor, int ncolors,
 			 SDL_Color *colors);
 static void GGI_VideoQuit(_THIS);

 /* Hardware surface functions */
 static int GGI_AllocHWSurface(_THIS, SDL_Surface *surface);
 static int GGI_LockHWSurface(_THIS, SDL_Surface *surface);
 static void GGI_UnlockHWSurface(_THIS, SDL_Surface *surface);
 static void GGI_FreeHWSurface(_THIS, SDL_Surface *surface);

 /* GGI driver bootstrap functions */

 static int GGI_Available(void)
 {
 	ggi_visual_t *vis;

 	vis = NULL;
 	if (ggiInit() == 0) {
 		vis = ggiOpen(NULL);
 		if (vis != NULL) {
 			ggiClose(vis);
 		}
 	}
 	return (vis != NULL);
 }

 static void GGI_DeleteDevice(SDL_VideoDevice *device)
 {
 	SDL_free(device->hidden);
 	SDL_free(device);
 }

 static SDL_VideoDevice *GGI_CreateDevice(int devindex)
 {
 	SDL_VideoDevice *device;

 	/* Initialize all variables that we clean on shutdown */
 	device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice));
 	if ( device ) {
 		SDL_memset(device, 0, (sizeof *device));
 		device->hidden = (struct SDL_PrivateVideoData *)
 				SDL_malloc((sizeof *device->hidden));
 	}
 	if ( (device == NULL) || (device->hidden == NULL) ) {
 		SDL_OutOfMemory();
 		if ( device ) {
 			SDL_free(device);
 		}
 		return(0);
 	}
 	SDL_memset(device->hidden, 0, (sizeof *device->hidden));

 	/* Set the function pointers */
 	device->VideoInit = GGI_VideoInit;
 	device->ListModes = GGI_ListModes;
 	device->SetVideoMode = GGI_SetVideoMode;
 	device->SetColors = GGI_SetColors;
 	device->UpdateRects = NULL;
 	device->VideoQuit = GGI_VideoQuit;
 	device->AllocHWSurface = GGI_AllocHWSurface;
 	device->CheckHWBlit = NULL;
 	device->FillHWRect = NULL;
 	device->SetHWColorKey = NULL;
 	device->SetHWAlpha = NULL;
 	device->LockHWSurface = GGI_LockHWSurface;
 	device->UnlockHWSurface = GGI_UnlockHWSurface;
 	device->FlipHWSurface = NULL;
 	device->FreeHWSurface = GGI_FreeHWSurface;
 	device->SetCaption = NULL;
 	device->SetIcon = NULL;
 	device->IconifyWindow = NULL;
 	device->GrabInput = NULL;
 	device->GetWMInfo = NULL;
 	device->InitOSKeymap = GGI_InitOSKeymap;
 	device->PumpEvents = GGI_PumpEvents;

 	device->free = GGI_DeleteDevice;

 	return device;
 }

 VideoBootStrap GGI_bootstrap = {
 	"ggi", "General Graphics Interface (GGI)",
 	GGI_Available, GGI_CreateDevice
 };


 static SDL_Rect video_mode;
 static SDL_Rect *SDL_modelist[4] = { NULL, NULL, NULL, NULL };

 int GGI_VideoInit(_THIS, SDL_PixelFormat *vformat)
 {
 	ggi_mode mode =
 	{
 		1,
 		{ GGI_AUTO, GGI_AUTO },
 		{ GGI_AUTO, GGI_AUTO },
 		{ 0, 0 },
 		GT_AUTO,
 		{ GGI_AUTO, GGI_AUTO }
 	};
 	struct private_hwdata *priv;
 	ggi_color pal[256], map[256];
 	const ggi_directbuffer *db;
 	int err, num_bufs;
 	ggi_pixel white, black;

 	priv = SDL_malloc(sizeof(struct private_hwdata));
 	if (priv == NULL)
 	{
 		SDL_SetError("Unhandled GGI mode type!\n");
 		GGI_VideoQuit(NULL);
 	}

 	if (ggiInit() != 0)
 	{
 		SDL_SetError("Unable to initialize GGI!\n");
 		GGI_VideoQuit(NULL);
 	}

 	VIS = ggiOpen(NULL);
 	if (VIS == NULL)
 	{
 		SDL_SetError("Unable to open default GGI visual!\n");
 		ggiExit();
 		GGI_VideoQuit(NULL);
 	}

 	ggiSetFlags(VIS, GGIFLAG_ASYNC);

 	/* Validate mode, autodetecting any GGI_AUTO or GT_AUTO fields */
 	ggiCheckMode(VIS, &mode);

 	/* At this point we should have a valid mode - try to set it */
 	err = ggiSetMode(VIS, &mode);

 	/* If we couldn't set _any_ modes, something is very wrong */
 	if (err)
 	{
 		SDL_SetError("Can't set a mode!\n");
 		ggiClose(VIS);
 		ggiExit();
 		GGI_VideoQuit(NULL);
 	}

 	/* Determine the current screen size */
 	this->info.current_w = mode.virt.x;
 	this->info.current_h = mode.virt.y;

 	/* Set a palette for palletized modes */
 	if (GT_SCHEME(mode.graphtype) == GT_PALETTE)
 	{
 		ggiSetColorfulPalette(VIS);
 		ggiGetPalette(VIS, 0, 1 << vformat->BitsPerPixel, pal);
 	}

 	/* Now we try to get the DirectBuffer info, which determines whether
 	 * SDL can access hardware surfaces directly. */

 	num_bufs = ggiDBGetNumBuffers(VIS);

 	if (num_bufs > 0)
 	{
 		db = ggiDBGetBuffer(VIS, 0); /* Only handle one DB for now */

 		vformat->BitsPerPixel = db->buffer.plb.pixelformat->depth;

 		vformat->Rmask = db->buffer.plb.pixelformat->red_mask;
 		vformat->Gmask = db->buffer.plb.pixelformat->green_mask;
 		vformat->Bmask = db->buffer.plb.pixelformat->blue_mask;

 		/* Fill in our hardware acceleration capabilities */

 		this->info.wm_available = 0;
 		this->info.hw_available = 1;
 		this->info.video_mem = db->buffer.plb.stride * mode.virt.y;
 	}

 	video_mode.x = 0;
 	video_mode.y = 0;
 	video_mode.w = mode.virt.x;
 	video_mode.h = mode.virt.y;
 	SDL_modelist[((vformat->BitsPerPixel + 7) / 8) - 1] = &video_mode;

 	/* We're done! */
 	return(0);
 }

 static SDL_Rect **GGI_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
 {
 	return(&SDL_modelist[((format->BitsPerPixel + 7) / 8) - 1]);
 }

 /* Various screen update functions available */
 static void GGI_DirectUpdate(_THIS, int numrects, SDL_Rect *rects);

 SDL_Surface *GGI_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags)
 {
 	ggi_mode mode =
 	{
 		1,
 		{ GGI_AUTO, GGI_AUTO },
 		{ GGI_AUTO, GGI_AUTO },
 		{ 0, 0 },
 		GT_AUTO,
 		{ GGI_AUTO, GGI_AUTO }
 	};
         const ggi_directbuffer *db;
 	ggi_color pal[256];
 	int err;

 	fprintf(stderr, "GGI_SetVideoMode()\n");

 	mode.visible.x = mode.virt.x = width;
 	mode.visible.y = mode.virt.y = height;

 	/* Translate requested SDL bit depth into a GGI mode */
 	switch (bpp)
 	{
 		case 1:  mode.graphtype = GT_1BIT;  break;
 		case 2:  mode.graphtype = GT_2BIT;  break;
 		case 4:  mode.graphtype = GT_4BIT;  break;
 		case 8:  mode.graphtype = GT_8BIT;  break;
 		case 15: mode.graphtype = GT_15BIT; break;
 		case 16: mode.graphtype = GT_16BIT; break;
 		case 24: mode.graphtype = GT_24BIT; break;
 		case 32: mode.graphtype = GT_32BIT; break;
 		default:
 		SDL_SetError("Unknown SDL bit depth, using GT_AUTO....\n");
 		mode.graphtype = GT_AUTO;
 	}

 	/* Validate mode, autodetecting any GGI_AUTO or GT_AUTO fields */
 	ggiCheckMode(VIS, &mode);

 	/* At this point we should have a valid mode - try to set it */
 	err = ggiSetMode(VIS, &mode);

 	/* If we couldn't set _any_ modes, something is very wrong */
 	if (err)
 	{
 		SDL_SetError("Can't set a mode!\n");
 		ggiClose(VIS);
 		ggiExit();
 		GGI_VideoQuit(NULL);
 	}

 	/* Set a palette for palletized modes */
 	if (GT_SCHEME(mode.graphtype) == GT_PALETTE)
 	{
 		ggiSetColorfulPalette(VIS);
 		ggiGetPalette(VIS, 0, 1 << bpp, pal);
 	}

 	db = ggiDBGetBuffer(VIS, 0);

 	/* Set up the new mode framebuffer */
 	current->flags = (SDL_FULLSCREEN | SDL_HWSURFACE);
 	current->w = mode.virt.x;
 	current->h = mode.virt.y;
 	current->pitch = db->buffer.plb.stride;
 	current->pixels = db->read;

 	/* Set the blit function */
 	this->UpdateRects = GGI_DirectUpdate;

 	/* We're done */
 	return(current);
 }

 static int GGI_AllocHWSurface(_THIS, SDL_Surface *surface)
 {
 	return(-1);
 }
 static void GGI_FreeHWSurface(_THIS, SDL_Surface *surface)
 {
 	return;
 }
 static int GGI_LockHWSurface(_THIS, SDL_Surface *surface)
 {
 	return(0);
 }
 static void GGI_UnlockHWSurface(_THIS, SDL_Surface *surface)
 {
 	return;
 }

 static void GGI_DirectUpdate(_THIS, int numrects, SDL_Rect *rects)
 {
 	int i;

 /*	ggiFlush(VIS); */

 	for (i = 0; i < numrects; i++)
 	{
 		ggiFlushRegion(VIS, rects[i].x, rects[i].y, rects[i].w, rects[i].h);
 	}
 	return;
 }

 int GGI_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
 {
 	int i;
 	ggi_color pal[256];

 	/* Set up the colormap */
 	for (i = 0; i < ncolors; i++)
 	{
 		pal[i].r = (colors[i].r << 8) | colors[i].r;
 		pal[i].g = (colors[i].g << 8) | colors[i].g;
 		pal[i].b = (colors[i].b << 8) | colors[i].b;
 	}

 	ggiSetPalette(VIS, firstcolor, ncolors, pal);

 	return 1;
 }

 void GGI_VideoQuit(_THIS)
 {
 }
 void GGI_FinalQuit(void)
 {
 }
	/*
	SDL - Simple DirectMedia Layer
	Copyright (C) 1997-2009 Sam Lantinga

	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Lesser General Public
	License as published by the Free Software Foundation; either
	version 2.1 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public
	License along with this library; if not, write to the Free Software
	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

	Sam Lantinga
	slouken@libsdl.org
	*/
	#include "SDL_config.h"

	/* GGI-based SDL video driver implementation.
	*/

	#include <fcntl.h>
	#include <unistd.h>
	#include <sys/mman.h>

	#include <ggi/ggi.h>
	#include <ggi/gii.h>

	#include "SDL_video.h"
	#include "SDL_mouse.h"
	#include "../SDL_sysvideo.h"
	#include "../SDL_pixels_c.h"
	#include "../../events/SDL_events_c.h"
	#include "SDL_ggivideo.h"
	#include "SDL_ggimouse_c.h"
	#include "SDL_ggievents_c.h"


	struct private_hwdata
	{
	ggi_visual_t vis;
	};

	ggi_visual_t VIS;

	/* Initialization/Query functions */
	static int GGI_VideoInit(_THIS, SDL_PixelFormat *vformat);
	static SDL_Rect *GGI_ListModes(_THIS, SDL_PixelFormat format, Uint32 flags);
	static SDL_Surface GGI_SetVideoMode(_THIS, SDL_Surface current, int width, int height, int bpp, Uint32 flags);
	static int GGI_SetColors(_THIS, int firstcolor, int ncolors,
	SDL_Color *colors);
	static void GGI_VideoQuit(_THIS);

	/* Hardware surface functions */
	static int GGI_AllocHWSurface(_THIS, SDL_Surface *surface);
	static int GGI_LockHWSurface(_THIS, SDL_Surface *surface);
	static void GGI_UnlockHWSurface(_THIS, SDL_Surface *surface);
	static void GGI_FreeHWSurface(_THIS, SDL_Surface *surface);

	/* GGI driver bootstrap functions */

	static int GGI_Available(void)
	{
	ggi_visual_t *vis;

	vis = NULL;
	if (ggiInit() == 0) {
	vis = ggiOpen(NULL);
	if (vis != NULL) {
	ggiClose(vis);
	}
	}
	return (vis != NULL);
	}

	static void GGI_DeleteDevice(SDL_VideoDevice *device)
	{
	SDL_free(device->hidden);
	SDL_free(device);
	}

	static SDL_VideoDevice *GGI_CreateDevice(int devindex)
	{
	SDL_VideoDevice *device;

	/* Initialize all variables that we clean on shutdown */
	device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice));
	if ( device ) {
	SDL_memset(device, 0, (sizeof *device));
	device->hidden = (struct SDL_PrivateVideoData *)
	SDL_malloc((sizeof *device->hidden));
	}
	if ( (device == NULL) \|\| (device->hidden == NULL) ) {
	SDL_OutOfMemory();
	if ( device ) {
	SDL_free(device);
	}
	return(0);
	}
	SDL_memset(device->hidden, 0, (sizeof *device->hidden));

	/* Set the function pointers */
	device->VideoInit = GGI_VideoInit;
	device->ListModes = GGI_ListModes;
	device->SetVideoMode = GGI_SetVideoMode;
	device->SetColors = GGI_SetColors;
	device->UpdateRects = NULL;
	device->VideoQuit = GGI_VideoQuit;
	device->AllocHWSurface = GGI_AllocHWSurface;
	device->CheckHWBlit = NULL;
	device->FillHWRect = NULL;
	device->SetHWColorKey = NULL;
	device->SetHWAlpha = NULL;
	device->LockHWSurface = GGI_LockHWSurface;
	device->UnlockHWSurface = GGI_UnlockHWSurface;
	device->FlipHWSurface = NULL;
	device->FreeHWSurface = GGI_FreeHWSurface;
	device->SetCaption = NULL;
	device->SetIcon = NULL;
	device->IconifyWindow = NULL;
	device->GrabInput = NULL;
	device->GetWMInfo = NULL;
	device->InitOSKeymap = GGI_InitOSKeymap;
	device->PumpEvents = GGI_PumpEvents;

	device->free = GGI_DeleteDevice;

	return device;
	}

	VideoBootStrap GGI_bootstrap = {
	"ggi", "General Graphics Interface (GGI)",
	GGI_Available, GGI_CreateDevice
	};


	static SDL_Rect video_mode;
	static SDL_Rect *SDL_modelist[4] = { NULL, NULL, NULL, NULL };

	int GGI_VideoInit(_THIS, SDL_PixelFormat *vformat)
	{
	ggi_mode mode =
	{
	1,
	{ GGI_AUTO, GGI_AUTO },
	{ GGI_AUTO, GGI_AUTO },
	{ 0, 0 },
	GT_AUTO,
	{ GGI_AUTO, GGI_AUTO }
	};
	struct private_hwdata *priv;
	ggi_color pal[256], map[256];
	const ggi_directbuffer *db;
	int err, num_bufs;
	ggi_pixel white, black;

	priv = SDL_malloc(sizeof(struct private_hwdata));
	if (priv == NULL)
	{
	SDL_SetError("Unhandled GGI mode type!\n");
	GGI_VideoQuit(NULL);
	}

	if (ggiInit() != 0)
	{
	SDL_SetError("Unable to initialize GGI!\n");
	GGI_VideoQuit(NULL);
	}

	VIS = ggiOpen(NULL);
	if (VIS == NULL)
	{
	SDL_SetError("Unable to open default GGI visual!\n");
	ggiExit();
	GGI_VideoQuit(NULL);
	}

	ggiSetFlags(VIS, GGIFLAG_ASYNC);

	/* Validate mode, autodetecting any GGI_AUTO or GT_AUTO fields */
	ggiCheckMode(VIS, &mode);

	/* At this point we should have a valid mode - try to set it */
	err = ggiSetMode(VIS, &mode);

	/* If we couldn't set _any_ modes, something is very wrong */
	if (err)
	{
	SDL_SetError("Can't set a mode!\n");
	ggiClose(VIS);
	ggiExit();
	GGI_VideoQuit(NULL);
	}

	/* Determine the current screen size */
	this->info.current_w = mode.virt.x;
	this->info.current_h = mode.virt.y;

	/* Set a palette for palletized modes */
	if (GT_SCHEME(mode.graphtype) == GT_PALETTE)
	{
	ggiSetColorfulPalette(VIS);
	ggiGetPalette(VIS, 0, 1 << vformat->BitsPerPixel, pal);
	}

	/* Now we try to get the DirectBuffer info, which determines whether
	* SDL can access hardware surfaces directly. */

	num_bufs = ggiDBGetNumBuffers(VIS);

	if (num_bufs > 0)
	{
	db = ggiDBGetBuffer(VIS, 0); /* Only handle one DB for now */

	vformat->BitsPerPixel = db->buffer.plb.pixelformat->depth;

	vformat->Rmask = db->buffer.plb.pixelformat->red_mask;
	vformat->Gmask = db->buffer.plb.pixelformat->green_mask;
	vformat->Bmask = db->buffer.plb.pixelformat->blue_mask;

	/* Fill in our hardware acceleration capabilities */

	this->info.wm_available = 0;
	this->info.hw_available = 1;
	this->info.video_mem = db->buffer.plb.stride * mode.virt.y;
	}

	video_mode.x = 0;
	video_mode.y = 0;
	video_mode.w = mode.virt.x;
	video_mode.h = mode.virt.y;
	SDL_modelist[((vformat->BitsPerPixel + 7) / 8) - 1] = &video_mode;

	/* We're done! */
	return(0);
	}

	static SDL_Rect *GGI_ListModes(_THIS, SDL_PixelFormat format, Uint32 flags)
	{
	return(&SDL_modelist[((format->BitsPerPixel + 7) / 8) - 1]);
	}

	/* Various screen update functions available */
	static void GGI_DirectUpdate(_THIS, int numrects, SDL_Rect *rects);

	SDL_Surface GGI_SetVideoMode(_THIS, SDL_Surface current, int width, int height, int bpp, Uint32 flags)
	{
	ggi_mode mode =
	{
	1,
	{ GGI_AUTO, GGI_AUTO },
	{ GGI_AUTO, GGI_AUTO },
	{ 0, 0 },
	GT_AUTO,
	{ GGI_AUTO, GGI_AUTO }
	};
	const ggi_directbuffer *db;
	ggi_color pal[256];
	int err;

	fprintf(stderr, "GGI_SetVideoMode()\n");

	mode.visible.x = mode.virt.x = width;
	mode.visible.y = mode.virt.y = height;

	/* Translate requested SDL bit depth into a GGI mode */
	switch (bpp)
	{
	case 1: mode.graphtype = GT_1BIT; break;
	case 2: mode.graphtype = GT_2BIT; break;
	case 4: mode.graphtype = GT_4BIT; break;
	case 8: mode.graphtype = GT_8BIT; break;
	case 15: mode.graphtype = GT_15BIT; break;
	case 16: mode.graphtype = GT_16BIT; break;
	case 24: mode.graphtype = GT_24BIT; break;
	case 32: mode.graphtype = GT_32BIT; break;
	default:
	SDL_SetError("Unknown SDL bit depth, using GT_AUTO....\n");
	mode.graphtype = GT_AUTO;
	}

	/* Validate mode, autodetecting any GGI_AUTO or GT_AUTO fields */
	ggiCheckMode(VIS, &mode);

	/* At this point we should have a valid mode - try to set it */
	err = ggiSetMode(VIS, &mode);

	/* If we couldn't set _any_ modes, something is very wrong */
	if (err)
	{
	SDL_SetError("Can't set a mode!\n");
	ggiClose(VIS);
	ggiExit();
	GGI_VideoQuit(NULL);
	}

	/* Set a palette for palletized modes */
	if (GT_SCHEME(mode.graphtype) == GT_PALETTE)
	{
	ggiSetColorfulPalette(VIS);
	ggiGetPalette(VIS, 0, 1 << bpp, pal);
	}

	db = ggiDBGetBuffer(VIS, 0);

	/* Set up the new mode framebuffer */
	current->flags = (SDL_FULLSCREEN \| SDL_HWSURFACE);
	current->w = mode.virt.x;
	current->h = mode.virt.y;
	current->pitch = db->buffer.plb.stride;
	current->pixels = db->read;

	/* Set the blit function */
	this->UpdateRects = GGI_DirectUpdate;

	/* We're done */
	return(current);
	}

	static int GGI_AllocHWSurface(_THIS, SDL_Surface *surface)
	{
	return(-1);
	}
	static void GGI_FreeHWSurface(_THIS, SDL_Surface *surface)
	{
	return;
	}
	static int GGI_LockHWSurface(_THIS, SDL_Surface *surface)
	{
	return(0);
	}
	static void GGI_UnlockHWSurface(_THIS, SDL_Surface *surface)
	{
	return;
	}

	static void GGI_DirectUpdate(_THIS, int numrects, SDL_Rect *rects)
	{
	int i;

	/* ggiFlush(VIS); */

	for (i = 0; i < numrects; i++)
	{
	ggiFlushRegion(VIS, rects[i].x, rects[i].y, rects[i].w, rects[i].h);
	}
	return;
	}

	int GGI_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
	{
	int i;
	ggi_color pal[256];

	/* Set up the colormap */
	for (i = 0; i < ncolors; i++)
	{
	pal[i].r = (colors[i].r << 8) \| colors[i].r;
	pal[i].g = (colors[i].g << 8) \| colors[i].g;
	pal[i].b = (colors[i].b << 8) \| colors[i].b;
	}

	ggiSetPalette(VIS, firstcolor, ncolors, pal);

	return 1;
	}

	void GGI_VideoQuit(_THIS)
	{
	}
	void GGI_FinalQuit(void)
	{
	}