/*
* DD_SurfaceComposition_Compose
*/
HRESULT DDAPI DD_SurfaceComposition_Compose(
LPDIRECTDRAWSURFACECOMPOSITION lpDDDestSurface,
LPRECT lpDestRect,
LPDIRECTDRAWSURFACE lpDDSrcSurface,
LPRECT lpSrcRect,
DWORD dwFlags,
LPDDCOMPOSEFX lpDDComposeFX )
{
LPDDRAWI_DIRECTDRAW pdrv;
LPDDRAWI_DDRAWSURFACE_LCL this_srcx;
LPDDRAWI_DDRAWSURFACE_LCL this_destx;
LPDDRAWI_DDRAWSURFACE_GBL this_src;
LPDDRAWI_DDRAWSURFACE_GBL this_dest;
this_destx = (LPDDRAWI_DDRAWSURFACE_LCL) lpDDDestSurface;
this_srcx = (LPDDRAWI_DDRAWSURFACE_LCL) lpDDSrcSurface;
if( !VALID_DIRECTDRAWSURFACE_PTR( this_destx ) )
{
DPF_ERR( "invalid dest specified") ;
return DDERR_INVALIDOBJECT;
}
this_dest = this_destx->lpGbl;
pdrv = this_dest->lpDD;
ENTER_DDRAW();
if( this_srcx != NULL )
{
if( !VALID_DIRECTDRAWSURFACE_PTR( this_srcx ) )
{
DPF_ERR( "Invalid source specified" );
LEAVE_DDRAW();
return DDERR_INVALIDOBJECT;
}
this_src = this_srcx->lpGbl;
if( SURFACE_LOST( this_srcx ) )
{
LEAVE_DDRAW();
return DDERR_SURFACELOST;
}
}
else
{
this_src = NULL;
}
LEAVE_DDRAW();
return DDERR_UNSUPPORTED;
} /* DD_SurfaceComposition_Compose */
/*
* InternalSurfaceRelease
*
* Done with a surface. if no one else is using it, then we can free it.
* Also called by ProcessSurfaceCleanup, EnumSurfaces and DD_Release.
*
* Assumes the lock is taken on the driver.
*/
DWORD InternalSurfaceRelease( LPDDRAWI_DDRAWSURFACE_INT this_int )
{
LPDDRAWI_DDRAWSURFACE_LCL this_lcl;
LPDDRAWI_DDRAWSURFACE_GBL this;
LPATTACHLIST pattachlist;
DWORD intrefcnt;
DWORD lclrefcnt;
DWORD gblrefcnt;
DWORD pid;
LPDDRAWI_DIRECTDRAW_LCL pdrv_lcl;
LPDDRAWI_DIRECTDRAW_GBL pdrv;
BOOL root_object_deleted;
BOOL do_free;
DWORD caps;
this_lcl = this_int->lpLcl;
this = this_lcl->lpGbl;
/*
* check owner of surface
*/
pid = GETCURRPID();
/*
* don't allow someone to free an implicitly created surface
*/
if( (this->dwRefCnt == 1) && (this_lcl->dwFlags & DDRAWISURF_IMPLICITCREATE) )
{
DPF_ERR( "Cannot free an implicitly created surface" );
return 0;
}
/*
* remove locks taken on this surface by the current process
*/
pdrv_lcl = this_lcl->lpSurfMore->lpDD_lcl;
pdrv = pdrv_lcl->lpGbl;
if( (this_lcl->dwLocalRefCnt & ~OBJECT_ISROOT) == 1 )
{
RemoveProcessLocks( pdrv_lcl, this, pid );
}
/*
* decrement the reference count. if it hits zero, free the surface
*/
this->dwRefCnt--;
gblrefcnt = this->dwRefCnt;
this_lcl->dwLocalRefCnt--;
lclrefcnt = this_lcl->dwLocalRefCnt & ~OBJECT_ISROOT;
this_int->dwIntRefCnt--;
intrefcnt = this_int->dwIntRefCnt;
DPF( 4, "DD_Surface_Release, Reference Count: Global = %ld Local = %ld Int = %ld",
gblrefcnt, lclrefcnt, intrefcnt );
/*
* local object at zero?
*/
root_object_deleted = FALSE;
if( lclrefcnt == 0 )
{
LPDDRAWI_DDRAWSURFACE_INT curr_int;
LPDDRAWI_DDRAWSURFACE_LCL curr_lcl;
LPDDRAWI_DDRAWSURFACE_GBL curr;
DWORD refcnt;
/*
* see if we are deleting the root object
*/
if( this_lcl->dwLocalRefCnt & OBJECT_ISROOT )
{
root_object_deleted = TRUE;
}
/*
* reset if primary surface is the one being released
*/
if( this_lcl->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE )
{
/*
* restore GDI stuff if this is the GDI driver
*/
if( pdrv->dwFlags & DDRAWI_DISPLAYDRV )
{
if( !SURFACE_LOST( this_lcl ) )
{
DPF( 2, "Resetting primary surface");
/*
* flip to the original primary surface if not emulated
*/
if( !(this_lcl->ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY) &&
!(this->dwGlobalFlags & DDRAWISURFGBL_ISGDISURFACE)) //pdrv->fpPrimaryOrig != this->fpVidMem) )
{
FlipToGDISurface( pdrv_lcl, this_int ); //, pdrv->fpPrimaryOrig );
}
}
/*
* Cause the GDI surface to be redrawn if the mode was ever changed.
*/
if (pdrv_lcl->dwLocalFlags & DDRAWILCL_MODEHASBEENCHANGED)
RedrawWindow( NULL, NULL, NULL, RDW_INVALIDATE | RDW_ERASE |
RDW_ALLCHILDREN );
}
}
/*
* if an overlay, remove surface from the overlay Z order list
*/
if( this_lcl->ddsCaps.dwCaps & DDSCAPS_OVERLAY )
{
// Remove surface from doubly linked list
this_lcl->dbnOverlayNode.prev->next = this_lcl->dbnOverlayNode.next;
this_lcl->dbnOverlayNode.next->prev = this_lcl->dbnOverlayNode.prev;
// If this surface is overlaying an emulated surface, we must notify
// the HEL that it needs to eventually update the part of the surface
// touched by this overlay.
if( this_lcl->lpSurfaceOverlaying != NULL )
{
// We have a pointer to the surface being overlayed, check to
// see if it is being emulated.
if( this_lcl->lpSurfaceOverlaying->lpLcl->ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY )
{
// Mark the destination region of this overlay as dirty.
DD_Surface_AddOverlayDirtyRect(
(LPDIRECTDRAWSURFACE)(this_lcl->lpSurfaceOverlaying),
&(this_lcl->rcOverlayDest) );
}
DD_Surface_Release(
(LPDIRECTDRAWSURFACE)(this_lcl->lpSurfaceOverlaying) );
}
}
/*
* hide a hardware overlay...
*/
if( (this_lcl->ddsCaps.dwCaps & DDSCAPS_OVERLAY) &&
(this_lcl->ddsCaps.dwCaps & DDSCAPS_VISIBLE) &&
(this_lcl->ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY) )
{
LPDDHALSURFCB_UPDATEOVERLAY uohalfn;
LPDDHALSURFCB_UPDATEOVERLAY uofn;
DWORD rc;
DDHAL_UPDATEOVERLAYDATA uod;
uofn = pdrv_lcl->lpDDCB->HALDDSurface.UpdateOverlay;
uohalfn = pdrv_lcl->lpDDCB->cbDDSurfaceCallbacks.UpdateOverlay;
if( (uohalfn != NULL) && (NULL != this_lcl->lpSurfaceOverlaying) )
{
DPF( 2, "Turning off hardware overlay" );
uod.UpdateOverlay = uohalfn;
uod.lpDD = pdrv;
uod.lpDDSrcSurface = this_lcl;
uod.lpDDDestSurface = this_lcl->lpSurfaceOverlaying->lpLcl;
uod.dwFlags = DDOVER_HIDE;
DOHALCALL( UpdateOverlay, uofn, uod, rc, FALSE );
}
}
/*
* release all implicitly created attached surfaces
*/
pattachlist = GetAttachList( this_lcl );
this_lcl->dwFlags |= DDRAWISURF_ISFREE;
while( pattachlist != NULL )
{
BOOL was_implicit;
/*
* break all attachments
*/
curr_int = pattachlist->lpIAttached;
if( pattachlist->dwFlags & DDAL_IMPLICIT )
was_implicit = TRUE;
else
was_implicit = FALSE;
DPF(3, "Deleting attachment from %08lx to %08lx (implicit = %d)",
curr_int, this_int, was_implicit);
DeleteOneAttachment( this_int, curr_int, TRUE, DOA_DELETEIMPLICIT );
// If the attachment was not implicit then curr_int may possibly have
// been destroyed as a result of DeleteOneAttachment.
if( was_implicit )
{
curr_lcl = curr_int->lpLcl;
curr = curr_lcl->lpGbl;
/*
* release an implicitly created surface
*/
if( !(curr_lcl->dwFlags & DDRAWISURF_ISFREE) )
{
if( curr_lcl->dwFlags & DDRAWISURF_IMPLICITCREATE )
{
refcnt = curr_int->dwIntRefCnt;
curr_lcl->dwFlags &= ~DDRAWISURF_IMPLICITCREATE;
while( refcnt > 0 )
{
InternalSurfaceRelease( curr_int );
refcnt--;
}
}
}
}
/*
* start again at the beginning of the list because
* DeleteOneAttachment may have modified the attachment list.
* HACKHACK: this fn call is needed to get around a compiler bug
*/
pattachlist = GetAttachList( this_lcl );
}
/*
* Free the nodes in the IUnknown list and release all the interfaces.
*/
FreeIUnknowns( this_lcl, TRUE );
/*
* If a palette is attached to this surface remove it (and, as a
* side effect, release it).
*/
if( this_lcl->lpDDPalette )
DD_Surface_SetPalette( (LPDIRECTDRAWSURFACE) this_int, NULL );
/*
* Release the attached clipper (if any).
*/
if( this_lcl->lpSurfMore->lpDDIClipper )
DD_Clipper_Release( (LPDIRECTDRAWCLIPPER)this_lcl->lpSurfMore->lpDDIClipper );
/*
* remove all attachments to us from other surfaces
*/
pattachlist = this_lcl->lpAttachListFrom;
while( pattachlist != NULL )
{
curr_int = pattachlist->lpIAttached;
DPF( 3, "Deleting attachment from %08lx", curr_int );
DeleteOneAttachment( curr_int, this_int, TRUE, DOA_DELETEIMPLICIT );
/*
* start again at the beginning of the list because
* DeleteOneAttachment may have modified the attachment list.
* HACKHACK: this fn call is needed to get around a compiler bug
*/
pattachlist = GetAttachListFrom( this_lcl );
}
this_lcl->dwFlags &= ~DDRAWISURF_ISFREE;
}
/*
* root object at zero?
*/
do_free = FALSE;
if( gblrefcnt == 0 )
{
/*
* get rid of all memory associated with this surface
*/
DestroySurface( this_lcl );
this_lcl->dwFlags |= DDRAWISURF_INVALID;
do_free = TRUE;
/*
* if this was the final delete, but this wasn't the root object,
* then we need to delete the dangling object
*/
if( !root_object_deleted )
{
LPDDRAWI_DDRAWSURFACE_LCL root_lcl;
/*
* Get the start of the root global data object. Since the
* global data always follows the local data, we just need
* to back up the size of the local data to get the start of
* the allocated block.
*
* NOTE: The local surface allocation now includes the
* additional local surface structure (DDRAWI_DDRAWSURFACE_MORE).
* So we need to back up by the size of that structure also.
*
* Since all duplicated surfaces have the same local data,
* we just need to test this surface for overlay data to determine
* if the root object had overlay data.
*/
if( this_lcl->dwFlags & DDRAWISURF_HASOVERLAYDATA )
{
root_lcl = (LPVOID) (((LPSTR) this) - ( sizeof( DDRAWI_DDRAWSURFACE_LCL ) +
sizeof( DDRAWI_DDRAWSURFACE_MORE ) ) );
}
else
{
root_lcl = (LPVOID) (((LPSTR) this) - ( offsetof( DDRAWI_DDRAWSURFACE_LCL, ddckCKSrcOverlay ) +
sizeof( DDRAWI_DDRAWSURFACE_MORE ) ) );
}
MemFree( root_lcl );
}
}
else if( lclrefcnt == 0 )
{
/*
* only remove the object if it wasn't the root. if it
* was the root, we must leave it dangling until the last
* object referencing it goes away.
*/
if( !root_object_deleted )
{
do_free = TRUE;
}
}
caps = this_lcl->ddsCaps.dwCaps;
/*
* If we are releasing an interface to a primary surface, update the pointer to the primary
* surface stored in the local driver object. If another interface to the primary surface exists,
* store that one. Otherwise, set the pointer to NULL.
*/
if( intrefcnt == 0 )
{
if( caps & DDSCAPS_PRIMARYSURFACE )
{
if( this_lcl->lpSurfMore->lpDD_lcl )
{
this_lcl->lpSurfMore->lpDD_lcl->lpPrimary = findOtherInterface(this_int, this_lcl, pdrv);
}
}
#ifdef SHAREDZ
if( caps & DDSCAPS_SHAREDBACKBUFFER )
{
if( this_lcl->lpSurfMore->lpDD_lcl )
{
this_lcl->lpSurfMore->lpDD_lcl->lpSharedBack = findOtherInterface(this_int, this_lcl, pdrv);
}
}
if( caps & DDSCAPS_SHAREDZBUFFER )
{
if( this_lcl->lpSurfMore->lpDD_lcl )
{
this_lcl->lpSurfMore->lpDD_lcl->lpSharedZ = findOtherInterface(this_int, this_lcl, pdrv);
}
}
#endif
}
/*
* free the object if needed
*/
if( do_free )
{
this_lcl->lpGbl = NULL;
#ifdef WINNT
/*
* Free the associated NT kernel-mode object only if it is a vram surface, it is not
* an execute buffer, and it has not yet been freed in the kernel
*/
if (!(caps & (DDSCAPS_EXECUTEBUFFER|DDSCAPS_SYSTEMMEMORY) ) && this_lcl->hDDSurface )
{
DPF(9,"Deleting NT kernel-mode object handle %08x",this_lcl->hDDSurface);
if (!DdDeleteSurfaceObject(this_lcl))
DPF(9,"DdDeleteSurfaceObject failed");
}
#endif
MemFree( this_lcl );
}
/*
* interface at zero?
*/
if( intrefcnt == 0)
{
LPDDRAWI_DDRAWSURFACE_INT curr_int;
LPDDRAWI_DDRAWSURFACE_INT last_int;
/*
* remove surface from list of all surfaces
*/
curr_int = pdrv->dsList;
last_int = NULL;
while( curr_int != this_int )
{
last_int = curr_int;
curr_int = curr_int->lpLink;
if( curr_int == NULL )
{
DPF_ERR( "Surface not in list!" );
return 0;
}
}
if( last_int == NULL )
{
pdrv->dsList = pdrv->dsList->lpLink;
}
else
{
last_int->lpLink = curr_int->lpLink;
}
/*
* just in case someone comes back in with this pointer, set
* an invalid vtbl & data ptr.
*/
this_int->lpVtbl = NULL;
this_int->lpLcl = NULL;
MemFree( this_int );
}
return intrefcnt;
} /* InternalSurfaceRelease */
/*
* DD_Surface_QueryInterface
*/
HRESULT DDAPI DD_Surface_QueryInterface(
LPDIRECTDRAWSURFACE lpDDSurface,
REFIID riid,
LPVOID FAR * ppvObj )
{
LPDDRAWI_DIRECTDRAW_GBL pdrv;
LPDDRAWI_DDRAWSURFACE_INT this_int;
LPDDRAWI_DDRAWSURFACE_LCL this_lcl;
#ifdef STREAMING
LPDDRAWI_DDRAWSURFACE_GBLSTREAMING psurf_streaming;
#endif
LPDDRAWI_DDRAWSURFACE_GBL this;
LPDDRAWI_DIRECTDRAW_LCL pdrv_lcl;
LPDDRAWI_DIRECTDRAW_INT pdrv_int;
D3DCreateTextProc lpfnD3DCreateTextProc;
D3DCreateDeviceProc lpfnD3DCreateDeviceProc;
HRESULT rval;
IUnknown FAR* lpIUnknown;
ENTER_DDRAW();
/*
* validate parms
*/
TRY
{
this_int = (LPDDRAWI_DDRAWSURFACE_INT) lpDDSurface;
if( !VALID_DIRECTDRAWSURFACE_PTR( this_int ) )
{
DPF_ERR( "Invalid surface pointer" );
LEAVE_DDRAW();
return DDERR_INVALIDOBJECT;
}
this_lcl = this_int->lpLcl;
if( !VALID_PTR_PTR( ppvObj ) )
{
DPF_ERR( "Invalid surface interface pointer" );
LEAVE_DDRAW();
return DDERR_INVALIDPARAMS;
}
*ppvObj = NULL;
if( !VALIDEX_IID_PTR( riid ) )
{
DPF_ERR( "Invalid IID pointer" );
LEAVE_DDRAW();
return DDERR_INVALIDPARAMS;
}
this = this_lcl->lpGbl;
pdrv = this->lpDD;
pdrv_lcl = this_lcl->lpSurfMore->lpDD_lcl;
pdrv_int = this_lcl->lpSurfMore->lpDD_int;
}
EXCEPT( EXCEPTION_EXECUTE_HANDLER )
{
DPF_ERR( "Exception encountered validating parameters" );
LEAVE_DDRAW();
return DDERR_INVALIDPARAMS;
}
/*
* asking for IUnknown?
*/
if( IsEqualIID(riid, &IID_IUnknown) ||
IsEqualIID(riid, &IID_IDirectDrawSurface) )
{
/*
* Our IUnknown interface is the same as our V1
* interface. We must always return the V1 interface
* if IUnknown is requested.
*/
if( this_int->lpVtbl == &ddSurfaceCallbacks )
*ppvObj = (LPVOID) this_int;
else
*ppvObj = (LPVOID) getDDSInterface( pdrv, this_int->lpLcl, &ddSurfaceCallbacks );
if( NULL == *ppvObj )
{
LEAVE_DDRAW();
return E_NOINTERFACE;
}
else
{
DD_Surface_AddRef( *ppvObj );
LEAVE_DDRAW();
return DD_OK;
}
}
/*
* asking for IDirectDrawSurface2?
*/
if( IsEqualIID(riid, &IID_IDirectDrawSurface2) )
{
/*
* if this is already an IDirectDrawSurface2 interface, just
* addref and return
*/
if( this_int->lpVtbl == (LPVOID) &ddSurface2Callbacks )
*ppvObj = (LPVOID) this_int;
else
*ppvObj = (LPVOID) getDDSInterface( pdrv, this_int->lpLcl, &ddSurface2Callbacks );
if( NULL == *ppvObj )
{
LEAVE_DDRAW();
return E_NOINTERFACE;
}
else
{
DD_Surface_AddRef( *ppvObj );
LEAVE_DDRAW();
return DD_OK;
}
}
#ifdef STREAMING
/*
* asking for IDirectDrawSurfaceStreaming?
*/
if( IsEqualIID(riid, &IID_IDirectDrawSurfaceStreaming) )
{
/*
* if this is already an IDirectDrawSurfaceStreaming interface,
* just addref and return
*/
if( this_int->lpVtbl == (LPVOID) &ddSurfaceStreamingCallbacks )
{
DD_Surface_AddRef( (LPDIRECTDRAWSURFACE) this_int );
*ppvObj = (LPVOID) this_int;
}
/*
* not an IDirectDrawSurfaceStreaming interface, so we need to
* create one
*/
else
{
psurf_streaming = NewSurfaceInterface( this_lcl, &ddSurfaceStreamingCallbacks );
if( psurf_streaming == NULL )
{
LEAVE_DDRAW();
return DDERR_OUTOFMEMORY;
}
*ppvObj = (LPVOID) psurf_streaming;
}
LEAVE_DDRAW();
return DD_OK;
}
#endif
#ifdef COMPOSITION
/*
* asking for IDirectDrawSurfaceComposition?
*/
if( IsEqualIID(riid, &IID_IDirectDrawSurfaceComposition) )
{
}
#endif
DPF( 2, "IID not understood by Surface QueryInterface - trying Direct3D" );
/*
* We maintain a list of IUnknowns aggregated by each surface.
* These IUnknowns are lazily evaluated, i.e., we only create
* the underlying aggregated object when someone requests the
* the IUnknown via QueryInterface.
*
* We could just hardcode the Direct3D interfaces, check for
* them here and create the appropriate interface but that's
* inflexible and we would have to track new interfaces added
* to Direct3D (a particularly big problem as there are likely
* to be many Direct3DDevice interfaces for different device
* types). So instead, we probe Direct3D but trying its create
* functions with the IID we have been passed and seeing if
* it suceeds or not.
*/
/*
* Do we have an existing aggregated IUnknown for this IID?
*/
lpIUnknown = FindIUnknown( this_lcl, riid );
if( lpIUnknown == NULL )
{
if( !D3D_INITIALIZED( pdrv_lcl ) )
{
/*
* Direct3D is not yet initialized. Before we can attempt
* to query for the texture or device interface we must
* initialize it.
*
* NOTE: Currently if initialization fails for any reason
* we fail the QueryInterface() with the error returned
* by InitD3D() (which will be E_NOINTERFACE if Direct3D
* is not properly installed). If we ever end up aggregating
* anything else then this is going to be WRONG as we may
* end up failing a query for a completely unrelated
* interface just because Direct3D failed to initialize.
* Hence, we must rethink this if we end up aggregating
* anything else.
*/
rval = InitD3D( pdrv_int );
if( FAILED( rval ) )
{
DPF_ERR( "Could not initialize Direct3D" );
LEAVE_DDRAW();
return rval;
}
}
DDASSERT( D3D_INITIALIZED( pdrv_lcl ) );
/*
* No matching interface yet - is it a Direct3D texture IID?
*/
lpfnD3DCreateTextProc = (D3DCreateTextProc) GetProcAddress( pdrv_lcl->hD3DInstance, D3DCREATETEXTURE_PROCNAME );
if( lpfnD3DCreateTextProc != NULL )
{
DPF( 3, "Attempting to create Direct3D Texture interface" );
rval = (*lpfnD3DCreateTextProc)( riid, lpDDSurface, &lpIUnknown, (LPUNKNOWN)lpDDSurface );
if( rval == DD_OK )
{
/*
* Found the interface. Add it to our list.
*/
if( InsertIUnknown( this_lcl, riid, lpIUnknown ) == NULL )
{
/*
* Insufficient memory. Discard the interface and fail.
*/
DPF_ERR( "Insufficient memory to aggregate the Direct3D Texture interface" );
lpIUnknown->lpVtbl->Release( lpIUnknown );
LEAVE_DDRAW();
return DDERR_OUTOFMEMORY;
}
}
else if ( rval != E_NOINTERFACE )
{
/*
* The CreateTexture call understood the IID but failed for some
* other reason. Fail the QueryInterface.
*/
DPF_ERR( "Direct3D CreateTexture with valid IID" );
LEAVE_DDRAW();
return rval;
}
}
else
{
DPF( 1, "Could not locate the Direct3D CreateTexture entry point!" );
}
}
if( lpIUnknown == NULL )
{
/*
* Still no matching interface - is it a Direct3D device IID?
*/
/*
* NOTE: Don't need to verify that Direct3D is initialized. If we
* got to here it must have been initialized (when we tried the
* texture interface).
*/
DDASSERT( D3D_INITIALIZED( pdrv_lcl ) );
lpfnD3DCreateDeviceProc = (D3DCreateDeviceProc) GetProcAddress( pdrv_lcl->hD3DInstance, D3DCREATEDEVICE_PROCNAME );
if( lpfnD3DCreateDeviceProc != NULL )
{
DPF( 3, "Attempting to create Direct3D Device interface" );
rval = (*lpfnD3DCreateDeviceProc)( riid,
pdrv_lcl->pD3DIUnknown,
lpDDSurface, &lpIUnknown,
(LPUNKNOWN)lpDDSurface );
if( rval == DD_OK )
{
/*
* Found the interface. Add it to our list.
*/
if( InsertIUnknown( this_lcl, riid, lpIUnknown ) == NULL )
{
/*
* Insufficient memory. Discard the interface and fail.
*/
DPF_ERR( "Insufficient memory to aggregate the Direct3D Device interface" );
lpIUnknown->lpVtbl->Release( lpIUnknown );
LEAVE_DDRAW();
return DDERR_OUTOFMEMORY;
}
}
else if ( rval != E_NOINTERFACE )
{
/*
* The CreateDevice call understood the IID but failed for some
* other reason. Fail the QueryInterface.
*/
DPF_ERR( "Direct3D CreateDevice with valid IID" );
LEAVE_DDRAW();
return rval;
}
}
else
{
DPF( 1, "Could not locate the Direct3D CreateDevice entry point!" );
}
}
if( lpIUnknown != NULL )
{
/*
* We have found an aggregated IID - pass the QueryInterface off
* on to it.
*/
DPF( 3, "Passing query to aggregated (Direct3D) interface" );
rval = lpIUnknown->lpVtbl->QueryInterface( lpIUnknown, riid, ppvObj );
if( rval == DD_OK )
{
DPF( 3, "Aggregated (Direct3D) QueryInterface successful" );
LEAVE_DDRAW();
return DD_OK;
}
}
DPF_ERR( "IID not understood by DirectDraw" );
LEAVE_DDRAW();
return E_NOINTERFACE;
} /* DD_Surface_QueryInterface */
/*
* DD_Surface_AddRef
*/
ULONG DDAPI DD_Surface_AddRef( LPDIRECTDRAWSURFACE lpDDSurface )
{
LPDDRAWI_DIRECTDRAW_GBL pdrv;
LPDDRAWI_DDRAWSURFACE_INT this_int;
LPDDRAWI_DDRAWSURFACE_LCL this_lcl;
LPDDRAWI_DDRAWSURFACE_GBL this;
DWORD rcnt;
ENTER_DDRAW();
TRY
{
/*
* validate parms
*/
this_int = (LPDDRAWI_DDRAWSURFACE_INT) lpDDSurface;
if( !VALID_DIRECTDRAWSURFACE_PTR( this_int ) )
{
DPF_ERR( "Invalid surface pointer" );
LEAVE_DDRAW();
return 0;
}
this_lcl = this_int->lpLcl;
this = this_lcl->lpGbl;
pdrv = this->lpDD;
// need to allow lost surfaces
#if 0
if( SURFACE_LOST( this_lcl ) )
{
LEAVE_DDRAW();
return 0;
}
#endif
}
EXCEPT( EXCEPTION_EXECUTE_HANDLER )
{
DPF_ERR( "Exception encountered validating parameters" );
LEAVE_DDRAW();
return 0;
}
/*
* If this surface is already being freed, immediately return to
* prevent recursion.
*/
if( this_lcl->dwFlags & DDRAWISURF_ISFREE )
{
DPF(3, "Leaving AddRef early to prevent recursion" );
LEAVE_DDRAW();
return 0;
}
/*
* update surface reference count
*/
this->dwRefCnt++;
this_lcl->dwLocalRefCnt++;
this_int->dwIntRefCnt++;
rcnt = this_lcl->dwLocalRefCnt & ~OBJECT_ISROOT;
DPF( 4, "DD_Surface_AddRef, Reference Count: Global = %ld Local = %ld Int = %ld",
this->dwRefCnt, rcnt, this_int->dwIntRefCnt );
LEAVE_DDRAW();
return this_int->dwIntRefCnt;
} /* DD_Surface_AddRef */
/*
* DD_Surface_Release
*
* Done with a surface. if no one else is using it, then we can free it.
*/
ULONG DDAPI DD_Surface_Release( LPDIRECTDRAWSURFACE lpDDSurface )
{
LPDDRAWI_DDRAWSURFACE_INT this_int;
LPDDRAWI_DDRAWSURFACE_LCL this_lcl;
DWORD rc;
LPDDRAWI_DIRECTDRAW_GBL pdrv;
LPDDRAWI_DDRAWSURFACE_INT pparentsurf_int;
ENTER_DDRAW();
TRY
{
this_int = (LPDDRAWI_DDRAWSURFACE_INT) lpDDSurface;
if( !VALID_DIRECTDRAWSURFACE_PTR( this_int ) )
{
DPF_ERR( "Invalid surface pointer" );
LEAVE_DDRAW();
return 0;
}
this_lcl = this_int->lpLcl;
pdrv = this_lcl->lpGbl->lpDD;
}
EXCEPT( EXCEPTION_EXECUTE_HANDLER )
{
DPF_ERR( "Exception encountered validating parameters" );
LEAVE_DDRAW();
return 0;
}
/*
* If this surface is already being freed, immediately return to
* prevent recursion.
*/
if( this_lcl->dwFlags & DDRAWISURF_ISFREE )
{
DPF(3, "Leaving Release early to prevent recursion" );
LEAVE_DDRAW();
return 0;
}
/*
* If this surface is part of a mip-map chain then we will need
* to update its parent map's mip-map count.
*/
pparentsurf_int = NULL;
if( this_lcl->ddsCaps.dwCaps & DDSCAPS_MIPMAP )
pparentsurf_int = FindParentMipMap( this_int );
rc = InternalSurfaceRelease( this_int );
/*
* Update the parent's mip-map count if necessary
* (if the surface really has gone and if the mip-map
* has a parent).
*/
if( ( rc == 0UL ) && ( pparentsurf_int != NULL ) )
UpdateMipMapCount( pparentsurf_int );
LEAVE_DDRAW();
return rc;
} /* DD_Surface_Release */
