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