reactos/subsystems/win32/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 GDIDEVICE IntGetPrimarySurface(VOID);
  16
  17 /* swtich this off to get rid of all dx debug msg */
  18 #define DX_DEBUG
  19
  20 #define DdHandleTable GdiHandleTable
  21
  22
  23
  24
  25 /************************************************************************/
  26 /* DIRECT DRAW OBJECT                                                   */
  27 /************************************************************************/
  28
  29 BOOL INTERNAL_CALL
  30 DD_Cleanup(PVOID ObjectBody)
  31 {
  32     PDD_DIRECTDRAW pDirectDraw = (PDD_DIRECTDRAW) ObjectBody;
  33
  34     DPRINT1("DD_Cleanup\n");
  35
  36     if (!pDirectDraw)
  37     {
  38         return FALSE;
  39     }
  40
  41     if (pDirectDraw->Global.dhpdev == NULL)
  42     {
  43         return FALSE;
  44     }
  45
  46     if (pDirectDraw->DrvDisableDirectDraw == NULL)
  47     {
  48         return FALSE;
  49     }
  50
  51     //if (pDirectDraw->pvmList != NULL)
  52     //{
  53     //    ExFreePool(pDirectDraw->pvmList);
  54     //}
  55     //
  56     //if (pDirectDraw->pdwFourCC != NULL)
  57     //{
  58     //    ExFreePool(pDirectDraw->pdwFourCC);
  59     //}
  60
  61     pDirectDraw->DrvDisableDirectDraw(pDirectDraw->Global.dhpdev);
  62     return TRUE;
  63 }
  64
  65 /* code for enable and reanble the drv */
  66 BOOL
  67 intEnableDriver(PDD_DIRECTDRAW pDirectDraw)
  68 {
  69      BOOL success;
  70      DD_HALINFO HalInfo;
  71
  72     /*clean up some of the cache entry */
  73     RtlZeroMemory(&pDirectDraw->DD,   sizeof(DD_CALLBACKS));
  74     RtlZeroMemory(&pDirectDraw->Surf, sizeof(DD_SURFACECALLBACKS));
  75     RtlZeroMemory(&pDirectDraw->Pal,  sizeof(DD_PALETTECALLBACKS));
  76     RtlZeroMemory(&pDirectDraw->Hal,  sizeof(DD_HALINFO));
  77     RtlZeroMemory(&HalInfo,  sizeof(DD_HALINFO));
  78     pDirectDraw->dwNumHeaps =0;
  79     pDirectDraw->dwNumFourCC = 0;
  80     pDirectDraw->pdwFourCC = NULL;
  81     pDirectDraw->pvmList = NULL;
  82
  83     /* Get DirectDraw infomations form the driver
  84      * DDK say pvmList, pdwFourCC is always NULL in frist call here
  85      * but we get back how many pvmList it whant we should alloc, same
  86      * with pdwFourCC.
  87      */
  88     success = pDirectDraw->DrvGetDirectDrawInfo( pDirectDraw->Global.dhpdev,
  89                                                  &HalInfo,
  90                                                  &pDirectDraw->dwNumHeaps,
  91                                                  NULL,
  92                                                  &pDirectDraw->dwNumFourCC,
  93                                                  NULL);
  94     if (!success)
  95     {
  96         DPRINT1("DrvGetDirectDrawInfo  frist call fail\n");
  97         GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
  98         return FALSE;
  99     }
 100
 101     /* The driver are not respnose to alloc the memory for pvmList
 102      * but it is win32k responsible todo, Windows 9x it is gdi32.dll
 103      */
 104     if (pDirectDraw->dwNumHeaps != 0)
 105     {
 106         pDirectDraw->pvmList = (PVIDEOMEMORY) ExAllocatePoolWithTag(PagedPool, pDirectDraw->dwNumHeaps * sizeof(VIDEOMEMORY), TAG_DXPVMLIST);
 107         if (pDirectDraw->pvmList == NULL)
 108         {
 109             return FALSE;
 110         }
 111     }
 112
 113      /* The driver are not respnose to alloc the memory for pdwFourCC
 114       * but it is win32k responsible todo, Windows 9x it is gdi32.dll
 115       */
 116
 117      if (pDirectDraw->dwNumFourCC != 0)
 118         {
 119             pDirectDraw->pdwFourCC = (LPDWORD) ExAllocatePoolWithTag(PagedPool, pDirectDraw->dwNumFourCC * sizeof(DWORD), TAG_DXFOURCC);
 120
 121             if (pDirectDraw->pdwFourCC == NULL)
 122             {
 123                 return FALSE;
 124             }
 125         }
 126
 127       success = pDirectDraw->DrvGetDirectDrawInfo( pDirectDraw->Global.dhpdev,
 128                                                    &HalInfo,
 129                                                    &pDirectDraw->dwNumHeaps,
 130                                                    pDirectDraw->pvmList,
 131                                                    &pDirectDraw->dwNumFourCC,
 132                                                    pDirectDraw->pdwFourCC);
 133     if (!success)
 134     {
 135         DPRINT1("DrvGetDirectDrawInfo  second call fail\n");
 136         GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
 137         return FALSE;
 138     }
 139
 140
 141     /* We need now convert the DD_HALINFO we got, it can be NT4 driver we
 142      * loading ReactOS supporting NT4 and higher to be loading.so we make
 143      * the HALInfo compatible here so we can easy pass it to gdi32.dll
 144      * without converting it later
 145      */
 146
 147     if ((HalInfo.dwSize != sizeof(DD_HALINFO)) &&
 148         (HalInfo.dwSize != sizeof(DD_HALINFO_V4)))
 149     {
 150          DPRINT1(" Fail not vaild driver DD_HALINFO struct found\n");
 151          GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
 152          return FALSE;
 153     }
 154
 155     if (HalInfo.dwSize != sizeof(DD_HALINFO))
 156     {
 157         if (HalInfo.dwSize == sizeof(DD_HALINFO_V4))
 158         {
 159             /* NT4 Compatible */
 160             DPRINT1("Got DD_HALINFO_V4 sturct we convert it to DD_HALINFO \n");
 161             HalInfo.dwSize = sizeof(DD_HALINFO);
 162             HalInfo.lpD3DGlobalDriverData = NULL;
 163             HalInfo.lpD3DHALCallbacks = NULL;
 164             HalInfo.lpD3DBufCallbacks = NULL;
 165         }
 166         else
 167         {
 168             /* Unknown version found */
 169             DPRINT1(" Fail : did not get DD_HALINFO size \n");
 170
 171             GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
 172             return FALSE;
 173         }
 174
 175         /* Copy it to user mode pointer the data */
 176         RtlCopyMemory(&pDirectDraw->Hal, &HalInfo, sizeof(DD_HALINFO));
 177     }
 178
 179     success = pDirectDraw->EnableDirectDraw( pDirectDraw->Global.dhpdev,
 180                                              &pDirectDraw->DD,
 181                                              &pDirectDraw->Surf,
 182                                              &pDirectDraw->Pal);
 183
 184     if (!success)
 185     {
 186         DPRINT1("EnableDirectDraw call fail\n");
 187         GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
 188         return FALSE;
 189     }
 190
 191     return TRUE;
 192 }
 193
 194
 195 HANDLE STDCALL
 196 NtGdiDdCreateDirectDrawObject(HDC hdc)
 197 {
 198     DC *pDC;
 199     HANDLE hDirectDraw;
 200     PDD_DIRECTDRAW pDirectDraw;
 201
 202     DPRINT1("NtGdiDdCreateDirectDrawObject\n");
 203
 204     /* Create a hdc if we do not have one */
 205     if (hdc == NULL)
 206     {
 207        return NULL;
 208     }
 209
 210     /* Look the hdc to gain the internal struct */
 211     pDC = DC_LockDc(hdc);
 212     if (!pDC)
 213     {
 214         return NULL;
 215     }
 216
 217     /* test see if drv got a dx interface or not */
 218     if  (( pDC->DriverFunctions.GetDirectDrawInfo == NULL) ||
 219          ( pDC->DriverFunctions.DisableDirectDraw == NULL) ||
 220          ( pDC->DriverFunctions.EnableDirectDraw == NULL))
 221     {
 222         DC_UnlockDc(pDC);
 223         return NULL;
 224     }
 225
 226     /* alloc and lock  the stucrt */
 227     hDirectDraw = GDIOBJ_AllocObj(DdHandleTable, GDI_OBJECT_TYPE_DIRECTDRAW);
 228     if (!hDirectDraw)
 229     {
 230         /* No more memmory */
 231         DC_UnlockDc(pDC);
 232         return NULL;
 233     }
 234
 235     pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDraw, GDI_OBJECT_TYPE_DIRECTDRAW);
 236     if (!pDirectDraw)
 237     {
 238         /* invalid handle */
 239         DC_UnlockDc(pDC);
 240         return NULL;
 241     }
 242
 243     /* setup the internal stuff */
 244     pDirectDraw->Global.dhpdev = pDC->PDev;
 245     pDirectDraw->Local.lpGbl = &pDirectDraw->Global;
 246
 247     pDirectDraw->DrvGetDirectDrawInfo = pDC->DriverFunctions.GetDirectDrawInfo;
 248     pDirectDraw->DrvDisableDirectDraw = pDC->DriverFunctions.DisableDirectDraw;
 249     pDirectDraw->EnableDirectDraw = pDC->DriverFunctions.EnableDirectDraw;
 250
 251     if (intEnableDriver(pDirectDraw) == FALSE)
 252     {
 253         /* FIXME delete the pDirectDraw and the handle */
 254         GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
 255         DC_UnlockDc(pDC);
 256         return NULL;
 257     }
 258
 259     GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
 260     DC_UnlockDc(pDC);
 261     DPRINT1("DirectDraw return handler 0x%x\n",hDirectDraw);
 262
 263     return hDirectDraw;
 264 }
 265
 266 BOOL STDCALL
 267 NtGdiDdDeleteDirectDrawObject( HANDLE hDirectDrawLocal)
 268 {
 269     DPRINT1("NtGdiDdDeleteDirectDrawObject\n");
 270     return GDIOBJ_FreeObj(DdHandleTable, hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
 271 }
 272
 273
 274 BOOL STDCALL
 275 NtGdiDdQueryDirectDrawObject(
 276     HANDLE hDirectDrawLocal,
 277     DD_HALINFO  *pHalInfo,
 278     DWORD *pCallBackFlags,
 279     LPD3DNTHAL_CALLBACKS puD3dCallbacks,
 280     LPD3DNTHAL_GLOBALDRIVERDATA puD3dDriverData,
 281     PDD_D3DBUFCALLBACKS puD3dBufferCallbacks,
 282     LPDDSURFACEDESC puD3dTextureFormats,
 283     DWORD *puNumHeaps,
 284     VIDEOMEMORY *puvmList,
 285     DWORD *puNumFourCC,
 286     DWORD *puFourCC
 287 )
 288 {
 289     PDD_DIRECTDRAW pDirectDraw;
 290     NTSTATUS Status = FALSE;
 291
 292     DPRINT1("NtGdiDdQueryDirectDrawObject\n");
 293     if (hDirectDrawLocal == NULL)
 294     {
 295        return FALSE;
 296     }
 297
 298     pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDrawLocal,
 299                                  GDI_OBJECT_TYPE_DIRECTDRAW);
 300
 301     if (!pDirectDraw)
 302     {
 303         return FALSE;
 304     }
 305
 306     _SEH_TRY
 307     {
 308         ProbeForWrite(pHalInfo,  sizeof(DD_HALINFO), 1);
 309         RtlCopyMemory(pHalInfo,&pDirectDraw->Hal, sizeof(DD_HALINFO));
 310
 311         ProbeForWrite(pCallBackFlags,  sizeof(DWORD)*3, 1);
 312         pCallBackFlags[0]=pDirectDraw->DD.dwFlags;
 313         pCallBackFlags[1]=pDirectDraw->Surf.dwFlags;
 314         pCallBackFlags[2]=pDirectDraw->Pal.dwFlags;
 315
 316         if (pDirectDraw->Hal.lpD3DHALCallbacks != NULL)
 317         {
 318             DPRINT1("Found DirectDraw CallBack for 3D Hal\n");
 319
 320             ProbeForWrite(puD3dCallbacks,  sizeof(D3DNTHAL_CALLBACKS), 1);
 321             RtlCopyMemory( puD3dCallbacks, pDirectDraw->Hal.lpD3DHALCallbacks,
 322                            sizeof( D3DNTHAL_CALLBACKS ) );
 323         }
 324
 325         if (pDirectDraw->Hal.lpD3DGlobalDriverData != NULL)
 326         {
 327             DPRINT1("Found DirectDraw Global DriverData \n");
 328
 329             ProbeForWrite(puD3dDriverData,  sizeof(D3DNTHAL_GLOBALDRIVERDATA), 1);
 330             RtlCopyMemory( puD3dDriverData, pDirectDraw->Hal.lpD3DGlobalDriverData,
 331                            sizeof(D3DNTHAL_GLOBALDRIVERDATA));
 332         }
 333
 334         if (pDirectDraw->Hal.lpD3DBufCallbacks != NULL)
 335         {
 336             DPRINT1("Found DirectDraw CallBack for 3D Hal Bufffer  \n");
 337             ProbeForWrite(puD3dBufferCallbacks,  sizeof(DD_D3DBUFCALLBACKS), 1);
 338             RtlCopyMemory( puD3dBufferCallbacks, pDirectDraw->Hal.lpD3DBufCallbacks,
 339                            sizeof(DD_D3DBUFCALLBACKS));
 340         }
 341
 342     /* FIXME LPDDSURFACEDESC puD3dTextureFormats */
 343
 344     ProbeForWrite(puNumHeaps,  sizeof(DWORD), 1);
 345     *puNumHeaps = pDirectDraw->dwNumHeaps;
 346
 347     if (pDirectDraw->pvmList != NULL)
 348     {
 349         ProbeForWrite(puvmList, sizeof(VIDEOMEMORY) * pDirectDraw->dwNumHeaps, 1);
 350         RtlCopyMemory( puvmList,
 351                        pDirectDraw->pvmList,
 352                        sizeof(VIDEOMEMORY) * pDirectDraw->dwNumHeaps);
 353     }
 354
 355     ProbeForWrite(puNumFourCC, sizeof(DWORD), 1);
 356     *puNumFourCC = pDirectDraw->dwNumFourCC;
 357
 358     if (pDirectDraw->pdwFourCC != NULL)
 359     {
 360         ProbeForWrite(puFourCC, sizeof(DWORD) * pDirectDraw->dwNumFourCC, 1);
 361         RtlCopyMemory( puFourCC,
 362                        pDirectDraw->pdwFourCC,
 363                        sizeof(DWORD) *  pDirectDraw->dwNumFourCC);
 364     }
 365     }
 366     _SEH_HANDLE
 367     {
 368         Status = _SEH_GetExceptionCode();
 369     }
 370     _SEH_END;
 371
 372     GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
 373
 374     if(!NT_SUCCESS(Status))
 375     {
 376         SetLastNtError(Status);
 377         return FALSE;
 378     }
 379
 380     return TRUE;
 381 }
 382
 383
 384 DWORD STDCALL NtGdiDdGetDriverInfo(
 385     HANDLE hDirectDrawLocal,
 386     PDD_GETDRIVERINFODATA puGetDriverInfoData)
 387
 388 {
 389     DWORD  ddRVal = 0;
 390     PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDrawLocal,
 391                                                 GDI_OBJECT_TYPE_DIRECTDRAW);
 392
 393     DPRINT1("NtGdiDdGetDriverInfo\n");
 394
 395     if (pDirectDraw == NULL)
 396     {
 397         return DDHAL_DRIVER_NOTHANDLED;
 398     }
 399
 400     /* it exsist two version of NtGdiDdGetDriverInfo we need check for both flags */
 401     if (!(pDirectDraw->Hal.dwFlags & DDHALINFO_GETDRIVERINFOSET))
 402          ddRVal++;
 403
 404     if (!(pDirectDraw->Hal.dwFlags & DDHALINFO_GETDRIVERINFO2))
 405          ddRVal++;
 406
 407     /* Now we are doing the call to drv DrvGetDriverInfo */
 408     if   (ddRVal == 2)
 409     {
 410         DPRINT1("NtGdiDdGetDriverInfo DDHAL_DRIVER_NOTHANDLED");
 411         ddRVal = DDHAL_DRIVER_NOTHANDLED;
 412     }
 413     else
 414     {
 415         ddRVal = pDirectDraw->Hal.GetDriverInfo(puGetDriverInfoData);
 416     }
 417
 418     GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
 419
 420     return ddRVal;
 421 }
 422
 423
 424
 425
 426 DWORD STDCALL NtGdiDdUnlock(
 427     HANDLE hSurface,
 428     PDD_UNLOCKDATA puUnlockData
 429 )
 430 {
 431         DWORD  ddRVal;
 432         PDD_DIRECTDRAW_GLOBAL lgpl;
 433
 434         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
 435 #ifdef DX_DEBUG
 436         DPRINT1("NtGdiDdUnlock\n");
 437 #endif
 438         if (pDirectDraw == NULL)
 439                 return DDHAL_DRIVER_NOTHANDLED;
 440
 441         /* backup the orignal PDev and info */
 442         lgpl = puUnlockData->lpDD;
 443
 444         /* use our cache version instead */
 445         puUnlockData->lpDD = &pDirectDraw->Global;
 446
 447         /* make the call */
 448         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_UNLOCK))
 449                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 450         else
 451         ddRVal = pDirectDraw->Surf.Unlock(puUnlockData);
 452
 453         /* But back the orignal PDev */
 454         puUnlockData->lpDD = lgpl;
 455
 456     GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
 457         return ddRVal;
 458 }
 459
 460 DWORD STDCALL NtGdiDdBlt(
 461     HANDLE hSurfaceDest,
 462     HANDLE hSurfaceSrc,
 463     PDD_BLTDATA puBltData
 464 )
 465 {
 466     DWORD  ddRVal;
 467         PDD_DIRECTDRAW_GLOBAL lgpl;
 468
 469     PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hSurfaceDest, GDI_OBJECT_TYPE_DIRECTDRAW);
 470 #ifdef DX_DEBUG
 471     DPRINT1("NtGdiDdBlt\n");
 472 #endif
 473         if (pDirectDraw == NULL)
 474                 return DDHAL_DRIVER_NOTHANDLED;
 475
 476         /* backup the orignal PDev and info */
 477         lgpl = puBltData->lpDD;
 478
 479         /* use our cache version instead */
 480         puBltData->lpDD = &pDirectDraw->Global;
 481
 482         /* make the call */
 483         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_BLT))
 484                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 485         else
 486         ddRVal = pDirectDraw->Surf.Blt(puBltData);
 487
 488         /* But back the orignal PDev */
 489         puBltData->lpDD = lgpl;
 490
 491     GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
 492     return ddRVal;
 493    }
 494
 495 DWORD STDCALL NtGdiDdSetColorKey(
 496     HANDLE hSurface,
 497     PDD_SETCOLORKEYDATA puSetColorKeyData
 498 )
 499 {
 500         DWORD  ddRVal;
 501         PDD_DIRECTDRAW_GLOBAL lgpl;
 502
 503         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
 504 #ifdef DX_DEBUG
 505         DPRINT1("NtGdiDdSetColorKey\n");
 506 #endif
 507         if (pDirectDraw == NULL)
 508                 return DDHAL_DRIVER_NOTHANDLED;
 509
 510         /* backup the orignal PDev and info */
 511         lgpl = puSetColorKeyData->lpDD;
 512
 513         /* use our cache version instead */
 514         puSetColorKeyData->lpDD = &pDirectDraw->Global;
 515
 516         /* make the call */
 517         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_SETCOLORKEY))
 518                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 519         else
 520         ddRVal = pDirectDraw->Surf.SetColorKey(puSetColorKeyData);
 521
 522         /* But back the orignal PDev */
 523         puSetColorKeyData->lpDD = lgpl;
 524
 525     GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
 526     return ddRVal;
 527 }
 528
 529
 530 DWORD STDCALL NtGdiDdAddAttachedSurface(
 531     HANDLE hSurface,
 532     HANDLE hSurfaceAttached,
 533     PDD_ADDATTACHEDSURFACEDATA puAddAttachedSurfaceData
 534 )
 535 {
 536         DWORD  ddRVal;
 537         PDD_DIRECTDRAW_GLOBAL lgpl;
 538
 539         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hSurfaceAttached, GDI_OBJECT_TYPE_DIRECTDRAW);
 540 #ifdef DX_DEBUG
 541         DPRINT1("NtGdiDdAddAttachedSurface\n");
 542 #endif
 543         if (pDirectDraw == NULL)
 544                 return DDHAL_DRIVER_NOTHANDLED;
 545
 546         /* backup the orignal PDev and info */
 547         lgpl = puAddAttachedSurfaceData->lpDD;
 548
 549         /* use our cache version instead */
 550         puAddAttachedSurfaceData->lpDD = &pDirectDraw->Global;
 551
 552         /* make the call */
 553         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_ADDATTACHEDSURFACE))
 554                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 555         else
 556         ddRVal = pDirectDraw->Surf.AddAttachedSurface(puAddAttachedSurfaceData);
 557
 558         /* But back the orignal PDev */
 559         puAddAttachedSurfaceData->lpDD = lgpl;
 560
 561     GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
 562     return ddRVal;
 563 }
 564
 565 DWORD STDCALL NtGdiDdGetBltStatus(
 566     HANDLE hSurface,
 567     PDD_GETBLTSTATUSDATA puGetBltStatusData
 568 )
 569 {
 570         DWORD  ddRVal;
 571         PDD_DIRECTDRAW_GLOBAL lgpl;
 572
 573         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
 574 #ifdef DX_DEBUG
 575         DPRINT1("NtGdiDdGetBltStatus\n");
 576 #endif
 577         if (pDirectDraw == NULL)
 578                 return DDHAL_DRIVER_NOTHANDLED;
 579
 580         /* backup the orignal PDev and info */
 581         lgpl = puGetBltStatusData->lpDD;
 582
 583         /* use our cache version instead */
 584         puGetBltStatusData->lpDD = &pDirectDraw->Global;
 585
 586         /* make the call */
 587         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_GETBLTSTATUS))
 588                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 589         else
 590         ddRVal = pDirectDraw->Surf.GetBltStatus(puGetBltStatusData);
 591
 592         /* But back the orignal PDev */
 593         puGetBltStatusData->lpDD = lgpl;
 594
 595     GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
 596     return ddRVal;
 597 }
 598
 599 DWORD STDCALL NtGdiDdGetFlipStatus(
 600     HANDLE hSurface,
 601     PDD_GETFLIPSTATUSDATA puGetFlipStatusData
 602 )
 603 {
 604     DWORD  ddRVal;
 605         PDD_DIRECTDRAW_GLOBAL lgpl;
 606
 607         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
 608 #ifdef DX_DEBUG
 609         DPRINT1("NtGdiDdGetFlipStatus\n");
 610 #endif
 611         if (pDirectDraw == NULL)
 612                 return DDHAL_DRIVER_NOTHANDLED;
 613
 614         /* backup the orignal PDev and info */
 615         lgpl = puGetFlipStatusData->lpDD;
 616
 617         /* use our cache version instead */
 618         puGetFlipStatusData->lpDD = &pDirectDraw->Global;
 619
 620         /* make the call */
 621         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_GETFLIPSTATUS))
 622                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 623         else
 624         ddRVal = pDirectDraw->Surf.GetFlipStatus(puGetFlipStatusData);
 625
 626         /* But back the orignal PDev */
 627         puGetFlipStatusData->lpDD = lgpl;
 628
 629     GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
 630     return ddRVal;
 631 }
 632
 633 DWORD STDCALL NtGdiDdUpdateOverlay(
 634     HANDLE hSurfaceDestination,
 635     HANDLE hSurfaceSource,
 636     PDD_UPDATEOVERLAYDATA puUpdateOverlayData
 637 )
 638 {
 639         DWORD  ddRVal;
 640         PDD_DIRECTDRAW_GLOBAL lgpl;
 641
 642     PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hSurfaceDestination, GDI_OBJECT_TYPE_DIRECTDRAW);
 643 #ifdef DX_DEBUG
 644     DPRINT1("NtGdiDdUpdateOverlay\n");
 645 #endif
 646         if (pDirectDraw == NULL)
 647                 return DDHAL_DRIVER_NOTHANDLED;
 648
 649         /* backup the orignal PDev and info */
 650         lgpl = puUpdateOverlayData->lpDD;
 651
 652         /* use our cache version instead */
 653         puUpdateOverlayData->lpDD = &pDirectDraw->Global;
 654
 655         /* make the call */
 656         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_UPDATEOVERLAY))
 657                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 658         else
 659         ddRVal = pDirectDraw->Surf.UpdateOverlay(puUpdateOverlayData);
 660
 661         /* But back the orignal PDev */
 662         puUpdateOverlayData->lpDD = lgpl;
 663
 664     GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
 665     return ddRVal;
 666 }
 667
 668 DWORD STDCALL NtGdiDdSetOverlayPosition(
 669     HANDLE hSurfaceSource,
 670     HANDLE hSurfaceDestination,
 671     PDD_SETOVERLAYPOSITIONDATA puSetOverlayPositionData
 672 )
 673 {
 674         DWORD  ddRVal;
 675         PDD_DIRECTDRAW_GLOBAL lgpl;
 676
 677     PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hSurfaceDestination, GDI_OBJECT_TYPE_DIRECTDRAW);
 678 #ifdef DX_DEBUG
 679     DPRINT1("NtGdiDdSetOverlayPosition\n");
 680 #endif
 681         if (pDirectDraw == NULL)
 682                 return DDHAL_DRIVER_NOTHANDLED;
 683
 684         /* backup the orignal PDev and info */
 685         lgpl = puSetOverlayPositionData->lpDD;
 686
 687         /* use our cache version instead */
 688         puSetOverlayPositionData->lpDD = &pDirectDraw->Global;
 689
 690         /* make the call */
 691         if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_SETOVERLAYPOSITION))
 692                 ddRVal = DDHAL_DRIVER_NOTHANDLED;
 693         else
 694         ddRVal = pDirectDraw->Surf.SetOverlayPosition(puSetOverlayPositionData);
 695
 696         /* But back the orignal PDev */
 697         puSetOverlayPositionData->lpDD = lgpl;
 698
 699     GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
 700     return ddRVal;
 701 }
 702
 703
 704 /************************************************************************/
 705 /* SURFACE OBJECT                                                       */
 706 /************************************************************************/
 707
 708 BOOL INTERNAL_CALL
 709 DDSURF_Cleanup(PVOID pDDSurf)
 710 {
 711         /* FIXME: implement
 712          * PDD_SURFACE pDDSurf = PVOID pDDSurf
 713          */
 714 #ifdef DX_DEBUG
 715     DPRINT1("DDSURF_Cleanup\n");
 716 #endif
 717         return TRUE;
 718 }
 719
 720 HANDLE STDCALL NtGdiDdCreateSurfaceObject(
 721     HANDLE hDirectDrawLocal,
 722     HANDLE hSurface,
 723     PDD_SURFACE_LOCAL puSurfaceLocal,
 724     PDD_SURFACE_MORE puSurfaceMore,
 725     PDD_SURFACE_GLOBAL puSurfaceGlobal,
 726     BOOL bComplete
 727 )
 728 {
 729         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
 730     PDD_SURFACE pSurface;
 731 #ifdef DX_DEBUG
 732         DPRINT1("NtGdiDdCreateSurfaceObject\n");
 733 #endif
 734         if (!pDirectDraw)
 735                 return NULL;
 736
 737         if (!hSurface)
 738                 hSurface = GDIOBJ_AllocObj(DdHandleTable, GDI_OBJECT_TYPE_DD_SURFACE);
 739
 740         pSurface = GDIOBJ_LockObj(DdHandleTable, hSurface, GDI_OBJECT_TYPE_DD_SURFACE);
 741
 742         if (!pSurface)
 743         {
 744                 GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
 745                 return NULL;
 746         }
 747
 748         pSurface->hDirectDrawLocal = hDirectDrawLocal;
 749
 750         RtlMoveMemory(&pSurface->Local, puSurfaceLocal, sizeof(DD_SURFACE_LOCAL));
 751         RtlMoveMemory(&pSurface->More, puSurfaceMore, sizeof(DD_SURFACE_MORE));
 752         RtlMoveMemory(&pSurface->Global, puSurfaceGlobal, sizeof(DD_SURFACE_GLOBAL));
 753         pSurface->Local.lpGbl = &pSurface->Global;
 754         pSurface->Local.lpSurfMore = &pSurface->More;
 755         pSurface->Local.lpAttachList = NULL;
 756         pSurface->Local.lpAttachListFrom = NULL;
 757         pSurface->More.lpVideoPort = NULL;
 758         // FIXME: figure out how to use this
 759         pSurface->bComplete = bComplete;
 760
 761         GDIOBJ_UnlockObjByPtr(DdHandleTable, pSurface);
 762         GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
 763
 764         return hSurface;
 765 }
 766
 767 BOOL STDCALL NtGdiDdDeleteSurfaceObject(
 768     HANDLE hSurface
 769 )
 770 {
 771 #ifdef DX_DEBUG
 772     DPRINT1("NtGdiDdDeleteSurfaceObject\n");
 773 #endif
 774     /* FIXME add right GDI_OBJECT_TYPE_ for everthing for now
 775        we are using same type */
 776         /* return GDIOBJ_FreeObj(hSurface, GDI_OBJECT_TYPE_DD_SURFACE); */
 777         return GDIOBJ_FreeObj(DdHandleTable, hSurface, GDI_OBJECT_TYPE_DD_SURFACE);
 778
 779 }
 780
 781
 782
 783 /************************************************************************/
 784 /* DIRECT DRAW SURFACR END                                                   */
 785 /************************************************************************/
 786
 787
 788 /*
 789 BOOL STDCALL NtGdiDdAttachSurface(
 790     HANDLE hSurfaceFrom,
 791     HANDLE hSurfaceTo
 792 )
 793 {
 794         PDD_SURFACE pSurfaceFrom = GDIOBJ_LockObj(hSurfaceFrom, GDI_OBJECT_TYPE_DD_SURFACE);
 795         if (!pSurfaceFrom)
 796                 return FALSE;
 797         PDD_SURFACE pSurfaceTo = GDIOBJ_LockObj(hSurfaceTo, GDI_OBJECT_TYPE_DD_SURFACE);
 798         if (!pSurfaceTo)
 799         {
 800                 GDIOBJ_UnlockObjByPtr(pSurfaceFrom);
 801                 return FALSE;
 802         }
 803
 804         if (pSurfaceFrom->Local.lpAttachListFrom)
 805         {
 806                 pSurfaceFrom->Local.lpAttachListFrom = pSurfaceFrom->AttachListFrom;
 807         }
 808
 809         GDIOBJ_UnlockObjByPtr(pSurfaceFrom);
 810         GDIOBJ_UnlockObjByPtr(pSurfaceTo);
 811         return TRUE;
 812 }
 813 */
 814
 815 DWORD STDCALL NtGdiDdGetAvailDriverMemory(
 816     HANDLE hDirectDrawLocal,
 817     PDD_GETAVAILDRIVERMEMORYDATA puGetAvailDriverMemoryData
 818 )
 819 {
 820         DWORD  ddRVal = DDHAL_DRIVER_NOTHANDLED;
 821         PDD_DIRECTDRAW_GLOBAL lgpl;
 822
 823         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
 824 #ifdef DX_DEBUG
 825         DPRINT1("NtGdiDdGetAvailDriverMemory\n");
 826 #endif
 827
 828         /* backup the orignal PDev and info */
 829         lgpl = puGetAvailDriverMemoryData->lpDD;
 830
 831         /* use our cache version instead */
 832         puGetAvailDriverMemoryData->lpDD = &pDirectDraw->Global;
 833
 834         /* make the call */
 835    // ddRVal = pDirectDraw->DdGetAvailDriverMemory(puGetAvailDriverMemoryData);
 836
 837         GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
 838
 839
 840         /* But back the orignal PDev */
 841         puGetAvailDriverMemoryData->lpDD = lgpl;
 842
 843         return ddRVal;
 844 }
 845
 846
 847
 848
 849 DWORD STDCALL NtGdiDdSetExclusiveMode(
 850     HANDLE hDirectDraw,
 851     PDD_SETEXCLUSIVEMODEDATA puSetExclusiveModeData
 852 )
 853 {
 854         DWORD  ddRVal;
 855         PDD_DIRECTDRAW_GLOBAL lgpl;
 856
 857         PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDraw, GDI_OBJECT_TYPE_DIRECTDRAW);
 858
 859 #ifdef DX_DEBUG
 860         DPRINT1("NtGdiDdSetExclusiveMode\n");
 861 #endif
 862
 863         /* backup the orignal PDev and info */
 864         lgpl = puSetExclusiveModeData->lpDD;
 865
 866         /* use our cache version instead */
 867         puSetExclusiveModeData->lpDD = &pDirectDraw->Global;
 868
 869         /* make the call */
 870     ddRVal = pDirectDraw->DdSetExclusiveMode(puSetExclusiveModeData);
 871
 872     GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
 873
 874         /* But back the orignal PDev */
 875         puSetExclusiveModeData->lpDD = lgpl;
 876
 877         return ddRVal;
 878 }
 879
 880
 881
 882
 883 /* EOF */