git.oblomov.eu Git - wine/blob - dlls/winedos/vga.c

   1 /*
   2  * VGA hardware emulation
   3  *
   4  * Copyright 1998 Ove Kåven (with some help from Marcus Meissner)
   5  *
   6  */
   7
   8 #include <string.h>
   9 #include "winbase.h"
  10 #include "wingdi.h"
  11 #include "winuser.h"
  12 #include "wincon.h"
  13 #include "miscemu.h"
  14 #include "dosexe.h"
  15 #include "vga.h"
  16 #include "ddraw.h"
  17 #include "services.h"
  18 #include "debugtools.h"
  19
  20 DEFAULT_DEBUG_CHANNEL(ddraw);
  21
  22 static IDirectDraw *lpddraw = NULL;
  23 static IDirectDrawSurface *lpddsurf;
  24 static IDirectDrawPalette *lpddpal;
  25 static DDSURFACEDESC sdesc;
  26 static LONG vga_polling,vga_refresh;
  27 static HANDLE poll_timer;
  28
  29 static int vga_width;
  30 static int vga_height;
  31 static int vga_depth;
  32
  33 typedef HRESULT (WINAPI *DirectDrawCreateProc)(LPGUID,LPDIRECTDRAW *,LPUNKNOWN);
  34 static DirectDrawCreateProc pDirectDrawCreate;
  35
  36 static PALETTEENTRY vga_def_palette[256]={
  37 /* red  green  blue */
  38   {0x00, 0x00, 0x00}, /* 0 - Black */
  39   {0x00, 0x00, 0x80}, /* 1 - Blue */
  40   {0x00, 0x80, 0x00}, /* 2 - Green */
  41   {0x00, 0x80, 0x80}, /* 3 - Cyan */
  42   {0x80, 0x00, 0x00}, /* 4 - Red */
  43   {0x80, 0x00, 0x80}, /* 5 - Magenta */
  44   {0x80, 0x80, 0x00}, /* 6 - Brown */
  45   {0xC0, 0xC0, 0xC0}, /* 7 - Light gray */
  46   {0x80, 0x80, 0x80}, /* 8 - Dark gray */
  47   {0x00, 0x00, 0xFF}, /* 9 - Light blue */
  48   {0x00, 0xFF, 0x00}, /* A - Light green */
  49   {0x00, 0xFF, 0xFF}, /* B - Light cyan */
  50   {0xFF, 0x00, 0x00}, /* C - Light red */
  51   {0xFF, 0x00, 0xFF}, /* D - Light magenta */
  52   {0xFF, 0xFF, 0x00}, /* E - Yellow */
  53   {0xFF, 0xFF, 0xFF}, /* F - White */
  54   {0,0,0} /* FIXME: a series of continuous rainbow hues should follow */
  55 };
  56
  57 static void VGA_DeinstallTimer(void)
  58 {
  59     if (poll_timer) {
  60         SERVICE_Delete( poll_timer );
  61         poll_timer = 0;
  62     }
  63 }
  64
  65 static void VGA_InstallTimer(unsigned Rate)
  66 {
  67     VGA_DeinstallTimer();
  68     if (!poll_timer)
  69         poll_timer = SERVICE_AddTimer( Rate, VGA_Poll, 0 );
  70 }
  71
  72 HANDLE VGA_AlphaConsole(void)
  73 {
  74     /* this assumes that no Win32 redirection has taken place, but then again,
  75      * only 16-bit apps are likely to use this part of Wine... */
  76     return GetStdHandle(STD_OUTPUT_HANDLE);
  77 }
  78
  79 char*VGA_AlphaBuffer(void)
  80 {
  81     return DOSMEM_MapDosToLinear(0xb8000);
  82 }
  83
  84 /*** GRAPHICS MODE ***/
  85
  86 typedef struct {
  87   unsigned Xres, Yres, Depth;
  88   int ret;
  89 } ModeSet;
  90
  91 static void WINAPI VGA_DoSetMode(ULONG_PTR arg)
  92 {
  93     LRESULT     res;
  94     HWND        hwnd;
  95     ModeSet *par = (ModeSet *)arg;
  96     par->ret=1;
  97
  98     if (lpddraw) VGA_Exit();
  99     if (!lpddraw) {
 100         if (!pDirectDrawCreate)
 101         {
 102             HMODULE hmod = LoadLibraryA( "ddraw.dll" );
 103             if (hmod) pDirectDrawCreate = (DirectDrawCreateProc)GetProcAddress( hmod, "DirectDrawCreate" );
 104             if (!pDirectDrawCreate) {
 105                 ERR("Can't lookup DirectDrawCreate from ddraw.dll.\n");
 106                 return;
 107             }
 108         }
 109         res = pDirectDrawCreate(NULL,&lpddraw,NULL);
 110         if (!lpddraw) {
 111             ERR("DirectDraw is not available (res = %lx)\n",res);
 112             return;
 113         }
 114         hwnd = CreateWindowExA(0,"STATIC","WINEDOS VGA",WS_POPUP|WS_BORDER|WS_CAPTION|WS_SYSMENU,0,0,par->Xres,par->Yres,0,0,0,NULL);
 115         if (!hwnd) {
 116             ERR("Failed to create user window.\n");
 117         }
 118         if ((res=IDirectDraw_SetCooperativeLevel(lpddraw,hwnd,DDSCL_FULLSCREEN|DDSCL_EXCLUSIVE))) {
 119             ERR("Could not set cooperative level to exclusive (%lx)\n",res);
 120         }
 121
 122         if ((res=IDirectDraw_SetDisplayMode(lpddraw,par->Xres,par->Yres,par->Depth))) {
 123             ERR("DirectDraw does not support requested display mode (%dx%dx%d), res = %lx!\n",par->Xres,par->Yres,par->Depth,res);
 124             IDirectDraw_Release(lpddraw);
 125             lpddraw=NULL;
 126             return;
 127         }
 128
 129         res=IDirectDraw_CreatePalette(lpddraw,DDPCAPS_8BIT,NULL,&lpddpal,NULL);
 130         if (res) {
 131             ERR("Could not create palette (res = %lx)\n",res);
 132             IDirectDraw_Release(lpddraw);
 133             lpddraw=NULL;
 134             return;
 135         }
 136         if ((res=IDirectDrawPalette_SetEntries(lpddpal,0,0,256,vga_def_palette))) {
 137             ERR("Could not set default palette entries (res = %lx)\n", res);
 138         }
 139
 140         memset(&sdesc,0,sizeof(sdesc));
 141         sdesc.dwSize=sizeof(sdesc);
 142         sdesc.dwFlags = DDSD_CAPS;
 143         sdesc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
 144         if (IDirectDraw_CreateSurface(lpddraw,&sdesc,&lpddsurf,NULL)||(!lpddsurf)) {
 145             ERR("DirectDraw surface is not available\n");
 146             IDirectDraw_Release(lpddraw);
 147             lpddraw=NULL;
 148             return;
 149         }
 150         IDirectDrawSurface_SetPalette(lpddsurf,lpddpal);
 151         vga_refresh=0;
 152         /* poll every 20ms (50fps should provide adequate responsiveness) */
 153         VGA_InstallTimer(20);
 154     }
 155     par->ret=0;
 156     return;
 157 }
 158
 159 int VGA_SetMode(unsigned Xres,unsigned Yres,unsigned Depth)
 160 {
 161     ModeSet par;
 162
 163     vga_width = Xres;
 164     vga_height = Yres;
 165     vga_depth = Depth;
 166
 167     if(Xres >= 640 || Yres >= 480) {
 168       par.Xres = Xres;
 169       par.Yres = Yres;
 170     } else {
 171       par.Xres = 640;
 172       par.Yres = 480;
 173     }
 174
 175     par.Depth = (Depth < 8) ? 8 : Depth;
 176
 177     MZ_RunInThread(VGA_DoSetMode, (ULONG_PTR)&par);
 178     return par.ret;
 179 }
 180
 181 int VGA_GetMode(unsigned*Height,unsigned*Width,unsigned*Depth)
 182 {
 183     if (!lpddraw) return 1;
 184     if (!lpddsurf) return 1;
 185     if (Height) *Height=sdesc.dwHeight;
 186     if (Width) *Width=sdesc.dwWidth;
 187     if (Depth) *Depth=sdesc.ddpfPixelFormat.u1.dwRGBBitCount;
 188     return 0;
 189 }
 190
 191 static void WINAPI VGA_DoExit(ULONG_PTR arg)
 192 {
 193     VGA_DeinstallTimer();
 194     IDirectDrawSurface_SetPalette(lpddsurf,NULL);
 195     IDirectDrawSurface_Release(lpddsurf);
 196     lpddsurf=NULL;
 197     IDirectDrawPalette_Release(lpddpal);
 198     lpddpal=NULL;
 199     IDirectDraw_Release(lpddraw);
 200     lpddraw=NULL;
 201 }
 202
 203 void VGA_Exit(void)
 204 {
 205     if (lpddraw) MZ_RunInThread(VGA_DoExit, 0);
 206 }
 207
 208 void VGA_SetPalette(PALETTEENTRY*pal,int start,int len)
 209 {
 210     if (!lpddraw) return;
 211     IDirectDrawPalette_SetEntries(lpddpal,0,start,len,pal);
 212 }
 213
 214 void VGA_SetQuadPalette(RGBQUAD*color,int start,int len)
 215 {
 216     PALETTEENTRY pal[256];
 217     int c;
 218
 219     if (!lpddraw) return;
 220     for (c=0; c<len; c++) {
 221         pal[c].peRed  =color[c].rgbRed;
 222         pal[c].peGreen=color[c].rgbGreen;
 223         pal[c].peBlue =color[c].rgbBlue;
 224         pal[c].peFlags=0;
 225     }
 226     IDirectDrawPalette_SetEntries(lpddpal,0,start,len,pal);
 227 }
 228
 229 LPSTR VGA_Lock(unsigned*Pitch,unsigned*Height,unsigned*Width,unsigned*Depth)
 230 {
 231     if (!lpddraw) return NULL;
 232     if (!lpddsurf) return NULL;
 233     if (IDirectDrawSurface_Lock(lpddsurf,NULL,&sdesc,0,0)) {
 234         ERR("could not lock surface!\n");
 235         return NULL;
 236     }
 237     if (Pitch) *Pitch=sdesc.u1.lPitch;
 238     if (Height) *Height=sdesc.dwHeight;
 239     if (Width) *Width=sdesc.dwWidth;
 240     if (Depth) *Depth=sdesc.ddpfPixelFormat.u1.dwRGBBitCount;
 241     return sdesc.lpSurface;
 242 }
 243
 244 void VGA_Unlock(void)
 245 {
 246     IDirectDrawSurface_Unlock(lpddsurf,sdesc.lpSurface);
 247 }
 248
 249 /*** TEXT MODE ***/
 250
 251 int VGA_SetAlphaMode(unsigned Xres,unsigned Yres)
 252 {
 253     COORD siz;
 254
 255     if (lpddraw) VGA_Exit();
 256
 257     /* the xterm is slow, so refresh only every 200ms (5fps) */
 258     VGA_InstallTimer(200);
 259
 260     siz.X = Xres;
 261     siz.Y = Yres;
 262     SetConsoleScreenBufferSize(VGA_AlphaConsole(),siz);
 263     return 0;
 264 }
 265
 266 void VGA_GetAlphaMode(unsigned*Xres,unsigned*Yres)
 267 {
 268     CONSOLE_SCREEN_BUFFER_INFO info;
 269     GetConsoleScreenBufferInfo(VGA_AlphaConsole(),&info);
 270     if (Xres) *Xres=info.dwSize.X;
 271     if (Yres) *Yres=info.dwSize.Y;
 272 }
 273
 274 void VGA_SetCursorPos(unsigned X,unsigned Y)
 275 {
 276     COORD pos;
 277
 278     if (!poll_timer) VGA_SetAlphaMode(80, 25);
 279     pos.X = X;
 280     pos.Y = Y;
 281     SetConsoleCursorPosition(VGA_AlphaConsole(),pos);
 282 }
 283
 284 void VGA_GetCursorPos(unsigned*X,unsigned*Y)
 285 {
 286     CONSOLE_SCREEN_BUFFER_INFO info;
 287     GetConsoleScreenBufferInfo(VGA_AlphaConsole(),&info);
 288     if (X) *X=info.dwCursorPosition.X;
 289     if (Y) *Y=info.dwCursorPosition.Y;
 290 }
 291
 292 void VGA_WriteChars(unsigned X,unsigned Y,unsigned ch,int attr,int count)
 293 {
 294     unsigned XR, YR;
 295     char*dat;
 296
 297     VGA_GetAlphaMode(&XR, &YR);
 298     dat = VGA_AlphaBuffer() + ((XR*Y + X) * 2);
 299     /* FIXME: also call WriteConsoleOutputA, for better responsiveness */
 300     while (count--) {
 301         *dat++ = ch;
 302         if (attr>=0) *dat = attr;
 303         dat++;
 304     }
 305 }
 306
 307 /*** CONTROL ***/
 308
 309 static void VGA_Poll_Graphics(void)
 310 {
 311   unsigned int Pitch, Height, Width, X, Y;
 312   char *surf;
 313   char *dat = DOSMEM_MapDosToLinear(0xa0000);
 314
 315   surf = VGA_Lock(&Pitch,&Height,&Width,NULL);
 316   if (!surf) return;
 317
 318   if(vga_width == 320 && vga_depth <= 4)
 319     for (Y=0; Y<vga_height; Y++,surf+=Pitch*2,dat+=vga_width/8) {
 320       for(X=0; X<vga_width; X+=8) {
 321        int offset = X/8;
 322        int Z;
 323        for(Z=0; Z<8; Z++) {
 324          int b0 =  (dat[offset] >> Z) & 0x1;
 325          int index = 7-Z;
 326          surf[(X+index)*2] = b0;
 327          surf[(X+index)*2+1] = b0;
 328          surf[(X+index)*2+Pitch] = b0;
 329          surf[(X+index)*2+Pitch+1] = b0;
 330        }
 331       }
 332     }
 333
 334   if(vga_width == 320 && vga_depth == 8)
 335     for (Y=0; Y<vga_height; Y++,surf+=Pitch*2,dat+=vga_width) {
 336       for(X=0; X<vga_width; X++) {
 337        int b0 = dat[X];
 338        surf[X*2] = b0;
 339        surf[X*2+1] = b0;
 340        surf[X*2+Pitch] = b0;
 341        surf[X*2+Pitch+1] = b0;
 342       }
 343     }
 344
 345   if(vga_depth <= 4)
 346     for (Y=0; Y<vga_height; Y++,surf+=Pitch,dat+=vga_width/8) {
 347       for(X=0; X<vga_width; X+=8) {
 348        int offset = X/8;
 349        int Z;
 350        for(Z=0; Z<8; Z++) {
 351          int b0 =  (dat[offset] >> Z) & 0x1;
 352          int index = 7-Z;
 353          surf[X+index] = b0;
 354        }
 355       }
 356     }
 357
 358   VGA_Unlock();
 359 }
 360
 361
 362 void CALLBACK VGA_Poll( ULONG_PTR arg )
 363 {
 364     char *dat;
 365     unsigned int Height,Width,Y,X;
 366
 367     if (!InterlockedExchangeAdd(&vga_polling, 1)) {
 368         /* FIXME: optimize by doing this only if the data has actually changed
 369          *        (in a way similar to DIBSection, perhaps) */
 370         if (lpddraw) {
 371          VGA_Poll_Graphics();
 372         } else {
 373           /* text mode */
 374           CHAR_INFO ch[80];
 375           COORD siz, off;
 376           SMALL_RECT dest;
 377           HANDLE con = VGA_AlphaConsole();
 378
 379           VGA_GetAlphaMode(&Width,&Height);
 380           dat = VGA_AlphaBuffer();
 381           siz.X = 80; siz.Y = 1;
 382           off.X = 0; off.Y = 0;
 383           /* copy from virtual VGA frame buffer to console */
 384           for (Y=0; Y<Height; Y++) {
 385               dest.Top=Y; dest.Bottom=Y;
 386               for (X=0; X<Width; X++) {
 387                   ch[X].Char.AsciiChar = *dat++;
 388                   /* WriteConsoleOutputA doesn't like "dead" chars */
 389                   if (ch[X].Char.AsciiChar == '\0')
 390                       ch[X].Char.AsciiChar = ' ';
 391                   ch[X].Attributes = *dat++;
 392               }
 393               dest.Left=0; dest.Right=Width+1;
 394               WriteConsoleOutputA(con, ch, siz, off, &dest);
 395           }
 396         }
 397         vga_refresh=1;
 398     }
 399     InterlockedDecrement(&vga_polling);
 400 }
 401
 402 static BYTE palreg,palcnt;
 403 static PALETTEENTRY paldat;
 404
 405 void VGA_ioport_out( WORD port, BYTE val )
 406 {
 407     switch (port) {
 408         case 0x3c8:
 409             palreg=val; palcnt=0; break;
 410         case 0x3c9:
 411             ((BYTE*)&paldat)[palcnt++]=val << 2;
 412             if (palcnt==3) {
 413                 VGA_SetPalette(&paldat,palreg++,1);
 414                 palcnt=0;
 415             }
 416             break;
 417     }
 418 }
 419
 420 BYTE VGA_ioport_in( WORD port )
 421 {
 422     BYTE ret;
 423
 424     switch (port) {
 425         case 0x3da:
 426             /* since we don't (yet?) serve DOS VM requests while VGA_Poll is running,
 427                we need to fake the occurrence of the vertical refresh */
 428             ret=vga_refresh?0x00:0x08;
 429             vga_refresh=0;
 430             break;
 431         default:
 432             ret=0xff;
 433     }
 434     return ret;
 435 }
 436
 437 void VGA_Clean(void)
 438 {
 439     VGA_Exit();
 440     VGA_DeinstallTimer();
 441 }