| 0,0 → 1,795 |
|---|
| /* |
| Copyright (C) 1996-1997 Id Software, Inc. |
| |
| This program is free software; you can redistribute it and/or |
| modify it under the terms of the GNU General Public License |
| as published by the Free Software Foundation; either version 2 |
| of the License, or (at your option) any later version. |
| |
| This program 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 General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program; if not, write to the Free Software |
| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| |
| */ |
| // |
| // vid_ext.c: extended video modes |
| // in this implementation, VESA-specific DOS video stuff |
| // |
| |
| // TODO: make dependencies on vid_vga.c explicit or eliminate them |
| |
| #include <stdlib.h> |
| #include <dos.h> |
| |
| #include "quakedef.h" |
| #include "d_local.h" |
| #include "dosisms.h" |
| #include "vid_dos.h" |
| #include <dpmi.h> |
| |
| #define MODE_SUPPORTED_IN_HW 0x0001 |
| #define COLOR_MODE 0x0008 |
| #define GRAPHICS_MODE 0x0010 |
| #define VGA_INCOMPATIBLE 0x0020 |
| #define LINEAR_FRAME_BUFFER 0x0080 |
| |
| #define LINEAR_MODE 0x4000 |
| |
| #define VESA_DONT_WAIT_VSYNC 0 // when page flipping |
| #define VESA_WAIT_VSYNC 0x80 |
| |
| #define MAX_VESA_MODES 30 // we'll just take the first 30 if there |
| // are more |
| typedef struct { |
| int pages[3]; // either 2 or 3 is valid |
| int vesamode; // LINEAR_MODE set if linear mode |
| void *plinearmem; // linear address of start of frame buffer |
| qboolean vga_incompatible; |
| } vesa_extra_t; |
| |
| static vmode_t vesa_modes[MAX_VESA_MODES] = |
| {{NULL, NULL, " ********* VESA modes ********* "}}; |
| static vesa_extra_t vesa_extra[MAX_VESA_MODES]; |
| static char names[MAX_VESA_MODES][10]; |
| |
| extern regs_t regs; |
| |
| static int VID_currentpage; |
| static int VID_displayedpage; |
| static int *VID_pagelist; |
| static byte *VID_membase; |
| static int VID_banked; |
| |
| typedef struct |
| { |
| int modenum; |
| int mode_attributes; |
| int winasegment; |
| int winbsegment; |
| int bytes_per_scanline; // bytes per logical scanline (+16) |
| int win; // window number (A=0, B=1) |
| int win_size; // window size (+6) |
| int granularity; // how finely i can set the window in vid mem (+4) |
| int width, height; // displayed width and height (+18, +20) |
| int bits_per_pixel; // er, better be 8, 15, 16, 24, or 32 (+25) |
| int bytes_per_pixel; // er, better be 1, 2, or 4 |
| int memory_model; // and better be 4 or 6, packed or direct color (+27) |
| int num_pages; // number of complete frame buffer pages (+29) |
| int red_width; // the # of bits in the red component (+31) |
| int red_pos; // the bit position of the red component (+32) |
| int green_width; // etc.. (+33) |
| int green_pos; // (+34) |
| int blue_width; // (+35) |
| int blue_pos; // (+36) |
| int pptr; |
| int pagesize; |
| int numpages; |
| } modeinfo_t; |
| |
| static modeinfo_t modeinfo; |
| |
| // all bytes to avoid problems with compiler field packing |
| typedef struct vbeinfoblock_s { |
| byte VbeSignature[4]; |
| byte VbeVersion[2]; |
| byte OemStringPtr[4]; |
| byte Capabilities[4]; |
| byte VideoModePtr[4]; |
| byte TotalMemory[2]; |
| byte OemSoftwareRev[2]; |
| byte OemVendorNamePtr[4]; |
| byte OemProductNamePtr[4]; |
| byte OemProductRevPtr[4]; |
| byte Reserved[222]; |
| byte OemData[256]; |
| } vbeinfoblock_t; |
| |
| static int totalvidmem; |
| static byte *ppal; |
| qboolean vsync_exists, de_exists; |
| |
| qboolean VID_ExtraGetModeInfo(int modenum); |
| int VID_ExtraInitMode (viddef_t *vid, vmode_t *pcurrentmode); |
| void VID_ExtraSwapBuffers (viddef_t *vid, vmode_t *pcurrentmode, |
| vrect_t *rects); |
| |
| |
| /* |
| ================ |
| VGA_BankedBeginDirectRect |
| ================ |
| */ |
| void VGA_BankedBeginDirectRect (viddef_t *lvid, struct vmode_s *pcurrentmode, |
| int x, int y, byte *pbitmap, int width, int height) |
| { |
| |
| if (!lvid->direct) |
| return; |
| |
| regs.x.ax = 0x4f05; |
| regs.x.bx = 0; |
| regs.x.dx = VID_displayedpage; |
| dos_int86(0x10); |
| |
| VGA_BeginDirectRect (lvid, pcurrentmode, x, y, pbitmap, width, height); |
| |
| regs.x.ax = 0x4f05; |
| regs.x.bx = 0; |
| regs.x.dx = VID_currentpage; |
| dos_int86(0x10); |
| } |
| |
| |
| /* |
| ================ |
| VGA_BankedEndDirectRect |
| ================ |
| */ |
| void VGA_BankedEndDirectRect (viddef_t *lvid, struct vmode_s *pcurrentmode, |
| int x, int y, int width, int height) |
| { |
| |
| if (!lvid->direct) |
| return; |
| |
| regs.x.ax = 0x4f05; |
| regs.x.bx = 0; |
| regs.x.dx = VID_displayedpage; |
| dos_int86(0x10); |
| |
| VGA_EndDirectRect (lvid, pcurrentmode, x, y, width, height); |
| |
| regs.x.ax = 0x4f05; |
| regs.x.bx = 0; |
| regs.x.dx = VID_currentpage; |
| dos_int86(0x10); |
| } |
| |
| |
| /* |
| ================ |
| VID_SetVESAPalette |
| ================ |
| */ |
| void VID_SetVESAPalette (viddef_t *lvid, vmode_t *pcurrentmode, |
| unsigned char *pal) |
| { |
| int i; |
| byte *pp; |
| |
| UNUSED(lvid); |
| UNUSED(pcurrentmode); |
| |
| pp = ppal; |
| |
| for (i=0 ; i<256 ; i++) |
| { |
| pp[2] = pal[0] >> 2; |
| pp[1] = pal[1] >> 2; |
| pp[0] = pal[2] >> 2; |
| pp += 4; |
| pal += 3; |
| } |
| |
| regs.x.ax = 0x4F09; |
| regs.x.bx = 0; |
| regs.x.cx = 256; |
| regs.x.dx = 0; |
| regs.x.es = ptr2real(ppal) >> 4; |
| regs.x.di = ptr2real(ppal) & 0xf; |
| dos_int86(0x10); |
| |
| if (regs.x.ax != 0x4f) |
| Sys_Error ("Unable to load VESA palette\n"); |
| } |
| |
| |
| |
| |
| /* |
| ================ |
| VID_ExtraFarToLinear |
| ================ |
| */ |
| void *VID_ExtraFarToLinear (void *ptr) |
| { |
| int temp; |
| |
| temp = (int)ptr; |
| return real2ptr(((temp & 0xFFFF0000) >> 12) + (temp & 0xFFFF)); |
| } |
| |
| |
| /* |
| ================ |
| VID_ExtraWaitDisplayEnable |
| ================ |
| */ |
| void VID_ExtraWaitDisplayEnable () |
| { |
| while ((inportb (0x3DA) & 0x01) == 1) |
| ; |
| } |
| |
| |
| /* |
| ================ |
| VID_ExtraVidLookForState |
| ================ |
| */ |
| qboolean VID_ExtraVidLookForState (unsigned state, unsigned mask) |
| { |
| int i; |
| double starttime, time; |
| |
| starttime = Sys_FloatTime (); |
| |
| do |
| { |
| for (i=0 ; i<100000 ; i++) |
| { |
| if ((inportb (0x3DA) & mask) == state) |
| return true; |
| } |
| |
| time = Sys_FloatTime (); |
| } while ((time - starttime) < 0.1); |
| |
| return false; |
| } |
| |
| |
| /* |
| ================ |
| VID_ExtraStateFound |
| ================ |
| */ |
| qboolean VID_ExtraStateFound (unsigned state) |
| { |
| int i, workingstate; |
| |
| workingstate = 0; |
| |
| for (i=0 ; i<10 ; i++) |
| { |
| if (!VID_ExtraVidLookForState(workingstate, state)) |
| { |
| return false; |
| } |
| |
| workingstate ^= state; |
| } |
| |
| return true; |
| } |
| |
| |
| /* |
| ================ |
| VID_InitExtra |
| ================ |
| */ |
| void VID_InitExtra (void) |
| { |
| int nummodes; |
| short *pmodenums; |
| vbeinfoblock_t *pinfoblock; |
| __dpmi_meminfo phys_mem_info; |
| |
| pinfoblock = dos_getmemory(sizeof(vbeinfoblock_t)); |
| |
| *(long *)pinfoblock->VbeSignature = 'V' + ('B'<<8) + ('E'<<16) + ('2'<<24); |
| |
| // see if VESA support is available |
| regs.x.ax = 0x4f00; |
| regs.x.es = ptr2real(pinfoblock) >> 4; |
| regs.x.di = ptr2real(pinfoblock) & 0xf; |
| dos_int86(0x10); |
| |
| if (regs.x.ax != 0x4f) |
| return; // no VESA support |
| |
| if (pinfoblock->VbeVersion[1] < 0x02) |
| return; // not VESA 2.0 or greater |
| |
| Con_Printf ("VESA 2.0 compliant adapter:\n%s\n", |
| VID_ExtraFarToLinear (*(byte **)&pinfoblock->OemStringPtr[0])); |
| |
| totalvidmem = *(unsigned short *)&pinfoblock->TotalMemory[0] << 16; |
| |
| pmodenums = (short *) |
| VID_ExtraFarToLinear (*(byte **)&pinfoblock->VideoModePtr[0]); |
| |
| // find 8 bit modes until we either run out of space or run out of modes |
| nummodes = 0; |
| |
| while ((*pmodenums != -1) && (nummodes < MAX_VESA_MODES)) |
| { |
| if (VID_ExtraGetModeInfo (*pmodenums)) |
| { |
| vesa_modes[nummodes].pnext = &vesa_modes[nummodes+1]; |
| if (modeinfo.width > 999) |
| { |
| if (modeinfo.height > 999) |
| { |
| sprintf (&names[nummodes][0], "%4dx%4d", modeinfo.width, |
| modeinfo.height); |
| names[nummodes][9] = 0; |
| } |
| else |
| { |
| sprintf (&names[nummodes][0], "%4dx%3d", modeinfo.width, |
| modeinfo.height); |
| names[nummodes][8] = 0; |
| } |
| } |
| else |
| { |
| if (modeinfo.height > 999) |
| { |
| sprintf (&names[nummodes][0], "%3dx%4d", modeinfo.width, |
| modeinfo.height); |
| names[nummodes][8] = 0; |
| } |
| else |
| { |
| sprintf (&names[nummodes][0], "%3dx%3d", modeinfo.width, |
| modeinfo.height); |
| names[nummodes][7] = 0; |
| } |
| } |
| |
| vesa_modes[nummodes].name = &names[nummodes][0]; |
| vesa_modes[nummodes].width = modeinfo.width; |
| vesa_modes[nummodes].height = modeinfo.height; |
| vesa_modes[nummodes].aspect = |
| ((float)modeinfo.height / (float)modeinfo.width) * |
| (320.0 / 240.0); |
| vesa_modes[nummodes].rowbytes = modeinfo.bytes_per_scanline; |
| vesa_modes[nummodes].planar = 0; |
| vesa_modes[nummodes].pextradata = &vesa_extra[nummodes]; |
| vesa_modes[nummodes].setmode = VID_ExtraInitMode; |
| vesa_modes[nummodes].swapbuffers = VID_ExtraSwapBuffers; |
| vesa_modes[nummodes].setpalette = VID_SetVESAPalette; |
| |
| if (modeinfo.mode_attributes & LINEAR_FRAME_BUFFER) |
| { |
| // add linear bit to mode for linear modes |
| vesa_extra[nummodes].vesamode = modeinfo.modenum | LINEAR_MODE; |
| vesa_extra[nummodes].pages[0] = 0; |
| vesa_extra[nummodes].pages[1] = modeinfo.pagesize; |
| vesa_extra[nummodes].pages[2] = modeinfo.pagesize * 2; |
| vesa_modes[nummodes].numpages = modeinfo.numpages; |
| |
| vesa_modes[nummodes].begindirectrect = VGA_BeginDirectRect; |
| vesa_modes[nummodes].enddirectrect = VGA_EndDirectRect; |
| |
| phys_mem_info.address = (int)modeinfo.pptr; |
| phys_mem_info.size = 0x400000; |
| |
| if (__dpmi_physical_address_mapping(&phys_mem_info)) |
| goto NextMode; |
| |
| vesa_extra[nummodes].plinearmem = |
| real2ptr (phys_mem_info.address); |
| } |
| else |
| { |
| // banked at 0xA0000 |
| vesa_extra[nummodes].vesamode = modeinfo.modenum; |
| vesa_extra[nummodes].pages[0] = 0; |
| vesa_extra[nummodes].plinearmem = |
| real2ptr(modeinfo.winasegment<<4); |
| |
| vesa_modes[nummodes].begindirectrect = |
| VGA_BankedBeginDirectRect; |
| vesa_modes[nummodes].enddirectrect = VGA_BankedEndDirectRect; |
| vesa_extra[nummodes].pages[1] = modeinfo.pagesize; |
| vesa_extra[nummodes].pages[2] = modeinfo.pagesize * 2; |
| vesa_modes[nummodes].numpages = modeinfo.numpages; |
| } |
| |
| vesa_extra[nummodes].vga_incompatible = |
| modeinfo.mode_attributes & VGA_INCOMPATIBLE; |
| |
| nummodes++; |
| } |
| NextMode: |
| pmodenums++; |
| } |
| |
| // add the VESA modes at the start of the mode list (if there are any) |
| if (nummodes) |
| { |
| vesa_modes[nummodes-1].pnext = pvidmodes; |
| pvidmodes = &vesa_modes[0]; |
| numvidmodes += nummodes; |
| ppal = dos_getmemory(256*4); |
| } |
| |
| dos_freememory(pinfoblock); |
| } |
| |
| |
| /* |
| ================ |
| VID_ExtraGetModeInfo |
| ================ |
| */ |
| qboolean VID_ExtraGetModeInfo(int modenum) |
| { |
| char *infobuf; |
| int numimagepages; |
| |
| infobuf = dos_getmemory(256); |
| |
| regs.x.ax = 0x4f01; |
| regs.x.cx = modenum; |
| regs.x.es = ptr2real(infobuf) >> 4; |
| regs.x.di = ptr2real(infobuf) & 0xf; |
| dos_int86(0x10); |
| if (regs.x.ax != 0x4f) |
| { |
| return false; |
| } |
| else |
| { |
| modeinfo.modenum = modenum; |
| modeinfo.bits_per_pixel = *(char*)(infobuf+25); |
| modeinfo.bytes_per_pixel = (modeinfo.bits_per_pixel+1)/8; |
| modeinfo.width = *(short*)(infobuf+18); |
| modeinfo.height = *(short*)(infobuf+20); |
| |
| // we do only 8-bpp in software |
| if ((modeinfo.bits_per_pixel != 8) || |
| (modeinfo.bytes_per_pixel != 1) || |
| (modeinfo.width > MAXWIDTH) || |
| (modeinfo.height > MAXHEIGHT)) |
| { |
| return false; |
| } |
| |
| modeinfo.mode_attributes = *(short*)infobuf; |
| |
| // we only want color graphics modes that are supported by the hardware |
| if ((modeinfo.mode_attributes & |
| (MODE_SUPPORTED_IN_HW | COLOR_MODE | GRAPHICS_MODE)) != |
| (MODE_SUPPORTED_IN_HW | COLOR_MODE | GRAPHICS_MODE)) |
| { |
| return false; |
| } |
| |
| // we only work with linear frame buffers, except for 320x200, which can |
| // effectively be linear when banked at 0xA000 |
| if (!(modeinfo.mode_attributes & LINEAR_FRAME_BUFFER)) |
| { |
| if ((modeinfo.width != 320) || (modeinfo.height != 200)) |
| return false; |
| } |
| |
| modeinfo.bytes_per_scanline = *(short*)(infobuf+16); |
| |
| modeinfo.pagesize = modeinfo.bytes_per_scanline * modeinfo.height; |
| |
| if (modeinfo.pagesize > totalvidmem) |
| return false; |
| |
| // force to one page if the adapter reports it doesn't support more pages |
| // than that, no matter how much memory it has--it may not have hardware |
| // support for page flipping |
| numimagepages = *(unsigned char *)(infobuf+29); |
| |
| if (numimagepages <= 0) |
| { |
| // wrong, but there seems to be an ATI VESA driver that reports 0 |
| modeinfo.numpages = 1; |
| } |
| else if (numimagepages < 3) |
| { |
| modeinfo.numpages = numimagepages; |
| } |
| else |
| { |
| modeinfo.numpages = 3; |
| } |
| |
| if (*(char*)(infobuf+2) & 5) |
| { |
| modeinfo.winasegment = *(unsigned short*)(infobuf+8); |
| modeinfo.win = 0; |
| } |
| else if (*(char*)(infobuf+3) & 5) |
| { |
| modeinfo.winbsegment = *(unsigned short*)(infobuf+8); |
| modeinfo.win = 1; |
| } |
| modeinfo.granularity = *(short*)(infobuf+4) * 1024; |
| modeinfo.win_size = *(short*)(infobuf+6) * 1024; |
| modeinfo.bits_per_pixel = *(char*)(infobuf+25); |
| modeinfo.bytes_per_pixel = (modeinfo.bits_per_pixel+1)/8; |
| modeinfo.memory_model = *(unsigned char*)(infobuf+27); |
| modeinfo.num_pages = *(char*)(infobuf+29) + 1; |
| |
| modeinfo.red_width = *(char*)(infobuf+31); |
| modeinfo.red_pos = *(char*)(infobuf+32); |
| modeinfo.green_width = *(char*)(infobuf+33); |
| modeinfo.green_pos = *(char*)(infobuf+34); |
| modeinfo.blue_width = *(char*)(infobuf+35); |
| modeinfo.blue_pos = *(char*)(infobuf+36); |
| |
| modeinfo.pptr = *(long *)(infobuf+40); |
| |
| #if 0 |
| printf("VID: (VESA) info for mode 0x%x\n", modeinfo.modenum); |
| printf(" mode attrib = 0x%0x\n", modeinfo.mode_attributes); |
| printf(" win a attrib = 0x%0x\n", *(unsigned char*)(infobuf+2)); |
| printf(" win b attrib = 0x%0x\n", *(unsigned char*)(infobuf+3)); |
| printf(" win a seg 0x%0x\n", (int) modeinfo.winasegment); |
| printf(" win b seg 0x%0x\n", (int) modeinfo.winbsegment); |
| printf(" bytes per scanline = %d\n", |
| modeinfo.bytes_per_scanline); |
| printf(" width = %d, height = %d\n", modeinfo.width, |
| modeinfo.height); |
| printf(" win = %c\n", 'A' + modeinfo.win); |
| printf(" win granularity = %d\n", modeinfo.granularity); |
| printf(" win size = %d\n", modeinfo.win_size); |
| printf(" bits per pixel = %d\n", modeinfo.bits_per_pixel); |
| printf(" bytes per pixel = %d\n", modeinfo.bytes_per_pixel); |
| printf(" memory model = 0x%x\n", modeinfo.memory_model); |
| printf(" num pages = %d\n", modeinfo.num_pages); |
| printf(" red width = %d\n", modeinfo.red_width); |
| printf(" red pos = %d\n", modeinfo.red_pos); |
| printf(" green width = %d\n", modeinfo.green_width); |
| printf(" green pos = %d\n", modeinfo.green_pos); |
| printf(" blue width = %d\n", modeinfo.blue_width); |
| printf(" blue pos = %d\n", modeinfo.blue_pos); |
| printf(" phys mem = %x\n", modeinfo.pptr); |
| #endif |
| } |
| |
| dos_freememory(infobuf); |
| |
| return true; |
| } |
| |
| |
| /* |
| ================ |
| VID_ExtraInitMode |
| ================ |
| */ |
| int VID_ExtraInitMode (viddef_t *lvid, vmode_t *pcurrentmode) |
| { |
| vesa_extra_t *pextra; |
| int pageoffset; |
| |
| pextra = pcurrentmode->pextradata; |
| |
| if (vid_nopageflip.value) |
| lvid->numpages = 1; |
| else |
| lvid->numpages = pcurrentmode->numpages; |
| |
| // clean up any old vid buffer lying around, alloc new if needed |
| if (!VGA_FreeAndAllocVidbuffer (lvid, lvid->numpages == 1)) |
| return -1; // memory alloc failed |
| |
| // clear the screen and wait for the next frame. VGA_pcurmode, which |
| // VGA_ClearVideoMem relies on, is guaranteed to be set because mode 0 is |
| // always the first mode set in a session |
| if (VGA_pcurmode) |
| VGA_ClearVideoMem (VGA_pcurmode->planar); |
| |
| // set the mode |
| regs.x.ax = 0x4f02; |
| regs.x.bx = pextra->vesamode; |
| dos_int86(0x10); |
| |
| if (regs.x.ax != 0x4f) |
| return 0; |
| |
| VID_banked = !(pextra->vesamode & LINEAR_MODE); |
| VID_membase = pextra->plinearmem; |
| VGA_width = lvid->width; |
| VGA_height = lvid->height; |
| VGA_rowbytes = lvid->rowbytes; |
| |
| lvid->colormap = host_colormap; |
| |
| VID_pagelist = &pextra->pages[0]; |
| |
| // wait for display enable by default only when triple-buffering on a VGA- |
| // compatible machine that actually has a functioning display enable status |
| vsync_exists = VID_ExtraStateFound (0x08); |
| de_exists = VID_ExtraStateFound (0x01); |
| |
| if (!pextra->vga_incompatible && |
| (lvid->numpages == 3) && |
| de_exists && |
| (_vid_wait_override.value == 0.0)) |
| { |
| Cvar_SetValue ("vid_wait", (float)VID_WAIT_DISPLAY_ENABLE); |
| |
| VID_displayedpage = 0; |
| VID_currentpage = 1; |
| } |
| else |
| { |
| if ((lvid->numpages == 1) && (_vid_wait_override.value == 0.0)) |
| { |
| Cvar_SetValue ("vid_wait", (float)VID_WAIT_NONE); |
| VID_displayedpage = VID_currentpage = 0; |
| } |
| else |
| { |
| Cvar_SetValue ("vid_wait", (float)VID_WAIT_VSYNC); |
| |
| VID_displayedpage = 0; |
| |
| if (lvid->numpages > 1) |
| VID_currentpage = 1; |
| else |
| VID_currentpage = 0; |
| } |
| } |
| |
| // TODO: really should be a call to a function |
| pageoffset = VID_pagelist[VID_displayedpage]; |
| |
| regs.x.ax = 0x4f07; |
| regs.x.bx = 0x80; // wait for vsync so we know page 0 is visible |
| regs.x.cx = pageoffset % VGA_rowbytes; |
| regs.x.dx = pageoffset / VGA_rowbytes; |
| dos_int86(0x10); |
| |
| if (VID_banked) |
| { |
| regs.x.ax = 0x4f05; |
| regs.x.bx = 0; |
| regs.x.dx = VID_currentpage; |
| dos_int86(0x10); |
| |
| VGA_pagebase = VID_membase; |
| } |
| else |
| { |
| VGA_pagebase = VID_membase + VID_pagelist[VID_currentpage]; |
| } |
| |
| if (lvid->numpages > 1) |
| { |
| lvid->buffer = VGA_pagebase; |
| lvid->conbuffer = lvid->buffer; |
| } |
| else |
| { |
| lvid->rowbytes = lvid->width; |
| } |
| |
| lvid->direct = VGA_pagebase; |
| lvid->conrowbytes = lvid->rowbytes; |
| lvid->conwidth = lvid->width; |
| lvid->conheight = lvid->height; |
| |
| lvid->maxwarpwidth = WARP_WIDTH; |
| lvid->maxwarpheight = WARP_HEIGHT; |
| |
| VGA_pcurmode = pcurrentmode; |
| |
| D_InitCaches (vid_surfcache, vid_surfcachesize); |
| |
| return 1; |
| } |
| |
| |
| /* |
| ================ |
| VID_ExtraSwapBuffers |
| ================ |
| */ |
| void VID_ExtraSwapBuffers (viddef_t *lvid, vmode_t *pcurrentmode, |
| vrect_t *rects) |
| { |
| int pageoffset; |
| |
| UNUSED(rects); |
| UNUSED(pcurrentmode); |
| |
| pageoffset = VID_pagelist[VID_currentpage]; |
| |
| // display the newly finished page |
| if (lvid->numpages > 1) |
| { |
| // page flipped |
| regs.x.ax = 0x4f07; |
| |
| if (vid_wait.value != VID_WAIT_VSYNC) |
| { |
| if ((vid_wait.value == VID_WAIT_DISPLAY_ENABLE) && de_exists) |
| VID_ExtraWaitDisplayEnable (); |
| |
| regs.x.bx = VESA_DONT_WAIT_VSYNC; |
| } |
| else |
| { |
| regs.x.bx = VESA_WAIT_VSYNC; // double buffered has to wait |
| } |
| |
| regs.x.cx = pageoffset % VGA_rowbytes; |
| regs.x.dx = pageoffset / VGA_rowbytes; |
| dos_int86(0x10); |
| |
| VID_displayedpage = VID_currentpage; |
| if (++VID_currentpage >= lvid->numpages) |
| VID_currentpage = 0; |
| |
| // |
| // set the new write window if this is a banked mode; otherwise, set the |
| // new address to which to write |
| // |
| if (VID_banked) |
| { |
| regs.x.ax = 0x4f05; |
| regs.x.bx = 0; |
| regs.x.dx = VID_currentpage; |
| dos_int86(0x10); |
| } |
| else |
| { |
| lvid->direct = lvid->buffer; // direct drawing goes to the |
| // currently displayed page |
| lvid->buffer = VID_membase + VID_pagelist[VID_currentpage]; |
| lvid->conbuffer = lvid->buffer; |
| } |
| |
| VGA_pagebase = lvid->buffer; |
| } |
| else |
| { |
| // non-page-flipped |
| if (vsync_exists && (vid_wait.value == VID_WAIT_VSYNC)) |
| { |
| VGA_WaitVsync (); |
| } |
| |
| while (rects) |
| { |
| VGA_UpdateLinearScreen ( |
| lvid->buffer + rects->x + (rects->y * lvid->rowbytes), |
| VGA_pagebase + rects->x + (rects->y * VGA_rowbytes), |
| rects->width, |
| rects->height, |
| lvid->rowbytes, |
| VGA_rowbytes); |
| |
| rects = rects->pnext; |
| } |
| } |
| } |
| |