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 /************************************************************************/
  17 /* DIRECT DRAW OBJECT                                                   */
  18 /************************************************************************/
  19
  20 BOOL INTERNAL_CALL
  21 DD_Cleanup(PVOID ObjectBody)
  22 {
  23         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(ObjectBody, GDI_OBJECT_TYPE_DIRECTDRAW);
  24         if (!pDirectDraw)
  25                 return FALSE;
  26
  27         pDirectDraw->DrvDisableDirectDraw(pDirectDraw->Global.dhpdev);
  28
  29         GDIOBJ_UnlockObjByPtr(pDirectDraw);
  30         return TRUE;
  31 }
  32
  33 HANDLE STDCALL NtGdiDdCreateDirectDrawObject(
  34     HDC hdc
  35 )
  36 {
  37         DD_CALLBACKS callbacks;
  38         DD_SURFACECALLBACKS surface_callbacks;
  39         DD_PALETTECALLBACKS palette_callbacks;
  40
  41         RtlZeroMemory(&callbacks, sizeof(DD_CALLBACKS));
  42         callbacks.dwSize = sizeof(DD_CALLBACKS);
  43         RtlZeroMemory(&surface_callbacks, sizeof(DD_SURFACECALLBACKS));
  44         surface_callbacks.dwSize = sizeof(DD_SURFACECALLBACKS);
  45         RtlZeroMemory(&palette_callbacks, sizeof(DD_PALETTECALLBACKS));
  46         palette_callbacks.dwSize = sizeof(DD_PALETTECALLBACKS);
  47
  48
  49         DC *pDC = DC_LockDc(hdc);
  50         if (!pDC)
  51                 return NULL;
  52
  53         if (!pDC->DriverFunctions.EnableDirectDraw)
  54         {
  55                 // Driver doesn't support DirectDraw
  56                 DC_UnlockDc(pDC);
  57                 return NULL;
  58         }
  59
  60         BOOL success = pDC->DriverFunctions.EnableDirectDraw(
  61                 pDC->PDev, &callbacks, &surface_callbacks, &palette_callbacks);
  62
  63         if (!success)
  64         {
  65                 // DirectDraw creation failed
  66                 DC_UnlockDc(pDC);
  67                 return NULL;
  68         }
  69
  70         HANDLE hDirectDraw = GDIOBJ_AllocObj(GDI_OBJECT_TYPE_DIRECTDRAW);
  71         if (!hDirectDraw)
  72         {
  73                 /* No more memmory */
  74                 DC_UnlockDc(pDC);
  75                 return NULL;
  76         }
  77
  78         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDraw, GDI_OBJECT_TYPE_DIRECTDRAW);
  79         if (!pDirectDraw)
  80         {
  81                 /* invalid handle */
  82                 DC_UnlockDc(pDC);
  83                 return NULL;
  84         }
  85
  86
  87         pDirectDraw->Global.dhpdev = pDC->PDev;
  88         pDirectDraw->Local.lpGbl = &pDirectDraw->Global;
  89
  90         pDirectDraw->DrvGetDirectDrawInfo = pDC->DriverFunctions.GetDirectDrawInfo;
  91         pDirectDraw->DrvDisableDirectDraw = pDC->DriverFunctions.DisableDirectDraw;
  92
  93     /* DD_CALLBACKS setup */
  94         RtlMoveMemory(&pDirectDraw->DD, &callbacks, sizeof(DD_CALLBACKS));
  95
  96         /* DD_SURFACECALLBACKS  setup*/
  97         RtlMoveMemory(&pDirectDraw->Surf, &surface_callbacks, sizeof(DD_SURFACECALLBACKS));
  98
  99         /* DD_PALETTECALLBACKS setup*/
 100         RtlMoveMemory(&pDirectDraw->Pal, &surface_callbacks, sizeof(DD_PALETTECALLBACKS));
 101
 102         GDIOBJ_UnlockObjByPtr(pDirectDraw);
 103         DC_UnlockDc(pDC);
 104
 105         return hDirectDraw;
 106 }
 107
 108 BOOL STDCALL NtGdiDdDeleteDirectDrawObject(
 109     HANDLE hDirectDrawLocal
 110 )
 111 {
 112         return GDIOBJ_FreeObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
 113 }
 114
 115 BOOL STDCALL NtGdiDdQueryDirectDrawObject(
 116     HANDLE hDirectDrawLocal,
 117     DD_HALINFO *pHalInfo,
 118     DWORD *pCallBackFlags,
 119     PD3DNTHAL_CALLBACKS puD3dCallbacks,
 120     PD3DNTHAL_GLOBALDRIVERDATA puD3dDriverData,
 121     PDD_D3DBUFCALLBACKS puD3dBufferCallbacks,
 122     LPDDSURFACEDESC puD3dTextureFormats,
 123     DWORD *puNumHeaps,
 124     VIDEOMEMORY *puvmList,
 125     DWORD *puNumFourCC,
 126     DWORD *puFourCC
 127 )
 128 {
 129         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
 130         if (!pDirectDraw)
 131                 return FALSE;
 132
 133         BOOL success = pDirectDraw->DrvGetDirectDrawInfo(
 134                 pDirectDraw->Global.dhpdev,
 135                 pHalInfo,
 136                 puNumHeaps,
 137                 puvmList,
 138                 puNumFourCC,
 139                 puFourCC);
 140
 141         if (!success)
 142         {
 143                 GDIOBJ_UnlockObjByPtr(pDirectDraw);
 144                 return FALSE;
 145         }
 146
 147         if (pHalInfo)
 148         {
 149        RtlMoveMemory(&pDirectDraw->Hal, pHalInfo, sizeof(DD_HALINFO));
 150
 151            if (pHalInfo->lpD3DHALCallbacks)
 152            {
 153                  RtlMoveMemory(puD3dCallbacks, pHalInfo->lpD3DHALCallbacks, sizeof(D3DNTHAL_CALLBACKS));
 154            }
 155
 156            if (pHalInfo->lpD3DGlobalDriverData)
 157            {
 158                  RtlMoveMemory(puD3dDriverData, pHalInfo->lpD3DGlobalDriverData, sizeof(D3DNTHAL_GLOBALDRIVERDATA));
 159            }
 160            if (pHalInfo->lpD3DBufCallbacks)
 161            {
 162                  RtlMoveMemory(puD3dBufferCallbacks, pHalInfo->lpD3DBufCallbacks, sizeof(DD_D3DBUFCALLBACKS));
 163            }
 164
 165          }
 166
 167         GDIOBJ_UnlockObjByPtr(pDirectDraw);
 168
 169         return TRUE;
 170 }
 171
 172
 173 DWORD STDCALL NtGdiDdGetDriverInfo(
 174     HANDLE hDirectDrawLocal,
 175     PDD_GETDRIVERINFODATA puGetDriverInfoData)
 176
 177 {
 178         DWORD  ddRVal;
 179
 180         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
 181         if (pDirectDraw == NULL)
 182                 return DDHAL_DRIVER_NOTHANDLED;
 183
 184         if   (!(pDirectDraw->Hal.dwFlags & DDHALINFO_GETDRIVERINFOSET))
 185              ddRVal = DDHAL_DRIVER_NOTHANDLED;
 186         else
 187              ddRVal = pDirectDraw->Hal.GetDriverInfo(puGetDriverInfoData);
 188
 189     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 190
 191         return ddRVal;
 192 }
 193
 194 /************************************************************************/
 195 /* DD CALLBACKS                                                         */
 196 /* FIXME NtGdiDdCreateSurface we do not call to ddCreateSurface         */
 197 /************************************************************************/
 198
 199 DWORD STDCALL NtGdiDdCreateSurface(
 200     HANDLE hDirectDrawLocal,
 201     HANDLE *hSurface,
 202     DDSURFACEDESC *puSurfaceDescription,
 203     DD_SURFACE_GLOBAL *puSurfaceGlobalData,
 204     DD_SURFACE_LOCAL *puSurfaceLocalData,
 205     DD_SURFACE_MORE *puSurfaceMoreData,
 206     PDD_CREATESURFACEDATA puCreateSurfaceData,
 207     HANDLE *puhSurface
 208 )
 209 {
 210         DWORD  ddRVal = DDHAL_DRIVER_NOTHANDLED;
 211         PDD_DIRECTDRAW_GLOBAL lgpl;
 212
 213         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
 214         if (pDirectDraw == NULL)
 215                 return DDHAL_DRIVER_NOTHANDLED;
 216
 217         /* backup the orignal PDev and info */
 218         lgpl = puCreateSurfaceData->lpDD;
 219
 220         /* use our cache version instead */
 221         puCreateSurfaceData->lpDD = &pDirectDraw->Global;
 222
 223         /* make the call */
 224         if (!(pDirectDraw->DD.dwFlags & DDHAL_CB32_CANCREATESURFACE))
 225                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 226         else
 227         {
 228            ddRVal = pDirectDraw->DD.CreateSurface(puCreateSurfaceData);
 229         }
 230
 231         /* But back the orignal PDev */
 232         puCreateSurfaceData->lpDD = lgpl;
 233
 234         GDIOBJ_UnlockObjByPtr(pDirectDraw);
 235         return ddRVal;
 236 }
 237
 238 DWORD STDCALL NtGdiDdWaitForVerticalBlank(
 239     HANDLE hDirectDrawLocal,
 240     PDD_WAITFORVERTICALBLANKDATA puWaitForVerticalBlankData
 241 )
 242 {
 243         DWORD  ddRVal;
 244         PDD_DIRECTDRAW_GLOBAL lgpl;
 245
 246         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
 247         if (pDirectDraw == NULL)
 248                 return DDHAL_DRIVER_NOTHANDLED;
 249
 250         /* backup the orignal PDev and info */
 251         lgpl = puWaitForVerticalBlankData->lpDD;
 252
 253         /* use our cache version instead */
 254         puWaitForVerticalBlankData->lpDD = &pDirectDraw->Global;
 255
 256         /* make the call */
 257         if (!(pDirectDraw->DD.dwFlags & DDHAL_CB32_WAITFORVERTICALBLANK))
 258                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 259         else
 260             ddRVal = pDirectDraw->DD.WaitForVerticalBlank(puWaitForVerticalBlankData);
 261
 262         /* But back the orignal PDev */
 263         puWaitForVerticalBlankData->lpDD = lgpl;
 264
 265     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 266         return ddRVal;
 267 }
 268
 269 DWORD STDCALL NtGdiDdCanCreateSurface(
 270     HANDLE hDirectDrawLocal,
 271     PDD_CANCREATESURFACEDATA puCanCreateSurfaceData
 272 )
 273 {
 274         DWORD  ddRVal;
 275         PDD_DIRECTDRAW_GLOBAL lgpl;
 276
 277         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
 278         if (pDirectDraw == NULL)
 279                 return DDHAL_DRIVER_NOTHANDLED;
 280
 281         /* backup the orignal PDev and info */
 282         lgpl = puCanCreateSurfaceData->lpDD;
 283
 284         /* use our cache version instead */
 285         puCanCreateSurfaceData->lpDD = &pDirectDraw->Global;
 286
 287         /* make the call */
 288         if (!(pDirectDraw->DD.dwFlags & DDHAL_CB32_CANCREATESURFACE))
 289                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 290         else
 291             ddRVal = pDirectDraw->DD.CanCreateSurface(puCanCreateSurfaceData);
 292
 293         /* But back the orignal PDev */
 294         puCanCreateSurfaceData->lpDD = lgpl;
 295
 296         GDIOBJ_UnlockObjByPtr(pDirectDraw);
 297         return ddRVal;
 298 }
 299
 300 DWORD STDCALL NtGdiDdGetScanLine(
 301     HANDLE hDirectDrawLocal,
 302     PDD_GETSCANLINEDATA puGetScanLineData
 303 )
 304 {
 305         DWORD  ddRVal;
 306         PDD_DIRECTDRAW_GLOBAL lgpl;
 307
 308         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
 309         if (pDirectDraw == NULL)
 310                 return DDHAL_DRIVER_NOTHANDLED;
 311
 312         /* backup the orignal PDev and info */
 313         lgpl = puGetScanLineData->lpDD;
 314
 315         /* use our cache version instead */
 316         puGetScanLineData->lpDD = &pDirectDraw->Global;
 317
 318         /* make the call */
 319         if (!(pDirectDraw->DD.dwFlags & DDHAL_CB32_GETSCANLINE))
 320                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 321         else
 322             ddRVal = pDirectDraw->DD.GetScanLine(puGetScanLineData);
 323
 324         /* But back the orignal PDev */
 325         puGetScanLineData->lpDD = lgpl;
 326
 327         GDIOBJ_UnlockObjByPtr(pDirectDraw);
 328         return ddRVal;
 329 }
 330
 331
 332
 333 /************************************************************************/
 334 /* Surface CALLBACKS                                                    */
 335 /* FIXME                                                                */
 336 /* NtGdiDdDestroySurface                                                */
 337 /************************************************************************/
 338
 339 DWORD STDCALL NtGdiDdDestroySurface(
 340     HANDLE hSurface,
 341     BOOL bRealDestroy
 342 )
 343 {
 344         DWORD  ddRVal  = DDHAL_DRIVER_NOTHANDLED;
 345
 346         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
 347         if (pDirectDraw == NULL)
 348                 return DDHAL_DRIVER_NOTHANDLED;
 349
 350         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_DESTROYSURFACE))
 351                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 352         else
 353         {
 354                 DD_DESTROYSURFACEDATA DestroySurf;
 355
 356                 /* FIXME
 357                  * bRealDestroy
 358                  * are we doing right ??
 359                  */
 360         DestroySurf.lpDD =  &pDirectDraw->Global;
 361
 362         DestroySurf.lpDDSurface = hSurface;  // ?
 363         DestroySurf.DestroySurface = pDirectDraw->Surf.DestroySurface;
 364
 365         ddRVal = pDirectDraw->Surf.DestroySurface(&DestroySurf);
 366         }
 367
 368
 369     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 370     return ddRVal;
 371 }
 372
 373 DWORD STDCALL NtGdiDdFlip(
 374     HANDLE hSurfaceCurrent,
 375     HANDLE hSurfaceTarget,
 376     HANDLE hSurfaceCurrentLeft,
 377     HANDLE hSurfaceTargetLeft,
 378     PDD_FLIPDATA puFlipData
 379 )
 380 {
 381         DWORD  ddRVal;
 382         PDD_DIRECTDRAW_GLOBAL lgpl;
 383
 384         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurfaceTarget, GDI_OBJECT_TYPE_DIRECTDRAW);
 385         if (pDirectDraw == NULL)
 386                 return DDHAL_DRIVER_NOTHANDLED;
 387
 388         /* backup the orignal PDev and info */
 389         lgpl = puFlipData->lpDD;
 390
 391         /* use our cache version instead */
 392         puFlipData->lpDD = &pDirectDraw->Global;
 393
 394         /* make the call */
 395         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_FLIP))
 396                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 397         else
 398         ddRVal = pDirectDraw->Surf.Flip(puFlipData);
 399
 400         /* But back the orignal PDev */
 401         puFlipData->lpDD = lgpl;
 402
 403     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 404     return ddRVal;
 405 }
 406
 407 DWORD STDCALL NtGdiDdLock(
 408     HANDLE hSurface,
 409     PDD_LOCKDATA puLockData,
 410     HDC hdcClip
 411 )
 412 {
 413         DWORD  ddRVal;
 414         PDD_DIRECTDRAW_GLOBAL lgpl;
 415
 416         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
 417         if (pDirectDraw == NULL)
 418                 return DDHAL_DRIVER_NOTHANDLED;
 419
 420         /* backup the orignal PDev and info */
 421         lgpl = puLockData->lpDD;
 422
 423         /* use our cache version instead */
 424         puLockData->lpDD = &pDirectDraw->Global;
 425
 426         /* make the call */
 427         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_LOCK))
 428                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 429         else
 430         ddRVal = pDirectDraw->Surf.Lock(puLockData);
 431
 432         /* But back the orignal PDev */
 433         puLockData->lpDD = lgpl;
 434
 435     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 436     return ddRVal;
 437 }
 438
 439 DWORD STDCALL NtGdiDdUnlock(
 440     HANDLE hSurface,
 441     PDD_UNLOCKDATA puUnlockData
 442 )
 443 {
 444         DWORD  ddRVal;
 445         PDD_DIRECTDRAW_GLOBAL lgpl;
 446
 447         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
 448         if (pDirectDraw == NULL)
 449                 return DDHAL_DRIVER_NOTHANDLED;
 450
 451         /* backup the orignal PDev and info */
 452         lgpl = puUnlockData->lpDD;
 453
 454         /* use our cache version instead */
 455         puUnlockData->lpDD = &pDirectDraw->Global;
 456
 457         /* make the call */
 458         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_UNLOCK))
 459                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 460         else
 461         ddRVal = pDirectDraw->Surf.Unlock(puUnlockData);
 462
 463         /* But back the orignal PDev */
 464         puUnlockData->lpDD = lgpl;
 465
 466     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 467         return ddRVal;
 468 }
 469
 470 DWORD STDCALL NtGdiDdBlt(
 471     HANDLE hSurfaceDest,
 472     HANDLE hSurfaceSrc,
 473     PDD_BLTDATA puBltData
 474 )
 475 {
 476     DWORD  ddRVal;
 477         PDD_DIRECTDRAW_GLOBAL lgpl;
 478
 479     PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurfaceDest, GDI_OBJECT_TYPE_DIRECTDRAW);
 480         if (pDirectDraw == NULL)
 481                 return DDHAL_DRIVER_NOTHANDLED;
 482
 483         /* backup the orignal PDev and info */
 484         lgpl = puBltData->lpDD;
 485
 486         /* use our cache version instead */
 487         puBltData->lpDD = &pDirectDraw->Global;
 488
 489         /* make the call */
 490         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_BLT))
 491                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 492         else
 493         ddRVal = pDirectDraw->Surf.Blt(puBltData);
 494
 495         /* But back the orignal PDev */
 496         puBltData->lpDD = lgpl;
 497
 498     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 499     return ddRVal;
 500    }
 501
 502 DWORD STDCALL NtGdiDdSetColorKey(
 503     HANDLE hSurface,
 504     PDD_SETCOLORKEYDATA puSetColorKeyData
 505 )
 506 {
 507         DWORD  ddRVal;
 508         PDD_DIRECTDRAW_GLOBAL lgpl;
 509
 510         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
 511         if (pDirectDraw == NULL)
 512                 return DDHAL_DRIVER_NOTHANDLED;
 513
 514         /* backup the orignal PDev and info */
 515         lgpl = puSetColorKeyData->lpDD;
 516
 517         /* use our cache version instead */
 518         puSetColorKeyData->lpDD = &pDirectDraw->Global;
 519
 520         /* make the call */
 521         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_SETCOLORKEY))
 522                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 523         else
 524         ddRVal = pDirectDraw->Surf.SetColorKey(puSetColorKeyData);
 525
 526         /* But back the orignal PDev */
 527         puSetColorKeyData->lpDD = lgpl;
 528
 529     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 530     return ddRVal;
 531 }
 532
 533
 534 DWORD STDCALL NtGdiDdAddAttachedSurface(
 535     HANDLE hSurface,
 536     HANDLE hSurfaceAttached,
 537     PDD_ADDATTACHEDSURFACEDATA puAddAttachedSurfaceData
 538 )
 539 {
 540         DWORD  ddRVal;
 541         PDD_DIRECTDRAW_GLOBAL lgpl;
 542
 543         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurfaceAttached, GDI_OBJECT_TYPE_DIRECTDRAW);
 544         if (pDirectDraw == NULL)
 545                 return DDHAL_DRIVER_NOTHANDLED;
 546
 547         /* backup the orignal PDev and info */
 548         lgpl = puAddAttachedSurfaceData->lpDD;
 549
 550         /* use our cache version instead */
 551         puAddAttachedSurfaceData->lpDD = &pDirectDraw->Global;
 552
 553         /* make the call */
 554         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_ADDATTACHEDSURFACE))
 555                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 556         else
 557         ddRVal = pDirectDraw->Surf.AddAttachedSurface(puAddAttachedSurfaceData);
 558
 559         /* But back the orignal PDev */
 560         puAddAttachedSurfaceData->lpDD = lgpl;
 561
 562     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 563     return ddRVal;
 564 }
 565
 566 DWORD STDCALL NtGdiDdGetBltStatus(
 567     HANDLE hSurface,
 568     PDD_GETBLTSTATUSDATA puGetBltStatusData
 569 )
 570 {
 571         DWORD  ddRVal;
 572         PDD_DIRECTDRAW_GLOBAL lgpl;
 573
 574         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
 575         if (pDirectDraw == NULL)
 576                 return DDHAL_DRIVER_NOTHANDLED;
 577
 578         /* backup the orignal PDev and info */
 579         lgpl = puGetBltStatusData->lpDD;
 580
 581         /* use our cache version instead */
 582         puGetBltStatusData->lpDD = &pDirectDraw->Global;
 583
 584         /* make the call */
 585         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_GETBLTSTATUS))
 586                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 587         else
 588         ddRVal = pDirectDraw->Surf.GetBltStatus(puGetBltStatusData);
 589
 590         /* But back the orignal PDev */
 591         puGetBltStatusData->lpDD = lgpl;
 592
 593     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 594     return ddRVal;
 595 }
 596
 597 DWORD STDCALL NtGdiDdGetFlipStatus(
 598     HANDLE hSurface,
 599     PDD_GETFLIPSTATUSDATA puGetFlipStatusData
 600 )
 601 {
 602     DWORD  ddRVal;
 603         PDD_DIRECTDRAW_GLOBAL lgpl;
 604
 605         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
 606         if (pDirectDraw == NULL)
 607                 return DDHAL_DRIVER_NOTHANDLED;
 608
 609         /* backup the orignal PDev and info */
 610         lgpl = puGetFlipStatusData->lpDD;
 611
 612         /* use our cache version instead */
 613         puGetFlipStatusData->lpDD = &pDirectDraw->Global;
 614
 615         /* make the call */
 616         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_GETFLIPSTATUS))
 617                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 618         else
 619         ddRVal = pDirectDraw->Surf.GetFlipStatus(puGetFlipStatusData);
 620
 621         /* But back the orignal PDev */
 622         puGetFlipStatusData->lpDD = lgpl;
 623
 624     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 625     return ddRVal;
 626 }
 627
 628 DWORD STDCALL NtGdiDdUpdateOverlay(
 629     HANDLE hSurfaceDestination,
 630     HANDLE hSurfaceSource,
 631     PDD_UPDATEOVERLAYDATA puUpdateOverlayData
 632 )
 633 {
 634         DWORD  ddRVal;
 635         PDD_DIRECTDRAW_GLOBAL lgpl;
 636
 637     PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurfaceDestination, GDI_OBJECT_TYPE_DIRECTDRAW);
 638         if (pDirectDraw == NULL)
 639                 return DDHAL_DRIVER_NOTHANDLED;
 640
 641         /* backup the orignal PDev and info */
 642         lgpl = puUpdateOverlayData->lpDD;
 643
 644         /* use our cache version instead */
 645         puUpdateOverlayData->lpDD = &pDirectDraw->Global;
 646
 647         /* make the call */
 648         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_UPDATEOVERLAY))
 649                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 650         else
 651         ddRVal = pDirectDraw->Surf.UpdateOverlay(puUpdateOverlayData);
 652
 653         /* But back the orignal PDev */
 654         puUpdateOverlayData->lpDD = lgpl;
 655
 656     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 657     return ddRVal;
 658 }
 659
 660 DWORD STDCALL NtGdiDdSetOverlayPosition(
 661     HANDLE hSurfaceSource,
 662     HANDLE hSurfaceDestination,
 663     PDD_SETOVERLAYPOSITIONDATA puSetOverlayPositionData
 664 )
 665 {
 666         DWORD  ddRVal;
 667         PDD_DIRECTDRAW_GLOBAL lgpl;
 668
 669     PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurfaceDestination, GDI_OBJECT_TYPE_DIRECTDRAW);
 670         if (pDirectDraw == NULL)
 671                 return DDHAL_DRIVER_NOTHANDLED;
 672
 673         /* backup the orignal PDev and info */
 674         lgpl = puSetOverlayPositionData->lpDD;
 675
 676         /* use our cache version instead */
 677         puSetOverlayPositionData->lpDD = &pDirectDraw->Global;
 678
 679         /* make the call */
 680         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_SETOVERLAYPOSITION))
 681                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 682         else
 683         ddRVal = pDirectDraw->Surf.SetOverlayPosition(puSetOverlayPositionData);
 684
 685         /* But back the orignal PDev */
 686         puSetOverlayPositionData->lpDD = lgpl;
 687
 688     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 689     return ddRVal;
 690 }
 691
 692
 693 /************************************************************************/
 694 /* SURFACE OBJECT                                                       */
 695 /************************************************************************/
 696
 697 BOOL INTERNAL_CALL
 698 DDSURF_Cleanup(PVOID pDDSurf)
 699 {
 700         /* FIXME: implement
 701          * PDD_SURFACE pDDSurf = PVOID pDDSurf
 702          */
 703         return TRUE;
 704 }
 705
 706 HANDLE STDCALL NtGdiDdCreateSurfaceObject(
 707     HANDLE hDirectDrawLocal,
 708     HANDLE hSurface,
 709     PDD_SURFACE_LOCAL puSurfaceLocal,
 710     PDD_SURFACE_MORE puSurfaceMore,
 711     PDD_SURFACE_GLOBAL puSurfaceGlobal,
 712     BOOL bComplete
 713 )
 714 {
 715         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
 716         if (!pDirectDraw)
 717                 return NULL;
 718
 719         if (!hSurface)
 720                 hSurface = GDIOBJ_AllocObj(GDI_OBJECT_TYPE_DD_SURFACE);
 721
 722         PDD_SURFACE pSurface = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DD_SURFACE);
 723         /* FIXME - Handle pSurface == NULL!!!! */
 724
 725         RtlMoveMemory(&pSurface->Local, puSurfaceLocal, sizeof(DD_SURFACE_LOCAL));
 726         RtlMoveMemory(&pSurface->More, puSurfaceMore, sizeof(DD_SURFACE_MORE));
 727         RtlMoveMemory(&pSurface->Global, puSurfaceGlobal, sizeof(DD_SURFACE_GLOBAL));
 728         pSurface->Local.lpGbl = &pSurface->Global;
 729         pSurface->Local.lpSurfMore = &pSurface->More;
 730         pSurface->Local.lpAttachList = NULL;
 731         pSurface->Local.lpAttachListFrom = NULL;
 732         pSurface->More.lpVideoPort = NULL;
 733         // FIXME: figure out how to use this
 734         pSurface->bComplete = bComplete;
 735
 736         GDIOBJ_UnlockObjByPtr(pSurface);
 737         GDIOBJ_UnlockObjByPtr(pDirectDraw);
 738
 739         return hSurface;
 740 }
 741
 742 BOOL STDCALL NtGdiDdDeleteSurfaceObject(
 743     HANDLE hSurface
 744 )
 745 {
 746         return GDIOBJ_FreeObj(hSurface, GDI_OBJECT_TYPE_DD_SURFACE);
 747 }
 748
 749
 750
 751 /************************************************************************/
 752 /* DIRECT DRAW SURFACR END                                                   */
 753 /************************************************************************/
 754
 755
 756 /*
 757 BOOL STDCALL NtGdiDdAttachSurface(
 758     HANDLE hSurfaceFrom,
 759     HANDLE hSurfaceTo
 760 )
 761 {
 762         PDD_SURFACE pSurfaceFrom = GDIOBJ_LockObj(hSurfaceFrom, GDI_OBJECT_TYPE_DD_SURFACE);
 763         if (!pSurfaceFrom)
 764                 return FALSE;
 765         PDD_SURFACE pSurfaceTo = GDIOBJ_LockObj(hSurfaceTo, GDI_OBJECT_TYPE_DD_SURFACE);
 766         if (!pSurfaceTo)
 767         {
 768                 GDIOBJ_UnlockObjByPtr(pSurfaceFrom);
 769                 return FALSE;
 770         }
 771
 772         if (pSurfaceFrom->Local.lpAttachListFrom)
 773         {
 774                 pSurfaceFrom->Local.lpAttachListFrom = pSurfaceFrom->AttachListFrom;
 775         }
 776
 777         GDIOBJ_UnlockObjByPtr(pSurfaceFrom);
 778         GDIOBJ_UnlockObjByPtr(pSurfaceTo);
 779         return TRUE;
 780 }
 781 */
 782
 783 DWORD STDCALL NtGdiDdGetAvailDriverMemory(
 784     HANDLE hDirectDrawLocal,
 785     PDD_GETAVAILDRIVERMEMORYDATA puGetAvailDriverMemoryData
 786 )
 787 {
 788         DWORD  ddRVal = DDHAL_DRIVER_NOTHANDLED;
 789         PDD_DIRECTDRAW_GLOBAL lgpl;
 790
 791         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
 792
 793         /* backup the orignal PDev and info */
 794         lgpl = puGetAvailDriverMemoryData->lpDD;
 795
 796         /* use our cache version instead */
 797         puGetAvailDriverMemoryData->lpDD = &pDirectDraw->Global;
 798
 799         /* make the call */
 800    // ddRVal = pDirectDraw->DdGetAvailDriverMemory(puGetAvailDriverMemoryData);
 801
 802         GDIOBJ_UnlockObjByPtr(pDirectDraw);
 803
 804
 805         /* But back the orignal PDev */
 806         puGetAvailDriverMemoryData->lpDD = lgpl;
 807
 808         return ddRVal;
 809 }
 810
 811
 812
 813
 814 DWORD STDCALL NtGdiDdSetExclusiveMode(
 815     HANDLE hDirectDraw,
 816     PDD_SETEXCLUSIVEMODEDATA puSetExclusiveModeData
 817 )
 818 {
 819         DWORD  ddRVal;
 820         PDD_DIRECTDRAW_GLOBAL lgpl;
 821
 822         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDraw, GDI_OBJECT_TYPE_DIRECTDRAW);
 823
 824         /* backup the orignal PDev and info */
 825         lgpl = puSetExclusiveModeData->lpDD;
 826
 827         /* use our cache version instead */
 828         puSetExclusiveModeData->lpDD = &pDirectDraw->Global;
 829
 830         /* make the call */
 831     ddRVal = pDirectDraw->DdSetExclusiveMode(puSetExclusiveModeData);
 832
 833     GDIOBJ_UnlockObjByPtr(pDirectDraw);
 834
 835         /* But back the orignal PDev */
 836         puSetExclusiveModeData->lpDD = lgpl;
 837
 838         return ddRVal;
 839 }
 840
 841
 842
 843
 844 /* EOF */