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