reactos/subsys/win32k/ntddraw/ddraw.c

   1 /*
   2  * COPYRIGHT:        See COPYING in the top level directory
   3  * PROJECT:          ReactOS kernel
   4  * PURPOSE:          Native DirectDraw implementation
   5  * FILE:             subsys/win32k/ntddraw/ddraw.c
   6  * PROGRAMER:        Peter Bajusz (hyp-x@stormregion.com)
   7  * REVISION HISTORY:
   8  *       25-10-2003  PB  Created
   9  */
  10
  11 #include <w32k.h>
  12
  13 #define NDEBUG
  14 #include <debug.h>
  15
  16 /* swtich this off to get rid of all dx debug msg */
  17 #define DX_DEBUG
  18
  19
  20 /************************************************************************/
  21 /* DIRECT DRAW OBJECT                                                   */
  22 /************************************************************************/
  23
  24 BOOL INTERNAL_CALL
  25 DD_Cleanup(PVOID ObjectBody)
  26 {
  27         PDD_DIRECTDRAW pDirectDraw = (PDD_DIRECTDRAW) ObjectBody;
  28 #ifdef DX_DEBUG
  29         DPRINT1("DD_Cleanup\n");
  30 #endif
  31
  32         if (!pDirectDraw)
  33                 return FALSE;
  34
  35     if (pDirectDraw->Global.dhpdev == NULL)
  36         return FALSE;
  37
  38     if (pDirectDraw->DrvDisableDirectDraw == NULL)
  39         return FALSE;
  40
  41         pDirectDraw->DrvDisableDirectDraw(pDirectDraw->Global.dhpdev);
  42         return TRUE;
  43 }
  44
  45 HANDLE STDCALL NtGdiDdCreateDirectDrawObject(
  46     HDC hdc
  47 )
  48 {
  49         DD_CALLBACKS callbacks;
  50         DD_SURFACECALLBACKS surface_callbacks;
  51         DD_PALETTECALLBACKS palette_callbacks;
  52 #ifdef DX_DEBUG
  53         DPRINT1("NtGdiDdCreateDirectDrawObject\n");
  54 #endif
  55
  56         RtlZeroMemory(&callbacks, sizeof(DD_CALLBACKS));
  57         callbacks.dwSize = sizeof(DD_CALLBACKS);
  58         RtlZeroMemory(&surface_callbacks, sizeof(DD_SURFACECALLBACKS));
  59         surface_callbacks.dwSize = sizeof(DD_SURFACECALLBACKS);
  60         RtlZeroMemory(&palette_callbacks, sizeof(DD_PALETTECALLBACKS));
  61         palette_callbacks.dwSize = sizeof(DD_PALETTECALLBACKS);
  62
  63         /* FIXME hdc can be zero for d3d9 */
  64     /* we need create it, if in that case */
  65         if (hdc == NULL)
  66         {
  67             return NULL;
  68     }
  69
  70         DC *pDC = DC_LockDc(hdc);
  71         if (!pDC)
  72                 return NULL;
  73
  74         if (!pDC->DriverFunctions.EnableDirectDraw)
  75         {
  76                 // Driver doesn't support DirectDraw
  77                 DC_UnlockDc(pDC);
  78                 return NULL;
  79         }
  80
  81         BOOL success = pDC->DriverFunctions.EnableDirectDraw(
  82                 pDC->PDev, &callbacks, &surface_callbacks, &palette_callbacks);
  83
  84         if (!success)
  85         {
  86 #ifdef DX_DEBUG
  87         DPRINT1("DirectDraw creation failed\n");
  88 #endif
  89                 // DirectDraw creation failed
  90                 DC_UnlockDc(pDC);
  91                 return NULL;
  92         }
  93
  94         HANDLE hDirectDraw = GDIOBJ_AllocObj(GDI_OBJECT_TYPE_DIRECTDRAW);
  95         if (!hDirectDraw)
  96         {
  97                 /* No more memmory */
  98 #ifdef DX_DEBUG
  99                 DPRINT1("No more memmory\n");
 100 #endif
 101                 DC_UnlockDc(pDC);
 102                 return NULL;
 103         }
 104
 105         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDraw, GDI_OBJECT_TYPE_DIRECTDRAW);
 106         if (!pDirectDraw)
 107         {
 108                 /* invalid handle */
 109 #ifdef DX_DEBUG
 110                 DPRINT1("invalid handle\n");
 111 #endif
 112                 DC_UnlockDc(pDC);
 113                 return NULL;
 114         }
 115
 116
 117         pDirectDraw->Global.dhpdev = pDC->PDev;
 118         pDirectDraw->Local.lpGbl = &pDirectDraw->Global;
 119
 120         pDirectDraw->DrvGetDirectDrawInfo = pDC->DriverFunctions.GetDirectDrawInfo;
 121         pDirectDraw->DrvDisableDirectDraw = pDC->DriverFunctions.DisableDirectDraw;
 122
 123     /* DD_CALLBACKS setup */
 124         RtlMoveMemory(&pDirectDraw->DD, &callbacks, sizeof(DD_CALLBACKS));
 125
 126         /* DD_SURFACECALLBACKS  setup*/
 127         RtlMoveMemory(&pDirectDraw->Surf, &surface_callbacks, sizeof(DD_SURFACECALLBACKS));
 128
 129         /* DD_PALETTECALLBACKS setup*/
 130         RtlMoveMemory(&pDirectDraw->Pal, &surface_callbacks, sizeof(DD_PALETTECALLBACKS));
 131
 132         GDIOBJ_UnlockObjByPtr(pDirectDraw);
 133         DC_UnlockDc(pDC);
 134
 135         return hDirectDraw;
 136 }
 137
 138 BOOL STDCALL NtGdiDdDeleteDirectDrawObject(
 139     HANDLE hDirectDrawLocal
 140 )
 141 {
 142 #ifdef DX_DEBUG
 143     DPRINT1("NtGdiDdDeleteDirectDrawObject\n");
 144 #endif
 145         return GDIOBJ_FreeObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
 146 }
 147
 148 BOOL STDCALL NtGdiDdQueryDirectDrawObject(
 149     HANDLE hDirectDrawLocal,
 150     DD_HALINFO  *pHalInfo,
 151     DWORD *pCallBackFlags,
 152     LPD3DNTHAL_CALLBACKS puD3dCallbacks,
 153     LPD3DNTHAL_GLOBALDRIVERDATA puD3dDriverData,
 154     PDD_D3DBUFCALLBACKS puD3dBufferCallbacks,
 155     LPDDSURFACEDESC puD3dTextureFormats,
 156     DWORD *puNumHeaps,
 157     VIDEOMEMORY *puvmList,
 158     DWORD *puNumFourCC,
 159     DWORD *puFourCC
 160 )
 161 {
 162 #ifdef DX_DEBUG
 163     DPRINT1("NtGdiDdQueryDirectDrawObject\n");
 164 #endif
 165
 166     /* Check for NULL pointer to prevent any one doing a mistake */
 167
 168     if (hDirectDrawLocal == NULL)
 169     {
 170 #ifdef DX_DEBUG
 171        DPRINT1("warning hDirectDraw handler is NULL, the handler is  DDRAWI_DIRECTDRAW_GBL.hDD\n");
 172        DPRINT1("and it is NtGdiDdCreateDirectDrawObject return value\n");
 173 #endif
 174        return FALSE;
 175     }
 176
 177
 178     if (pHalInfo == NULL)
 179     {
 180 #ifdef DX_DEBUG
 181        DPRINT1("warning pHalInfo buffer is NULL \n");
 182 #endif
 183        return FALSE;
 184     }
 185
 186     if ( pCallBackFlags == NULL)
 187     {
 188 #ifdef DX_DEBUG
 189        DPRINT1("warning pCallBackFlags s NULL, the size must be 3*DWORD in follow order \n");
 190        DPRINT1("pCallBackFlags[0] = flags in DD_CALLBACKS\n");
 191        DPRINT1("pCallBackFlags[1] = flags in DD_SURFACECALLBACKS\n");
 192        DPRINT1("pCallBackFlags[2] = flags in DD_PALETTECALLBACKS\n");
 193 #endif
 194        return FALSE;
 195     }
 196
 197
 198         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
 199
 200
 201         if (!pDirectDraw)
 202         {
 203         /* Fail to Lock DirectDraw handle */
 204 #ifdef DX_DEBUG
 205         DPRINT1(" Fail to Lock DirectDraw handle \n");
 206 #endif
 207                 return FALSE;
 208     }
 209
 210         BOOL success = pDirectDraw->DrvGetDirectDrawInfo(
 211                 pDirectDraw->Global.dhpdev,
 212                 pHalInfo,
 213                 puNumHeaps,
 214                 puvmList,
 215                 puNumFourCC,
 216                 puFourCC);
 217
 218         if (!success)
 219         {
 220 #ifdef DX_DEBUG
 221         DPRINT1(" Fail to get DirectDraw driver info \n");
 222 #endif
 223                 GDIOBJ_UnlockObjByPtr(pDirectDraw);
 224                 return FALSE;
 225         }
 226
 227
 228     /* rest the flag so we do not need do it later */
 229     pCallBackFlags[0]=0;
 230     pCallBackFlags[1]=0;
 231     pCallBackFlags[2]=0;
 232
 233         if (pHalInfo)
 234         {
 235
 236           {
 237              DDHALINFO* pHalInfo2 = ((DDHALINFO*) pHalInfo);
 238 #ifdef DX_DEBUG
 239              DPRINT1("Found DirectDraw CallBack for 2D and 3D Hal\n");
 240 #endif
 241              RtlMoveMemory(&pDirectDraw->Hal, pHalInfo2, sizeof(DDHALINFO));
 242
 243              if (pHalInfo2->lpDDExeBufCallbacks)
 244                  {
 245 #ifdef DX_DEBUG
 246                  DPRINT1("Found DirectDraw CallBack for 3D Hal Bufffer  \n");
 247 #endif
 248                  /* msdn DDHAL_D3DBUFCALLBACKS = DD_D3DBUFCALLBACKS */
 249                  RtlMoveMemory(puD3dBufferCallbacks, pHalInfo2->lpDDExeBufCallbacks, sizeof(DD_D3DBUFCALLBACKS));
 250              }
 251
 252 #ifdef DX_DEBUG
 253              DPRINT1("Do not support CallBack for 3D Hal\n");
 254 #endif
 255              /* FIXME we need D3DHAL be include
 256
 257              if (pHalInfo2->lpD3DHALCallbacks )
 258                  {
 259 #ifdef DX_DEBUG
 260                     DPRINT1("Found DirectDraw CallBack for 3D Hal\n");
 261 #endif
 262                             RtlMoveMemory(puD3dCallbacks, (ULONG *)pHalInfo2->lpD3DHALCallbacks, sizeof( D3DHAL_CALLBACKS ));
 263                  }
 264              */
 265
 266
 267              /* msdn say D3DHAL_GLOBALDRIVERDATA and D3DNTHAL_GLOBALDRIVERDATA are not same
 268                 but if u compare these in msdn it is exacly same */
 269
 270                  if (pHalInfo->lpD3DGlobalDriverData)
 271                  {
 272 #ifdef DX_DEBUG
 273                    DPRINT1("Found DirectDraw CallBack for 3D Hal Private  \n");
 274 #endif
 275                            RtlMoveMemory(puD3dDriverData, (ULONG *)pHalInfo2->lpD3DGlobalDriverData, sizeof(D3DNTHAL_GLOBALDRIVERDATA));
 276                  }
 277
 278              /* build the flag */
 279
 280              if (pHalInfo2->lpDDCallbacks!=NULL)
 281              {
 282 #ifdef DX_DEBUG
 283                     DPRINT1("Dectect DirectDraw lpDDCallbacks for 2D Hal flag = %d\n",pHalInfo2->lpDDCallbacks->dwFlags);
 284 #endif
 285                     pCallBackFlags[0] = pHalInfo2->lpDDCallbacks->dwFlags;
 286              }
 287
 288              if (pHalInfo2->lpDDCallbacks!=NULL)
 289              {
 290 #ifdef DX_DEBUG
 291                    DPRINT1("Dectect DirectDraw lpDDSurfaceCallbacks for 2D Hal flag = %d\n",pHalInfo2->lpDDSurfaceCallbacks->dwFlags);
 292 #endif
 293                    pCallBackFlags[1] = pHalInfo2->lpDDSurfaceCallbacks->dwFlags;
 294              }
 295
 296              if (pHalInfo2->lpDDCallbacks!=NULL)
 297              {
 298 #ifdef DX_DEBUG
 299                    DPRINT1("Dectect DirectDraw lpDDCallbacks for 2D Hal flag = %d\n",pHalInfo2->lpDDPaletteCallbacks->dwFlags);
 300 #endif
 301                    pCallBackFlags[2] = pHalInfo2->lpDDPaletteCallbacks->dwFlags;
 302              }
 303
 304           }
 305
 306 #ifdef DX_DEBUG
 307           DPRINT1("Found DirectDraw CallBack for 3D Hal\n");
 308 #endif
 309           RtlMoveMemory(&pDirectDraw->Hal, pHalInfo, sizeof(DD_HALINFO));
 310
 311           if (pHalInfo->lpD3DBufCallbacks)
 312               {
 313 #ifdef DX_DEBUG
 314                    DPRINT1("Found DirectDraw CallBack for 3D Hal Bufffer  \n");
 315 #endif
 316                            RtlMoveMemory(puD3dBufferCallbacks, pHalInfo->lpD3DBufCallbacks, sizeof(DD_D3DBUFCALLBACKS));
 317               }
 318
 319           if (pHalInfo->lpD3DHALCallbacks)
 320               {
 321 #ifdef DX_DEBUG
 322                    DPRINT1("Found DirectDraw CallBack for 3D Hal\n");
 323 #endif
 324                            RtlMoveMemory(puD3dCallbacks, pHalInfo->lpD3DHALCallbacks, sizeof(D3DNTHAL_CALLBACKS));
 325               }
 326
 327               if (pHalInfo->lpD3DGlobalDriverData)
 328               {
 329 #ifdef DX_DEBUG
 330                    DPRINT1("Found DirectDraw CallBack for 3D Hal Private  \n");
 331 #endif
 332                            RtlMoveMemory(puD3dDriverData, pHalInfo->lpD3DGlobalDriverData, sizeof(D3DNTHAL_GLOBALDRIVERDATA));
 333               }
 334
 335 #ifdef DX_DEBUG
 336           DPRINT1("Unkown DirectX driver interface\n");
 337 #endif
 338
 339            }
 340
 341 #ifdef DX_DEBUG
 342      else
 343          {
 344            DPRINT1("No DirectDraw Hal info have been found, it did not fail, it did gather some other info \n");
 345     }
 346 #endif
 347
 348         GDIOBJ_UnlockObjByPtr(pDirectDraw);
 349
 350         return TRUE;
 351 }
 352
 353
 354 DWORD STDCALL NtGdiDdGetDriverInfo(
 355     HANDLE hDirectDrawLocal,
 356     PDD_GETDRIVERINFODATA puGetDriverInfoData)
 357
 358 {
 359         DWORD  ddRVal = 0;
 360
 361         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
 362 #ifdef DX_DEBUG
 363         DPRINT1("NtGdiDdGetDriverInfo\n");
 364 #endif
 365
 366         if (pDirectDraw == NULL)
 367         {
 368 #ifdef DX_DEBUG
 369         DPRINT1("Can not lock DirectDraw handle \n");
 370 #endif
 371                 return DDHAL_DRIVER_NOTHANDLED;
 372     }
 373
 374
 375     /* it exsist two version of NtGdiDdGetDriverInfo we need check for both flags */
 376     if (!(pDirectDraw->Hal.dwFlags & DDHALINFO_GETDRIVERINFOSET))
 377          ddRVal++;
 378
 379     if (!(pDirectDraw->Hal.dwFlags & DDHALINFO_GETDRIVERINFO2))
 380          ddRVal++;
 381
 382
 383     /* Now we are doing the call to drv DrvGetDriverInfo */
 384         if   (ddRVal == 2)
 385         {
 386 #ifdef DX_DEBUG
 387          DPRINT1("NtGdiDdGetDriverInfo DDHAL_DRIVER_NOTHANDLED");
 388 #endif
 389              ddRVal = DDHAL_DRIVER_NOTHANDLED;
 390     }
 391         else
 392              ddRVal = pDirectDraw->Hal.GetDriverInfo(puGetDriverInfoData);
 393
 394     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 395
 396         return ddRVal;
 397 }
 398
 399 /************************************************************************/
 400 /* DD CALLBACKS                                                         */
 401 /* FIXME NtGdiDdCreateSurface we do not call to ddCreateSurface         */
 402 /************************************************************************/
 403
 404 DWORD STDCALL NtGdiDdCreateSurface(
 405     HANDLE hDirectDrawLocal,
 406     HANDLE *hSurface,
 407     DDSURFACEDESC *puSurfaceDescription,
 408     DD_SURFACE_GLOBAL *puSurfaceGlobalData,
 409     DD_SURFACE_LOCAL *puSurfaceLocalData,
 410     DD_SURFACE_MORE *puSurfaceMoreData,
 411     PDD_CREATESURFACEDATA puCreateSurfaceData,
 412     HANDLE *puhSurface
 413 )
 414 {
 415         DWORD  ddRVal = DDHAL_DRIVER_NOTHANDLED;
 416         PDD_DIRECTDRAW_GLOBAL lgpl;
 417 #ifdef DX_DEBUG
 418         DPRINT1("NtGdiDdCreateSurface\n");
 419 #endif
 420
 421         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
 422         if (pDirectDraw == NULL)
 423         {
 424 #ifdef DX_DEBUG
 425         DPRINT1("Can not lock the DirectDraw handle\n");
 426 #endif
 427                 return DDHAL_DRIVER_NOTHANDLED;
 428     }
 429
 430         /* backup the orignal PDev and info */
 431         lgpl = puCreateSurfaceData->lpDD;
 432
 433         /* use our cache version instead */
 434         puCreateSurfaceData->lpDD = &pDirectDraw->Global;
 435
 436         /* make the call */
 437         if (!(pDirectDraw->DD.dwFlags & DDHAL_CB32_CANCREATESURFACE))
 438         {
 439 #ifdef DX_DEBUG
 440         DPRINT1("DirectDraw HAL does not support Create Surface");
 441 #endif
 442                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 443     }
 444         else
 445         {
 446            ddRVal = pDirectDraw->DD.CreateSurface(puCreateSurfaceData);
 447         }
 448
 449         /* But back the orignal PDev */
 450         puCreateSurfaceData->lpDD = lgpl;
 451
 452         GDIOBJ_UnlockObjByPtr(pDirectDraw);
 453         return ddRVal;
 454 }
 455
 456 DWORD STDCALL NtGdiDdWaitForVerticalBlank(
 457     HANDLE hDirectDrawLocal,
 458     PDD_WAITFORVERTICALBLANKDATA puWaitForVerticalBlankData
 459 )
 460 {
 461         DWORD  ddRVal;
 462         PDD_DIRECTDRAW_GLOBAL lgpl;
 463 #ifdef DX_DEBUG
 464         DPRINT1("NtGdiDdWaitForVerticalBlank\n");
 465 #endif
 466
 467
 468         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
 469         if (pDirectDraw == NULL)
 470                 return DDHAL_DRIVER_NOTHANDLED;
 471
 472         /* backup the orignal PDev and info */
 473         lgpl = puWaitForVerticalBlankData->lpDD;
 474
 475         /* use our cache version instead */
 476         puWaitForVerticalBlankData->lpDD = &pDirectDraw->Global;
 477
 478         /* make the call */
 479         if (!(pDirectDraw->DD.dwFlags & DDHAL_CB32_WAITFORVERTICALBLANK))
 480                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 481         else
 482             ddRVal = pDirectDraw->DD.WaitForVerticalBlank(puWaitForVerticalBlankData);
 483
 484         /* But back the orignal PDev */
 485         puWaitForVerticalBlankData->lpDD = lgpl;
 486
 487     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 488         return ddRVal;
 489 }
 490
 491 DWORD STDCALL NtGdiDdCanCreateSurface(
 492     HANDLE hDirectDrawLocal,
 493     PDD_CANCREATESURFACEDATA puCanCreateSurfaceData
 494 )
 495 {
 496         DWORD  ddRVal;
 497         PDD_DIRECTDRAW_GLOBAL lgpl;
 498
 499         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
 500 #ifdef DX_DEBUG
 501         DPRINT1("NtGdiDdCanCreateSurface\n");
 502 #endif
 503         if (pDirectDraw == NULL)
 504                 return DDHAL_DRIVER_NOTHANDLED;
 505
 506         /* backup the orignal PDev and info */
 507         lgpl = puCanCreateSurfaceData->lpDD;
 508
 509         /* use our cache version instead */
 510         puCanCreateSurfaceData->lpDD = &pDirectDraw->Global;
 511
 512         /* make the call */
 513         if (!(pDirectDraw->DD.dwFlags & DDHAL_CB32_CANCREATESURFACE))
 514                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 515         else
 516             ddRVal = pDirectDraw->DD.CanCreateSurface(puCanCreateSurfaceData);
 517
 518         /* But back the orignal PDev */
 519         puCanCreateSurfaceData->lpDD = lgpl;
 520
 521         GDIOBJ_UnlockObjByPtr(pDirectDraw);
 522         return ddRVal;
 523 }
 524
 525 DWORD STDCALL NtGdiDdGetScanLine(
 526     HANDLE hDirectDrawLocal,
 527     PDD_GETSCANLINEDATA puGetScanLineData
 528 )
 529 {
 530         DWORD  ddRVal;
 531         PDD_DIRECTDRAW_GLOBAL lgpl;
 532
 533         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
 534 #ifdef DX_DEBUG
 535         DPRINT1("NtGdiDdGetScanLine\n");
 536 #endif
 537         if (pDirectDraw == NULL)
 538                 return DDHAL_DRIVER_NOTHANDLED;
 539
 540         /* backup the orignal PDev and info */
 541         lgpl = puGetScanLineData->lpDD;
 542
 543         /* use our cache version instead */
 544         puGetScanLineData->lpDD = &pDirectDraw->Global;
 545
 546         /* make the call */
 547         if (!(pDirectDraw->DD.dwFlags & DDHAL_CB32_GETSCANLINE))
 548                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 549         else
 550             ddRVal = pDirectDraw->DD.GetScanLine(puGetScanLineData);
 551
 552         /* But back the orignal PDev */
 553         puGetScanLineData->lpDD = lgpl;
 554
 555         GDIOBJ_UnlockObjByPtr(pDirectDraw);
 556         return ddRVal;
 557 }
 558
 559
 560
 561 /************************************************************************/
 562 /* Surface CALLBACKS                                                    */
 563 /* FIXME                                                                */
 564 /* NtGdiDdDestroySurface                                                */
 565 /************************************************************************/
 566
 567 DWORD STDCALL NtGdiDdDestroySurface(
 568     HANDLE hSurface,
 569     BOOL bRealDestroy
 570 )
 571 {
 572         DWORD  ddRVal  = DDHAL_DRIVER_NOTHANDLED;
 573
 574         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
 575 #ifdef DX_DEBUG
 576         DPRINT1("NtGdiDdDestroySurface\n");
 577 #endif
 578         if (pDirectDraw == NULL)
 579                 return DDHAL_DRIVER_NOTHANDLED;
 580
 581         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_DESTROYSURFACE))
 582                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 583         else
 584         {
 585                 DD_DESTROYSURFACEDATA DestroySurf;
 586
 587                 /* FIXME
 588                  * bRealDestroy
 589                  * are we doing right ??
 590                  */
 591         DestroySurf.lpDD =  &pDirectDraw->Global;
 592
 593         DestroySurf.lpDDSurface = hSurface;  // ?
 594         DestroySurf.DestroySurface = pDirectDraw->Surf.DestroySurface;
 595
 596         ddRVal = pDirectDraw->Surf.DestroySurface(&DestroySurf);
 597         }
 598
 599
 600     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 601     return ddRVal;
 602 }
 603
 604 DWORD STDCALL NtGdiDdFlip(
 605     HANDLE hSurfaceCurrent,
 606     HANDLE hSurfaceTarget,
 607     HANDLE hSurfaceCurrentLeft,
 608     HANDLE hSurfaceTargetLeft,
 609     PDD_FLIPDATA puFlipData
 610 )
 611 {
 612         DWORD  ddRVal;
 613         PDD_DIRECTDRAW_GLOBAL lgpl;
 614
 615         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurfaceTarget, GDI_OBJECT_TYPE_DIRECTDRAW);
 616 #ifdef DX_DEBUG
 617         DPRINT1("NtGdiDdFlip\n");
 618 #endif
 619
 620         if (pDirectDraw == NULL)
 621                 return DDHAL_DRIVER_NOTHANDLED;
 622
 623         /* backup the orignal PDev and info */
 624         lgpl = puFlipData->lpDD;
 625
 626         /* use our cache version instead */
 627         puFlipData->lpDD = &pDirectDraw->Global;
 628
 629         /* make the call */
 630         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_FLIP))
 631                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 632         else
 633         ddRVal = pDirectDraw->Surf.Flip(puFlipData);
 634
 635         /* But back the orignal PDev */
 636         puFlipData->lpDD = lgpl;
 637
 638     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 639     return ddRVal;
 640 }
 641
 642 DWORD STDCALL NtGdiDdLock(
 643     HANDLE hSurface,
 644     PDD_LOCKDATA puLockData,
 645     HDC hdcClip
 646 )
 647 {
 648         DWORD  ddRVal;
 649         PDD_DIRECTDRAW_GLOBAL lgpl;
 650
 651         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
 652 #ifdef DX_DEBUG
 653         DPRINT1("NtGdiDdLock\n");
 654 #endif
 655         if (pDirectDraw == NULL)
 656                 return DDHAL_DRIVER_NOTHANDLED;
 657
 658         /* backup the orignal PDev and info */
 659         lgpl = puLockData->lpDD;
 660
 661         /* use our cache version instead */
 662         puLockData->lpDD = &pDirectDraw->Global;
 663
 664         /* make the call */
 665         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_LOCK))
 666                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 667         else
 668         ddRVal = pDirectDraw->Surf.Lock(puLockData);
 669
 670         /* But back the orignal PDev */
 671         puLockData->lpDD = lgpl;
 672
 673     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 674     return ddRVal;
 675 }
 676
 677 DWORD STDCALL NtGdiDdUnlock(
 678     HANDLE hSurface,
 679     PDD_UNLOCKDATA puUnlockData
 680 )
 681 {
 682         DWORD  ddRVal;
 683         PDD_DIRECTDRAW_GLOBAL lgpl;
 684
 685         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
 686 #ifdef DX_DEBUG
 687         DPRINT1("NtGdiDdUnlock\n");
 688 #endif
 689         if (pDirectDraw == NULL)
 690                 return DDHAL_DRIVER_NOTHANDLED;
 691
 692         /* backup the orignal PDev and info */
 693         lgpl = puUnlockData->lpDD;
 694
 695         /* use our cache version instead */
 696         puUnlockData->lpDD = &pDirectDraw->Global;
 697
 698         /* make the call */
 699         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_UNLOCK))
 700                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 701         else
 702         ddRVal = pDirectDraw->Surf.Unlock(puUnlockData);
 703
 704         /* But back the orignal PDev */
 705         puUnlockData->lpDD = lgpl;
 706
 707     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 708         return ddRVal;
 709 }
 710
 711 DWORD STDCALL NtGdiDdBlt(
 712     HANDLE hSurfaceDest,
 713     HANDLE hSurfaceSrc,
 714     PDD_BLTDATA puBltData
 715 )
 716 {
 717     DWORD  ddRVal;
 718         PDD_DIRECTDRAW_GLOBAL lgpl;
 719
 720     PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurfaceDest, GDI_OBJECT_TYPE_DIRECTDRAW);
 721 #ifdef DX_DEBUG
 722     DPRINT1("NtGdiDdBlt\n");
 723 #endif
 724         if (pDirectDraw == NULL)
 725                 return DDHAL_DRIVER_NOTHANDLED;
 726
 727         /* backup the orignal PDev and info */
 728         lgpl = puBltData->lpDD;
 729
 730         /* use our cache version instead */
 731         puBltData->lpDD = &pDirectDraw->Global;
 732
 733         /* make the call */
 734         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_BLT))
 735                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 736         else
 737         ddRVal = pDirectDraw->Surf.Blt(puBltData);
 738
 739         /* But back the orignal PDev */
 740         puBltData->lpDD = lgpl;
 741
 742     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 743     return ddRVal;
 744    }
 745
 746 DWORD STDCALL NtGdiDdSetColorKey(
 747     HANDLE hSurface,
 748     PDD_SETCOLORKEYDATA puSetColorKeyData
 749 )
 750 {
 751         DWORD  ddRVal;
 752         PDD_DIRECTDRAW_GLOBAL lgpl;
 753
 754         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
 755 #ifdef DX_DEBUG
 756         DPRINT1("NtGdiDdSetColorKey\n");
 757 #endif
 758         if (pDirectDraw == NULL)
 759                 return DDHAL_DRIVER_NOTHANDLED;
 760
 761         /* backup the orignal PDev and info */
 762         lgpl = puSetColorKeyData->lpDD;
 763
 764         /* use our cache version instead */
 765         puSetColorKeyData->lpDD = &pDirectDraw->Global;
 766
 767         /* make the call */
 768         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_SETCOLORKEY))
 769                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 770         else
 771         ddRVal = pDirectDraw->Surf.SetColorKey(puSetColorKeyData);
 772
 773         /* But back the orignal PDev */
 774         puSetColorKeyData->lpDD = lgpl;
 775
 776     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 777     return ddRVal;
 778 }
 779
 780
 781 DWORD STDCALL NtGdiDdAddAttachedSurface(
 782     HANDLE hSurface,
 783     HANDLE hSurfaceAttached,
 784     PDD_ADDATTACHEDSURFACEDATA puAddAttachedSurfaceData
 785 )
 786 {
 787         DWORD  ddRVal;
 788         PDD_DIRECTDRAW_GLOBAL lgpl;
 789
 790         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurfaceAttached, GDI_OBJECT_TYPE_DIRECTDRAW);
 791 #ifdef DX_DEBUG
 792         DPRINT1("NtGdiDdAddAttachedSurface\n");
 793 #endif
 794         if (pDirectDraw == NULL)
 795                 return DDHAL_DRIVER_NOTHANDLED;
 796
 797         /* backup the orignal PDev and info */
 798         lgpl = puAddAttachedSurfaceData->lpDD;
 799
 800         /* use our cache version instead */
 801         puAddAttachedSurfaceData->lpDD = &pDirectDraw->Global;
 802
 803         /* make the call */
 804         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_ADDATTACHEDSURFACE))
 805                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 806         else
 807         ddRVal = pDirectDraw->Surf.AddAttachedSurface(puAddAttachedSurfaceData);
 808
 809         /* But back the orignal PDev */
 810         puAddAttachedSurfaceData->lpDD = lgpl;
 811
 812     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 813     return ddRVal;
 814 }
 815
 816 DWORD STDCALL NtGdiDdGetBltStatus(
 817     HANDLE hSurface,
 818     PDD_GETBLTSTATUSDATA puGetBltStatusData
 819 )
 820 {
 821         DWORD  ddRVal;
 822         PDD_DIRECTDRAW_GLOBAL lgpl;
 823
 824         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
 825 #ifdef DX_DEBUG
 826         DPRINT1("NtGdiDdGetBltStatus\n");
 827 #endif
 828         if (pDirectDraw == NULL)
 829                 return DDHAL_DRIVER_NOTHANDLED;
 830
 831         /* backup the orignal PDev and info */
 832         lgpl = puGetBltStatusData->lpDD;
 833
 834         /* use our cache version instead */
 835         puGetBltStatusData->lpDD = &pDirectDraw->Global;
 836
 837         /* make the call */
 838         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_GETBLTSTATUS))
 839                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 840         else
 841         ddRVal = pDirectDraw->Surf.GetBltStatus(puGetBltStatusData);
 842
 843         /* But back the orignal PDev */
 844         puGetBltStatusData->lpDD = lgpl;
 845
 846     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 847     return ddRVal;
 848 }
 849
 850 DWORD STDCALL NtGdiDdGetFlipStatus(
 851     HANDLE hSurface,
 852     PDD_GETFLIPSTATUSDATA puGetFlipStatusData
 853 )
 854 {
 855     DWORD  ddRVal;
 856         PDD_DIRECTDRAW_GLOBAL lgpl;
 857
 858         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
 859 #ifdef DX_DEBUG
 860         DPRINT1("NtGdiDdGetFlipStatus\n");
 861 #endif
 862         if (pDirectDraw == NULL)
 863                 return DDHAL_DRIVER_NOTHANDLED;
 864
 865         /* backup the orignal PDev and info */
 866         lgpl = puGetFlipStatusData->lpDD;
 867
 868         /* use our cache version instead */
 869         puGetFlipStatusData->lpDD = &pDirectDraw->Global;
 870
 871         /* make the call */
 872         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_GETFLIPSTATUS))
 873                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 874         else
 875         ddRVal = pDirectDraw->Surf.GetFlipStatus(puGetFlipStatusData);
 876
 877         /* But back the orignal PDev */
 878         puGetFlipStatusData->lpDD = lgpl;
 879
 880     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 881     return ddRVal;
 882 }
 883
 884 DWORD STDCALL NtGdiDdUpdateOverlay(
 885     HANDLE hSurfaceDestination,
 886     HANDLE hSurfaceSource,
 887     PDD_UPDATEOVERLAYDATA puUpdateOverlayData
 888 )
 889 {
 890         DWORD  ddRVal;
 891         PDD_DIRECTDRAW_GLOBAL lgpl;
 892
 893     PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurfaceDestination, GDI_OBJECT_TYPE_DIRECTDRAW);
 894 #ifdef DX_DEBUG
 895     DPRINT1("NtGdiDdUpdateOverlay\n");
 896 #endif
 897         if (pDirectDraw == NULL)
 898                 return DDHAL_DRIVER_NOTHANDLED;
 899
 900         /* backup the orignal PDev and info */
 901         lgpl = puUpdateOverlayData->lpDD;
 902
 903         /* use our cache version instead */
 904         puUpdateOverlayData->lpDD = &pDirectDraw->Global;
 905
 906         /* make the call */
 907         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_UPDATEOVERLAY))
 908                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 909         else
 910         ddRVal = pDirectDraw->Surf.UpdateOverlay(puUpdateOverlayData);
 911
 912         /* But back the orignal PDev */
 913         puUpdateOverlayData->lpDD = lgpl;
 914
 915     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 916     return ddRVal;
 917 }
 918
 919 DWORD STDCALL NtGdiDdSetOverlayPosition(
 920     HANDLE hSurfaceSource,
 921     HANDLE hSurfaceDestination,
 922     PDD_SETOVERLAYPOSITIONDATA puSetOverlayPositionData
 923 )
 924 {
 925         DWORD  ddRVal;
 926         PDD_DIRECTDRAW_GLOBAL lgpl;
 927
 928     PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurfaceDestination, GDI_OBJECT_TYPE_DIRECTDRAW);
 929 #ifdef DX_DEBUG
 930     DPRINT1("NtGdiDdSetOverlayPosition\n");
 931 #endif
 932         if (pDirectDraw == NULL)
 933                 return DDHAL_DRIVER_NOTHANDLED;
 934
 935         /* backup the orignal PDev and info */
 936         lgpl = puSetOverlayPositionData->lpDD;
 937
 938         /* use our cache version instead */
 939         puSetOverlayPositionData->lpDD = &pDirectDraw->Global;
 940
 941         /* make the call */
 942         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_SETOVERLAYPOSITION))
 943                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 944         else
 945         ddRVal = pDirectDraw->Surf.SetOverlayPosition(puSetOverlayPositionData);
 946
 947         /* But back the orignal PDev */
 948         puSetOverlayPositionData->lpDD = lgpl;
 949
 950     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 951     return ddRVal;
 952 }
 953
 954
 955 /************************************************************************/
 956 /* SURFACE OBJECT                                                       */
 957 /************************************************************************/
 958
 959 BOOL INTERNAL_CALL
 960 DDSURF_Cleanup(PVOID pDDSurf)
 961 {
 962         /* FIXME: implement
 963          * PDD_SURFACE pDDSurf = PVOID pDDSurf
 964          */
 965 #ifdef DX_DEBUG
 966     DPRINT1("DDSURF_Cleanup\n");
 967 #endif
 968         return TRUE;
 969 }
 970
 971 HANDLE STDCALL NtGdiDdCreateSurfaceObject(
 972     HANDLE hDirectDrawLocal,
 973     HANDLE hSurface,
 974     PDD_SURFACE_LOCAL puSurfaceLocal,
 975     PDD_SURFACE_MORE puSurfaceMore,
 976     PDD_SURFACE_GLOBAL puSurfaceGlobal,
 977     BOOL bComplete
 978 )
 979 {
 980         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
 981 #ifdef DX_DEBUG
 982         DPRINT1("NtGdiDdCreateSurfaceObject\n");
 983 #endif
 984         if (!pDirectDraw)
 985                 return NULL;
 986
 987         if (!hSurface)
 988                 hSurface = GDIOBJ_AllocObj(GDI_OBJECT_TYPE_DD_SURFACE);
 989
 990         PDD_SURFACE pSurface = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DD_SURFACE);
 991         /* FIXME - Handle pSurface == NULL!!!! */
 992
 993         RtlMoveMemory(&pSurface->Local, puSurfaceLocal, sizeof(DD_SURFACE_LOCAL));
 994         RtlMoveMemory(&pSurface->More, puSurfaceMore, sizeof(DD_SURFACE_MORE));
 995         RtlMoveMemory(&pSurface->Global, puSurfaceGlobal, sizeof(DD_SURFACE_GLOBAL));
 996         pSurface->Local.lpGbl = &pSurface->Global;
 997         pSurface->Local.lpSurfMore = &pSurface->More;
 998         pSurface->Local.lpAttachList = NULL;
 999         pSurface->Local.lpAttachListFrom = NULL;
1000         pSurface->More.lpVideoPort = NULL;
1001         // FIXME: figure out how to use this
1002         pSurface->bComplete = bComplete;
1003
1004         GDIOBJ_UnlockObjByPtr(pSurface);
1005         GDIOBJ_UnlockObjByPtr(pDirectDraw);
1006
1007         return hSurface;
1008 }
1009
1010 BOOL STDCALL NtGdiDdDeleteSurfaceObject(
1011     HANDLE hSurface
1012 )
1013 {
1014 #ifdef DX_DEBUG
1015     DPRINT1("NtGdiDdDeleteSurfaceObject\n");
1016 #endif
1017     /* FIXME add right GDI_OBJECT_TYPE_ for everthing for now
1018        we are using same type */
1019         /* return GDIOBJ_FreeObj(hSurface, GDI_OBJECT_TYPE_DD_SURFACE); */
1020         return GDIOBJ_FreeObj(hSurface, GDI_OBJECT_TYPE_DD_SURFACE);
1021
1022 }
1023
1024
1025
1026 /************************************************************************/
1027 /* DIRECT DRAW SURFACR END                                                   */
1028 /************************************************************************/
1029
1030
1031 /*
1032 BOOL STDCALL NtGdiDdAttachSurface(
1033     HANDLE hSurfaceFrom,
1034     HANDLE hSurfaceTo
1035 )
1036 {
1037         PDD_SURFACE pSurfaceFrom = GDIOBJ_LockObj(hSurfaceFrom, GDI_OBJECT_TYPE_DD_SURFACE);
1038         if (!pSurfaceFrom)
1039                 return FALSE;
1040         PDD_SURFACE pSurfaceTo = GDIOBJ_LockObj(hSurfaceTo, GDI_OBJECT_TYPE_DD_SURFACE);
1041         if (!pSurfaceTo)
1042         {
1043                 GDIOBJ_UnlockObjByPtr(pSurfaceFrom);
1044                 return FALSE;
1045         }
1046
1047         if (pSurfaceFrom->Local.lpAttachListFrom)
1048         {
1049                 pSurfaceFrom->Local.lpAttachListFrom = pSurfaceFrom->AttachListFrom;
1050         }
1051
1052         GDIOBJ_UnlockObjByPtr(pSurfaceFrom);
1053         GDIOBJ_UnlockObjByPtr(pSurfaceTo);
1054         return TRUE;
1055 }
1056 */
1057
1058 DWORD STDCALL NtGdiDdGetAvailDriverMemory(
1059     HANDLE hDirectDrawLocal,
1060     PDD_GETAVAILDRIVERMEMORYDATA puGetAvailDriverMemoryData
1061 )
1062 {
1063         DWORD  ddRVal = DDHAL_DRIVER_NOTHANDLED;
1064         PDD_DIRECTDRAW_GLOBAL lgpl;
1065
1066         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
1067 #ifdef DX_DEBUG
1068         DPRINT1("NtGdiDdGetAvailDriverMemory\n");
1069 #endif
1070
1071         /* backup the orignal PDev and info */
1072         lgpl = puGetAvailDriverMemoryData->lpDD;
1073
1074         /* use our cache version instead */
1075         puGetAvailDriverMemoryData->lpDD = &pDirectDraw->Global;
1076
1077         /* make the call */
1078    // ddRVal = pDirectDraw->DdGetAvailDriverMemory(puGetAvailDriverMemoryData);
1079
1080         GDIOBJ_UnlockObjByPtr(pDirectDraw);
1081
1082
1083         /* But back the orignal PDev */
1084         puGetAvailDriverMemoryData->lpDD = lgpl;
1085
1086         return ddRVal;
1087 }
1088
1089
1090
1091
1092 DWORD STDCALL NtGdiDdSetExclusiveMode(
1093     HANDLE hDirectDraw,
1094     PDD_SETEXCLUSIVEMODEDATA puSetExclusiveModeData
1095 )
1096 {
1097         DWORD  ddRVal;
1098         PDD_DIRECTDRAW_GLOBAL lgpl;
1099
1100         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDraw, GDI_OBJECT_TYPE_DIRECTDRAW);
1101
1102 #ifdef DX_DEBUG
1103         DPRINT1("NtGdiDdSetExclusiveMode\n");
1104 #endif
1105
1106         /* backup the orignal PDev and info */
1107         lgpl = puSetExclusiveModeData->lpDD;
1108
1109         /* use our cache version instead */
1110         puSetExclusiveModeData->lpDD = &pDirectDraw->Global;
1111
1112         /* make the call */
1113     ddRVal = pDirectDraw->DdSetExclusiveMode(puSetExclusiveModeData);
1114
1115     GDIOBJ_UnlockObjByPtr(pDirectDraw);
1116
1117         /* But back the orignal PDev */
1118         puSetExclusiveModeData->lpDD = lgpl;
1119
1120         return ddRVal;
1121 }
1122
1123
1124
1125
1126 /* EOF */