git.oblomov.eu Git - wine/blob - dlls/ddraw/dsurface/hal.c

   1 /*      DirectDrawSurface HAL driver
   2  *
   3  * Copyright 2001 TransGaming Technologies Inc.
   4  */
   5
   6 #include "config.h"
   7
   8 #include <assert.h>
   9 #include <stdlib.h>
  10
  11 #include "debugtools.h"
  12 #include "ddraw_private.h"
  13 #include "ddraw/user.h"
  14 #include "ddraw/hal.h"
  15 #include "dsurface/main.h"
  16 #include "dsurface/dib.h"
  17 #include "dsurface/user.h"
  18 #include "dsurface/hal.h"
  19
  20 DEFAULT_DEBUG_CHANNEL(ddraw);
  21
  22 static ICOM_VTABLE(IDirectDrawSurface7) HAL_IDirectDrawSurface7_VTable;
  23
  24 static HRESULT HAL_DirectDrawSurface_create_surface(IDirectDrawSurfaceImpl* This,
  25                                                     IDirectDrawImpl* pDD)
  26 {
  27     HAL_PRIV_VAR(priv, This);
  28     HAL_DDRAW_PRIV_VAR(ddpriv, pDD);
  29     LPDDRAWI_DIRECTDRAW_GBL dd_gbl = pDD->local.lpGbl;
  30     LPDDRAWI_DDRAWSURFACE_LCL local = &This->local;
  31     DDHAL_CREATESURFACEDATA data;
  32     HRESULT hr;
  33
  34     data.lpDD = dd_gbl;
  35     data.lpDDSurfaceDesc = (LPDDSURFACEDESC)&This->surface_desc;
  36     data.lplpSList = &local;
  37     data.dwSCnt = 1;
  38     data.ddRVal = 0;
  39     data.CreateSurface = dd_gbl->lpDDCBtmp->HALDD.CreateSurface;
  40     hr = data.CreateSurface(&data);
  41
  42     if (hr == DDHAL_DRIVER_HANDLED) {
  43         if (This->global.fpVidMem < 4) {
  44             /* grab framebuffer data from current_mode */
  45             priv->hal.fb_pitch = dd_gbl->vmiData.lDisplayPitch;
  46             priv->hal.fb_vofs  = ddpriv->hal.next_vofs;
  47             priv->hal.fb_addr  = ((LPBYTE)dd_gbl->vmiData.fpPrimary) +
  48                                  dd_gbl->vmiData.lDisplayPitch * priv->hal.fb_vofs;
  49             TRACE("vofs=%ld, addr=%p\n", priv->hal.fb_vofs, priv->hal.fb_addr);
  50             ddpriv->hal.next_vofs += This->surface_desc.dwHeight;
  51
  52             This->global.fpVidMem = (FLATPTR)priv->hal.fb_addr;
  53             This->global.u4.lPitch = priv->hal.fb_pitch;
  54         }
  55         This->surface_desc.lpSurface = (LPVOID)This->global.fpVidMem;
  56         This->surface_desc.dwFlags |= DDSD_LPSURFACE;
  57         if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_EXECUTEBUFFER) {
  58             This->surface_desc.u1.dwLinearSize = This->global.u4.dwLinearSize;
  59             This->surface_desc.dwFlags |= DDSD_LINEARSIZE;
  60         } else {
  61             This->surface_desc.u1.lPitch = This->global.u4.lPitch;
  62             This->surface_desc.dwFlags |= DDSD_PITCH;
  63         }
  64     }
  65     else priv->hal.need_late = TRUE;
  66
  67     return data.ddRVal;
  68 }
  69
  70 static inline BOOL HAL_IsUser(IDirectDrawSurfaceImpl* This)
  71 {
  72     HAL_PRIV_VAR(priv, This);
  73     if (This->surface_desc.ddsCaps.dwCaps & (DDSCAPS_TEXTURE | DDSCAPS_EXECUTEBUFFER))
  74         return FALSE;
  75     if (priv->hal.fb_addr)
  76         return FALSE;
  77     return TRUE;
  78 }
  79
  80 HRESULT
  81 HAL_DirectDrawSurface_Construct(IDirectDrawSurfaceImpl* This,
  82                                 IDirectDrawImpl* pDD,
  83                                 const DDSURFACEDESC2* pDDSD)
  84 {
  85     HAL_PRIV_VAR(priv, This);
  86     LPDDRAWI_DIRECTDRAW_GBL dd_gbl = pDD->local.lpGbl;
  87     HRESULT hr;
  88
  89     TRACE("(%p,%p,%p)\n",This,pDD,pDDSD);
  90
  91     /* copy surface_desc, we may want to modify it before DIB construction */
  92     This->surface_desc = *pDDSD;
  93
  94     /* the driver may want to dereference these pointers */
  95     This->local.lpSurfMore = &This->more;
  96     This->local.lpGbl = &This->global;
  97     This->gmore = &This->global_more;
  98
  99     if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_TEXTURE) {
 100         hr = HAL_DirectDrawSurface_create_surface(This, pDD);
 101         if (FAILED(hr)) return hr;
 102
 103         hr = DIB_DirectDrawSurface_Construct(This, pDD, &This->surface_desc);
 104         if (FAILED(hr)) return hr;
 105     }
 106     else if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_EXECUTEBUFFER) {
 107         FIXME("create execute buffer\n");
 108         return DDERR_GENERIC;
 109     }
 110     else {
 111         if (!(dd_gbl->dwFlags & DDRAWI_MODECHANGED)) {
 112             /* force a mode set (HALs like DGA may need it) */
 113             hr = HAL_DirectDraw_SetDisplayMode(ICOM_INTERFACE(pDD, IDirectDraw7),
 114                                                pDD->width, pDD->height,
 115                                                pDD->pixelformat.u1.dwRGBBitCount,
 116                                                0, 0);
 117             if (FAILED(hr)) return hr;
 118         }
 119
 120         if (dd_gbl->vmiData.fpPrimary) {
 121             hr = HAL_DirectDrawSurface_create_surface(This, pDD);
 122             if (FAILED(hr)) return hr;
 123
 124             if (priv->hal.need_late) {
 125                 /* this doesn't make sense... driver error? */
 126                 ERR("driver failed to create framebuffer surface\n");
 127                 return DDERR_GENERIC;
 128             }
 129
 130             hr = DIB_DirectDrawSurface_Construct(This, pDD, &This->surface_desc);
 131             if (FAILED(hr)) return hr;
 132         } else {
 133             /* no framebuffer, construct User-based primary */
 134             hr = User_DirectDrawSurface_Construct(This, pDD, pDDSD);
 135             if (FAILED(hr)) return hr;
 136
 137             /* must notify HAL *after* creating User-based primary */
 138             /* (or use CreateSurfaceEx, which we don't yet) */
 139             hr = HAL_DirectDrawSurface_create_surface(This, pDD);
 140             if (FAILED(hr)) return hr;
 141
 142             priv->hal.need_late = FALSE;
 143         }
 144     }
 145
 146     ICOM_INIT_INTERFACE(This, IDirectDrawSurface7,
 147                         HAL_IDirectDrawSurface7_VTable);
 148
 149     This->final_release = HAL_DirectDrawSurface_final_release;
 150     This->late_allocate = HAL_DirectDrawSurface_late_allocate;
 151     This->duplicate_surface = HAL_DirectDrawSurface_duplicate_surface;
 152
 153     This->flip_data   = HAL_DirectDrawSurface_flip_data;
 154     This->flip_update = HAL_DirectDrawSurface_flip_update;
 155
 156     This->set_palette    = HAL_DirectDrawSurface_set_palette;
 157
 158     This->get_display_window = HAL_DirectDrawSurface_get_display_window;
 159
 160     return DD_OK;
 161 }
 162
 163 HRESULT
 164 HAL_DirectDrawSurface_Create(IDirectDrawImpl *pDD,
 165                              const DDSURFACEDESC2 *pDDSD,
 166                              LPDIRECTDRAWSURFACE7 *ppSurf,
 167                              IUnknown *pUnkOuter)
 168 {
 169     IDirectDrawSurfaceImpl* This;
 170     HRESULT hr;
 171     assert(pUnkOuter == NULL);
 172
 173     This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 174                      sizeof(*This) + sizeof(HAL_DirectDrawSurfaceImpl));
 175     if (This == NULL) return E_OUTOFMEMORY;
 176
 177     This->private = (HAL_DirectDrawSurfaceImpl*)(This+1);
 178
 179     hr = HAL_DirectDrawSurface_Construct(This, pDD, pDDSD);
 180     if (FAILED(hr))
 181         HeapFree(GetProcessHeap(), 0, This);
 182     else
 183         *ppSurf = ICOM_INTERFACE(This, IDirectDrawSurface7);
 184
 185     return hr;
 186 }
 187
 188 void HAL_DirectDrawSurface_final_release(IDirectDrawSurfaceImpl* This)
 189 {
 190     LPDDRAWI_DIRECTDRAW_GBL dd_gbl = This->more.lpDD_lcl->lpGbl;
 191     DDHAL_DESTROYSURFACEDATA data;
 192
 193     /* destroy HAL surface */
 194     data.lpDD = dd_gbl;
 195     data.lpDDSurface = &This->local;
 196     data.ddRVal = 0;
 197     data.DestroySurface = dd_gbl->lpDDCBtmp->HALDDSurface.DestroySurface;
 198     data.DestroySurface(&data);
 199
 200     if (HAL_IsUser(This)) {
 201         User_DirectDrawSurface_final_release(This);
 202     } else {
 203         DIB_DirectDrawSurface_final_release(This);
 204     }
 205 }
 206
 207 HRESULT HAL_DirectDrawSurface_late_allocate(IDirectDrawSurfaceImpl* This)
 208 {
 209     HAL_PRIV_VAR(priv, This);
 210     if (priv->hal.need_late) {
 211         priv->hal.need_late = FALSE;
 212         return HAL_DirectDrawSurface_create_surface(This, This->ddraw_owner);
 213     }
 214     return DD_OK;
 215 }
 216
 217 void HAL_DirectDrawSurface_set_palette(IDirectDrawSurfaceImpl* This,
 218                                        IDirectDrawPaletteImpl* pal)
 219 {
 220     LPDDRAWI_DIRECTDRAW_GBL dd_gbl = This->more.lpDD_lcl->lpGbl;
 221     DDHAL_SETPALETTEDATA data;
 222
 223     DIB_DirectDrawSurface_set_palette(This, pal);
 224     data.lpDD = dd_gbl;
 225     data.lpDDSurface = &This->local;
 226     data.lpDDPalette = &pal->global;
 227     data.ddRVal = 0;
 228     data.Attach = TRUE; /* what's this? */
 229     data.SetPalette = dd_gbl->lpDDCBtmp->HALDDSurface.SetPalette;
 230     if (data.SetPalette)
 231         data.SetPalette(&data);
 232 }
 233
 234 HRESULT HAL_DirectDrawSurface_duplicate_surface(IDirectDrawSurfaceImpl* This,
 235                                                 LPDIRECTDRAWSURFACE7* ppDup)
 236 {
 237     return HAL_DirectDrawSurface_Create(This->ddraw_owner,
 238                                              &This->surface_desc, ppDup, NULL);
 239 }
 240
 241 void HAL_DirectDrawSurface_lock_update(IDirectDrawSurfaceImpl* This,
 242                                        LPCRECT pRect, DWORD dwFlags)
 243 {
 244     LPDDRAWI_DIRECTDRAW_GBL dd_gbl = This->more.lpDD_lcl->lpGbl;
 245     DDHAL_LOCKDATA      data;
 246
 247     data.lpDD           = dd_gbl;
 248     data.lpDDSurface    = &This->local;
 249     data.ddRVal         = 0;
 250     data.lpSurfData     = This->surface_desc.lpSurface; /* FIXME: correct? */
 251     if (pRect) {
 252         data.rArea.top  = pRect->top;
 253         data.rArea.bottom       = pRect->bottom;
 254         data.rArea.left = pRect->left;
 255         data.rArea.right        = pRect->right;
 256         data.bHasRect   = TRUE;
 257     } else {
 258         data.bHasRect   = FALSE;
 259     }
 260     data.dwFlags        = dwFlags;
 261
 262     data.Lock           = dd_gbl->lpDDCBtmp->HALDDSurface.Lock;
 263     if (data.Lock && (data.Lock(&data) == DDHAL_DRIVER_HANDLED))
 264         return;
 265
 266     if (HAL_IsUser(This)) {
 267         User_DirectDrawSurface_lock_update(This, pRect, dwFlags);
 268     } else {
 269         Main_DirectDrawSurface_lock_update(This, pRect, dwFlags);
 270     }
 271 }
 272
 273 void HAL_DirectDrawSurface_unlock_update(IDirectDrawSurfaceImpl* This,
 274                                          LPCRECT pRect)
 275 {
 276     LPDDRAWI_DIRECTDRAW_GBL dd_gbl = This->more.lpDD_lcl->lpGbl;
 277     DDHAL_UNLOCKDATA    data;
 278
 279     data.lpDD           = dd_gbl;
 280     data.lpDDSurface    = &This->local;
 281     data.ddRVal         = 0;
 282     data.Unlock         = dd_gbl->lpDDCBtmp->HALDDSurface.Unlock;
 283     if (data.Unlock && (data.Unlock(&data) == DDHAL_DRIVER_HANDLED))
 284         return;
 285
 286     if (HAL_IsUser(This)) {
 287         User_DirectDrawSurface_unlock_update(This, pRect);
 288     } else {
 289         Main_DirectDrawSurface_unlock_update(This, pRect);
 290     }
 291 }
 292
 293 BOOL HAL_DirectDrawSurface_flip_data(IDirectDrawSurfaceImpl* front,
 294                                      IDirectDrawSurfaceImpl* back,
 295                                      DWORD dwFlags)
 296 {
 297     HAL_PRIV_VAR(front_priv, front);
 298     HAL_PRIV_VAR(back_priv, back);
 299     LPDDRAWI_DIRECTDRAW_GBL dd_gbl = front->more.lpDD_lcl->lpGbl;
 300     DDHAL_FLIPDATA data;
 301     BOOL ret;
 302
 303     {
 304         DWORD tmp;
 305         tmp = front_priv->hal.fb_vofs;
 306         front_priv->hal.fb_vofs = back_priv->hal.fb_vofs;
 307         back_priv->hal.fb_vofs = tmp;
 308     }
 309     {
 310         LPVOID tmp;
 311         tmp = front_priv->hal.fb_addr;
 312         front_priv->hal.fb_addr = back_priv->hal.fb_addr;
 313         back_priv->hal.fb_addr = tmp;
 314     }
 315
 316     if (HAL_IsUser(front)) {
 317         ret = User_DirectDrawSurface_flip_data(front, back, dwFlags);
 318     } else {
 319         ret = DIB_DirectDrawSurface_flip_data(front, back, dwFlags);
 320     }
 321
 322     TRACE("(%p,%p)\n",front,back);
 323     data.lpDD = dd_gbl;
 324     data.lpSurfCurr = &front->local;
 325     data.lpSurfTarg = &back->local;
 326     data.lpSurfCurrLeft = NULL;
 327     data.lpSurfTargLeft = NULL;
 328     data.dwFlags = dwFlags;
 329     data.ddRVal = 0;
 330     data.Flip = dd_gbl->lpDDCBtmp->HALDDSurface.Flip;
 331     if (data.Flip)
 332         if (data.Flip(&data) == DDHAL_DRIVER_HANDLED) ret = FALSE;
 333
 334     return ret;
 335 }
 336
 337 void HAL_DirectDrawSurface_flip_update(IDirectDrawSurfaceImpl* This, DWORD dwFlags)
 338 {
 339     if (HAL_IsUser(This)) {
 340         User_DirectDrawSurface_flip_update(This, dwFlags);
 341     }
 342 }
 343
 344 HWND HAL_DirectDrawSurface_get_display_window(IDirectDrawSurfaceImpl* This)
 345 {
 346     return 0;
 347 }
 348
 349 static ICOM_VTABLE(IDirectDrawSurface7) HAL_IDirectDrawSurface7_VTable =
 350 {
 351     Main_DirectDrawSurface_QueryInterface,
 352     Main_DirectDrawSurface_AddRef,
 353     Main_DirectDrawSurface_Release,
 354     Main_DirectDrawSurface_AddAttachedSurface,
 355     Main_DirectDrawSurface_AddOverlayDirtyRect,
 356     DIB_DirectDrawSurface_Blt,
 357     Main_DirectDrawSurface_BltBatch,
 358     DIB_DirectDrawSurface_BltFast,
 359     Main_DirectDrawSurface_DeleteAttachedSurface,
 360     Main_DirectDrawSurface_EnumAttachedSurfaces,
 361     Main_DirectDrawSurface_EnumOverlayZOrders,
 362     Main_DirectDrawSurface_Flip,
 363     Main_DirectDrawSurface_GetAttachedSurface,
 364     Main_DirectDrawSurface_GetBltStatus,
 365     Main_DirectDrawSurface_GetCaps,
 366     Main_DirectDrawSurface_GetClipper,
 367     Main_DirectDrawSurface_GetColorKey,
 368     Main_DirectDrawSurface_GetDC,
 369     Main_DirectDrawSurface_GetFlipStatus,
 370     Main_DirectDrawSurface_GetOverlayPosition,
 371     Main_DirectDrawSurface_GetPalette,
 372     Main_DirectDrawSurface_GetPixelFormat,
 373     Main_DirectDrawSurface_GetSurfaceDesc,
 374     Main_DirectDrawSurface_Initialize,
 375     Main_DirectDrawSurface_IsLost,
 376     Main_DirectDrawSurface_Lock,
 377     Main_DirectDrawSurface_ReleaseDC,
 378     DIB_DirectDrawSurface_Restore,
 379     Main_DirectDrawSurface_SetClipper,
 380     Main_DirectDrawSurface_SetColorKey,
 381     Main_DirectDrawSurface_SetOverlayPosition,
 382     Main_DirectDrawSurface_SetPalette,
 383     Main_DirectDrawSurface_Unlock,
 384     Main_DirectDrawSurface_UpdateOverlay,
 385     Main_DirectDrawSurface_UpdateOverlayDisplay,
 386     Main_DirectDrawSurface_UpdateOverlayZOrder,
 387     Main_DirectDrawSurface_GetDDInterface,
 388     Main_DirectDrawSurface_PageLock,
 389     Main_DirectDrawSurface_PageUnlock,
 390     DIB_DirectDrawSurface_SetSurfaceDesc,
 391     Main_DirectDrawSurface_SetPrivateData,
 392     Main_DirectDrawSurface_GetPrivateData,
 393     Main_DirectDrawSurface_FreePrivateData,
 394     Main_DirectDrawSurface_GetUniquenessValue,
 395     Main_DirectDrawSurface_ChangeUniquenessValue,
 396     Main_DirectDrawSurface_SetPriority,
 397     Main_DirectDrawSurface_GetPriority,
 398     Main_DirectDrawSurface_SetLOD,
 399     Main_DirectDrawSurface_GetLOD
 400 };