dlls/x11drv/x11ddraw.c

   1 /*
   2  * DirectDraw driver interface
   3  *
   4  * Copyright 2001 TransGaming Technologies, Inc.
   5  */
   6
   7 #include "config.h"
   8
   9 #include <string.h>
  10
  11 #include "ts_xlib.h"
  12 #include "x11drv.h"
  13 #include "x11ddraw.h"
  14 #include "xvidmode.h"
  15 #include "dga2.h"
  16
  17 #include "windef.h"
  18 #include "wingdi.h"
  19 #include "ddrawi.h"
  20 #include "bitmap.h"
  21 #include "debugtools.h"
  22
  23 DEFAULT_DEBUG_CHANNEL(x11drv);
  24
  25 extern int dxgrab;
  26
  27 LPDDRAWI_DDRAWSURFACE_LCL X11DRV_DD_Primary;
  28 LPDDRAWI_DDRAWSURFACE_GBL X11DRV_DD_PrimaryGbl;
  29 HWND X11DRV_DD_PrimaryWnd;
  30 HBITMAP X11DRV_DD_PrimaryDIB;
  31 Drawable X11DRV_DD_PrimaryDrawable;
  32 ATOM X11DRV_DD_UserClass;
  33 BOOL X11DRV_DD_IsDirect;
  34 static UINT X11DRV_DD_GrabMessage;
  35 static WNDPROC X11DRV_DD_GrabOldProcedure;
  36
  37 static void SetPrimaryDIB(HBITMAP hBmp)
  38 {
  39   X11DRV_DD_PrimaryDIB = hBmp;
  40   if (hBmp) {
  41     BITMAPOBJ *bmp;
  42     bmp = (BITMAPOBJ *)GDI_GetObjPtr( hBmp, BITMAP_MAGIC );
  43     X11DRV_DD_PrimaryDrawable = (Pixmap)bmp->physBitmap;
  44     GDI_ReleaseObj( hBmp );
  45   } else {
  46     X11DRV_DD_PrimaryDrawable = 0;
  47   }
  48 }
  49
  50 static LRESULT WINAPI GrabWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
  51 {
  52   Display *display = thread_display();
  53
  54   if(message != X11DRV_DD_GrabMessage)
  55     return CallWindowProcA(X11DRV_DD_GrabOldProcedure, hWnd, message, wParam, lParam);
  56
  57   TRACE("hwnd=%d, grab=%d\n", hWnd, wParam);
  58
  59   if (wParam)
  60   {
  61     /* find the X11 window that ddraw uses */
  62     Window win = X11DRV_get_whole_window(hWnd);
  63     TRACE("X11 window: %ld\n", win);
  64     if (!win) {
  65       TRACE("host off desktop\n");
  66       win = root_window;
  67     }
  68
  69     TSXGrabPointer(display, win, True, 0, GrabModeAsync, GrabModeAsync, win, None, CurrentTime);
  70   }
  71   else
  72   {
  73     TSXUngrabPointer(display, CurrentTime);
  74   }
  75
  76   return 0;
  77 }
  78
  79 static void GrabPointer(BOOL grab)
  80 {
  81   WND*    pWnd;
  82
  83   if(grab) {
  84     Window window = X11DRV_get_whole_window(GetFocus());
  85     if(window)
  86       XSetInputFocus(thread_display(), window, RevertToParent, CurrentTime);
  87   }
  88
  89   if(!X11DRV_DD_GrabMessage)
  90     X11DRV_DD_GrabMessage = RegisterWindowMessageA("WINE_X11DRV_GRABPOINTER");
  91
  92   pWnd = WIN_FindWndPtr(X11DRV_DD_PrimaryWnd);
  93   if(!pWnd)
  94     return;
  95
  96   X11DRV_DD_GrabOldProcedure = pWnd->winproc;
  97   pWnd->winproc = GrabWndProc;
  98
  99   WIN_ReleaseWndPtr(pWnd);
 100
 101   SendMessageA(X11DRV_DD_PrimaryWnd, X11DRV_DD_GrabMessage, grab ? 1 : 0, 0);
 102
 103   pWnd = WIN_FindWndPtr(X11DRV_DD_PrimaryWnd);
 104   if(!pWnd)
 105     return;
 106
 107   if(pWnd->winproc != GrabWndProc)
 108     ERR("Window procedure has been changed!\n");
 109   else
 110     pWnd->winproc = X11DRV_DD_GrabOldProcedure;
 111
 112   WIN_ReleaseWndPtr(pWnd);
 113 }
 114
 115 static DWORD PASCAL X11DRV_DDHAL_DestroyDriver(LPDDHAL_DESTROYDRIVERDATA data)
 116 {
 117   data->ddRVal = DD_OK;
 118   return DDHAL_DRIVER_HANDLED;
 119 }
 120
 121 static DWORD PASCAL X11DRV_DDHAL_CreateSurface(LPDDHAL_CREATESURFACEDATA data)
 122 {
 123   if (data->lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE) {
 124     X11DRV_DD_Primary = *data->lplpSList;
 125     X11DRV_DD_PrimaryWnd = (HWND)X11DRV_DD_Primary->lpSurfMore->lpDDRAWReserved;
 126     X11DRV_DD_PrimaryGbl = X11DRV_DD_Primary->lpGbl;
 127     SetPrimaryDIB(GET_LPDDRAWSURFACE_GBL_MORE(X11DRV_DD_PrimaryGbl)->hKernelSurface);
 128     X11DRV_DD_UserClass = GlobalFindAtomA("WINE_DDRAW");
 129     if (dxgrab) GrabPointer(TRUE);
 130   }
 131   data->ddRVal = DD_OK;
 132   return DDHAL_DRIVER_NOTHANDLED;
 133 }
 134
 135 static DWORD PASCAL X11DRV_DDHAL_CreatePalette(LPDDHAL_CREATEPALETTEDATA data)
 136 {
 137   FIXME("stub\n");
 138   /* only makes sense to do anything if the X server is running at 8bpp,
 139    * which few people do nowadays */
 140   data->ddRVal = DD_OK;
 141   return DDHAL_DRIVER_HANDLED;
 142 }
 143
 144 static DDHAL_DDCALLBACKS hal_ddcallbacks = {
 145   sizeof(DDHAL_DDCALLBACKS),
 146   0x3ff, /* all callbacks are 32-bit */
 147   X11DRV_DDHAL_DestroyDriver,
 148   X11DRV_DDHAL_CreateSurface,
 149   NULL, /* SetColorKey */
 150   NULL, /* SetMode */
 151   NULL, /* WaitForVerticalBlank */
 152   NULL, /* CanCreateSurface */
 153   X11DRV_DDHAL_CreatePalette,
 154   NULL, /* GetScanLine */
 155   NULL, /* SetExclusiveMode */
 156   NULL  /* FlipToGDISurface */
 157 };
 158
 159 static DWORD PASCAL X11DRV_DDHAL_DestroySurface(LPDDHAL_DESTROYSURFACEDATA data)
 160 {
 161   if (data->lpDDSurface == X11DRV_DD_Primary) {
 162     if (dxgrab) GrabPointer(FALSE);
 163     X11DRV_DD_Primary = NULL;
 164     X11DRV_DD_PrimaryWnd = 0;
 165     X11DRV_DD_PrimaryGbl = NULL;
 166     SetPrimaryDIB(0);
 167     X11DRV_DD_UserClass = 0;
 168   }
 169   data->ddRVal = DD_OK;
 170   return DDHAL_DRIVER_HANDLED;
 171 }
 172
 173 static DWORD PASCAL X11DRV_DDHAL_SetPalette(LPDDHAL_SETPALETTEDATA data)
 174 {
 175   Colormap pal = data->lpDDPalette->u1.dwReserved1;
 176   if (pal) {
 177     if (data->lpDDSurface == X11DRV_DD_Primary) {
 178       FIXME("stub\n");
 179       /* we should probably find the ddraw window (maybe data->lpDD->lpExclusiveOwner->hWnd),
 180        * and attach the palette to it */
 181     }
 182   }
 183   data->ddRVal = DD_OK;
 184   return DDHAL_DRIVER_HANDLED;
 185 }
 186
 187 static DDHAL_DDSURFACECALLBACKS hal_ddsurfcallbacks = {
 188   sizeof(DDHAL_DDSURFACECALLBACKS),
 189   0x3fff, /* all callbacks are 32-bit */
 190   X11DRV_DDHAL_DestroySurface,
 191   NULL, /* Flip */
 192   NULL, /* SetClipList */
 193   NULL, /* Lock */
 194   NULL, /* Unlock */
 195   NULL, /* Blt */
 196   NULL, /* SetColorKey */
 197   NULL, /* AddAttachedSurface */
 198   NULL, /* GetBltStatus */
 199   NULL, /* GetFlipStatus */
 200   NULL, /* UpdateOverlay */
 201   NULL, /* SetOverlayPosition */
 202   NULL, /* reserved4 */
 203   X11DRV_DDHAL_SetPalette
 204 };
 205
 206 static DWORD PASCAL X11DRV_DDHAL_DestroyPalette(LPDDHAL_DESTROYPALETTEDATA data)
 207 {
 208   Colormap pal = data->lpDDPalette->u1.dwReserved1;
 209   if (pal) TSXFreeColormap(gdi_display, pal);
 210   data->ddRVal = DD_OK;
 211   return DDHAL_DRIVER_HANDLED;
 212 }
 213
 214 static DWORD PASCAL X11DRV_DDHAL_SetPaletteEntries(LPDDHAL_SETENTRIESDATA data)
 215 {
 216   X11DRV_DDHAL_SetPalEntries(data->lpDDPalette->u1.dwReserved1,
 217                              data->dwBase, data->dwNumEntries,
 218                              data->lpEntries);
 219   data->ddRVal = DD_OK;
 220   return DDHAL_DRIVER_HANDLED;
 221 }
 222
 223 static DDHAL_DDPALETTECALLBACKS hal_ddpalcallbacks = {
 224   sizeof(DDHAL_DDPALETTECALLBACKS),
 225   0x3, /* all callbacks are 32-bit */
 226   X11DRV_DDHAL_DestroyPalette,
 227   X11DRV_DDHAL_SetPaletteEntries
 228 };
 229
 230 static X11DEVICE x11device = {
 231   NULL
 232 };
 233
 234 static DWORD PASCAL X11DRV_DDHAL_GetDriverInfo(LPDDHAL_GETDRIVERINFODATA data)
 235 {
 236   LPX11DRIVERINFO info = x11device.lpInfo;
 237   while (info) {
 238     if (IsEqualGUID(&data->guidInfo, info->lpGuid)) {
 239       DWORD dwSize = info->dwSize;
 240       data->dwActualSize = dwSize;
 241       if (data->dwExpectedSize < dwSize) dwSize = data->dwExpectedSize;
 242       memcpy(data->lpvData, info->lpvData, dwSize);
 243       data->ddRVal = DD_OK;
 244       return DDHAL_DRIVER_HANDLED;
 245     }
 246     info = info->lpNext;
 247   }
 248   data->ddRVal = DDERR_CURRENTLYNOTAVAIL;
 249   return DDHAL_DRIVER_HANDLED;
 250 }
 251
 252 static DDHALINFO hal_info = {
 253   sizeof(DDHALINFO),
 254   &hal_ddcallbacks,
 255   &hal_ddsurfcallbacks,
 256   &hal_ddpalcallbacks,
 257   {     /* vmiData */
 258    0     /* fpPrimary */
 259   },
 260   {     /* ddCaps (only stuff the HAL implements here) */
 261    sizeof(DDCORECAPS),                                                  /* dwSize */
 262    DDCAPS_GDI | DDCAPS_PALETTE,                                         /* dwCaps */
 263    DDCAPS2_CERTIFIED | DDCAPS2_NONLOCALVIDMEM | DDCAPS2_NOPAGELOCKREQUIRED |
 264    DDCAPS2_WIDESURFACES | DDCAPS2_PRIMARYGAMMA | DDCAPS2_FLIPNOVSYNC,   /* dwCaps2 */
 265    0,                                                                   /* dwCKeyCaps */
 266    0,                                                                   /* dwFXCaps */
 267    0,                                                                   /* dwFXAlphaCaps */
 268    DDPCAPS_8BIT | DDPCAPS_PRIMARYSURFACE,                               /* dwPalCaps */
 269    0,                                                                   /* dwSVCaps */
 270    0,                                                                   /* dwAlphaBltConstBitDepths */
 271    0,                                                                   /* dwAlphaBltPixelBitDepths */
 272    0,                                                                   /* dwAlphaBltSurfaceBitDepths */
 273    0,                                                                   /* dwAlphaOverlayBltConstBitDepths */
 274    0,                                                                   /* dwAlphaOverlayBltPixelBitDepths */
 275    0,                                                                   /* dwAlphaOverlayBltSurfaceBitDepths */
 276    0,                                                                   /* dwZBufferBitDepths */
 277    16*1024*1024,                                                        /* dwVidMemTotal */
 278    16*1024*1024,                                                        /* dwVidMemFree */
 279    0,                                                                   /* dwMaxVisibleOverlays */
 280    0,                                                                   /* dwCurrVisibleOverlays */
 281    0,                                                                   /* dwNumFourCCCodes */
 282    0,                                                                   /* dwAlignBoundarySrc */
 283    0,                                                                   /* dwAlignSizeSrc */
 284    0,                                                                   /* dwAlignBoundaryDest */
 285    0,                                                                   /* dwAlignSizeDest */
 286    0,                                                                   /* dwAlignStrideAlign */
 287    {0},                                                                 /* dwRops */
 288    {                                                                    /* ddsCaps */
 289     DDSCAPS_BACKBUFFER | DDSCAPS_FLIP | DDSCAPS_FRONTBUFFER |
 290     DDSCAPS_OFFSCREENPLAIN | DDSCAPS_PALETTE | DDSCAPS_PRIMARYSURFACE |
 291     DDSCAPS_SYSTEMMEMORY | DDSCAPS_TEXTURE | DDSCAPS_VIDEOMEMORY |
 292     DDSCAPS_VISIBLE | DDSCAPS_LOCALVIDMEM | DDSCAPS_NONLOCALVIDMEM      /* dwCaps */
 293    },
 294    0,                                                                   /* dwMinOverlayStretch */
 295    0,                                                                   /* dwMaxOverlayStretch */
 296    0,                                                                   /* dwMinLiveVideoStretch */
 297    0,                                                                   /* dwMaxLiveVideoStretch */
 298    0,                                                                   /* dwMinHwCodecStretch */
 299    0,                                                                   /* dwMaxHwCodecStretch */
 300    0,                                                                   /* dwReserved1 */
 301    0,                                                                   /* dwReserved2 */
 302    0,                                                                   /* dwReserved2 */
 303    0,                                                                   /* dwSVBCaps */
 304    0,                                                                   /* dwSVBCKeyCaps */
 305    0,                                                                   /* dwSVBFXCaps */
 306    {0},                                                                 /* dwSVBRops */
 307    0,                                                                   /* dwVSBCaps */
 308    0,                                                                   /* dwVSBCKeyCaps */
 309    0,                                                                   /* dwVSBFXCaps */
 310    {0},                                                                 /* dwVSBRops */
 311    0,                                                                   /* dwSSBCaps */
 312    0,                                                                   /* dwSSBCKeyCaps */
 313    0,                                                                   /* dwSSBFXCaps */
 314    {0},                                                                 /* dwSSBRops */
 315    0,                                                                   /* dwMaxVideoPorts */
 316    0,                                                                   /* dwCurrVideoPorts */
 317    0                                                                    /* dwSVBCaps */
 318   },
 319   0,    /* dwMonitorFrequency */
 320   X11DRV_DDHAL_GetDriverInfo,
 321   0,    /* dwModeIndex */
 322   NULL, /* lpdwFourCC */
 323   0,    /* dwNumModes */
 324   NULL, /* lpModeInfo */
 325   DDHALINFO_ISPRIMARYDISPLAY | DDHALINFO_MODEXILLEGAL | DDHALINFO_GETDRIVERINFOSET, /* dwFlags */
 326   &x11device,
 327   0,    /* hInstance */
 328   0,    /* lpD3DGlobalDriverData */
 329   0,    /* lpD3DHALCallbacks */
 330   NULL  /* lpDDExeBufCallbacks */
 331 };
 332
 333 static LPDDHALDDRAWFNS ddraw_fns;
 334 static DWORD ddraw_ver;
 335
 336 static void X11DRV_DDHAL_SetInfo(void)
 337 {
 338   (ddraw_fns->lpSetInfo)(&hal_info, FALSE);
 339 }
 340
 341 INT X11DRV_DCICommand(INT cbInput, const DCICMD *lpCmd, LPVOID lpOutData)
 342 {
 343   TRACE("(%d,(%ld,%ld,%ld),%p)\n", cbInput, lpCmd->dwCommand,
 344         lpCmd->dwParam1, lpCmd->dwParam2, lpOutData);
 345
 346   switch (lpCmd->dwCommand) {
 347   case DDNEWCALLBACKFNS:
 348     ddraw_fns = (LPDDHALDDRAWFNS)lpCmd->dwParam1;
 349     return TRUE;
 350   case DDVERSIONINFO:
 351     {
 352       LPDDVERSIONDATA lpVer = (LPDDVERSIONDATA)lpOutData;
 353       ddraw_ver = lpCmd->dwParam1;
 354       if (!lpVer) break;
 355       /* well, whatever... the DDK says so */
 356       lpVer->dwHALVersion = DD_RUNTIME_VERSION;
 357     }
 358     return TRUE;
 359   case DDGET32BITDRIVERNAME:
 360     {
 361       LPDD32BITDRIVERDATA lpData = (LPDD32BITDRIVERDATA)lpOutData;
 362       /* here, we could ask ddraw to load a separate DLL, that
 363        * would contain the 32-bit ddraw HAL */
 364       strcpy(lpData->szName,"x11drv");
 365       /* the entry point named here should initialize our hal_info
 366        * with 32-bit entry points (ignored for now) */
 367       strcpy(lpData->szEntryPoint,"DriverInit");
 368       lpData->dwContext = 0;
 369     }
 370     return TRUE;
 371   case DDCREATEDRIVEROBJECT:
 372     {
 373       LPDWORD lpInstance = (LPDWORD)lpOutData;
 374
 375       /* FIXME: get x11drv's hInstance */
 376 #ifdef HAVE_LIBXXF86DGA2
 377       if (!X11DRV_XF86DGA2_CreateDriver(&hal_info))
 378 #endif
 379       {
 380 #ifdef HAVE_LIBXXF86VM
 381         X11DRV_XF86VM_CreateDriver(&hal_info);
 382 #endif
 383       }
 384 #ifdef HAVE_OPENGL
 385       /*X11DRV_GLX_CreateDriver(&hal_info);*/
 386 #endif
 387
 388       (ddraw_fns->lpSetInfo)(&hal_info, FALSE);
 389       *lpInstance = hal_info.hInstance;
 390     }
 391     return TRUE;
 392   }
 393   return 0;
 394 }
 395
 396 void X11DRV_DDHAL_SwitchMode(DWORD dwModeIndex, LPVOID fb_addr, LPVIDMEM fb_mem)
 397 {
 398   LPDDHALMODEINFO info = &hal_info.lpModeInfo[dwModeIndex];
 399
 400   hal_info.dwModeIndex        = dwModeIndex;
 401   hal_info.dwMonitorFrequency = info->wRefreshRate;
 402   hal_info.vmiData.fpPrimary  = (FLATPTR)fb_addr;
 403   hal_info.vmiData.dwDisplayWidth  = info->dwWidth;
 404   hal_info.vmiData.dwDisplayHeight = info->dwHeight;
 405   hal_info.vmiData.lDisplayPitch   = info->lPitch;
 406   hal_info.vmiData.ddpfDisplay.dwSize = info->dwBPP ? sizeof(hal_info.vmiData.ddpfDisplay) : 0;
 407   hal_info.vmiData.ddpfDisplay.dwFlags = (info->wFlags & DDMODEINFO_PALETTIZED) ? DDPF_PALETTEINDEXED8 : 0;
 408   hal_info.vmiData.ddpfDisplay.u1.dwRGBBitCount = (info->dwBPP > 24) ? 24 : info->dwBPP;
 409   hal_info.vmiData.ddpfDisplay.u2.dwRBitMask = info->dwRBitMask;
 410   hal_info.vmiData.ddpfDisplay.u3.dwGBitMask = info->dwGBitMask;
 411   hal_info.vmiData.ddpfDisplay.u4.dwBBitMask = info->dwBBitMask;
 412   hal_info.vmiData.dwNumHeaps = fb_mem ? 1 : 0;
 413   hal_info.vmiData.pvmList = fb_mem;
 414
 415   X11DRV_DDHAL_SetInfo();
 416 }
 417
 418 void X11DRV_DDHAL_SetPalEntries(Colormap pal, DWORD dwBase, DWORD dwNumEntries,
 419                                 LPPALETTEENTRY lpEntries)
 420 {
 421   XColor c;
 422   int n;
 423
 424   if (pal) {
 425     c.flags = DoRed|DoGreen|DoBlue;
 426     c.pixel = dwBase;
 427     for (n=0; n<dwNumEntries; n++,c.pixel++) {
 428       c.red   = lpEntries[n].peRed   << 8;
 429       c.green = lpEntries[n].peGreen << 8;
 430       c.blue  = lpEntries[n].peBlue  << 8;
 431       TSXStoreColor(gdi_display, pal, &c);
 432     }
 433     TSXFlush(gdi_display); /* update display immediately */
 434   }
 435 }