int GGIMesa_fbdev_setmode(ggi_visual *vis, ggi_mode *mode) { int err; if ((err = ggiCheckMode(vis, mode)) != 0) { return err; } GGIMESADPRINT_CORE("display-fbdev-mesa: setmode %dx%d#%dx%dF%d[0x%02x]\n", mode->visible.x, mode->visible.y, mode->virt.x, mode->virt.y, mode->frames, mode->graphtype); memcpy(LIBGGI_MODE(vis), mode, sizeof(ggi_mode)); /* Now actually set the mode */ err = do_setmode(vis); if (err != 0) { return err; } GGIMESADPRINT_CORE("display-fbdev-mesa: setmode success.\n"); return 0; }
int GGI_lcd823_setmode(struct ggi_visual *vis, ggi_mode *mode) { int err; if ((err = ggiCheckMode(vis, mode)) != 0) { return err; } if (LIBGGI_PAL(vis)->clut.data) { free(LIBGGI_PAL(vis)->clut.data); LIBGGI_PAL(vis)->clut.data = NULL; } if (LIBGGI_PAL(vis)->priv) { free(LIBGGI_PAL(vis)->priv); LIBGGI_PAL(vis)->priv = NULL; } _GGI_lcd823_free_dbs(vis); memcpy(LIBGGI_MODE(vis), mode, sizeof(ggi_mode)); /* Now actually set the mode */ err = do_setmode(vis); if (err != 0) { return err; } /* Reset panning and frames */ vis->d_frame_num = vis->origin_x = vis->origin_y = 0; return 0; }
int GGI_palemu_setmode(struct ggi_visual *vis, ggi_mode *mode) { ggi_palemu_priv *priv = PALEMU_PRIV(vis); int err; DPRINT_MODE("display-palemu: setmode %dx%d#%dx%dF%d[0x%02x]\n", mode->visible.x, mode->visible.y, mode->virt.x, mode->virt.y, mode->frames, mode->graphtype); MANSYNC_ignore(vis); if ((err = ggiCheckMode(vis->instance.stem, mode)) != 0) { return err; } _ggiZapMode(vis, 0); *LIBGGI_MODE(vis) = *mode; priv->parent_mode.visible = mode->visible; priv->parent_mode.virt = mode->virt; priv->parent_mode.dpp = mode->dpp; priv->parent_mode.size = mode->size; priv->parent_mode.frames = 1; if ((err = do_setmode(vis)) != 0) { DPRINT_MODE("display-palemu: setmode failed (%d).\n", err); return err; } priv->squish.x = mode->visible.x / target_width; priv->squish.y = mode->visible.y / target_height; DPRINT_MODE("display-palemu: Attempting to setmode on parent " "visual...\n"); if (priv->target == PALEMU_TARGET) { err = _ggi_palemu_Open(vis); } else { err = _ggi_monotext_Open(vis); } if (err != 0) { return err; } /* Initialize palette */ ggiSetColorfulPalette(vis->instance.stem); MANSYNC_SETFLAGS(vis, LIBGGI_FLAGS(vis)); MANSYNC_cont(vis); DPRINT_MODE("display-palemu: setmode succeeded.\n"); return 0; }
static void perf_CHECK(TeleUser *u, TeleEvent *ev) { TeleCmdOpenData *d = (TeleCmdOpenData *) ev->data; ggi_mode mode; T_Long reply_sequence; int err; /* get target to check mode */ mode.graphtype = (ggi_graphtype) d->graphtype; mode.frames = (uint32_t) d->frames; mode.visible.x = (int16_t) d->visible.width; mode.visible.y = (int16_t) d->visible.height; mode.virt.x = (int16_t) d->virt.width; mode.virt.y = (int16_t) d->virt.height; mode.size.x = (int16_t) d->size.width; mode.size.y = (int16_t) d->size.height; mode.dpp.x = (int16_t) d->dot.width; mode.dpp.y = (int16_t) d->dot.height; d->error = ggiCheckMode(vis, &mode); /* send result back to client */ reply_sequence = ev->sequence; tserver_new_event(u, ev, TELE_CMD_CHECK, sizeof(TeleCmdOpenData), 0); ev->sequence = reply_sequence; d->graphtype = (T_Long) mode.graphtype; d->frames = (T_Long) mode.frames; d->visible.width = (T_Long) mode.visible.x; d->visible.height = (T_Long) mode.visible.y; d->virt.width = (T_Long) mode.virt.x; d->virt.height = (T_Long) mode.virt.y; d->size.width = (T_Long) mode.size.x; d->size.height = (T_Long) mode.size.y; d->dot.width = (T_Long) mode.dpp.x; d->dot.height = (T_Long) mode.dpp.y; err = tserver_write(u, ev); if (err == TELE_ERROR_SHUTDOWN) { /* Client has gone away */ close_connection(1); return; } }
static int query_format(uint32_t format) { ggi_mode mode; uint32_t vfcap; vfcap = VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW | VFCAP_ACCEPT_STRIDE; if ((!vo_depthonscreen || !vo_dbpp) && ggi_conf.vis) { if (ggiGetMode(ggi_conf.vis, &mode) == 0) { vo_depthonscreen = GT_DEPTH(mode.graphtype); vo_dbpp = GT_SIZE(mode.graphtype); } if (GT_SCHEME(mode.graphtype) == GT_AUTO) { ggiCheckMode(ggi_conf.vis, &mode); } if (GT_SCHEME(mode.graphtype) != GT_TRUECOLOR) { mode.graphtype = GT_32BIT; vo_depthonscreen = GT_DEPTH(mode.graphtype); vo_dbpp = GT_SIZE(mode.graphtype); } } if ((IMGFMT_IS_BGR(format) && (IMGFMT_BGR_DEPTH(format) == vo_dbpp)) || (IMGFMT_IS_RGB(format) && (IMGFMT_RGB_DEPTH(format) == vo_dbpp))) { return vfcap; } if (IMGFMT_IS_BGR(format) || IMGFMT_IS_RGB(format)) { set_graphtype(format, &mode); if (ggiCheckMode(ggi_conf.drawvis, &mode) < 0) { return 0; } else { return vfcap; } } return (0); }
int GGI_vcsa_setmode(struct ggi_visual *vis, ggi_mode *mode) { char libname[GGI_MAX_APILEN], libargs[GGI_MAX_APILEN]; int err, id; if ((err = ggiCheckMode(vis->instance.stem, mode)) != 0) { return err; } DPRINT_MODE("display-vcsa: setmode %dx%d#%dx%dF%d[0x%02x]\n", mode->visible.x, mode->visible.y, mode->virt.x, mode->virt.y, mode->frames, mode->graphtype); memcpy(LIBGGI_MODE(vis), mode, sizeof(ggi_mode)); _ggiZapMode(vis, 0); /* load API libraries */ for (id=1; GGI_vcsa_getapi(vis, id, libname, libargs) == 0; id++) { err = _ggiOpenDL(vis, libggi->config, libname, libargs, NULL); if (err) { fprintf(stderr,"display-vcsa: Error opening the " "%s (%s) library.\n", libname, libargs); return GGI_EFATAL; } DPRINT_LIBS("Success in loading %s (%s)\n", libname, libargs); } /* setup drawing primitives */ vis->opdraw->putpixel_nc = GGI_vcsa_putpixel_nc; vis->opdraw->getpixel_nc = GGI_vcsa_getpixel_nc; vis->opdraw->putc = GGI_vcsa_putc; vis->opdraw->puts = GGI_vcsa_puts; vis->opdraw->getcharsize = GGI_vcsa_getcharsize; vis->opdraw->drawhline_nc = GGI_vcsa_drawhline_nc; vis->opdraw->puthline = GGI_vcsa_puthline; vis->opdraw->gethline = GGI_vcsa_gethline; vis->opcolor->mapcolor = GGI_vcsa_mapcolor; vis->opcolor->unmappixel = GGI_vcsa_unmappixel; /* indicate API change */ ggiIndicateChange(vis->instance.stem, GGI_CHG_APILIST); DPRINT_MODE("display-vcsa: setmode Success.\n"); return 0; }
int GGI_trueemu_setmode(struct ggi_visual *vis, ggi_mode *mode) { ggi_trueemu_priv *priv = TRUEEMU_PRIV(vis); int err; DPRINT_MODE("display-trueemu: setmode %dx%d#%dx%dF%d[0x%02x]\n", mode->visible.x, mode->visible.y, mode->virt.x, mode->virt.y, mode->frames, mode->graphtype); MANSYNC_ignore(vis); if ((err = ggiCheckMode(vis->instance.stem, mode)) != 0) { return err; } _ggiZapMode(vis, 0); *LIBGGI_MODE(vis) = *mode; priv->mode.visible = mode->visible; priv->mode.virt = mode->virt; priv->mode.dpp = mode->dpp; priv->mode.size = mode->size; priv->mode.frames = 1; if ((err = do_setmode(vis)) != 0) { DPRINT_MODE("display-trueemu: setmode failed (%d).\n", err); return err; } DPRINT_MODE("display-trueemu: Attempting to setmode on parent " "visual...\n"); if ((err = _ggi_trueemu_Open(vis)) != 0) { return err; } MANSYNC_SETFLAGS(vis, LIBGGI_FLAGS(vis)); MANSYNC_cont(vis); DPRINT_MODE("display-trueemu: setmode succeeded.\n"); return 0; }
static void testcase8(const char *desc) { int err; ggi_visual_t vis; ggi_mode mode; printteststart(__FILE__, __PRETTY_FUNCTION__, EXPECTED2PASS, desc); if (dontrun) return; err = ggiInit(); printassert(err == GGI_OK, "ggiInit failed with %i\n", err); vis = ggiOpen(NULL); printassert(vis != NULL, "ggiOpen() failed\n"); mode.virt.x = mode.virt.y = GGI_AUTO; mode.visible.x = mode.visible.y = GGI_AUTO; mode.frames = GGI_AUTO; mode.graphtype = GT_AUTO; mode.dpp.x = mode.dpp.y = 1; mode.size.x = -19493; mode.size.y = 31831; /* Get the default mode */ ggiCheckMode(vis, &mode); err = ggiSetMode(vis, &mode); if (err != GGI_OK) { printfailure("ggiSetMode() failed even though ggiCheckMode() was called!\n"); ggiClose(vis); ggiExit(); return; } ggiClose(vis); ggiExit(); printsuccess(); return; }
static int config(uint32_t width, uint32_t height, uint32_t d_width, uint32_t d_height, uint32_t flags, char *title, uint32_t format) { ggi_mode mode = { 1, /* frames */ {width, height}, /* visible */ {GGI_AUTO, GGI_AUTO}, /* virt */ {GGI_AUTO, GGI_AUTO}, /* size */ GT_AUTO, /* graphtype */ {GGI_AUTO, GGI_AUTO} /* dots per pixel */ }; set_graphtype(format, &mode); #if 0 printf("[ggi] mode: "); ggiPrintMode(&mode); printf("\n"); #endif ggiCheckMode(ggi_conf.vis, &mode); if (ggiSetMode(ggi_conf.vis, &mode) < 0) { mp_msg(MSGT_VO, MSGL_ERR, "[ggi] unable to set display mode\n"); return (-1); } if (ggiGetMode(ggi_conf.vis, &mode) < 0) { mp_msg(MSGT_VO, MSGL_ERR, "[ggi] unable to get display mode\n"); return (-1); } if ((mode.graphtype == GT_INVALID) || (mode.graphtype == GT_AUTO)) { mp_msg(MSGT_VO, MSGL_ERR, "[ggi] not supported depth/bpp\n"); return (-1); } #if 0 printf("[ggi] mode: "); ggiPrintMode(&mode); printf("\n"); #endif #ifdef HAVE_GGIWMH ggiWmhSetTitle(ggi_conf.vis, title); if (vo_ontop) window_ontop(); #endif ggiSetFlags(ggi_conf.vis, GGIFLAG_ASYNC); if (GT_SCHEME(mode.graphtype) == GT_PALETTE) ggiSetColorfulPalette(ggi_conf.vis); if (GT_SCHEME(mode.graphtype) != GT_TRUECOLOR) { ggi_mode drawmode; ggi_conf.drawvis = ggiOpen("display-memory", NULL); if (ggi_conf.drawvis == NULL) { mp_msg(MSGT_VO, MSGL_ERR, "[ggi] unable to get backbuffer for conversion\n"); return -1; } memcpy(&drawmode, &mode, sizeof(ggi_mode)); drawmode.graphtype = GT_32BIT; drawmode.size.x = GGI_AUTO; drawmode.size.y = GGI_AUTO; ggiCheckMode(ggi_conf.drawvis, &drawmode); if (ggiSetMode(ggi_conf.drawvis, &drawmode) < 0) { mp_msg(MSGT_VO, MSGL_ERR, "[ggi] unable to set backbuffer mode\n"); return -1; } mode.graphtype = drawmode.graphtype; ggiSetFlags(ggi_conf.drawvis, GGIFLAG_ASYNC); } vo_depthonscreen = GT_DEPTH(mode.graphtype); vo_screenwidth = mode.virt.x; vo_screenheight = mode.virt.y; vo_dwidth = width; vo_dheight = height; vo_dbpp = GT_SIZE(mode.graphtype); /* calculate top, left corner */ vo_dx = (vo_screenwidth - vo_dwidth) / 2; vo_dy = (vo_screenheight - vo_dheight) / 2; ggi_conf.srcwidth = width; ggi_conf.srcheight = height; ggi_conf.srcformat = format; ggi_conf.voflags = flags; if (IMGFMT_IS_RGB(ggi_conf.srcformat)) { ggi_conf.srcdepth = IMGFMT_RGB_DEPTH(ggi_conf.srcformat); } else if (IMGFMT_IS_BGR(ggi_conf.srcformat)) { ggi_conf.srcdepth = IMGFMT_BGR_DEPTH(ggi_conf.srcformat); } else { mp_msg(MSGT_VO, MSGL_FATAL, "[ggi] Unknown image format: %s\n", vo_format_name(ggi_conf.srcformat)); return (-1); } mp_msg(MSGT_VO, MSGL_INFO, "[ggi] input: %dx%dx%d, output: %dx%dx%d\n", ggi_conf.srcwidth, ggi_conf.srcheight, ggi_conf.srcdepth, mode.virt.x, mode.virt.y, vo_dbpp); ggi_conf.srcbpp = (ggi_conf.srcdepth + 7) / 8; ggi_conf.flushregion.x1 = vo_dx; ggi_conf.flushregion.y1 = vo_dy; ggi_conf.flushregion.x2 = vo_dwidth; ggi_conf.flushregion.y2 = vo_dheight; return (0); }
static void testcase1(const char *desc) { int ret; ggi_visual_t vis; ggi_mode mode; ggi_pixel pixel_color; ggi_color color_color; #if 0 unsigned int j, size; const ggi_directbuffer *dbuf = NULL; #endif color_color.r = 0x0000; color_color.g = 0xffff; color_color.b = 0xffff; printteststart(__FILE__, __PRETTY_FUNCTION__, EXPECTED2PASS, desc); if (dontrun) return; vis = ggNewStem(libggi, NULL); if (vis == NULL) { printfailure("Couldn't create stem for %s", DISPLAYSTR); return; } ret = ggiOpen(vis, DISPLAYSTR, NULL); if (ret != 0) { printfailure("Couldn't open %s", DISPLAYSTR); return; } #if 0 /* Here, XGGI would switch to async mode, * if there were a place to hook in ggiFlush() */ ggiSetFlags(vis, GGIFLAG_ASYNC); #endif /* Now check, if mansync is actually running * - note, we are in sync mode here. */ /* stop mansync. If it runs as it should, * we don't fail with an assertion here */ ret = MANSYNC_stop(STEM_API_DATA(vis, libggi, struct ggi_visual*)); if (ret != 0) { printfailure("BUG: mansync not running - forgot to call " "MANSYNC_start(vis) right after MANSYNC_init(vis)?\n"); goto exit_testcase; } /* now restart it */ ret = MANSYNC_start(STEM_API_DATA(vis, libggi, struct ggi_visual*)); if (ret != 0) { printfailure("BUG: mansync couldn't be relaunched\n"); goto exit_testcase; } ggiParseMode("", &mode); ggiCheckMode(vis, &mode); ret = ggiSetMode(vis, &mode); if (ret != GGI_OK) { printfailure("expected return value: \"%i\"\n" "actual return value: \"%i\"\n", GGI_OK, ret); goto exit_testcase; } /* Disable directbuffer as this is not required to * perform the test */ #if 0 ret = -1; size = GT_SIZE(mode.graphtype); for (j = 0; (dbuf = ggiDBGetBuffer(vis, j)) != NULL; j++) { if ((dbuf->type & GGI_DB_SIMPLE_PLB) && ((8*dbuf->buffer.plb.stride) % size) == 0) { /* found */ ret = GGI_OK; break; } } if (ret != GGI_OK) { printfailure("This mode and target has no suitable DirectBuffer\n"); goto exit_testcase; } if (ggiResourceAcquire(dbuf->resource, GGI_ACTYPE_WRITE | GGI_ACTYPE_READ) != 0) { printfailure("Unable to acquire DirectBuffer\n"); goto exit_testcase; } #endif /* ... and now draw something. */ pixel_color = ggiMapColor(vis, &color_color); ggiSetGCForeground(vis, pixel_color); ggiFillscreen(vis); #if 0 ggiResourceRelease(dbuf->resource); #endif exit_testcase: ggDelStem(vis); printsuccess(); return; }
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); }
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 int GGIopen(struct ggi_visual *vis, struct ggi_dlhandle *dlh, const char *args, void *argptr, uint32_t_t_t *dlret) { ggi_mode mode; void *memptr=NULL; suid_hook *priv; int x, err = GGI_ENOMEM; LIBGGI_GC(vis) = malloc(sizeof(ggi_gc)); if (LIBGGI_GC(vis) == NULL) { return GGI_ENOMEM; } priv = LIBGGI_PRIVATE(vis) = malloc(sizeof(suid_hook)); if (priv == NULL) { goto out_freegc; } priv->is_up=0; priv->dev_mem=_suidtarget_dev_mem=-1; priv->mmap_length=0; /* Open GII for input */ vis->input = giiOpen("input-linux-kbd", NULL); if (vis->input == NULL) { fprintf(stderr, "display-suidkgi: Couldn't open kbd.\n"); goto out_freepriv; } /* Has mode management */ vis->opdisplay->getmode=GGI_suidkgi_getmode; vis->opdisplay->setmode=GGI_suidkgi_setmode; vis->opdisplay->checkmode=GGI_suidkgi_checkmode; vis->opdisplay->flush=GGI_suidkgi_flush; vis->opdisplay->kgicommand=GGI_suidkgi_kgicommand; vis->opdisplay->setflags=GGI_suidkgi_setflags; vis->opdraw->setorigin=GGI_suidkgi_setorigin; vis->w_frame = malloc(sizeof(ggi_directbuffer)); /* FIXME ! */ vis->r_frame = malloc(sizeof(ggi_directbuffer)); /* FIXME ! */ LIBGGI_CURWRITE(vis)=NULL; LIBGGI_CURREAD(vis)=NULL; if (iopl(3)) {perror("iopl");exit(2); } DPRINT("IOPL is here.\n"); if (-1 == (priv->dev_mem = _suidtarget_dev_mem = open("/dev/mem",O_RDWR))) { perror("opening /dev/mem");exit(3); } memptr=mmap(NULL,64*1024,PROT_READ|PROT_WRITE,MAP_SHARED,priv->dev_mem,0xa0000); DPRINT("Have mmap at %p.\n",memptr); /* law_base=0xf3000000; */ if (suidkgi_init_module()) {DPRINT("Init has failed. Tough luck.\n");exit(1); } DPRINT("Init was o.k.\n"); signal(SIGSEGV,get_killed); signal(SIGINT,get_killed); signal(SIGTERM,get_killed); priv->is_up=1; #if 1 /* Not sure, if this is needed, but ... */ mode.frames=1; mode.graphtype=GT_TEXT16; mode.visible.x=mode.virt.x=80; mode.visible.y=mode.virt.y=25; mode.dpp.x = 8;mode.dpp.y =16; x=GGI_suidkgi_checkmode(vis,&mode); DPRINT("TESTMODE1 says %d.\n",x); x=GGI_suidkgi_setmode(vis,&mode); DPRINT("SETMODE1 says %d.\n",x); #endif #undef TESTING_THE_SUID_TARGET #ifdef TESTING_THE_SUID_TARGET #ifdef GoneByeBye for(x=0;x<480;x++) { GGI_suidkgi_setsplitline(vis, x); ggUSleep(100000); } #endif mode.frames=1; mode.graphtype=GT_8BIT; mode.visible.x=mode.virt.x=320; mode.visible.y=mode.virt.y=200; mode.dpp.x =mode.dpp.y =1; x=ggiCheckMode(vis,&mode); DPRINT("TESTMODE3 says %d.\n",x); x=ggiSetMode(vis,&mode); DPRINT("SETMODE3 says %d.\n",x); sleep(1); { int y; for(y=0;y<200;y++) { for(x=0;x<320;x++) { *((unsigned char *)memptr+x+y*320)=x+y; } ggUSleep(1); } } sleep(1); mode.frames=1; mode.graphtype=GT_TEXT16; mode.visible.x=mode.virt.x=80; mode.visible.y=mode.virt.y=25; mode.dpp.x = 8;mode.dpp.y =16; x=GGI_suidkgi_checkmode(vis,&mode); DPRINT("TESTMODE4 says %d.\n",x); x=GGI_suidkgi_setmode(vis,&mode); DPRINT("SETMODE4 says %d.\n",x); sleep(1); suidkgi_cleanup_module(); DPRINT("Cleanup went well.\n"); close(priv->dev_mem); exit(1); #endif *dlret = GGI_DL_OPDISPLAY|GGI_DL_OPDRAW; return 0; out_freepriv: free(priv); out_freegc: free(LIBGGI_GC(vis); return err; }
static void testcase4(const char *desc) { int err; ggi_visual_t vis; ggi_mode mode; ggi_coord size; printteststart(__FILE__, __PRETTY_FUNCTION__, EXPECTED2PASS, desc); if (dontrun) return; err = ggiInit(); printassert(err == GGI_OK, "ggiInit failed with %i\n", err); vis = ggiOpen(NULL); printassert(vis != NULL, "ggiOpen() failed\n"); err = ggiCheckSimpleMode( vis, GGI_AUTO, GGI_AUTO, GGI_AUTO, GT_AUTO, &mode); printassert(err == GGI_OK, "ggiCheckSimpleMode: can't find a mode\n"); if(err != GGI_OK) { ggiClose(vis); ggiExit(); printsuccess(); return; } printassert(mode.size.x != GGI_AUTO && mode.size.y != GGI_AUTO, "physical size is apparently not supported\n"); if(mode.size.x == GGI_AUTO || mode.size.y == GGI_AUTO) { ggiClose(vis); ggiExit(); printsuccess(); return; } /* Clear out all but the physical size */ mode.frames = GGI_AUTO; mode.visible.x = GGI_AUTO; mode.visible.y = GGI_AUTO; mode.virt.x = GGI_AUTO; mode.virt.y = GGI_AUTO; mode.graphtype = GT_AUTO; mode.dpp.x = GGI_AUTO; mode.dpp.y = GGI_AUTO; size = mode.size; /* This mode should be there */ err = ggiCheckMode(vis, &mode); ggiClose(vis); ggiExit(); if (err != GGI_OK) { printfailure("ggiCheckMode: expected return value: GGI_OK\n" "actual return value: %i\n", err); return; } if (mode.size.x != size.x) { printfailure( "ggiCheckMode: size.x: expected return value: %i\n" "actual return value: %i\n", size.x, mode.size.x); return; } if (mode.size.y != size.y) { printfailure( "ggiCheckMode: size.y: expected return value: %i\n" "actual return value: %i\n", size.y, mode.size.y); return; } printsuccess(); }
int GGI_palemu_checkmode(struct ggi_visual *vis, ggi_mode *mode) { ggi_palemu_priv *priv = PALEMU_PRIV(vis); ggi_mode par_mode; int tmperr, err = 0; DPRINT_MODE("display-palemu: checkmode %dx%d#%dx%dF%d[0x%02x]\n", mode->visible.x, mode->visible.y, mode->virt.x, mode->virt.y, mode->frames, mode->graphtype); /* Handle graphtype */ if (GT_SCHEME(mode->graphtype) == GT_AUTO) { GT_SETSCHEME(mode->graphtype, GT_PALETTE); } mode->graphtype = _GGIhandle_gtauto(mode->graphtype); if (GT_SCHEME(mode->graphtype) != GT_PALETTE) { GT_SETSCHEME(mode->graphtype, GT_PALETTE); err = -1; } if (GT_DEPTH(mode->graphtype) > 8) { GT_SETDEPTH(mode->graphtype, 8); err = -1; } if (GT_SIZE(mode->graphtype) != GT_DEPTH(mode->graphtype)) { GT_SETSIZE(mode->graphtype, GT_DEPTH(mode->graphtype)); err = -1; } /* Handle geometry */ if (mode->visible.x == GGI_AUTO) { mode->visible.x = priv->parent_defmode.visible.x; } if (mode->visible.y == GGI_AUTO) { mode->visible.y = priv->parent_defmode.visible.y; } if (mode->virt.x == GGI_AUTO) { mode->virt.x = priv->parent_defmode.virt.x; } if (mode->virt.y == GGI_AUTO) { mode->virt.y = priv->parent_defmode.virt.y; } if (mode->dpp.x == GGI_AUTO) { mode->dpp.x = priv->parent_defmode.dpp.x; } if (mode->dpp.y == GGI_AUTO) { mode->dpp.y = priv->parent_defmode.dpp.y; } if (mode->size.x == GGI_AUTO) { mode->size.x = priv->parent_defmode.size.x; } if (mode->size.y == GGI_AUTO) { mode->size.y = priv->parent_defmode.size.y; } if (mode->frames == GGI_AUTO) { mode->frames = 1; } /* Now check mode against the parent target (letting the parent * target handle any remaining GT_AUTO and GGI_AUTO values). */ par_mode = *mode; par_mode.graphtype = priv->parent_defmode.graphtype; tmperr = ggiCheckMode(priv->parent, &par_mode); if (tmperr) err = tmperr; mode->visible = par_mode.visible; mode->virt = par_mode.virt; mode->dpp = par_mode.dpp; mode->size = par_mode.size; /* When the parent is palettized, we must limit the * resulting depth to be <= the parent depth. */ if ((GT_SCHEME(par_mode.graphtype) == GT_PALETTE) && (GT_DEPTH(par_mode.graphtype) < GT_DEPTH(mode->graphtype))) { GT_SETDEPTH(mode->graphtype, GT_DEPTH(par_mode.graphtype)); GT_SETSIZE(mode->graphtype, GT_DEPTH(par_mode.graphtype)); err = -1; } DPRINT_MODE("display-palemu: result %d %dx%d#%dx%dF%d[0x%02x]\n", err, mode->visible.x, mode->visible.y, mode->virt.x, mode->virt.y, mode->frames, mode->graphtype); return err; }
int GGI_trueemu_checkmode(struct ggi_visual *vis, ggi_mode *mode) { ggi_trueemu_priv *priv = TRUEEMU_PRIV(vis); ggi_mode par_mode; int tmperr, err = 0; DPRINT_MODE("display-trueemu: checkmode %dx%d#%dx%dF%d[0x%02x]\n", mode->visible.x, mode->visible.y, mode->virt.x, mode->virt.y, mode->frames, mode->graphtype); /* Handle graphtype */ if (GT_SCHEME(mode->graphtype) == GT_AUTO) { GT_SETSCHEME(mode->graphtype, GT_TRUECOLOR); } mode->graphtype = _GGIhandle_gtauto(mode->graphtype); if (GT_SCHEME(mode->graphtype) != GT_TRUECOLOR) { GT_SETSCHEME(mode->graphtype, GT_TRUECOLOR); err = -1; } if (GT_DEPTH(mode->graphtype) != 24) { GT_SETDEPTH(mode->graphtype, 24); err = -1; } if ((GT_SIZE(mode->graphtype) != GT_DEPTH(mode->graphtype)) && (GT_SIZE(mode->graphtype) != 32)) { GT_SETSIZE(mode->graphtype, GT_DEPTH(mode->graphtype)); err = -1; } /* Handle geometry */ if (mode->visible.x == GGI_AUTO) { mode->visible.x = priv->mode.visible.x; } if (mode->visible.y == GGI_AUTO) { mode->visible.y = priv->mode.visible.y; } if (mode->virt.x == GGI_AUTO) { mode->virt.x = priv->mode.virt.x; } if (mode->virt.y == GGI_AUTO) { mode->virt.y = priv->mode.virt.y; } if (mode->dpp.x == GGI_AUTO) { mode->dpp.x = priv->mode.dpp.x; } if (mode->dpp.y == GGI_AUTO) { mode->dpp.y = priv->mode.dpp.y; } if (mode->size.x == GGI_AUTO) { mode->size.x = priv->mode.size.x; } if (mode->size.y == GGI_AUTO) { mode->size.y = priv->mode.size.y; } if (mode->frames == GGI_AUTO) { mode->frames = 1; } /* Now let the parent target have it's say in the checkmode * process. It can deal with any remaining GGI_AUTO or GT_AUTO * values that came from priv->mode. */ par_mode = *mode; par_mode.graphtype = priv->mode.graphtype; tmperr = ggiCheckMode(priv->parent, &par_mode); if (tmperr) err = tmperr; mode->visible = par_mode.visible; mode->virt = par_mode.virt; mode->dpp = par_mode.dpp; mode->size = par_mode.size; DPRINT_MODE("display-trueemu: upgraded to %dx%d#%dx%dF%d[0x%02x]\n", mode->visible.x, mode->visible.y, mode->virt.x, mode->virt.y, mode->frames, mode->graphtype); return err; }